* Copyright (C) 2003, 2004, 2005, 2006 Joe Walnes.

* Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 XStream Committers.

* All rights reserved.

*

* The software in this package is published under the terms of the BSD

* style license a copy of which has been included with this distribution in

* the LICENSE.txt file.

*

* Created on 26. September 2003 by Joe Walnes

*/

* Simple facade to XStream library, a Java-XML serialization tool. <p/>

* <p>

* <hr>

* <b>Example</b><blockquote>

*

* <pre>

* XStream xstream = new XStream();

* String xml = xstream.toXML(myObject); // serialize to XML

* Object myObject2 = xstream.fromXML(xml); // deserialize from XML

* </pre>

*

* </blockquote>

* <hr>

* <p/>

* <h3>Aliasing classes</h3>

* <p/>

* <p>

* To create shorter XML, you can specify aliases for classes using the <code>alias()</code>

* method. For example, you can shorten all occurrences of element

* <code>&lt;com.blah.MyThing&gt;</code> to <code>&lt;my-thing&gt;</code> by registering an

* alias for the class.

* <p>

* <hr>

* <blockquote>

*

* <pre>

* xstream.alias(&quot;my-thing&quot;, MyThing.class);

* </pre>

*

* </blockquote>

* <hr>

* <p/>

* <h3>Converters</h3>

* <p/>

* <p>

* XStream contains a map of {@link com.thoughtworks.xstream.converters.Converter} instances, each

* of which acts as a strategy for converting a particular type of class to XML and back again. Out

* of the box, XStream contains converters for most basic types (String, Date, int, boolean, etc)

* and collections (Map, List, Set, Properties, etc). For other objects reflection is used to

* serialize each field recursively.

* </p>

* <p/>

* <p>

* Extra converters can be registered using the <code>registerConverter()</code> method. Some

* non-standard converters are supplied in the {@link com.thoughtworks.xstream.converters.extended}

* package and you can create your own by implementing the

* {@link com.thoughtworks.xstream.converters.Converter} interface.

* </p>

* <p/>

* <p>

* <hr>

* <b>Example</b><blockquote>

*

* <pre>

* xstream.registerConverter(new SqlTimestampConverter());

* xstream.registerConverter(new DynamicProxyConverter());

* </pre>

*

* </blockquote>

* <hr>

* <p>

* The converters can be registered with an explicit priority. By default they are registered with

* XStream.PRIORITY_NORMAL. Converters of same priority will be used in the reverse sequence

* they have been registered. The default converter, i.e. the converter which will be used if

* no other registered converter is suitable, can be registered with priority

* XStream.PRIORITY_VERY_LOW. XStream uses by default the

* {@link com.thoughtworks.xstream.converters.reflection.ReflectionConverter} as the fallback

* converter.

* </p>

* <p/>

* <p>

* <hr>

* <b>Example</b><blockquote>

*

* <pre>

* xstream.registerConverter(new CustomDefaultConverter(), XStream.PRIORITY_VERY_LOW);

* </pre>

*

* </blockquote>

* <hr>

* <p/>

* <h3>Object graphs</h3>

* <p/>

* <p>

* XStream has support for object graphs; a deserialized object graph will keep references intact,

* including circular references.

* </p>

* <p/>

* <p>

* XStream can signify references in XML using either relative/absolute XPath or IDs. The mode can be changed using

* <code>setMode()</code>:

* </p>

* <p/>

* <table border='1'>

* <tr>

* <td><code>xstream.setMode(XStream.XPATH_RELATIVE_REFERENCES);</code></td>

* <td><i>(Default)</i> Uses XPath relative references to signify duplicate references. This produces XML

* with the least clutter.</td>

* </tr>

* <tr>

* <td><code>xstream.setMode(XStream.XPATH_ABSOLUTE_REFERENCES);</code></td>

* <td>Uses XPath absolute references to signify duplicate

* references. This produces XML with the least clutter.</td>

* </tr>

* <tr>

* <td><code>xstream.setMode(XStream.SINGLE_NODE_XPATH_RELATIVE_REFERENCES);</code></td>

* <td>Uses XPath relative references to signify duplicate references. The XPath expression ensures that

* a single node only is selected always.</td>

* </tr>

* <tr>

* <td><code>xstream.setMode(XStream.SINGLE_NODE_XPATH_ABSOLUTE_REFERENCES);</code></td>

* <td>Uses XPath absolute references to signify duplicate references.  The XPath expression ensures that

* a single node only is selected always.</td>

* </tr>

* <tr>

* <td><code>xstream.setMode(XStream.ID_REFERENCES);</code></td>

* <td>Uses ID references to signify duplicate references. In some scenarios, such as when using

* hand-written XML, this is easier to work with.</td>

* </tr>

* <tr>

* <td><code>xstream.setMode(XStream.NO_REFERENCES);</code></td>

* <td>This disables object graph support and treats the object structure like a tree. Duplicate

* references are treated as two separate objects and circular references cause an exception. This

* is slightly faster and uses less memory than the other two modes.</td>

