public Object unmarshal(final HierarchicalStreamReader reader, final UnmarshallingContext context) { Object result = instantiateNewInstance(reader, context); result = doUnmarshal(result, reader, context); return serializationMethodInvoker.callReadResolve(result); }
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { // force unmarshal as LogRotator return ref.unmarshal(reader,context); }
@Override protected Converter createDefaultConverter() { // replace default reflection converter reflectionConverter = new RobustReflectionConverter(getMapper(),new JVM().bestReflectionProvider(), new PluginClassOwnership()); return reflectionConverter; }
String attrAlias = (String) it.next(); String attrName = mapper.attributeForAlias(attrAlias); Class classDefiningField = determineWhichClassDefinesField(reader); boolean fieldExistsInClass = fieldDefinedInClass(result, attrName); if (fieldExistsInClass) { Field field = reflectionProvider.getField(result.getClass(), attrName); if (hasCriticalField(concrete, fieldName)) { critical = true; break; Class classDefiningField = determineWhichClassDefinesField(reader); boolean fieldExistsInClass = !implicitCollectionHasSameName && fieldDefinedInClass(result,fieldName); Class type = determineType(reader, fieldExistsInClass, result, fieldName, classDefiningField); final Object value; if (fieldExistsInClass) { Field field = reflectionProvider.getField(result.getClass(),fieldName); value = unmarshalField(context, result, type, field); seenFields.add(classDefiningField, fieldName); } else { implicitCollectionsForCurrentObject = writeValueToImplicitCollection(context, value, implicitCollectionsForCurrentObject, result, fieldName); addErrorInContext(context, e); } catch (LinkageError e) { if (critical) { throw e;
/** * Inform monitor that some data in a deprecated format has been loaded, during * XStream unmarshalling when the Saveable containing this object is not available. * @param context XStream unmarshalling context * @param version Hudson release when the data structure changed. */ public static void report(UnmarshallingContext context, String version) { RobustReflectionConverter.addErrorInContext(context, new ReportException(version)); }
public void marshal(Object original, final HierarchicalStreamWriter writer, final MarshallingContext context) { final Object source = serializationMethodInvoker.callWriteReplace(original); if (source.getClass() != original.getClass()) { writer.addAttribute(mapper.aliasForAttribute("resolves-to"), mapper.serializedClass(source.getClass())); } OwnerContext oc = OwnerContext.find(context); oc.startVisiting(writer, classOwnership.ownerOf(original.getClass())); try { doMarshal(source, writer, context); } finally { oc.stopVisiting(); } }
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); } }
@Override public Object doUnmarshal(Object result, final HierarchicalStreamReader reader, final UnmarshallingContext context) { result = super.doUnmarshal(result, reader, context); injecto.inject(result); return result; } }
String attrAlias = (String) it.next(); String attrName = mapper.attributeForAlias(attrAlias); Class classDefiningField = determineWhichClassDefinesField(reader); boolean fieldExistsInClass = fieldDefinedInClass(result, attrName); if (fieldExistsInClass) { Field field = reflectionProvider.getField(result.getClass(), attrName); if (hasCriticalField(concrete, fieldName)) { critical = true; break; Class classDefiningField = determineWhichClassDefinesField(reader); boolean fieldExistsInClass = !implicitCollectionHasSameName && fieldDefinedInClass(result,fieldName); Class type = determineType(reader, fieldExistsInClass, result, fieldName, classDefiningField); final Object value; if (fieldExistsInClass) { Field field = reflectionProvider.getField(result.getClass(),fieldName); value = unmarshalField(context, result, type, field); seenFields.add(classDefiningField, fieldName); } else { implicitCollectionsForCurrentObject = writeValueToImplicitCollection(context, value, implicitCollectionsForCurrentObject, result, fieldName); addErrorInContext(context, e); } catch (LinkageError e) { if (critical) { throw e;
private Object read(HierarchicalStreamReader reader, UnmarshallingContext context, Map map) { reader.moveDown(); try { return readItem(reader, context, map); } catch (CriticalXStreamException x) { throw x; } catch (XStreamException x) { RobustReflectionConverter.addErrorInContext(context, x); return ERROR; } catch (LinkageError x) { RobustReflectionConverter.addErrorInContext(context, x); return ERROR; } finally { reader.moveUp(); } }
public void marshal(Object original, final HierarchicalStreamWriter writer, final MarshallingContext context) { final Object source = serializationMethodInvoker.callWriteReplace(original); if (source.getClass() != original.getClass()) { writer.addAttribute(mapper.aliasForAttribute("resolves-to"), mapper.serializedClass(source.getClass())); } doMarshal(source, writer, context); }
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); } }
@Override public Object doUnmarshal(Object result, final HierarchicalStreamReader reader, final UnmarshallingContext context) { result = super.doUnmarshal(result, reader, context); injecto.inject(result); return result; } }
String attrAlias = (String) it.next(); String attrName = mapper.attributeForAlias(attrAlias); Class classDefiningField = determineWhichClassDefinesField(reader); boolean fieldExistsInClass = fieldDefinedInClass(result, attrName); if (fieldExistsInClass) { Field field = reflectionProvider.getField(result.getClass(), attrName); Class classDefiningField = determineWhichClassDefinesField(reader); boolean fieldExistsInClass = !implicitCollectionHasSameName && fieldDefinedInClass(result,fieldName); Class type = determineType(reader, fieldExistsInClass, result, fieldName, classDefiningField); final Object value; if (fieldExistsInClass) { Field field = reflectionProvider.getField(result.getClass(),fieldName); value = unmarshalField(context, result, type, field); seenFields.add(classDefiningField, fieldName); } else { implicitCollectionsForCurrentObject = writeValueToImplicitCollection(context, value, implicitCollectionsForCurrentObject, result, fieldName); addErrorInContext(context, e); } catch (CannotResolveClassException e) { LOGGER.log(WARNING, "Skipping a non-existent type " + e.getMessage()); addErrorInContext(context, e); } catch (LinkageError e) { LOGGER.log(WARNING, "Failed to resolve a type " + e.getMessage()); addErrorInContext(context, e);
public Object unmarshal(final HierarchicalStreamReader reader, final UnmarshallingContext context) { Object result = instantiateNewInstance(reader, context); result = doUnmarshal(result, reader, context); return serializationMethodInvoker.callReadResolve(result); }
@Override protected void populateCollection(HierarchicalStreamReader reader, UnmarshallingContext context, Collection collection) { while (reader.hasMoreChildren()) { reader.moveDown(); try { Object item = readItem(reader, context, collection); collection.add(item); } catch (CriticalXStreamException e) { throw e; } catch (XStreamException e) { RobustReflectionConverter.addErrorInContext(context, e); } catch (LinkageError e) { RobustReflectionConverter.addErrorInContext(context, e); } reader.moveUp(); } }
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { // force unmarshal as LogRotator return ref.unmarshal(reader,context); }
public ConverterImpl(Mapper m) { ref = new RobustReflectionConverter(m,new JVM().bestReflectionProvider()); }
public void marshal(Object original, final HierarchicalStreamWriter writer, final MarshallingContext context) { final Object source = serializationMethodInvoker.callWriteReplace(original); if (source.getClass() != original.getClass()) { writer.addAttribute(mapper.aliasForAttribute("resolves-to"), mapper.serializedClass(source.getClass())); } doMarshal(source, writer, context); }
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); } }