public Class realClass(String elementName) { return delegate.realClass(elementName); }
public Class realClass(String elementName) { return realClassMapper.realClass(elementName); }
private Class determineWhichClassDefinesField(HierarchicalStreamReader reader) { String definedIn = reader.getAttribute(mapper.aliasForAttribute("defined-in")); return definedIn == null ? null : mapper.realClass(definedIn); }
private void readCallback(HierarchicalStreamReader reader, UnmarshallingContext context, List callbacksToEnhance, List callbacks) { Callback callback = (Callback)context.convertAnother(null, mapper.realClass(reader .getNodeName())); callbacks.add(callback); if (callback == null) { callbacksToEnhance.add(NoOp.INSTANCE); } else { callbacksToEnhance.add(callback); } }
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); } }
private Class readDeclaringClass(HierarchicalStreamReader reader) { String attributeName = mapper.aliasForSystemAttribute("defined-in"); String definedIn = attributeName == null ? null : reader.getAttribute(attributeName); return definedIn == null ? null : mapper.realClass(definedIn); }
public Object fromString(String str) { try { return mapper.realClass(str); } catch (CannotResolveClassException e) { throw new ConversionException("Cannot load java class " + str, e.getCause()); } } }
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); }
@Override public Class classForType(SerializedType type) { if (SerializedType.emptyType().equals(type)) { return Void.class; } try { return xStream.getMapper().realClass(type.getName()); } catch (CannotResolveClassException e) { return UnknownSerializedType.class; } }
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; }
@SuppressWarnings("unchecked") public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { String attributeName = mapper.aliasForSystemAttribute("enum-type"); if (attributeName == null) { throw new ConversionException("No EnumType specified for EnumSet"); } Class enumTypeForSet = mapper.realClass(reader.getAttribute(attributeName)); EnumSet set = EnumSet.noneOf(enumTypeForSet); String[] enumValues = reader.getValue().split(","); for (int i = 0; i < enumValues.length; i++) { String enumValue = enumValues[i]; if(enumValue.length() > 0) { set.add(Enum.valueOf(enumTypeForSet, enumValue)); } } return set; }
protected Object readBareItem(final HierarchicalStreamReader reader, final UnmarshallingContext context, final Object current) { final String className = HierarchicalStreams.readClassAttribute(reader, mapper()); final Class itemType = className == null ? type : mapper().realClass(className); if (Mapper.Null.class.equals(itemType)) { return null; } else { return context.convertAnother(current, itemType); } } }
protected Object readItem(Class type, HierarchicalStreamReader reader, UnmarshallingContext context, Object current) { String className = HierarchicalStreams.readClassAttribute(reader, mapper()); Class itemType = className == null ? type : mapper().realClass(className); if (Mapper.Null.class.equals(itemType)) { return null; } else { return context.convertAnother(current, itemType); } } }
private Class determineType(HierarchicalStreamReader reader, Object result, String fieldName) { final String classAttributeName = classAttributeIdentifier != null ? classAttributeIdentifier : mapper.aliasForSystemAttribute("class"); String classAttribute = classAttributeName == null ? null : reader.getAttribute(classAttributeName); if (classAttribute != null) { return mapper.realClass(classAttribute); } else { return mapper.defaultImplementationOf(beanProvider.getPropertyType(result, fieldName)); } }
@Override protected Object readItem( HierarchicalStreamReader reader, UnmarshallingContext context, Object current) { Class theClass = clazz; if (subclasses != null) { String attribute = reader.getAttribute("type"); if (attribute != null) { theClass = mapper().realClass(attribute); } } return context.convertAnother(current, theClass, new ReferenceConverter(theClass)); } }
@SuppressWarnings("unchecked") public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) { String attributeName = mapper().aliasForSystemAttribute("enum-type"); if (attributeName == null) { throw new ConversionException("No EnumType specified for EnumMap"); } Class type = mapper().realClass(reader.getAttribute(attributeName)); EnumMap map = new EnumMap(type); populateMap(reader, context, map); return map; } }
/** * Given a filename, the unescape method returns the key which originated it. * * @param name the filename * @return the original key */ protected Object extractKey(final String name) { final String key = unescape(name.substring(0, name.length() - 4)); if ("null@null".equals(key)) { return null; } final int idx = key.indexOf('@'); if (idx < 0) { final ConversionException exception = new ConversionException("No valid key"); exception.add("key", key); throw exception; } final Class type = getMapper().realClass(key.substring(0, idx)); final Converter converter = getConverterLookup().lookupConverterForType(type); if (converter instanceof SingleValueConverter) { final SingleValueConverter svConverter = (SingleValueConverter)converter; return svConverter.fromString(key.substring(idx + 1)); } else { final ConversionException exception = new ConversionException( "No SingleValueConverter available for key type"); exception.add("key-type", type.getName()); throw exception; } }
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()); } }
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(); }