public Object unmarshal(final HierarchicalStreamReader reader, final UnmarshallingContext context) { final Object result = reflectionProvider.newInstance(context.getRequiredType()); final Class resultType = result.getClass(); final String fieldName = mapper.realMember(resultType, attrName); final Field field = reflectionProvider.getFieldOrNull(resultType, fieldName); if (field != null) { if (Modifier.isTransient(field.getModifiers())) { reflectionProvider.writeField(result, fieldName, value, declaringClass); if (!seenFields.add(new FastField(declaringClass, fieldName))) { throw new DuplicateFieldException(fieldName final Class classDefiningField = valueField.getDeclaringClass(); final String fieldName = valueField.getName(); final Field field = fieldName == null ? null : reflectionProvider.getField( classDefiningField, fieldName); type = mapper.defaultImplementationOf(reflectionProvider.getFieldType( result, fieldName, classDefiningField)); final Class definedType = reflectionProvider.getFieldType( result, fieldName, classDefiningField); if (!definedType.isPrimitive()) { reflectionProvider.writeField(result, fieldName, value, classDefiningField); if (!seenFields.add(new FastField(classDefiningField, fieldName))) { throw new DuplicateFieldException(fieldName
final Class[] fieldType = new Class[1]; final Class[] definingType = new Class[1]; reflectionProvider.visitSerializableFields(source, new ReflectionProvider.Visitor() { public void visit(final String fieldName, final Class type, final Class definedIn, final Object value) { final Class defaultType = mapper.defaultImplementationOf(fieldType[0]); if (!actualType.equals(defaultType)) { final String serializedClassName = mapper.serializedClass(actualType); if (!serializedClassName.equals(mapper.serializedClass(defaultType))) { final String attributeName = mapper.aliasForSystemAttribute("class"); if (attributeName != null) { writer.addAttribute(attributeName, serializedClassName); context.convertAnother(realValue[0]); } else { writer.setValue(tagValue[0]);
/** * @deprecated As of 1.4.5, use {@link #getFieldOrNull(Class, String)} instead */ public boolean fieldDefinedInClass(String fieldName, Class type) { return this.wrapped.fieldDefinedInClass(fieldName, type); }
private Map writeValueToImplicitCollection(UnmarshallingContext context, Object value, Map implicitCollections, Object result, String itemFieldName) { String fieldName = mapper.getFieldNameForItemTypeAndName(context.getRequiredType(), value.getClass(), itemFieldName); if (fieldName != null) { if (implicitCollections == null) { implicitCollections = new HashMap(); // lazy instantiation } Collection collection = (Collection) implicitCollections.get(fieldName); if (collection == null) { Class fieldType = mapper.defaultImplementationOf(reflectionProvider.getFieldType(result, fieldName, null)); if (!Collection.class.isAssignableFrom(fieldType)) { throw new ObjectAccessException("Field " + fieldName + " of " + result.getClass().getName() + " is configured for an implicit Collection, but field is of type " + fieldType.getName()); } if (pureJavaReflectionProvider == null) { pureJavaReflectionProvider = new PureJavaReflectionProvider(); } collection = (Collection)pureJavaReflectionProvider.newInstance(fieldType); reflectionProvider.writeField(result, fieldName, collection, null); implicitCollections.put(fieldName, collection); } collection.add(value); } return implicitCollections; }
public void defaultReadObject() { if (serializationMembers.getSerializablePersistentFields(currentType[0]) != null) { readFieldsFromStream(); return; } if (!reader.hasMoreChildren()) { return; } reader.moveDown(); if (!reader.getNodeName().equals(ELEMENT_DEFAULT)) { throw new ConversionException("Expected <" + ELEMENT_DEFAULT + "/> element in readObject() stream"); } while (reader.hasMoreChildren()) { reader.moveDown(); String fieldName = mapper.realMember(currentType[0], reader.getNodeName()); if (mapper.shouldSerializeMember(currentType[0], fieldName)) { String classAttribute = HierarchicalStreams.readClassAttribute(reader, mapper); final Class type; if (classAttribute != null) { type = mapper.realClass(classAttribute); } else { type = mapper.defaultImplementationOf(reflectionProvider.getFieldType(result, fieldName, currentType[0])); } Object value = context.convertAnother(result, type); reflectionProvider.writeField(result, fieldName, value, currentType[0]); } reader.moveUp(); } reader.moveUp(); }
String attrName = mapper.attributeForAlias(attrAlias); Class classDefiningField = determineWhichClassDefinesField(reader); boolean fieldExistsInClass = fieldDefinedInClass(result, attrName); if (fieldExistsInClass) { Field field = reflectionProvider.getField(result.getClass(), attrName); SingleValueConverter converter = mapper.getConverterFromAttribute(field.getDeclaringClass(),attrName,field.getType()); Class type = field.getType(); if (converter == null) { converter = mapper.getConverterFromItemType(type); throw new ConversionException("Cannot convert type " + value.getClass().getName() + " to type " + type.getName()); reflectionProvider.writeField(result, attrName, value, classDefiningField); seenFields.add(classDefiningField, attrName); final Object value; if (fieldExistsInClass) { Field field = reflectionProvider.getField(result.getClass(),fieldName); value = unmarshalField(context, result, type, field); Class definedType = reflectionProvider.getFieldType(result, fieldName, classDefiningField); if (!definedType.isPrimitive()) { type = definedType; reflectionProvider.writeField(result, fieldName, value, classDefiningField); seenFields.add(classDefiningField, fieldName); } else {
String attrName = mapper.realMember(result.getClass(), mapper.attributeForAlias(attrAlias)); Class classDefiningField = determineWhichClassDefinesField(reader); boolean fieldExistsInClass = reflectionProvider.fieldDefinedInClass(attrName, result.getClass()); if (fieldExistsInClass) { Field field = reflectionProvider.getField(result.getClass(), attrName); if (Modifier.isTransient(field.getModifiers()) && ! shouldUnmarshalTransientFields()) { continue; throw new ConversionException("Cannot convert type " + value.getClass().getName() + " to type " + type.getName()); reflectionProvider.writeField(result, attrName, value, classDefiningField); seenFields.add(classDefiningField, attrName); while (reader.hasMoreChildren()) { boolean fieldExistsInClass = implicitCollectionMapping == null && reflectionProvider.fieldDefinedInClass(fieldName, result.getClass()); final Object value; if (fieldExistsInClass) { Field field = reflectionProvider.getField(classDefiningField != null ? classDefiningField : result.getClass(), fieldName); Class definedType = reflectionProvider.getFieldType(result, fieldName, classDefiningField); if (!definedType.isPrimitive()) { type = definedType; reflectionProvider.writeField(result, fieldName, value, classDefiningField); seenFields.add(classDefiningField, fieldName); } else if (type != null) {
.realMember(resultType, mapper.attributeForAlias(attrAlias)); Field field = reflectionProvider.getFieldOrNull(resultType, attrName); if (field != null && shouldUnmarshalField(field)) { Class classDefiningField = field.getDeclaringClass(); if (!mapper.shouldSerializeMember(classDefiningField, attrName)) { continue; reflectionProvider.writeField(result, attrName, value, classDefiningField); field = reflectionProvider.getFieldOrNull(fieldDeclaringClass, fieldName); if (field == null) { field = reflectionProvider.getFieldOrNull(field .getDeclaringClass() .getSuperclass(), fieldName); reflectionProvider.writeField(result, fieldName, value, field.getDeclaringClass()); seenFields.add(new FastField(field.getDeclaringClass(), fieldName)); } else if (type != null) { Object array = ((ArraysList)value).toPhysicalArray(); final FieldLocation fieldLocation = (FieldLocation)entry.getKey(); final Field field = reflectionProvider.getFieldOrNull(fieldLocation.definedIn, fieldLocation.fieldName); reflectionProvider.writeField(result, fieldLocation.fieldName, array, field != null ? field.getDeclaringClass() : null);
private void writeField(String fieldName, String aliasName, Class fieldType, Class definedIn, Object newObj) { try { if (!mapper.shouldSerializeMember(definedIn, aliasName)) { return; } ExtendedHierarchicalStreamWriterHelper.startNode(writer, mapper.serializedMember(definedIn, aliasName), fieldType); Class actualType = newObj.getClass(); Class defaultType = mapper.defaultImplementationOf(fieldType); if (!actualType.equals(defaultType)) { String serializedClassName = mapper.serializedClass(actualType); if (!serializedClassName.equals(mapper.serializedClass(defaultType))) { writer.addAttribute(mapper.aliasForSystemAttribute("class"), serializedClassName); } } if (seenFields.contains(aliasName)) { writer.addAttribute(mapper.aliasForAttribute("defined-in"), mapper.serializedClass(definedIn)); } Field field = reflectionProvider.getField(definedIn,fieldName); marshallField(context, newObj, field); writer.endNode(); } catch (RuntimeException e) { // intercept an exception so that the stack trace shows how we end up marshalling the object in question throw new RuntimeException("Failed to serialize "+definedIn.getName()+"#"+fieldName+" for "+source.getClass(),e); } }
public void writeField(String fieldName, String aliasName, Class fieldType, Class definedIn, Object newObj) { Class actualType = newObj != null ? newObj.getClass() : fieldType; ExtendedHierarchicalStreamWriterHelper.startNode(writer, aliasName != null ? aliasName : mapper.serializedMember(sourceType, fieldName), actualType); if (newObj != null) { Class defaultType = mapper.defaultImplementationOf(fieldType); if (!actualType.equals(defaultType)) { String serializedClassName = mapper.serializedClass(actualType); if (!serializedClassName.equals(mapper.serializedClass(defaultType))) { String attributeName = mapper.aliasForSystemAttribute("class"); if (attributeName != null) { writer.addAttribute(attributeName, serializedClassName); } } } final Field defaultField = (Field)defaultFieldDefinition.get(fieldName); if (defaultField.getDeclaringClass() != definedIn) { String attributeName = mapper.aliasForSystemAttribute("defined-in"); if (attributeName != null) { writer.addAttribute( attributeName, mapper.serializedClass(definedIn)); } } Field field = reflectionProvider.getField(definedIn, fieldName); marshallField(context, newObj, field); } writer.endNode(); }
protected Object instantiateNewInstance(HierarchicalStreamReader reader, UnmarshallingContext context) { String attributeName = mapper.aliasForSystemAttribute("resolves-to"); String readResolveValue = attributeName == null ? null : reader .getAttribute(attributeName); Object currentObject = context.currentObject(); if (currentObject != null) { return currentObject; } else if (readResolveValue != null) { return reflectionProvider.newInstance(mapper.realClass(readResolveValue)); } else { return reflectionProvider.newInstance(context.getRequiredType()); } }
protected Object instantiateNewInstance(HierarchicalStreamReader reader, UnmarshallingContext context) { String readResolveValue = reader.getAttribute(mapper.aliasForAttribute("resolves-to")); Class type = readResolveValue != null ? mapper.realClass(readResolveValue) : context.getRequiredType(); Object currentObject = context.currentObject(); if (currentObject != null) { if (type.isInstance(currentObject)) return currentObject; } return reflectionProvider.newInstance(type); }
private Class determineType(HierarchicalStreamReader reader, boolean validField, Object result, String fieldName, Class definedInCls) { String classAttribute = reader.getAttribute(mapper.aliasForAttribute("class")); Class fieldType = reflectionProvider.getFieldType(result, fieldName, definedInCls); if (classAttribute != null) { Class specifiedType = mapper.realClass(classAttribute); if(fieldType.isAssignableFrom(specifiedType)) // make sure that the specified type in XML is compatible with the field type. // this allows the code to evolve in more flexible way. return specifiedType; } if (!validField) { Class itemType = mapper.getItemTypeForItemFieldName(result.getClass(), fieldName); if (itemType != null) { return itemType; } else { return mapper.realClass(reader.getNodeName()); } } else { return mapper.defaultImplementationOf(fieldType); } }
public void visit(String fieldName, Class type, Class definedIn, Object value) { if (!mapper.shouldSerializeMember(definedIn, fieldName)) { return; && !mapper.shouldSerializeMember(lookupType, fieldName)) { lookupType = definedIn; fieldName, reflectionProvider.getField(lookupType, fieldName)); SingleValueConverter converter = mapper.getConverterFromItemType( fieldName, type, definedIn); if (converter != null) { if (writtenAttributes.contains(fieldName)) { ConversionException exception = new ConversionException("Cannot write field as attribute for object, attribute name already in use"); exception.add("field-name", fieldName); exception.add("object-type", sourceType.getName()); throw exception; writer.addAttribute(attribute, str);
public void visit(final String fieldName, final Class type, final Class definedIn, final Object value) { if (!mapper.shouldSerializeMember(definedIn, fieldName)) { return; final String alias = mapper.serializedMember(definedIn, fieldName); if (!defaultFieldDefinition.containsKey(alias)) { final Class lookupType = sourceType; defaultFieldDefinition.put( alias, reflectionProvider.getField(lookupType, fieldName)); } else if (!fieldIsEqual(field)) { final ConversionException exception = new ConversionException( "Cannot write attribute twice for object"); exception.add("alias", alias); exception.add("type", sourceType.getName()); throw exception; ? (ConverterMatcher)enumMapper.getConverterFromItemType(null, type, null) : (ConverterMatcher)mapper.getLocalConverter(definedIn, fieldName); if (converter == null) { } else { if (str != null) { writer.addAttribute(alias, str);
reflectionProvider.visitSerializableFields(source, new ReflectionProvider.Visitor() { final Set writtenAttributes = new HashSet(); final Field defaultField = (Field)defaultFieldDefinition.get(info.fieldName); Mapper.ImplicitCollectionMapping mapping = mapper .getImplicitCollectionDefForFieldName( defaultField.getDeclaringClass() == info.definedIn ? sourceType : info.definedIn, info.fieldName); if (obj == null) { itemType = Object.class; itemName = mapper.serializedClass(null); } else if (isEntry) { final String entryName = mapping.getItemFieldName() != null ? mapping.getItemFieldName() : mapper.serializedClass(Map.Entry.class); Map.Entry entry = (Map.Entry)obj; ExtendedHierarchicalStreamWriterHelper.startNode( fieldMarshaller.writeItem(entry.getKey()); fieldMarshaller.writeItem(entry.getValue()); writer.endNode(); continue; } else if (mapping.getItemFieldName() != null) {
private void writeValueToImplicitCollection(Object value, Map implicitCollections, Object result, final FieldLocation fieldLocation) { Collection collection = (Collection)implicitCollections.get(fieldLocation); if (collection == null) { final Field field = reflectionProvider.getFieldOrNull(fieldLocation.definedIn, fieldLocation.fieldName); Class physicalFieldType = field != null ? field.getType() : reflectionProvider.getFieldType(result, fieldLocation.fieldName, null); if (physicalFieldType.isArray()) { collection = new ArraysList(physicalFieldType); } else { Class fieldType = mapper.defaultImplementationOf(physicalFieldType); if (!(Collection.class.isAssignableFrom(fieldType) || Map.class .isAssignableFrom(fieldType))) { pureJavaReflectionProvider = new PureJavaReflectionProvider(); Object instance = pureJavaReflectionProvider.newInstance(fieldType); if (instance instanceof Collection) { collection = (Collection)instance; } else { Mapper.ImplicitCollectionMapping implicitCollectionMapping = mapper .getImplicitCollectionDefForFieldName(fieldLocation.definedIn, fieldLocation.fieldName); collection = new MappingList( (Map)instance, implicitCollectionMapping.getKeyFieldName()); reflectionProvider.writeField(result, fieldLocation.fieldName, instance, field != null ? field.getDeclaringClass() : null);
public boolean add(Object object) { if (object == null) { boolean containsNull = !map.containsKey(null); map.put(null, null); return containsNull; } Class itemType = object.getClass(); if (keyFieldName != null) { Field field = (Field)fieldCache.get(itemType); if (field == null) { field = reflectionProvider.getField(itemType, keyFieldName); fieldCache.put(itemType, field); } if (field != null) { Object key = Fields.read(field, object); return map.put(key, object) == null; } } else if (object instanceof Map.Entry) { final Map.Entry entry = (Map.Entry)object; return map.put(entry.getKey(), entry.getValue()) == null; } ConversionException exception = new ConversionException("Element is not defined as entry for implicit map"); exception.add("map-type", map.getClass().getName()); exception.add("element-type", object.getClass().getName()); throw exception; }
public void visitSerializableFields(final Object object, final Visitor visitor) { wrapped.visitSerializableFields(object, new Visitor() { public void visit(String name, Class type, Class definedIn, Object value) { if (!Serializable.class.isAssignableFrom(definedIn)) { visitor.visit(name, type, definedIn, value); } } }); } }
public void writeField(Object object, String fieldName, Object value, Class definedIn) { this.wrapped.writeField(object, fieldName, value, definedIn); }