protected static void marshalComparator( Mapper mapper, Comparator comparator, HierarchicalStreamWriter writer, MarshallingContext context) { if (comparator != null) { writer.startNode("comparator"); writer.addAttribute( mapper.aliasForSystemAttribute("class"), mapper.serializedClass(comparator.getClass())); context.convertAnother(comparator); writer.endNode(); } }
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 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); } }
private Class determineWhichClassDefinesField(HierarchicalStreamReader reader) { String definedIn = reader.getAttribute(mapper.aliasForAttribute("defined-in")); return definedIn == null ? null : mapper.realClass(definedIn); }
public void visit(String fieldName, Class type, Class definedIn, Object value) { SingleValueConverter converter = mapper.getConverterFromItemType(fieldName, type, definedIn); if (converter == null) converter = mapper.getConverterFromItemType(fieldName, type); if (converter == null) converter = mapper.getConverterFromItemType(type); if (converter != null) { if (value != null) { final String str = converter.toString(value); if (str != null) { writer.addAttribute(mapper.aliasForAttribute(fieldName), str); } } seenAsAttributes.add(fieldName); } } });
@Override public Object unmarshal(final HierarchicalStreamReader reader, final UnmarshallingContext context) { final boolean oldFormat = "custom".equals(reader.getAttribute(mapper.aliasForSystemAttribute("serialization"))); if (oldFormat) { reader.moveDown(); reader.moveDown(); } final Map<String, Long> elements = new HashMap<>(); while (reader.hasMoreChildren()) { reader.moveDown(); final String name = reader.getNodeName(); elements.put(oldFormat ? name : mapper.realMember(ValueRange.class, name), Long.valueOf(reader.getValue())); reader.moveUp(); } if (oldFormat) { reader.moveUp(); reader.moveUp(); } return ValueRange.of(elements.get("minSmallest").longValue(), elements.get("minLargest").longValue(), elements .get("maxSmallest") .longValue(), elements.get("maxLargest").longValue()); }
InvocationHandler handler = null; Class handlerType = null; while (reader.hasMoreChildren()) { reader.moveDown(); String elementName = reader.getNodeName(); if (elementName.equals("interface")) { interfaces.add(mapper.realClass(reader.getValue())); } else if (elementName.equals("handler")) { String attributeName = mapper.aliasForSystemAttribute("class"); if (attributeName != null) { handlerType = mapper.realClass(reader.getAttribute(attributeName)); break; throw new ConversionException("No InvocationHandler specified for dynamic proxy"); proxy = Proxy.newProxyInstance(classLoaderReference.getReference(), interfacesAsArray, DUMMY); handler = (InvocationHandler) context.convertAnother(proxy, handlerType); reader.moveUp(); if (HANDLER != 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; SingleValueConverter converter = mapper.getConverterFromAttribute( classDefiningField, attrName, field.getType()); Class type = field.getType(); if (converter != null) { Object value = converter.fromString(reader.getAttribute(attrAlias)); if (type.isPrimitive()) { type = Primitives.box(type); ? resultType : explicitDeclaringClass; String fieldName = mapper.realMember(fieldDeclaringClass, originalNodeName); Mapper.ImplicitCollectionMapping implicitCollectionMapping = mapper .getImplicitCollectionDefForFieldName(fieldDeclaringClass, fieldName); final Object value; String implicitFieldName = null; Class itemType = mapper.getItemTypeForItemFieldName(fieldDeclaringClass, fieldName); if (itemType != null) { String classAttribute = HierarchicalStreams.readClassAttribute( reader, mapper); if (classAttribute != null) { type = mapper.realClass(classAttribute);
if (result instanceof Saveable && context.get("Saveable") == null) context.put("Saveable", result); 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); while (reader.hasMoreChildren()) { reader.moveDown(); String fieldName = mapper.realMember(result.getClass(), reader.getNodeName()); for (Class<?> concrete = result.getClass(); concrete != null; concrete = concrete.getSuperclass()) { boolean implicitCollectionHasSameName = mapper.getImplicitCollectionDefForFieldName(result.getClass(), reader.getNodeName()) != null; value = context.convertAnother(result, type);
public Map readFieldsFromStream() { final Map fields = new HashMap(); reader.moveDown(); if (reader.getNodeName().equals(ELEMENT_FIELDS)) { String name = reader.getAttribute(ATTRIBUTE_NAME); Class type = mapper.realClass(reader.getAttribute(ATTRIBUTE_CLASS)); Object value = context.convertAnother(result, type); fields.put(name, value); reader.moveUp(); while (reader.hasMoreChildren()) { reader.moveDown(); String name = mapper.realMember(currentType[0], reader.getNodeName()); if (mapper.shouldSerializeMember(currentType[0], name)) { String classAttribute = HierarchicalStreams.readClassAttribute(reader, mapper); Class type; if (classAttribute != null) { type = mapper.realClass(classAttribute); } else { ObjectStreamField field = objectStreamClass.getField(name); Object value = context.convertAnother(result, type); fields.put(name, value); throw new ConversionException("Expected <" + ELEMENT_FIELDS + "/> or <" + ELEMENT_DEFAULT + "/> element when calling ObjectInputStream.readFields()");
public void writeFieldsToStream(Map fields) { ObjectStreamClass objectStreamClass = ObjectStreamClass.lookup(currentType[0]); writer.startNode(ELEMENT_DEFAULT); for (Iterator iterator = fields.keySet().iterator(); iterator.hasNext();) { String name = (String) iterator.next(); if (!mapper.shouldSerializeMember(currentType[0], name)) { continue; } ObjectStreamField field = objectStreamClass.getField(name); Object value = fields.get(name); if (field == null) { throw new MissingFieldException(value.getClass().getName(), name); } if (value != null) { ExtendedHierarchicalStreamWriterHelper.startNode( writer, mapper.serializedMember(source.getClass(), name), value.getClass()); if (field.getType() != value.getClass() && !field.getType().isPrimitive()) { String attributeName = mapper.aliasForSystemAttribute(ATTRIBUTE_CLASS); if (attributeName != null) { writer.addAttribute(attributeName, mapper.serializedClass(value.getClass())); } } context.convertAnother(value); writer.endNode(); } } writer.endNode(); }
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(); }
public void writeToStream(final Object object) { if (object == null) { writer.startNode("null"); writer.endNode(); } else { ExtendedHierarchicalStreamWriterHelper.startNode(writer, mapper.serializedClass(object.getClass()), object.getClass()); context.convertAnother(object); writer.endNode(); } }
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { String methodName = null; String declaringClassName = null; while((methodName == null || declaringClassName == null) && reader.hasMoreChildren()) { reader.moveDown(); if (reader.getNodeName().equals("name")) { methodName = reader.getValue(); } else if (reader.getNodeName().equals("clazz")) { declaringClassName = reader.getValue(); } reader.moveUp(); } Class declaringClass = (Class)javaClassConverter.fromString(declaringClassName); try { return declaringClass.getDeclaredField(mapper.realMember(declaringClass, methodName)); } catch (NoSuchFieldException e) { throw new ConversionException(e); } } }
String attributeName = mapper.aliasForSystemAttribute(ATTRIBUTE_SERIALIZATION); if (attributeName != null && !ATTRIBUTE_VALUE_CUSTOM.equals(reader.getAttribute(attributeName))) { throw new ConversionException("Cannot deserialize object with new readObject()/writeObject() methods"); reader.moveDown(); if (!reader.getNodeName().equals(ELEMENT_FIELD)) { throw new ConversionException("Expected <" + ELEMENT_FIELD + "/> element inside <" + ELEMENT_FIELD + "/>"); throw new ConversionException("Expected <" + ELEMENT_FIELDS + "/> or <" + ELEMENT_DEFAULT + "/> element when calling ObjectInputStream.readFields()"); while (reader.hasMoreChildren()) { reader.moveDown(); String nodeName = reader.getNodeName(); if (nodeName.equals(ELEMENT_UNSERIALIZABLE_PARENTS)) { String classAttribute = HierarchicalStreams.readClassAttribute(reader, mapper); if (classAttribute == null) { currentType[0] = mapper.defaultImplementationOf(mapper.realClass(nodeName)); } else { currentType[0] = mapper.realClass(classAttribute);
private void write(final String fieldName, final long value, final HierarchicalStreamWriter writer) { ExtendedHierarchicalStreamWriterHelper.startNode(writer, mapper.serializedMember(ValueRange.class, fieldName), long.class); writer.setValue(String.valueOf(value)); writer.endNode(); } }
final Iterator it = reader.getAttributeNames(); systemAttributes.add(mapper.aliasForSystemAttribute("class")); final String fieldName = mapper.realMember(resultType, attrName); final Field field = reflectionProvider.getFieldOrNull(resultType, fieldName); if (field != null) { if (Modifier.isTransient(field.getModifiers())) { final Class declaringClass = field.getDeclaringClass(); ConverterMatcher converter = UseAttributeForEnumMapper.isEnum(type) ? (ConverterMatcher)enumMapper.getConverterFromItemType(null, type, null) : (ConverterMatcher)mapper.getLocalConverter(declaringClass, fieldName); if (converter == null) { converter = lookup.lookupConverterForType(type); .readClassAttribute(reader, mapper); if (classAttribute != null) { type = mapper.realClass(classAttribute); } else { type = mapper.defaultImplementationOf(reflectionProvider.getFieldType( result, fieldName, classDefiningField)); final Object value = context.convertAnother( result, type, mapper.getLocalConverter(field.getDeclaringClass(), field.getName()));
public Object unmarshal(final HierarchicalStreamReader reader, final UnmarshallingContext context) { final Object result = instantiateNewInstance(context); final Set seenProperties = new HashSet() { public boolean add(Object e) { if (!super.add(e)) { throw new DuplicatePropertyException(((FastField)e).getName()); } return true; } }; Class resultType = result.getClass(); while (reader.hasMoreChildren()) { reader.moveDown(); String propertyName = mapper.realMember(resultType, reader.getNodeName()); if (mapper.shouldSerializeMember(resultType, propertyName)) { boolean propertyExistsInClass = beanProvider.propertyDefinedInClass(propertyName, resultType); if (propertyExistsInClass) { Class type = determineType(reader, result, propertyName); Object value = context.convertAnother(result, type); beanProvider.writeProperty(result, propertyName, value); seenProperties.add(new FastField(resultType, propertyName)); } else if (!mapper.isIgnoredElement(propertyName)) { throw new MissingFieldException(resultType.getName(), propertyName); } } reader.moveUp(); } return result; }
private void writeField(String propertyName, Class fieldType, Object newObj) { Class actualType = newObj.getClass(); Class defaultType = mapper.defaultImplementationOf(fieldType); String serializedMember = mapper.serializedMember(source.getClass(), propertyName); ExtendedHierarchicalStreamWriterHelper.startNode(writer, serializedMember, actualType); if (!actualType.equals(defaultType) && classAttributeName != null) { writer.addAttribute(classAttributeName, mapper.serializedClass(actualType)); } context.convertAnother(newObj); writer.endNode(); }
public Object unmarshal(final HierarchicalStreamReader reader, final UnmarshallingContext context) { final List list = new ArrayList(); while (reader.hasMoreChildren()) { reader.moveDown(); final Object item; final String className = HierarchicalStreams.readClassAttribute(reader, mapper); final Class itemType = className == null ? arrayType.getComponentType() : mapper.realClass(className); if (Mapper.Null.class.equals(itemType)) { item = null; } else { item = context.convertAnother(null, itemType); } list.add(item); reader.moveUp(); } final Object array = Array.newInstance(arrayType.getComponentType(), list.size()); for (int i = 0; i < list.size(); ++i) { Array.set(array, i, list.get(i)); } return array; }