import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
/**
 * Creates a new ToAttributedValueConverter instance.
 * 
 * @param type the type that is handled by this converter instance
 * @param mapper the mapper in use
 * @param reflectionProvider the reflection provider in use
 * @param lookup the converter lookup in use
 * @param valueFieldName the field defining the tag's value (may be null)
 * @param valueDefinedIn the type defining the field
 */
public ToAttributedValueConverter(
        final Class<?> type, final Mapper mapper, final ReflectionProvider reflectionProvider,
        final ConverterLookup lookup, final String valueFieldName, final Class<?> valueDefinedIn) {
    this.type = type;
    this.mapper = mapper;
    this.reflectionProvider = reflectionProvider;
    this.lookup = lookup;

    if (valueFieldName == null) {
        valueField = null;
    } else {
        Field field = null;
        try {
            field = (valueDefinedIn != null ? valueDefinedIn : type).getDeclaredField(valueFieldName);
            if (!field.isAccessible()) {
                field.setAccessible(true);
            }
        } catch (final NoSuchFieldException e) {
            throw new IllegalArgumentException(e.getMessage() + ": " + valueFieldName);
        }
        valueField = field;
    }
    enumMapper = UseAttributeForEnumMapper.createEnumMapper(mapper);
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
private XStream(
        final ReflectionProvider reflectionProvider, final HierarchicalStreamDriver driver,
        final ClassLoaderReference classLoader, final Mapper mapper,
        final DefaultConverterLookup defaultConverterLookup) {
    this(reflectionProvider, driver, classLoader, mapper, new ConverterLookup() {
        @Override
        public Converter lookupConverterForType(final Class<?> type) {
            return defaultConverterLookup.lookupConverterForType(type);
        }
    }, new ConverterRegistry() {
        @Override
        public void registerConverter(final Converter converter, final int priority) {
            defaultConverterLookup.registerConverter(converter, priority);
        }
    });
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
/**
 * Creates a new ToAttributedValueConverter instance.
 * 
 * @param mapper the mapper in use
 * @param reflectionProvider the reflection provider in use
 * @param lookup the converter lookup in use
 * @param valueFieldName the field defining the tag's value (may be null)
 * @param valueDefinedIn the type defining the field
 */
public IdentifiableToIdConverter(
    final Class<Identifiable<?>> type, final Mapper mapper, final ReflectionProvider reflectionProvider,
    final ConverterLookup lookup, final String valueFieldName, Class<?> valueDefinedIn) {
    this.type = type;

       Field field = null;
       try {
           field = (valueDefinedIn != null ? valueDefinedIn : type.getSuperclass())
               .getDeclaredField("id");
          
           if (!field.isAccessible()) {
               field.setAccessible(true);
           }
       } catch (NoSuchFieldException e) {
           throw new IllegalArgumentException(e.getMessage() + ": " + valueFieldName);
       }
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
/**
 * Construct an AnnotationMapper.
 *
 * @param wrapped the next {@link Mapper} in the chain
 * @since 1.4.5
 */
public AnnotationMapper(
        final Mapper wrapped, final ConverterRegistry converterRegistry, final ConverterLookup converterLookup,
        final ClassLoaderReference classLoaderReference, final ReflectionProvider reflectionProvider) {
    super(wrapped);
    this.converterRegistry = converterRegistry;
    annotatedTypes.add(Object.class);
    setupMappers();
    locked = true;

    final ClassLoader classLoader = classLoaderReference.getReference();
    arguments = new Object[]{
        this, classLoaderReference, reflectionProvider, converterLookup, new JVM(), classLoader != null
            ? classLoader
            : new TypedNull<>(ClassLoader.class)};
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
public void testCanReadXmlUnfriendlyXPathReferences() {
    xstream.setMarshallingStrategy(new ReferenceByXPathMarshallingStrategy(ReferenceByXPathMarshallingStrategy.RELATIVE) {

        protected TreeUnmarshaller createUnmarshallingContext(Object root,
            HierarchicalStreamReader reader, ConverterLookup converterLookup, Mapper mapper) {
            return new XStream12ReferenceByXPathUnmarshaller(root, reader, converterLookup, mapper);
        }
        
    });
    xstream.alias("foo$bar", StringBuffer.class);
    xstream.alias("x_y", StringBuffer.class);
    String xml =
        "<list>\n" +
        "  <foo_-bar>foo</foo_-bar>\n" +
        "  <foo_-bar reference=\"../foo$bar\"/>\n" +
        "  <x__y>bar</x__y>\n" +
        "  <x__y reference=\"../x_y\"/>\n" +
        "</list>";
    
    List list = (List)xstream.fromXML(xml);
    assertEquals(4, list.size());
    assertSame(list.get(0), list.get(1));
    assertEquals("foo", list.get(0).toString());
    assertSame(list.get(2), list.get(3));
    assertEquals("bar", list.get(2).toString());
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
public XStream(ReflectionProvider paramReflectionProvider, HierarchicalStreamDriver paramHierarchicalStreamDriver, ClassLoaderReference paramClassLoaderReference, Mapper paramMapper, ConverterLookup paramConverterLookup, ConverterRegistry paramConverterRegistry)
{
  if (paramReflectionProvider == null)
    paramReflectionProvider = JVM.newReflectionProvider();
  this.reflectionProvider = paramReflectionProvider;
  this.hierarchicalStreamDriver = paramHierarchicalStreamDriver;
  this.classLoaderReference = paramClassLoaderReference;
  this.converterLookup = paramConverterLookup;
  this.converterRegistry = paramConverterRegistry;
  Mapper localMapper;
  if (paramMapper == null)
    localMapper = buildMapper();
  else
    localMapper = paramMapper;
  this.mapper = localMapper;
  setupMappers();
  setupSecurity();
  setupAliases();
  setupDefaultImplementations();
  setupConverters();
  setupImmutableTypes();
  setMode(1003);
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
/**
 * Construct an AnnotationMapper.
 * 
 * @param wrapped the next {@link Mapper} in the chain
 * @since 1.4.5
 */
public AnnotationMapper(
        final Mapper wrapped, final ConverterRegistry converterRegistry, final ConverterLookup converterLookup,
        final ClassLoaderReference classLoaderReference, final ReflectionProvider reflectionProvider) {
    super(wrapped);
    this.converterRegistry = converterRegistry;
    annotatedTypes.add(Object.class);
    setupMappers();
    locked = true;

    final ClassLoader classLoader = classLoaderReference.getReference();
    arguments = new Object[]{
        this, classLoaderReference, reflectionProvider, converterLookup, new JVM(),
        classLoader != null ? classLoader : new TypedNull<ClassLoader>(ClassLoader.class)};
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
public ReferenceByXPathUnmarshaller(
        final Object root, final HierarchicalStreamReader reader, final ConverterLookup converterLookup,
        final Mapper mapper) {
    super(root, reader, converterLookup, mapper);
    this.reader = new PathTrackingReader(reader, pathTracker);
    isNameEncoding = reader.underlyingReader() instanceof AbstractReader;
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
public TreeUnmarshaller(
        final Object root, final HierarchicalStreamReader reader, final ConverterLookup converterLookup,
        final Mapper mapper) {
    this.root = root;
    this.reader = reader;
    this.converterLookup = converterLookup;
    this.mapper = mapper;
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
/**
 * Set a custom XStream {@link ConverterLookup} to use.
 * Also used as {@link ConverterRegistry} if the given reference implements it as well.
 * @since 4.0
 * @see DefaultConverterLookup
 */
public void setConverterLookup(ConverterLookup converterLookup) {
	this.converterLookup = converterLookup;
	if (converterLookup instanceof ConverterRegistry) {
		this.converterRegistry = (ConverterRegistry) converterLookup;
	}
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
public void marshal(HierarchicalStreamWriter writer, Object obj,
    ConverterLookup converterLookup, Mapper mapper, DataHolder dataHolder) {
    if (marshaller == null) {
        marshaller = new ReferenceByIdMarshaller(writer, converterLookup, mapper);
    }
    marshaller.start(obj, dataHolder);
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
public Object unmarshal(Object root, HierarchicalStreamReader reader,
    DataHolder dataHolder, ConverterLookup converterLookup, Mapper mapper) {
    if (unmarshaller == null) {
        unmarshaller = new ReferenceByIdUnmarshaller(
            root, reader, converterLookup, mapper);
    }
    return unmarshaller.start(dataHolder);
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
@Override
protected ReferenceByXPathUnmarshaller createUnmarshallingContext(Object root,
                                                                  HierarchicalStreamReader reader,
                                                                  ConverterLookup converterLookup,
                                                                  Mapper mapper) {

    assertNull("strategy can only make one unmarshaller", requestedUnmarshaller);
    requestedUnmarshaller = (ReferenceByXPathUnmarshaller) super.createUnmarshallingContext(root, reader, converterLookup, mapper);
    return requestedUnmarshaller;
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
@Override
protected ReferenceByXPathMarshaller createMarshallingContext(HierarchicalStreamWriter writer,
                                                              ConverterLookup converterLookup,
                                                              Mapper mapper) {

    assertNull("strategy can only make one marshaller", requestedMarshaller);
    requestedMarshaller = (ReferenceByXPathMarshaller) super.createMarshallingContext(writer, converterLookup, mapper);
    return requestedMarshaller;
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
public TreeUnmarshaller(Object paramObject, HierarchicalStreamReader paramHierarchicalStreamReader, ConverterLookup paramConverterLookup, Mapper paramMapper)
{
  this.root = paramObject;
  this.reader = paramHierarchicalStreamReader;
  this.converterLookup = paramConverterLookup;
  this.mapper = paramMapper;
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
public HibernateCollectionConverter(ConverterLookup converterLookup)
{
  listSetConverter = converterLookup.lookupConverterForType(ArrayList.class);
  mapConverter = converterLookup.lookupConverterForType(HashMap.class);
  treeMapConverter = converterLookup.lookupConverterForType(TreeMap.class);
  treeSetConverter = converterLookup.lookupConverterForType(TreeSet.class);
  defaultConverter = converterLookup.lookupConverterForType(Object.class);
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
private ConverterLookup getDefaultConverterLookup()
{
	return getConverterLookup();
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
protected ConverterLookup getConverterLookup() {
    return xstream.getConverterLookup();
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
/**
 * Constructs a NamedMapConverter with attribute support handling an explicit Map type.
 * 
 * @param type the Map type this instance will handle
 * @param mapper the mapper
 * @param entryName the name of the entry elements
 * @param keyName the name of the key elements
 * @param keyType the base type of key elements
 * @param valueName the name of the value elements
 * @param valueType the base type of value elements
 * @param keyAsAttribute flag to write key as attribute of entry element
 * @param valueAsAttribute flag to write value as attribute of entry element
 * @param lookup used to lookup SingleValueConverter for attributes
 * @since 1.4.5
 */
public NamedMapConverter(
        @SuppressWarnings("rawtypes") final Class<? extends Map> type, final Mapper mapper, final String entryName,
        final String keyName, final Class<?> keyType, final String valueName, final Class<?> valueType,
        final boolean keyAsAttribute, final boolean valueAsAttribute, final ConverterLookup lookup) {
    super(mapper, type);
    this.entryName = entryName != null && entryName.length() == 0 ? null : entryName;
    this.keyName = keyName != null && keyName.length() == 0 ? null : keyName;
    this.keyType = keyType;
    this.valueName = valueName != null && valueName.length() == 0 ? null : valueName;
    this.valueType = valueType;
    this.keyAsAttribute = keyAsAttribute;
    this.valueAsAttribute = valueAsAttribute;
    this.lookup = lookup;
    enumMapper = UseAttributeForEnumMapper.createEnumMapper(mapper);

    if (keyType == null || valueType == null) {
        throw new IllegalArgumentException("Class types of key and value are mandatory");
    }
    if (entryName == null) {
        if (keyAsAttribute || valueAsAttribute) {
            throw new IllegalArgumentException("Cannot write attributes to map entry, if map entry must be omitted");
        }
        if (valueName == null) {
            throw new IllegalArgumentException("Cannot write value as text of entry, if entry must be omitted");
        }
    }
    if (keyName == null) {
        throw new IllegalArgumentException("Cannot write key without name");
    }
    if (valueName == null) {
        if (valueAsAttribute) {
            throw new IllegalArgumentException("Cannot write value as attribute without name");
        } else if (!keyAsAttribute) {
            throw new IllegalArgumentException("Cannot write value as text of entry, if key is also child element");
        }
    }
    if (keyAsAttribute && valueAsAttribute && keyName.equals(valueName)) {
        throw new IllegalArgumentException("Cannot write key and value with same attribute name");
    }
}
 

import com.thoughtworks.xstream.converters.ConverterLookup; //导入依赖的package包/类
/**
 * @since 1.4.5
 */
public ThrowableConverter(final ConverterLookup lookup) {
    this.lookup = lookup;
}