public boolean shouldSerializeMember(Class definedIn, String fieldName) { return delegate.shouldSerializeMember(definedIn, fieldName); }
public boolean shouldVisit(String name, Class definedIn) { return mapper.shouldSerializeMember(definedIn, name); }
public boolean shouldSerializeMember(Class definedIn, String fieldName) { return shouldSerializeMemberMapper.shouldSerializeMember(definedIn, fieldName); }
private void handleUnknownField(Class classDefiningField, String fieldName, Class resultType, String originalNodeName) { if (classDefiningField == null) { for (Class cls = resultType; cls != null; cls = cls.getSuperclass()) { if (!mapper.shouldSerializeMember(cls, originalNodeName)) { return; } } } throw new UnknownFieldException(resultType.getName(), fieldName); }
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 visit(String fieldName, Class type, Class definedIn, Object value) { if (!mapper.shouldSerializeMember(definedIn, fieldName)) { return; && !mapper.shouldSerializeMember(lookupType, fieldName)) { lookupType = definedIn;
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 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; }
if (field != null && shouldUnmarshalField(field)) { Class classDefiningField = field.getDeclaringClass(); if (!mapper.shouldSerializeMember(classDefiningField, attrName)) { continue; while (field != null && !(fieldAlreadyChecked = shouldUnmarshalField(field) && mapper.shouldSerializeMember( field.getDeclaringClass(), fieldName))) { field = reflectionProvider.getFieldOrNull(field .shouldSerializeMember(field.getDeclaringClass(), fieldName)))) { String classAttribute = HierarchicalStreams.readClassAttribute( reader, mapper);
public void visit(final String fieldName, final Class type, final Class definedIn, final Object value) { if (!mapper.shouldSerializeMember(definedIn, fieldName)) { return;
reader.moveDown(); String name = mapper.realMember(currentType[0], reader.getNodeName()); if (mapper.shouldSerializeMember(currentType[0], name)) { String classAttribute = HierarchicalStreams.readClassAttribute(reader, mapper); Class type;
writtenDefaultFields = true; if (!mapper.shouldSerializeMember(currentType[0], field.getName())) { continue;
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(); }
@Override public boolean shouldVisit(final String name, final Class<?> definedIn) { return mapper.shouldSerializeMember(definedIn, name); }
@Override public boolean shouldSerializeMember(final Class<?> definedIn, final String fieldName) { return shouldSerializeMemberMapper.shouldSerializeMember(definedIn, fieldName); }
private void handleUnknownField(final Class<?> classDefiningField, final String fieldName, final Class<?> resultType, final String originalNodeName) { if (classDefiningField == null) { for (Class<?> cls = resultType; cls != null; cls = cls.getSuperclass()) { if (!mapper.shouldSerializeMember(cls, originalNodeName)) { return; } } } throw new UnknownFieldException(resultType.getName(), fieldName); }
private void handleUnknownField(Class classDefiningField, String fieldName, Class resultType, String originalNodeName) { if (classDefiningField == null) { for (Class cls = resultType; cls != null; cls = cls.getSuperclass()) { if (!mapper.shouldSerializeMember(cls, originalNodeName)) { return; } } } throw new UnknownFieldException(resultType.getName(), fieldName); }
private void handleUnknownField(Class classDefiningField, String fieldName, Class resultType, String originalNodeName) { if (classDefiningField == null) { for (Class cls = resultType; cls != null; cls = cls.getSuperclass()) { if (!mapper.shouldSerializeMember(cls, originalNodeName)) { return; } } } throw new UnknownFieldException(resultType.getName(), fieldName); }
private void handleUnknownField(Class classDefiningField, String fieldName, Class resultType, String originalNodeName) { if (classDefiningField == null) { for (Class cls = resultType; cls != null; cls = cls.getSuperclass()) { if (!mapper.shouldSerializeMember(cls, originalNodeName)) { return; } } } throw new UnknownFieldException(resultType.getName(), fieldName); }
private void handleUnknownField(Class classDefiningField, String fieldName, Class resultType, String originalNodeName) { if (classDefiningField == null) { for (Class cls = resultType; cls != null; cls = cls.getSuperclass()) { if (!mapper.shouldSerializeMember(cls, originalNodeName)) { return; } } } throw new UnknownFieldException(resultType.getName(), fieldName); }