* </tr>

* </table>

* <h3>Thread safety</h3>

* <p>

* The XStream instance is thread-safe. That is, once the XStream instance has been created and

* configured, it may be shared across multiple threads allowing objects to be

* serialized/deserialized concurrently. <em>Note, that this only applies if annotations are not

* auto-detected on -the-fly.</em>

* </p>

* <h3>Implicit collections</h3>

* <p/>

* <p>

* To avoid the need for special tags for collections, you can define implicit collections using one

* of the <code>addImplicitCollection</code> methods.

* </p>

*

* @author Joe Walnes

* @author J&ouml;rg Schaible

* @author Mauro Talevi

* @author Guilherme Silveira

*/

    // CAUTION: The sequence of the fields is intentional for an optimal XML output of a

    // self-serialization!

    private ReflectionProvider reflectionProvider;

    private HierarchicalStreamDriver hierarchicalStreamDriver;

    private ClassLoaderReference classLoaderReference;

    private MarshallingStrategy marshallingStrategy;

    private ConverterLookup converterLookup;

    private ConverterRegistry converterRegistry;

    private Mapper mapper;

    private PackageAliasingMapper packageAliasingMapper;

    private ClassAliasingMapper classAliasingMapper;

    private FieldAliasingMapper fieldAliasingMapper;

    private AttributeAliasingMapper attributeAliasingMapper;

    private SystemAttributeAliasingMapper systemAttributeAliasingMapper;

    private AttributeMapper attributeMapper;

    private DefaultImplementationsMapper defaultImplementationsMapper;

    private ImmutableTypesMapper immutableTypesMapper;

    private ImplicitCollectionMapper implicitCollectionMapper;

    private LocalConversionMapper localConversionMapper;

    private AnnotationConfiguration annotationConfiguration;

    private transient JVM jvm = new JVM();

    public static final int NO_REFERENCES = 1001;

    public static final int ID_REFERENCES = 1002;

    public static final int XPATH_RELATIVE_REFERENCES = 1003;

    public static final int XPATH_ABSOLUTE_REFERENCES = 1004;

    public static final int SINGLE_NODE_XPATH_RELATIVE_REFERENCES = 1005;

    public static final int SINGLE_NODE_XPATH_ABSOLUTE_REFERENCES = 1006;

    public static final int PRIORITY_VERY_HIGH = 10000;

    public static final int PRIORITY_NORMAL = 0;

    public static final int PRIORITY_LOW = -10;

    public static final int PRIORITY_VERY_LOW = -20;

    private static final String ANNOTATION_MAPPER_TYPE = "com.thoughtworks.xstream.mapper.AnnotationMapper";

    /**

     * Constructs a default XStream. The instance will use the {@link XppDriver} as default and

     * tries to determine the best match for the {@link ReflectionProvider} on its own.

     *

     * @throws InitializationException in case of an initialization problem

     */

    public XStream() {

        this(null, (Mapper)null, new XppDriver());

    }

    /**

     * Constructs an XStream with a special {@link ReflectionProvider}. The instance will use

     * the {@link XppDriver} as default.

     *

     * @throws InitializationException in case of an initialization problem

     */

    public XStream(ReflectionProvider reflectionProvider) {

        this(reflectionProvider, (Mapper)null, new XppDriver());

    }

    /**

     * Constructs an XStream with a special {@link HierarchicalStreamDriver}. The instance will

     * tries to determine the best match for the {@link ReflectionProvider} on its own.

     *

     * @throws InitializationException in case of an initialization problem

     */

    public XStream(HierarchicalStreamDriver hierarchicalStreamDriver) {

        this(null, (Mapper)null, hierarchicalStreamDriver);

    }

    /**

     * Constructs an XStream with a special {@link HierarchicalStreamDriver} and

     * {@link ReflectionProvider}.

     *

     * @throws InitializationException in case of an initialization problem

     */

    public XStream(

        ReflectionProvider reflectionProvider, HierarchicalStreamDriver hierarchicalStreamDriver) {

        this(reflectionProvider, (Mapper)null, hierarchicalStreamDriver);

    }

    /**

     * Constructs an XStream with a special {@link HierarchicalStreamDriver} and

     * {@link ReflectionProvider} and additionally with a prepared {@link Mapper}.

     *

     * @throws InitializationException in case of an initialization problem

     * @deprecated As of 1.3, use

     *             {@link #XStream(ReflectionProvider, HierarchicalStreamDriver, ClassLoader, Mapper)}

     *             instead

     */

    public XStream(

        ReflectionProvider reflectionProvider, Mapper mapper, HierarchicalStreamDriver driver) {

        this(

            reflectionProvider, driver, new ClassLoaderReference(new CompositeClassLoader()),

            mapper, new DefaultConverterLookup(), null);

    }

    /**

     * Constructs an XStream with a special {@link HierarchicalStreamDriver} and

     * {@link ReflectionProvider} and additionally with a prepared {@link ClassLoader} to use.

     *

     * @throws InitializationException in case of an initialization problem

     * @since 1.3

     */

    public XStream(

        ReflectionProvider reflectionProvider, HierarchicalStreamDriver driver,

        ClassLoader classLoader) {

        this(reflectionProvider, driver, classLoader, null);

    }

    /**

     * Constructs an XStream with a special {@link HierarchicalStreamDriver} and

     * {@link ReflectionProvider} and additionally with a prepared {@link Mapper} and the

     * {@link ClassLoader} in use.

     * <p>

     * Note, if the class loader should be changed later again, you should provide a

     * {@link ClassLoaderReference} as {@link ClassLoader} that is also use in the

     * {@link Mapper} chain.

     * </p>

     *

     * @throws InitializationException in case of an initialization problem

     * @since 1.3

     */

    public XStream(

        ReflectionProvider reflectionProvider, HierarchicalStreamDriver driver,

        ClassLoader classLoader, Mapper mapper) {

        this(

            reflectionProvider, driver, classLoader, mapper, new DefaultConverterLookup(), null);

    }

    /**

     * Constructs an XStream with a special {@link HierarchicalStreamDriver},

     * {@link ReflectionProvider}, a prepared {@link Mapper} and the {@link ClassLoader} in use

     * and an own {@link ConverterRegistry}.

     * <p>

     * Note, if the class loader should be changed later again, you should provide a

     * {@link ClassLoaderReference} as {@link ClassLoader} that is also use in the

     * {@link Mapper} chain.

     * </p>

     *

     * @throws InitializationException in case of an initialization problem

     * @since 1.3

     */

    public XStream(

        ReflectionProvider reflectionProvider, HierarchicalStreamDriver driver,

        ClassLoader classLoader, Mapper mapper, ConverterLookup converterLookup,

        ConverterRegistry converterRegistry) {

        jvm = new JVM();

        if (reflectionProvider == null) {

            reflectionProvider = jvm.bestReflectionProvider();

        }

        this.reflectionProvider = reflectionProvider;

        this.hierarchicalStreamDriver = driver;

        this.classLoaderReference = classLoader instanceof ClassLoaderReference

            ? (ClassLoaderReference)classLoader

            : new ClassLoaderReference(classLoader);

        this.converterLookup = converterLookup;

        this.converterRegistry = converterRegistry != null

            ? converterRegistry

            : (converterLookup instanceof ConverterRegistry

                ? (ConverterRegistry)converterLookup

                : null);

        this.mapper = mapper == null ? buildMapper() : mapper;

        setupMappers();

        setupAliases();

        setupDefaultImplementations();

        setupConverters();

        setupImmutableTypes();

        setMode(XPATH_RELATIVE_REFERENCES);

    }

    private Mapper buildMapper() {

        Mapper mapper = new DefaultMapper(classLoaderReference);

        if (useXStream11XmlFriendlyMapper()) {

            mapper = new XStream11XmlFriendlyMapper(mapper);

        }

        mapper = new DynamicProxyMapper(mapper);

        mapper = new PackageAliasingMapper(mapper);

        mapper = new ClassAliasingMapper(mapper);

        mapper = new FieldAliasingMapper(mapper);

        mapper = new AttributeAliasingMapper(mapper);

        mapper = new SystemAttributeAliasingMapper(mapper);

        mapper = new ImplicitCollectionMapper(mapper);

        mapper = new OuterClassMapper(mapper);

        mapper = new ArrayMapper(mapper);

        mapper = new DefaultImplementationsMapper(mapper);

        mapper = new AttributeMapper(mapper, converterLookup, reflectionProvider);

        if (JVM.is15()) {

            mapper = buildMapperDynamically(

                "com.thoughtworks.xstream.mapper.EnumMapper", new Class[]{Mapper.class},

                new Object[]{mapper});

        }

        mapper = new LocalConversionMapper(mapper);

        mapper = new ImmutableTypesMapper(mapper);

        if (JVM.is15()) {

            mapper = buildMapperDynamically(ANNOTATION_MAPPER_TYPE, new Class[]{

                Mapper.class, ConverterRegistry.class, ClassLoader.class,

                ReflectionProvider.class, JVM.class}, new Object[]{

                mapper, converterLookup, classLoaderReference, reflectionProvider, jvm});

        }

        mapper = wrapMapper((MapperWrapper)mapper);

        mapper = new CachingMapper(mapper);

        return mapper;

    }

    private Mapper buildMapperDynamically(String className, Class[] constructorParamTypes,

        Object[] constructorParamValues) {

        try {

            Class type = Class.forName(className, false, classLoaderReference.getReference());

            Constructor constructor = type.getConstructor(constructorParamTypes);

            return (Mapper)constructor.newInstance(constructorParamValues);

        } catch (Exception e) {

            throw new com.thoughtworks.xstream.InitializationException(

                "Could not instantiate mapper : " + className, e);

        }

    }

    protected MapperWrapper wrapMapper(MapperWrapper next) {

        return next;

    }

    protected boolean useXStream11XmlFriendlyMapper() {

        return false;

    }

    private void setupMappers() {

        packageAliasingMapper = (PackageAliasingMapper)this.mapper

            .lookupMapperOfType(PackageAliasingMapper.class);

        classAliasingMapper = (ClassAliasingMapper)this.mapper

            .lookupMapperOfType(ClassAliasingMapper.class);

        fieldAliasingMapper = (FieldAliasingMapper)this.mapper

            .lookupMapperOfType(FieldAliasingMapper.class);

        attributeMapper = (AttributeMapper)this.mapper

            .lookupMapperOfType(AttributeMapper.class);

        attributeAliasingMapper = (AttributeAliasingMapper)this.mapper

            .lookupMapperOfType(AttributeAliasingMapper.class);

        systemAttributeAliasingMapper = (SystemAttributeAliasingMapper)this.mapper

            .lookupMapperOfType(SystemAttributeAliasingMapper.class);

        implicitCollectionMapper = (ImplicitCollectionMapper)this.mapper

            .lookupMapperOfType(ImplicitCollectionMapper.class);

        defaultImplementationsMapper = (DefaultImplementationsMapper)this.mapper

            .lookupMapperOfType(DefaultImplementationsMapper.class);

        immutableTypesMapper = (ImmutableTypesMapper)this.mapper

            .lookupMapperOfType(ImmutableTypesMapper.class);

        localConversionMapper = (LocalConversionMapper)this.mapper

            .lookupMapperOfType(LocalConversionMapper.class);

        annotationConfiguration = (AnnotationConfiguration)this.mapper

            .lookupMapperOfType(AnnotationConfiguration.class);

    }

    protected void setupAliases() {

        if (classAliasingMapper == null) {

            return;

        }

        alias("null", Mapper.Null.class);

        alias("int", Integer.class);

        alias("float", Float.class);

        alias("double", Double.class);

        alias("long", Long.class);

        alias("short", Short.class);

        alias("char", Character.class);

        alias("byte", Byte.class);

        alias("boolean", Boolean.class);

        alias("number", Number.class);

        alias("object", Object.class);

        alias("big-int", BigInteger.class);

        alias("big-decimal", BigDecimal.class);

        alias("string-buffer", StringBuffer.class);

        alias("string", String.class);

        alias("java-class", Class.class);

        alias("method", Method.class);

        alias("constructor", Constructor.class);

        alias("field", Field.class);

        alias("date", Date.class);

        alias("uri", URI.class);

        alias("url", URL.class);

        alias("bit-set", BitSet.class);

        alias("map", Map.class);

        alias("entry", Map.Entry.class);

        alias("properties", Properties.class);

        alias("list", List.class);

        alias("set", Set.class);

        alias("sorted-set", SortedSet.class);

        alias("linked-list", LinkedList.class);

        alias("vector", Vector.class);

        alias("tree-map", TreeMap.class);

        alias("tree-set", TreeSet.class);

        alias("hashtable", Hashtable.class);

        if (jvm.supportsAWT()) {

            // Instantiating these two classes starts the AWT system, which is undesirable.

            // Calling loadClass ensures a reference to the class is found but they are not

            // instantiated.

            alias("awt-color", jvm.loadClass("java.awt.Color"));

            alias("awt-font", jvm.loadClass("java.awt.Font"));

            alias("awt-text-attribute", jvm.loadClass("java.awt.font.TextAttribute"));

        }

        if (jvm.supportsSQL()) {

            alias("sql-timestamp", jvm.loadClass("java.sql.Timestamp"));

            alias("sql-time", jvm.loadClass("java.sql.Time"));

            alias("sql-date", jvm.loadClass("java.sql.Date"));

        }

        alias("file", File.class);

        alias("locale", Locale.class);

        alias("gregorian-calendar", Calendar.class);

        if (JVM.is14()) {

            aliasDynamically("auth-subject", "javax.security.auth.Subject");

            alias("linked-hash-map", jvm.loadClass("java.util.LinkedHashMap"));

            alias("linked-hash-set", jvm.loadClass("java.util.LinkedHashSet"));

            alias("trace", jvm.loadClass("java.lang.StackTraceElement"));

            alias("currency", jvm.loadClass("java.util.Currency"));

            aliasType("charset", jvm.loadClass("java.nio.charset.Charset"));

        }

        if (JVM.is15()) {

            aliasDynamically("duration", "javax.xml.datatype.Duration");

            alias("enum-set", jvm.loadClass("java.util.EnumSet"));

            alias("enum-map", jvm.loadClass("java.util.EnumMap"));

            alias("string-builder", jvm.loadClass("java.lang.StringBuilder"));

            alias("uuid", jvm.loadClass("java.util.UUID"));

        }

    }

    private void aliasDynamically(String alias, String className) {

        Class type = jvm.loadClass(className);

        if (type != null) {

            alias(alias, type);

        }

    }

    protected void setupDefaultImplementations() {

        if (defaultImplementationsMapper == null) {

            return;

        }

        addDefaultImplementation(HashMap.class, Map.class);

        addDefaultImplementation(ArrayList.class, List.class);

        addDefaultImplementation(HashSet.class, Set.class);

        addDefaultImplementation(TreeSet.class, SortedSet.class);

        addDefaultImplementation(GregorianCalendar.class, Calendar.class);

    }

    protected void setupConverters() {

        final ReflectionConverter reflectionConverter = new ReflectionConverter(

            mapper, reflectionProvider);

        registerConverter(reflectionConverter, PRIORITY_VERY_LOW);

        registerConverter(

            new SerializableConverter(mapper, reflectionProvider, classLoaderReference), PRIORITY_LOW);

        registerConverter(new ExternalizableConverter(mapper, classLoaderReference), PRIORITY_LOW);

        registerConverter(new NullConverter(), PRIORITY_VERY_HIGH);

        registerConverter(new IntConverter(), PRIORITY_NORMAL);

        registerConverter(new FloatConverter(), PRIORITY_NORMAL);

        registerConverter(new DoubleConverter(), PRIORITY_NORMAL);

        registerConverter(new LongConverter(), PRIORITY_NORMAL);

        registerConverter(new ShortConverter(), PRIORITY_NORMAL);

        registerConverter((Converter)new CharConverter(), PRIORITY_NORMAL);

        registerConverter(new BooleanConverter(), PRIORITY_NORMAL);

        registerConverter(new ByteConverter(), PRIORITY_NORMAL);

        registerConverter(new StringConverter(), PRIORITY_NORMAL);

        registerConverter(new StringBufferConverter(), PRIORITY_NORMAL);

        registerConverter(new DateConverter(), PRIORITY_NORMAL);

        registerConverter(new BitSetConverter(), PRIORITY_NORMAL);

        registerConverter(new URIConverter(), PRIORITY_NORMAL);

        registerConverter(new URLConverter(), PRIORITY_NORMAL);

        registerConverter(new BigIntegerConverter(), PRIORITY_NORMAL);

        registerConverter(new BigDecimalConverter(), PRIORITY_NORMAL);

        registerConverter(new ArrayConverter(mapper), PRIORITY_NORMAL);

        registerConverter(new CharArrayConverter(), PRIORITY_NORMAL);

        registerConverter(new CollectionConverter(mapper), PRIORITY_NORMAL);

        registerConverter(new MapConverter(mapper), PRIORITY_NORMAL);

        registerConverter(new TreeMapConverter(mapper), PRIORITY_NORMAL);

        registerConverter(new TreeSetConverter(mapper), PRIORITY_NORMAL);

        registerConverter(new PropertiesConverter(), PRIORITY_NORMAL);

        registerConverter((Converter)new EncodedByteArrayConverter(), PRIORITY_NORMAL);

        registerConverter(new FileConverter(), PRIORITY_NORMAL);

        if (jvm.supportsSQL()) {

            registerConverter(new SqlTimestampConverter(), PRIORITY_NORMAL);

            registerConverter(new SqlTimeConverter(), PRIORITY_NORMAL);

            registerConverter(new SqlDateConverter(), PRIORITY_NORMAL);

        }

        registerConverter(

            new DynamicProxyConverter(mapper, classLoaderReference), PRIORITY_NORMAL);

        registerConverter(new JavaClassConverter(classLoaderReference), PRIORITY_NORMAL);

        registerConverter(new JavaMethodConverter(classLoaderReference), PRIORITY_NORMAL);

        registerConverter(new JavaFieldConverter(classLoaderReference), PRIORITY_NORMAL);

        if (jvm.supportsAWT()) {

            registerConverter(new FontConverter(), PRIORITY_NORMAL);

            registerConverter(new ColorConverter(), PRIORITY_NORMAL);

            registerConverter(new TextAttributeConverter(), PRIORITY_NORMAL);

        }

        if (jvm.supportsSwing()) {

            registerConverter(

                new LookAndFeelConverter(mapper, reflectionProvider), PRIORITY_NORMAL);

        }

        registerConverter(new LocaleConverter(), PRIORITY_NORMAL);

        registerConverter(new GregorianCalendarConverter(), PRIORITY_NORMAL);

        if (JVM.is14()) {

            // late bound converters - allows XStream to be compiled on earlier JDKs

            registerConverterDynamically(

                "com.thoughtworks.xstream.converters.extended.SubjectConverter",

                PRIORITY_NORMAL, new Class[]{Mapper.class}, new Object[]{mapper});

            registerConverterDynamically(

                "com.thoughtworks.xstream.converters.extended.ThrowableConverter",

                PRIORITY_NORMAL, new Class[]{Converter.class},

                new Object[]{reflectionConverter});

            registerConverterDynamically(

                "com.thoughtworks.xstream.converters.extended.StackTraceElementConverter",

                PRIORITY_NORMAL, null, null);

            registerConverterDynamically(

                "com.thoughtworks.xstream.converters.extended.CurrencyConverter",

                PRIORITY_NORMAL, null, null);

            registerConverterDynamically(

                "com.thoughtworks.xstream.converters.extended.RegexPatternConverter",

                PRIORITY_NORMAL, new Class[]{Converter.class},

                new Object[]{reflectionConverter});

            registerConverterDynamically(

                "com.thoughtworks.xstream.converters.extended.CharsetConverter",

                PRIORITY_NORMAL, null, null);

        }

        if (JVM.is15()) {

            // late bound converters - allows XStream to be compiled on earlier JDKs

            if (jvm.loadClass("javax.xml.datatype.Duration") != null) {

                registerConverterDynamically(

                    "com.thoughtworks.xstream.converters.extended.DurationConverter",

                    PRIORITY_NORMAL, null, null);

            }

            registerConverterDynamically(

                "com.thoughtworks.xstream.converters.enums.EnumConverter", PRIORITY_NORMAL,

                null, null);

            registerConverterDynamically(

                "com.thoughtworks.xstream.converters.enums.EnumSetConverter", PRIORITY_NORMAL,

                new Class[]{Mapper.class}, new Object[]{mapper});

            registerConverterDynamically(

                "com.thoughtworks.xstream.converters.enums.EnumMapConverter", PRIORITY_NORMAL,

                new Class[]{Mapper.class}, new Object[]{mapper});

            registerConverterDynamically(

                "com.thoughtworks.xstream.converters.basic.StringBuilderConverter",

                PRIORITY_NORMAL, null, null);

            registerConverterDynamically(

                "com.thoughtworks.xstream.converters.basic.UUIDConverter", PRIORITY_NORMAL,

                null, null);

        }

        registerConverter(

            new SelfStreamingInstanceChecker(reflectionConverter, this), PRIORITY_NORMAL);

    }

    private void registerConverterDynamically(String className, int priority,

        Class[] constructorParamTypes, Object[] constructorParamValues) {

        try {

            Class type = Class.forName(className, false, classLoaderReference.getReference());

            Constructor constructor = type.getConstructor(constructorParamTypes);

            Object instance = constructor.newInstance(constructorParamValues);

            if (instance instanceof Converter) {

                registerConverter((Converter)instance, priority);

            } else if (instance instanceof SingleValueConverter) {

                registerConverter((SingleValueConverter)instance, priority);

            }

        } catch (Exception e) {

            throw new com.thoughtworks.xstream.InitializationException(

                "Could not instantiate converter : " + className, e);

        }

    }

    protected void setupImmutableTypes() {

        if (immutableTypesMapper == null) {

            return;

        }

        // primitives are always immutable

        addImmutableType(boolean.class);

        addImmutableType(Boolean.class);

        addImmutableType(byte.class);

        addImmutableType(Byte.class);

        addImmutableType(char.class);

        addImmutableType(Character.class);

        addImmutableType(double.class);

        addImmutableType(Double.class);

        addImmutableType(float.class);

        addImmutableType(Float.class);

        addImmutableType(int.class);

        addImmutableType(Integer.class);

        addImmutableType(long.class);

        addImmutableType(Long.class);

        addImmutableType(short.class);

        addImmutableType(Short.class);

        // additional types

        addImmutableType(Mapper.Null.class);

        addImmutableType(BigDecimal.class);

        addImmutableType(BigInteger.class);

        addImmutableType(String.class);

        addImmutableType(URI.class);

        addImmutableType(URL.class);

        addImmutableType(File.class);

        addImmutableType(Class.class);

        if (jvm.supportsAWT()) {

            addImmutableTypeDynamically("java.awt.font.TextAttribute");

        }

        if (JVM.is14()) {

            // late bound types - allows XStream to be compiled on earlier JDKs

            addImmutableTypeDynamically("java.nio.charset.Charset");

            addImmutableTypeDynamically("java.util.Currency");

        }

    }

    private void addImmutableTypeDynamically(String className) {

        Class type = jvm.loadClass(className);

        if (type != null) {

            addImmutableType(type);

        }

    }

    public void setMarshallingStrategy(MarshallingStrategy marshallingStrategy) {

        this.marshallingStrategy = marshallingStrategy;

    }

    /**

     * Serialize an object to a pretty-printed XML String.

     *

     * @throws XStreamException if the object cannot be serialized

     */

    public String toXML(Object obj) {

        Writer writer = new StringWriter();

        toXML(obj, writer);

        return writer.toString();

    }

    /**

     * Serialize an object to the given Writer as pretty-printed XML. The Writer will be flushed

     * afterwards and in case of an exception.

     *

     * @throws XStreamException if the object cannot be serialized

     */

    public void toXML(Object obj, Writer out) {

        HierarchicalStreamWriter writer = hierarchicalStreamDriver.createWriter(out);

        try {

            marshal(obj, writer);

        } finally {

            writer.flush();

        }

    }

    /**

     * Serialize an object to the given OutputStream as pretty-printed XML. The OutputStream

     * will be flushed afterwards and in case of an exception.

     *

     * @throws XStreamException if the object cannot be serialized

     */

    public void toXML(Object obj, OutputStream out) {

        HierarchicalStreamWriter writer = hierarchicalStreamDriver.createWriter(out);

        try {

            marshal(obj, writer);

        } finally {

            writer.flush();

        }

    }

    /**

     * Serialize and object to a hierarchical data structure (such as XML).

     *

     * @throws XStreamException if the object cannot be serialized

     */

    public void marshal(Object obj, HierarchicalStreamWriter writer) {

        marshal(obj, writer, null);

    }

    /**

     * Serialize and object to a hierarchical data structure (such as XML).

     *

     * @param dataHolder Extra data you can use to pass to your converters. Use this as you

     *            want. If not present, XStream shall create one lazily as needed.

     * @throws XStreamException if the object cannot be serialized

     */

    public void marshal(Object obj, HierarchicalStreamWriter writer, DataHolder dataHolder) {

        marshallingStrategy.marshal(writer, obj, converterLookup, mapper, dataHolder);

    }

    /**

     * Deserialize an object from an XML String.

     *

     * @throws XStreamException if the object cannot be deserialized

     */

    public Object fromXML(String xml) {

        return fromXML(new StringReader(xml));

    }

    /**

     * Deserialize an object from an XML Reader.

     *

     * @throws XStreamException if the object cannot be deserialized

     */

    public Object fromXML(Reader reader) {

        return unmarshal(hierarchicalStreamDriver.createReader(reader), null);

    }

    /**

     * Deserialize an object from an XML InputStream.

     *

     * @throws XStreamException if the object cannot be deserialized

     */

    public Object fromXML(InputStream input) {

        return unmarshal(hierarchicalStreamDriver.createReader(input), null);

    }

    /**

     * Deserialize an object from a URL.

     *

     * Depending on the parser implementation, some might take the file path as SystemId to

     * resolve additional references.

     *

     * @throws XStreamException if the object cannot be deserialized

     * @since 1.4

     */

    public Object fromXML(URL url) {

        return unmarshal(hierarchicalStreamDriver.createReader(url), null);

    }

    /**

     * Deserialize an object from a file.

     *

     * Depending on the parser implementation, some might take the file path as SystemId to

     * resolve additional references.

     *

     * @throws XStreamException if the object cannot be deserialized

     * @since 1.4

     */

    public Object fromXML(File file) {

        return unmarshal(hierarchicalStreamDriver.createReader(file), null);

    }

    /**

     * Deserialize an object from an XML String, populating the fields of the given root object

     * instead of instantiating a new one. Note, that this is a special use case! With the

     * ReflectionConverter XStream will write directly into the raw memory area of the existing

     * object. Use with care!

     *

     * @throws XStreamException if the object cannot be deserialized

     */

    public Object fromXML(String xml, Object root) {

        return fromXML(new StringReader(xml), root);

    }

    /**

     * Deserialize an object from an XML Reader, populating the fields of the given root object

     * instead of instantiating a new one. Note, that this is a special use case! With the

     * ReflectionConverter XStream will write directly into the raw memory area of the existing

     * object. Use with care!

     *

     * @throws XStreamException if the object cannot be deserialized

     */

    public Object fromXML(Reader xml, Object root) {

        return unmarshal(hierarchicalStreamDriver.createReader(xml), root);

    }

    /**

     * Deserialize an object from a URL, populating the fields of the given root

     * object instead of instantiating a new one. Note, that this is a special use case! With

     * the ReflectionConverter XStream will write directly into the raw memory area of the

     * existing object. Use with care!

     *

     * Depending on the parser implementation, some might take the file path as SystemId to

     * resolve additional references.

     *

     * @throws XStreamException if the object cannot be deserialized

     * @since 1.4

     */

    public Object fromXML(URL url, Object root) {

        return unmarshal(hierarchicalStreamDriver.createReader(url), root);

    }

    /**

     * Deserialize an object from a file, populating the fields of the given root

     * object instead of instantiating a new one. Note, that this is a special use case! With

     * the ReflectionConverter XStream will write directly into the raw memory area of the

     * existing object. Use with care!

     *

     * Depending on the parser implementation, some might take the file path as SystemId to

     * resolve additional references.

     *

     * @throws XStreamException if the object cannot be deserialized

     * @since 1.4

     */

    public Object fromXML(File file, Object root) {

        return unmarshal(hierarchicalStreamDriver.createReader(file), root);

    }

    /**

     * Deserialize an object from an XML InputStream, populating the fields of the given root

     * object instead of instantiating a new one. Note, that this is a special use case! With

     * the ReflectionConverter XStream will write directly into the raw memory area of the

     * existing object. Use with care!

     *

     * @throws XStreamException if the object cannot be deserialized

     */

    public Object fromXML(InputStream input, Object root) {

        return unmarshal(hierarchicalStreamDriver.createReader(input), root);

    }

    /**

     * Deserialize an object from a hierarchical data structure (such as XML).

     *

     * @throws XStreamException if the object cannot be deserialized

     */

    public Object unmarshal(HierarchicalStreamReader reader) {

        return unmarshal(reader, null, null);

    }

    /**

     * Deserialize an object from a hierarchical data structure (such as XML), populating the

     * fields of the given root object instead of instantiating a new one. Note, that this is a

     * special use case! With the ReflectionConverter XStream will write directly into the raw

     * memory area of the existing object. Use with care!

     *

     * @throws XStreamException if the object cannot be deserialized

     */

    public Object unmarshal(HierarchicalStreamReader reader, Object root) {

        return unmarshal(reader, root, null);

    }

    /**

     * Deserialize an object from a hierarchical data structure (such as XML).

     *

     * @param root If present, the passed in object will have its fields populated, as opposed

     *            to XStream creating a new instance. Note, that this is a special use case!

     *            With the ReflectionConverter XStream will write directly into the raw memory

     *            area of the existing object. Use with care!

     * @param dataHolder Extra data you can use to pass to your converters. Use this as you

     *            want. If not present, XStream shall create one lazily as needed.

     * @throws XStreamException if the object cannot be deserialized

     */

    public Object unmarshal(HierarchicalStreamReader reader, Object root, DataHolder dataHolder) {

        try {

            return marshallingStrategy.unmarshal(

                root, reader, dataHolder, converterLookup, mapper);

        } catch (ConversionException e) {

            Package pkg = getClass().getPackage();

            e.add("version", pkg != null ? pkg.getImplementationVersion() : "not available");

            throw e;

        }

    }

    /**

     * Alias a Class to a shorter name to be used in XML elements.

     *

     * @param name Short name

     * @param type Type to be aliased

     * @throws InitializationException if no {@link ClassAliasingMapper} is available

     */

    public void alias(String name, Class type) {

        if (classAliasingMapper == null) {

            throw new com.thoughtworks.xstream.InitializationException("No "

                + ClassAliasingMapper.class.getName()

                + " available");

        }

        classAliasingMapper.addClassAlias(name, type);

    }

    /**

     * Alias a type to a shorter name to be used in XML elements. Any class that is assignable

     * to this type will be aliased to the same name.

     *

     * @param name Short name

     * @param type Type to be aliased

     * @since 1.2

     * @throws InitializationException if no {@link ClassAliasingMapper} is available

     */

    public void aliasType(String name, Class type) {

        if (classAliasingMapper == null) {

            throw new com.thoughtworks.xstream.InitializationException("No "

                + ClassAliasingMapper.class.getName()

                + " available");

        }

        classAliasingMapper.addTypeAlias(name, type);

    }

    /**

     * Alias a Class to a shorter name to be used in XML elements.

     *

     * @param name Short name

     * @param type Type to be aliased

     * @param defaultImplementation Default implementation of type to use if no other specified.

     * @throws InitializationException if no {@link DefaultImplementationsMapper} or no

     *             {@link ClassAliasingMapper} is available

     */

    public void alias(String name, Class type, Class defaultImplementation) {

        alias(name, type);

        addDefaultImplementation(defaultImplementation, type);

    }

    /**

     * Alias a package to a shorter name to be used in XML elements.

     *

     * @param name Short name

     * @param pkgName package to be aliased

     * @throws InitializationException if no {@link DefaultImplementationsMapper} or no

     *             {@link PackageAliasingMapper} is available

     * @since 1.3.1

     */

    public void aliasPackage(String name, String pkgName) {

        if (packageAliasingMapper == null) {

            throw new com.thoughtworks.xstream.InitializationException("No "

                + PackageAliasingMapper.class.getName()

                + " available");

        }

        packageAliasingMapper.addPackageAlias(name, pkgName);

    }

    /**

     * Create an alias for a field name.

     *

     * @param alias the alias itself

     * @param definedIn the type that declares the field

     * @param fieldName the name of the field

     * @throws InitializationException if no {@link FieldAliasingMapper} is available

     */

    public void aliasField(String alias, Class definedIn, String fieldName) {

        if (fieldAliasingMapper == null) {

            throw new com.thoughtworks.xstream.InitializationException("No "

                + FieldAliasingMapper.class.getName()

                + " available");

        }

        fieldAliasingMapper.addFieldAlias(alias, definedIn, fieldName);

    }

    /**

     * Create an alias for an attribute

     *

     * @param alias the alias itself

     * @param attributeName the name of the attribute

     * @throws InitializationException if no {@link AttributeAliasingMapper} is available

     */

    public void aliasAttribute(String alias, String attributeName) {

        if (attributeAliasingMapper == null) {

            throw new com.thoughtworks.xstream.InitializationException("No "

                + AttributeAliasingMapper.class.getName()

                + " available");

        }

        attributeAliasingMapper.addAliasFor(attributeName, alias);

    }

    /**

     * Create an alias for a system attribute. XStream will not write a system attribute if its

     * alias is set to <code>null</code>. However, this is not reversible, i.e. deserialization

     * of the result is likely to fail afterwards and will not produce an object equal to the

     * originally written one.

     *

     * @param alias the alias itself (may be <code>null</code>)

     * @param systemAttributeName the name of the system attribute

     * @throws InitializationException if no {@link SystemAttributeAliasingMapper} is available