450 lines
25 KiB
Java
450 lines
25 KiB
Java
package com.thoughtworks.xstream.converters.reflection;
|
|
|
|
import com.thoughtworks.xstream.converters.ConversionException;
|
|
import com.thoughtworks.xstream.converters.MarshallingContext;
|
|
import com.thoughtworks.xstream.converters.UnmarshallingContext;
|
|
import com.thoughtworks.xstream.converters.reflection.ReflectionProvider;
|
|
import com.thoughtworks.xstream.core.ClassLoaderReference;
|
|
import com.thoughtworks.xstream.core.JVM;
|
|
import com.thoughtworks.xstream.core.util.CustomObjectInputStream;
|
|
import com.thoughtworks.xstream.core.util.CustomObjectOutputStream;
|
|
import com.thoughtworks.xstream.core.util.Fields;
|
|
import com.thoughtworks.xstream.core.util.HierarchicalStreams;
|
|
import com.thoughtworks.xstream.io.ExtendedHierarchicalStreamWriterHelper;
|
|
import com.thoughtworks.xstream.io.HierarchicalStreamReader;
|
|
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
|
|
import com.thoughtworks.xstream.io.StreamException;
|
|
import com.thoughtworks.xstream.mapper.Mapper;
|
|
import java.io.IOException;
|
|
import java.io.InvalidObjectException;
|
|
import java.io.ObjectInputValidation;
|
|
import java.io.ObjectStreamClass;
|
|
import java.io.ObjectStreamField;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
/* loaded from: classes.dex */
|
|
public class SerializableConverter extends AbstractReflectionConverter {
|
|
private static final String ATTRIBUTE_CLASS = "class";
|
|
private static final String ATTRIBUTE_NAME = "name";
|
|
private static final String ATTRIBUTE_SERIALIZATION = "serialization";
|
|
private static final String ATTRIBUTE_VALUE_CUSTOM = "custom";
|
|
private static final String ELEMENT_DEFAULT = "default";
|
|
private static final String ELEMENT_FIELD = "field";
|
|
private static final String ELEMENT_FIELDS = "fields";
|
|
private static final String ELEMENT_NULL = "null";
|
|
private static final String ELEMENT_UNSERIALIZABLE_PARENTS = "unserializable-parents";
|
|
static /* synthetic */ Class class$java$io$Serializable;
|
|
static /* synthetic */ Class class$java$lang$Object;
|
|
private final ClassLoaderReference classLoaderReference;
|
|
|
|
private static class UnserializableParentsReflectionProvider extends ReflectionProviderWrapper {
|
|
public UnserializableParentsReflectionProvider(ReflectionProvider reflectionProvider) {
|
|
super(reflectionProvider);
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.converters.reflection.ReflectionProviderWrapper, com.thoughtworks.xstream.converters.reflection.ReflectionProvider
|
|
public void visitSerializableFields(Object obj, final ReflectionProvider.Visitor visitor) {
|
|
this.wrapped.visitSerializableFields(obj, new ReflectionProvider.Visitor() { // from class: com.thoughtworks.xstream.converters.reflection.SerializableConverter.UnserializableParentsReflectionProvider.1
|
|
@Override // com.thoughtworks.xstream.converters.reflection.ReflectionProvider.Visitor
|
|
public void visit(String str, Class cls, Class cls2, Object obj2) {
|
|
Class cls3 = SerializableConverter.class$java$io$Serializable;
|
|
if (cls3 == null) {
|
|
cls3 = SerializableConverter.class$("java.io.Serializable");
|
|
SerializableConverter.class$java$io$Serializable = cls3;
|
|
}
|
|
if (cls3.isAssignableFrom(cls2)) {
|
|
return;
|
|
}
|
|
visitor.visit(str, cls, cls2, obj2);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
public SerializableConverter(Mapper mapper, ReflectionProvider reflectionProvider, ClassLoaderReference classLoaderReference) {
|
|
super(mapper, new UnserializableParentsReflectionProvider(reflectionProvider));
|
|
this.classLoaderReference = classLoaderReference;
|
|
}
|
|
|
|
static /* synthetic */ Class class$(String str) {
|
|
try {
|
|
return Class.forName(str);
|
|
} catch (ClassNotFoundException e) {
|
|
throw new NoClassDefFoundError().initCause(e);
|
|
}
|
|
}
|
|
|
|
private boolean isSerializable(Class cls) {
|
|
if (cls == null) {
|
|
return false;
|
|
}
|
|
Class cls2 = class$java$io$Serializable;
|
|
if (cls2 == null) {
|
|
cls2 = class$("java.io.Serializable");
|
|
class$java$io$Serializable = cls2;
|
|
}
|
|
if (!cls2.isAssignableFrom(cls) || cls.isInterface()) {
|
|
return false;
|
|
}
|
|
if (!this.serializationMembers.supportsReadObject(cls, true) && !this.serializationMembers.supportsWriteObject(cls, true)) {
|
|
return false;
|
|
}
|
|
Iterator it = hierarchyFor(cls).iterator();
|
|
while (it.hasNext()) {
|
|
Class cls3 = class$java$io$Serializable;
|
|
if (cls3 == null) {
|
|
cls3 = class$("java.io.Serializable");
|
|
class$java$io$Serializable = cls3;
|
|
}
|
|
if (!cls3.isAssignableFrom((Class) it.next())) {
|
|
return canAccess(cls);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public Object readField(ObjectStreamField objectStreamField, Class cls, Object obj) {
|
|
return Fields.read(Fields.find(cls, objectStreamField.getName()), obj);
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.converters.ConverterMatcher
|
|
public boolean canConvert(Class cls) {
|
|
return JVM.canCreateDerivedObjectOutputStream() && isSerializable(cls);
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter
|
|
public void doMarshal(final Object obj, final HierarchicalStreamWriter hierarchicalStreamWriter, final MarshallingContext marshallingContext) {
|
|
Class cls;
|
|
String aliasForSystemAttribute;
|
|
String aliasForSystemAttribute2;
|
|
String aliasForSystemAttribute3 = this.mapper.aliasForSystemAttribute(ATTRIBUTE_SERIALIZATION);
|
|
if (aliasForSystemAttribute3 != null) {
|
|
hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute3, ATTRIBUTE_VALUE_CUSTOM);
|
|
}
|
|
final Class[] clsArr = new Class[1];
|
|
final boolean[] zArr = {false};
|
|
CustomObjectOutputStream.StreamCallback streamCallback = new CustomObjectOutputStream.StreamCallback() { // from class: com.thoughtworks.xstream.converters.reflection.SerializableConverter.1
|
|
@Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
|
|
public void close() {
|
|
throw new UnsupportedOperationException("Objects are not allowed to call ObjectOutputStream.close() from writeObject()");
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
|
|
public void defaultWriteObject() {
|
|
String aliasForSystemAttribute4;
|
|
ObjectStreamClass lookup = ObjectStreamClass.lookup(clsArr[0]);
|
|
if (lookup == null) {
|
|
return;
|
|
}
|
|
boolean z = false;
|
|
for (ObjectStreamField objectStreamField : lookup.getFields()) {
|
|
Object readField = SerializableConverter.this.readField(objectStreamField, clsArr[0], obj);
|
|
if (readField != null) {
|
|
if (!zArr[0]) {
|
|
hierarchicalStreamWriter.startNode(SerializableConverter.this.mapper.serializedClass(clsArr[0]));
|
|
zArr[0] = true;
|
|
}
|
|
if (!z) {
|
|
hierarchicalStreamWriter.startNode("default");
|
|
z = true;
|
|
}
|
|
if (SerializableConverter.this.mapper.shouldSerializeMember(clsArr[0], objectStreamField.getName())) {
|
|
Class<?> cls2 = readField.getClass();
|
|
ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, SerializableConverter.this.mapper.serializedMember(obj.getClass(), objectStreamField.getName()), cls2);
|
|
if (!cls2.equals(SerializableConverter.this.mapper.defaultImplementationOf(objectStreamField.getType())) && (aliasForSystemAttribute4 = SerializableConverter.this.mapper.aliasForSystemAttribute(SerializableConverter.ATTRIBUTE_CLASS)) != null) {
|
|
hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute4, SerializableConverter.this.mapper.serializedClass(cls2));
|
|
}
|
|
marshallingContext.convertAnother(readField);
|
|
hierarchicalStreamWriter.endNode();
|
|
}
|
|
}
|
|
}
|
|
if (zArr[0] && !z) {
|
|
hierarchicalStreamWriter.startNode("default");
|
|
hierarchicalStreamWriter.endNode();
|
|
} else if (z) {
|
|
hierarchicalStreamWriter.endNode();
|
|
}
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
|
|
public void flush() {
|
|
hierarchicalStreamWriter.flush();
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
|
|
public void writeFieldsToStream(Map map) {
|
|
String aliasForSystemAttribute4;
|
|
ObjectStreamClass lookup = ObjectStreamClass.lookup(clsArr[0]);
|
|
hierarchicalStreamWriter.startNode("default");
|
|
for (String str : map.keySet()) {
|
|
if (SerializableConverter.this.mapper.shouldSerializeMember(clsArr[0], str)) {
|
|
ObjectStreamField field = lookup.getField(str);
|
|
Object obj2 = map.get(str);
|
|
if (field == null) {
|
|
throw new MissingFieldException(obj2.getClass().getName(), str);
|
|
}
|
|
if (obj2 != null) {
|
|
ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, SerializableConverter.this.mapper.serializedMember(obj.getClass(), str), obj2.getClass());
|
|
if (field.getType() != obj2.getClass() && !field.getType().isPrimitive() && (aliasForSystemAttribute4 = SerializableConverter.this.mapper.aliasForSystemAttribute(SerializableConverter.ATTRIBUTE_CLASS)) != null) {
|
|
hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute4, SerializableConverter.this.mapper.serializedClass(obj2.getClass()));
|
|
}
|
|
marshallingContext.convertAnother(obj2);
|
|
hierarchicalStreamWriter.endNode();
|
|
}
|
|
}
|
|
}
|
|
hierarchicalStreamWriter.endNode();
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.core.util.CustomObjectOutputStream.StreamCallback
|
|
public void writeToStream(Object obj2) {
|
|
if (obj2 == null) {
|
|
hierarchicalStreamWriter.startNode(SerializableConverter.ELEMENT_NULL);
|
|
hierarchicalStreamWriter.endNode();
|
|
} else {
|
|
ExtendedHierarchicalStreamWriterHelper.startNode(hierarchicalStreamWriter, SerializableConverter.this.mapper.serializedClass(obj2.getClass()), obj2.getClass());
|
|
marshallingContext.convertAnother(obj2);
|
|
hierarchicalStreamWriter.endNode();
|
|
}
|
|
}
|
|
};
|
|
try {
|
|
Iterator it = hierarchyFor(obj.getClass()).iterator();
|
|
boolean z = false;
|
|
while (it.hasNext()) {
|
|
clsArr[0] = (Class) it.next();
|
|
if (class$java$io$Serializable == null) {
|
|
cls = class$("java.io.Serializable");
|
|
class$java$io$Serializable = cls;
|
|
} else {
|
|
cls = class$java$io$Serializable;
|
|
}
|
|
if (cls.isAssignableFrom(clsArr[0])) {
|
|
if (z) {
|
|
marshalUnserializableParent(hierarchicalStreamWriter, marshallingContext, obj);
|
|
z = false;
|
|
}
|
|
if (this.serializationMembers.supportsWriteObject(clsArr[0], false)) {
|
|
zArr[0] = true;
|
|
hierarchicalStreamWriter.startNode(this.mapper.serializedClass(clsArr[0]));
|
|
if (clsArr[0] != this.mapper.defaultImplementationOf(clsArr[0]) && (aliasForSystemAttribute = this.mapper.aliasForSystemAttribute(ATTRIBUTE_CLASS)) != null) {
|
|
hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute, clsArr[0].getName());
|
|
}
|
|
CustomObjectOutputStream customObjectOutputStream = CustomObjectOutputStream.getInstance(marshallingContext, streamCallback);
|
|
this.serializationMembers.callWriteObject(clsArr[0], obj, customObjectOutputStream);
|
|
customObjectOutputStream.popCallback();
|
|
hierarchicalStreamWriter.endNode();
|
|
} else if (this.serializationMembers.supportsReadObject(clsArr[0], false)) {
|
|
zArr[0] = true;
|
|
hierarchicalStreamWriter.startNode(this.mapper.serializedClass(clsArr[0]));
|
|
if (clsArr[0] != this.mapper.defaultImplementationOf(clsArr[0]) && (aliasForSystemAttribute2 = this.mapper.aliasForSystemAttribute(ATTRIBUTE_CLASS)) != null) {
|
|
hierarchicalStreamWriter.addAttribute(aliasForSystemAttribute2, clsArr[0].getName());
|
|
}
|
|
streamCallback.defaultWriteObject();
|
|
hierarchicalStreamWriter.endNode();
|
|
} else {
|
|
zArr[0] = false;
|
|
streamCallback.defaultWriteObject();
|
|
if (zArr[0]) {
|
|
hierarchicalStreamWriter.endNode();
|
|
}
|
|
}
|
|
} else {
|
|
z = true;
|
|
}
|
|
}
|
|
} catch (IOException e) {
|
|
throw new StreamException("Cannot write defaults", e);
|
|
}
|
|
}
|
|
|
|
protected void doMarshalConditionally(Object obj, HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext) {
|
|
if (isSerializable(obj.getClass())) {
|
|
doMarshal(obj, hierarchicalStreamWriter, marshallingContext);
|
|
} else {
|
|
super.doMarshal(obj, hierarchicalStreamWriter, marshallingContext);
|
|
}
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.converters.reflection.AbstractReflectionConverter
|
|
public Object doUnmarshal(final Object obj, final HierarchicalStreamReader hierarchicalStreamReader, final UnmarshallingContext unmarshallingContext) {
|
|
final Class[] clsArr = new Class[1];
|
|
String aliasForSystemAttribute = this.mapper.aliasForSystemAttribute(ATTRIBUTE_SERIALIZATION);
|
|
if (aliasForSystemAttribute != null && !ATTRIBUTE_VALUE_CUSTOM.equals(hierarchicalStreamReader.getAttribute(aliasForSystemAttribute))) {
|
|
throw new ConversionException("Cannot deserialize object with new readObject()/writeObject() methods");
|
|
}
|
|
CustomObjectInputStream.StreamCallback streamCallback = new CustomObjectInputStream.StreamCallback() { // from class: com.thoughtworks.xstream.converters.reflection.SerializableConverter.2
|
|
@Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
|
|
public void close() {
|
|
throw new UnsupportedOperationException("Objects are not allowed to call ObjectInputStream.close() from readObject()");
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
|
|
public void defaultReadObject() {
|
|
Class defaultImplementationOf;
|
|
if (SerializableConverter.this.serializationMembers.getSerializablePersistentFields(clsArr[0]) != null) {
|
|
readFieldsFromStream();
|
|
return;
|
|
}
|
|
if (hierarchicalStreamReader.hasMoreChildren()) {
|
|
hierarchicalStreamReader.moveDown();
|
|
if (!hierarchicalStreamReader.getNodeName().equals("default")) {
|
|
throw new ConversionException("Expected <default/> element in readObject() stream");
|
|
}
|
|
while (hierarchicalStreamReader.hasMoreChildren()) {
|
|
hierarchicalStreamReader.moveDown();
|
|
String realMember = SerializableConverter.this.mapper.realMember(clsArr[0], hierarchicalStreamReader.getNodeName());
|
|
if (SerializableConverter.this.mapper.shouldSerializeMember(clsArr[0], realMember)) {
|
|
String readClassAttribute = HierarchicalStreams.readClassAttribute(hierarchicalStreamReader, SerializableConverter.this.mapper);
|
|
if (readClassAttribute != null) {
|
|
defaultImplementationOf = SerializableConverter.this.mapper.realClass(readClassAttribute);
|
|
} else {
|
|
SerializableConverter serializableConverter = SerializableConverter.this;
|
|
defaultImplementationOf = serializableConverter.mapper.defaultImplementationOf(serializableConverter.reflectionProvider.getFieldType(obj, realMember, clsArr[0]));
|
|
}
|
|
SerializableConverter.this.reflectionProvider.writeField(obj, realMember, unmarshallingContext.convertAnother(obj, defaultImplementationOf), clsArr[0]);
|
|
}
|
|
hierarchicalStreamReader.moveUp();
|
|
}
|
|
hierarchicalStreamReader.moveUp();
|
|
}
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
|
|
public Map readFieldsFromStream() {
|
|
Class type;
|
|
HashMap hashMap = new HashMap();
|
|
hierarchicalStreamReader.moveDown();
|
|
if (hierarchicalStreamReader.getNodeName().equals(SerializableConverter.ELEMENT_FIELDS)) {
|
|
while (hierarchicalStreamReader.hasMoreChildren()) {
|
|
hierarchicalStreamReader.moveDown();
|
|
if (!hierarchicalStreamReader.getNodeName().equals(SerializableConverter.ELEMENT_FIELD)) {
|
|
throw new ConversionException("Expected <field/> element inside <field/>");
|
|
}
|
|
hashMap.put(hierarchicalStreamReader.getAttribute("name"), unmarshallingContext.convertAnother(obj, SerializableConverter.this.mapper.realClass(hierarchicalStreamReader.getAttribute(SerializableConverter.ATTRIBUTE_CLASS))));
|
|
hierarchicalStreamReader.moveUp();
|
|
}
|
|
} else {
|
|
if (!hierarchicalStreamReader.getNodeName().equals("default")) {
|
|
throw new ConversionException("Expected <fields/> or <default/> element when calling ObjectInputStream.readFields()");
|
|
}
|
|
ObjectStreamClass lookup = ObjectStreamClass.lookup(clsArr[0]);
|
|
while (hierarchicalStreamReader.hasMoreChildren()) {
|
|
hierarchicalStreamReader.moveDown();
|
|
String realMember = SerializableConverter.this.mapper.realMember(clsArr[0], hierarchicalStreamReader.getNodeName());
|
|
if (SerializableConverter.this.mapper.shouldSerializeMember(clsArr[0], realMember)) {
|
|
String readClassAttribute = HierarchicalStreams.readClassAttribute(hierarchicalStreamReader, SerializableConverter.this.mapper);
|
|
if (readClassAttribute != null) {
|
|
type = SerializableConverter.this.mapper.realClass(readClassAttribute);
|
|
} else {
|
|
ObjectStreamField field = lookup.getField(realMember);
|
|
if (field == null) {
|
|
throw new MissingFieldException(clsArr[0].getName(), realMember);
|
|
}
|
|
type = field.getType();
|
|
}
|
|
hashMap.put(realMember, unmarshallingContext.convertAnother(obj, type));
|
|
}
|
|
hierarchicalStreamReader.moveUp();
|
|
}
|
|
}
|
|
hierarchicalStreamReader.moveUp();
|
|
return hashMap;
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
|
|
public Object readFromStream() {
|
|
hierarchicalStreamReader.moveDown();
|
|
Object convertAnother = unmarshallingContext.convertAnother(obj, HierarchicalStreams.readClassType(hierarchicalStreamReader, SerializableConverter.this.mapper));
|
|
hierarchicalStreamReader.moveUp();
|
|
return convertAnother;
|
|
}
|
|
|
|
@Override // com.thoughtworks.xstream.core.util.CustomObjectInputStream.StreamCallback
|
|
public void registerValidation(final ObjectInputValidation objectInputValidation, int i) {
|
|
unmarshallingContext.addCompletionCallback(new Runnable() { // from class: com.thoughtworks.xstream.converters.reflection.SerializableConverter.2.1
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
try {
|
|
objectInputValidation.validateObject();
|
|
} catch (InvalidObjectException e) {
|
|
throw new ObjectAccessException("Cannot validate object", e);
|
|
}
|
|
}
|
|
}, i);
|
|
}
|
|
};
|
|
while (hierarchicalStreamReader.hasMoreChildren()) {
|
|
hierarchicalStreamReader.moveDown();
|
|
String nodeName = hierarchicalStreamReader.getNodeName();
|
|
if (nodeName.equals(ELEMENT_UNSERIALIZABLE_PARENTS)) {
|
|
super.doUnmarshal(obj, hierarchicalStreamReader, unmarshallingContext);
|
|
} else {
|
|
String readClassAttribute = HierarchicalStreams.readClassAttribute(hierarchicalStreamReader, this.mapper);
|
|
if (readClassAttribute == null) {
|
|
Mapper mapper = this.mapper;
|
|
clsArr[0] = mapper.defaultImplementationOf(mapper.realClass(nodeName));
|
|
} else {
|
|
clsArr[0] = this.mapper.realClass(readClassAttribute);
|
|
}
|
|
if (this.serializationMembers.supportsReadObject(clsArr[0], false)) {
|
|
CustomObjectInputStream customObjectInputStream = CustomObjectInputStream.getInstance(unmarshallingContext, streamCallback, this.classLoaderReference);
|
|
this.serializationMembers.callReadObject(clsArr[0], obj, customObjectInputStream);
|
|
customObjectInputStream.popCallback();
|
|
} else {
|
|
try {
|
|
streamCallback.defaultReadObject();
|
|
} catch (IOException e) {
|
|
throw new StreamException("Cannot read defaults", e);
|
|
}
|
|
}
|
|
}
|
|
hierarchicalStreamReader.moveUp();
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
protected Object doUnmarshalConditionally(Object obj, HierarchicalStreamReader hierarchicalStreamReader, UnmarshallingContext unmarshallingContext) {
|
|
return isSerializable(obj.getClass()) ? doUnmarshal(obj, hierarchicalStreamReader, unmarshallingContext) : super.doUnmarshal(obj, hierarchicalStreamReader, unmarshallingContext);
|
|
}
|
|
|
|
protected List hierarchyFor(Class cls) {
|
|
ArrayList arrayList = new ArrayList();
|
|
while (true) {
|
|
Class cls2 = class$java$lang$Object;
|
|
if (cls2 == null) {
|
|
cls2 = class$("java.lang.Object");
|
|
class$java$lang$Object = cls2;
|
|
}
|
|
if (cls == cls2 || cls == null) {
|
|
break;
|
|
}
|
|
arrayList.add(cls);
|
|
cls = cls.getSuperclass();
|
|
}
|
|
Collections.reverse(arrayList);
|
|
return arrayList;
|
|
}
|
|
|
|
protected void marshalUnserializableParent(HierarchicalStreamWriter hierarchicalStreamWriter, MarshallingContext marshallingContext, Object obj) {
|
|
hierarchicalStreamWriter.startNode(ELEMENT_UNSERIALIZABLE_PARENTS);
|
|
super.doMarshal(obj, hierarchicalStreamWriter, marshallingContext);
|
|
hierarchicalStreamWriter.endNode();
|
|
}
|
|
|
|
public SerializableConverter(Mapper mapper, ReflectionProvider reflectionProvider, ClassLoader classLoader) {
|
|
this(mapper, reflectionProvider, new ClassLoaderReference(classLoader));
|
|
}
|
|
|
|
public SerializableConverter(Mapper mapper, ReflectionProvider reflectionProvider) {
|
|
this(mapper, new UnserializableParentsReflectionProvider(reflectionProvider), new ClassLoaderReference(null));
|
|
}
|
|
}
|