// =================== DO NOT EDIT THIS FILE ====================
// Generated by Modello 2.3.0,
// any modifications will be overwritten.
// ==============================================================

package org.codehaus.modello.test.features.io.stax;

  //---------------------------------/
 //- Imported classes and packages -/
//---------------------------------/

import java.io.ByteArrayInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.text.DateFormat;
import java.text.ParsePosition;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.xml.XMLConstants;
import javax.xml.stream.*;
import org.codehaus.modello.test.features.Action;
import org.codehaus.modello.test.features.AnnotationTest;
import org.codehaus.modello.test.features.ArrayFeatures;
import org.codehaus.modello.test.features.AssociationFeatures;
import org.codehaus.modello.test.features.BaseClass;
import org.codehaus.modello.test.features.BidiInList;
import org.codehaus.modello.test.features.BidiInSet;
import org.codehaus.modello.test.features.Bidirectional;
import org.codehaus.modello.test.features.ContentTest;
import org.codehaus.modello.test.features.DueTo;
import org.codehaus.modello.test.features.Features;
import org.codehaus.modello.test.features.File;
import org.codehaus.modello.test.features.InterfacesFeature;
import org.codehaus.modello.test.features.JavaFeatures;
import org.codehaus.modello.test.features.NodeItem;
import org.codehaus.modello.test.features.Reference;
import org.codehaus.modello.test.features.SimpleInterface;
import org.codehaus.modello.test.features.SimpleTypes;
import org.codehaus.modello.test.features.SubClassLevel1;
import org.codehaus.modello.test.features.SubClassLevel2;
import org.codehaus.modello.test.features.SubClassLevel3;
import org.codehaus.modello.test.features.SubInterface;
import org.codehaus.modello.test.features.SuperThing;
import org.codehaus.modello.test.features.Thing;
import org.codehaus.modello.test.features.Thingy;
import org.codehaus.modello.test.features.XdocFeatures;
import org.codehaus.modello.test.features.XmlAttributes;
import org.codehaus.modello.test.features.XmlContent;
import org.codehaus.modello.test.features.XmlContentLong;
import org.codehaus.modello.test.features.XmlContentLongWithAttributes;
import org.codehaus.modello.test.features.XmlFeatures;
import org.codehaus.modello.test.features.XmlFieldsOrder;
import org.codehaus.modello.test.features.XmlFieldsOrderParent;
import org.codehaus.modello.test.features.XmlFieldsOrderParent2;
import org.codehaus.modello.test.features.XmlTransientFields;
import org.codehaus.modello.test.features.XsdFeatures;
import org.codehaus.modello.test.features.other.PackageNameFeature;
import org.codehaus.modello.test.features.other.SubInterfaceInPackage;
import org.codehaus.plexus.util.xml.Xpp3Dom;

/**
 * Class ModelloFeaturesTestStaxReader.
 * 
 * @version $Revision$ $Date$
 */
@SuppressWarnings( "all" )
public class ModelloFeaturesTestStaxReader
{

      //-----------/
     //- Methods -/
    //-----------/

    /**
     * Method determineVersion.
     * 
     * @param reader a reader object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return String
     */
    public String determineVersion( Reader reader )
        throws IOException, XMLStreamException
    {
        XMLStreamReader xmlStreamReader = XMLInputFactory.newInstance().createXMLStreamReader( reader );
        while ( xmlStreamReader.hasNext() )
        {
            int eventType = xmlStreamReader.next();
            if ( eventType == XMLStreamConstants.START_ELEMENT )
            {
                return getVersionFromField( xmlStreamReader );
            }
        }
        throw new XMLStreamException( "Version not found in document", xmlStreamReader.getLocation() );
    } //-- String determineVersion( Reader )

    /**
     * Method getVersionFromField.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @throws XMLStreamException XMLStreamException if any.
     * @return String
     */
    private String getVersionFromField( XMLStreamReader xmlStreamReader )
        throws XMLStreamException
    {
        int depth = 0;
        while ( depth >= 0 )
        {
            int eventType = xmlStreamReader.next();
            if ( eventType == XMLStreamConstants.START_ELEMENT )
            {
                if ( depth == 0 && "versionField".equals( xmlStreamReader.getLocalName() ) )
                {
                    return xmlStreamReader.getElementText();
                }
                depth++;
            }
            if ( eventType == XMLStreamConstants.END_ELEMENT )
            {
                depth--;
            }
        }
        throw new XMLStreamException( "Field: 'versionField' does not exist in the document.", xmlStreamReader.getLocation() );
    } //-- String getVersionFromField( XMLStreamReader )

    /**
     * Method read.
     * 
     * @param reader a reader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return Features
     */
    public Features read( Reader reader, boolean strict )
        throws IOException, XMLStreamException
    {
        XMLStreamReader xmlStreamReader = XMLInputFactory.newInstance().createXMLStreamReader( reader );

        return read( xmlStreamReader, strict );
    } //-- Features read( Reader, boolean )

    /**
     * Method read.
     * 
     * @param reader a reader object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return Features
     */
    public Features read( Reader reader )
        throws IOException, XMLStreamException
    {
        return read( reader, true );
    } //-- Features read( Reader )

    /**
     * Method read.
     * 
     * @param stream a stream object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return Features
     */
    public Features read( InputStream stream, boolean strict )
        throws IOException, XMLStreamException
    {
        XMLStreamReader xmlStreamReader = XMLInputFactory.newInstance().createXMLStreamReader( stream );

        return read( xmlStreamReader, strict );
    } //-- Features read( InputStream, boolean )

    /**
     * Method read.
     * 
     * @param stream a stream object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return Features
     */
    public Features read( InputStream stream )
        throws IOException, XMLStreamException
    {
        return read( stream, true );
    } //-- Features read( InputStream )

    /**
     * Method read.
     * 
     * @param filePath a filePath object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return Features
     */
    public Features read( String filePath, boolean strict )
        throws IOException, XMLStreamException
    {
        java.io.File file = new java.io.File( filePath );
        XMLStreamReader xmlStreamReader = XMLInputFactory.newInstance().createXMLStreamReader( file.toURI().toURL().toExternalForm(), new FileInputStream( file ) );

        return read( xmlStreamReader, strict );
    } //-- Features read( String, boolean )

    /**
     * Method read.
     * 
     * @param filePath a filePath object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return Features
     */
    public Features read( String filePath )
        throws IOException, XMLStreamException
    {
        return read( filePath, true );
    } //-- Features read( String )

    /**
     * Method buildDom.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param trim a trim object.
     * @throws XMLStreamException XMLStreamException if any.
     * @return Xpp3Dom
     */
    private Xpp3Dom buildDom( XMLStreamReader xmlStreamReader, boolean trim )
        throws XMLStreamException
    {
        java.util.Stack elements = new java.util.Stack();
        java.util.Stack values = new java.util.Stack();
        int eventType = xmlStreamReader.getEventType();
        boolean spacePreserve = false;
        while ( xmlStreamReader.hasNext() )
        {
            if ( eventType == XMLStreamConstants.START_ELEMENT )
            {
                spacePreserve = false;
                String rawName = xmlStreamReader.getLocalName();
                Xpp3Dom element = new Xpp3Dom( rawName );
                if ( !elements.empty() )
                {
                    Xpp3Dom parent = (Xpp3Dom) elements.peek();
                    parent.addChild( element );
                }
                elements.push( element );
                if ( xmlStreamReader.isEndElement() )
                {
                    values.push( null );
                }
                else
                {
                    values.push( new StringBuilder() );
                }
                int attributesSize = xmlStreamReader.getAttributeCount();
                for ( int i = 0; i < attributesSize; i++ )
                {
                    String prefix = xmlStreamReader.getAttributePrefix( i );
                    String localName = xmlStreamReader.getAttributeLocalName( i );
                    String value = xmlStreamReader.getAttributeValue( i );
                    if ( XMLConstants.DEFAULT_NS_PREFIX.equals( xmlStreamReader.getAttributeName( i ).getPrefix() ) )
                    {
                        element.setAttribute( localName, value );
                    }
                    else
                    {
                        element.setAttribute( prefix + ':'+ localName , value );
                    }
                    spacePreserve = spacePreserve || ( "xml".equals( prefix ) && "space".equals( localName ) && "preserve".equals( value ) );
                }
            }
            else if ( eventType == XMLStreamConstants.CHARACTERS )
            {
                StringBuilder valueBuffer = (StringBuilder) values.peek();
                String text = xmlStreamReader.getText();
                if ( trim && !spacePreserve )
                {
                    text = text.trim();
                }
                valueBuffer.append( text );
            }
            else if ( eventType == XMLStreamConstants.END_ELEMENT )
            {
                Xpp3Dom element = (Xpp3Dom) elements.pop();
                // this Object could be null if it is a singleton tag
                Object accumulatedValue = values.pop();
                if ( element.getChildCount() == 0 )
                {
                    element.setValue( ( accumulatedValue == null ) ? null : accumulatedValue.toString() );
                }
                if ( values.empty() )
                {
                    return element;
                }
            }
            eventType = xmlStreamReader.next();
        }
        throw new IllegalStateException( "End of document found before returning to 0 depth" );
    } //-- Xpp3Dom buildDom( XMLStreamReader, boolean )

    /**
     * Method checkFieldWithDuplicate.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param parsed a parsed object.
     * @param alias a alias object.
     * @param tagName a tagName object.
     * @throws XMLStreamException XMLStreamException if any.
     * @return boolean
     */
    private boolean checkFieldWithDuplicate( XMLStreamReader xmlStreamReader, String tagName, String alias, java.util.Set parsed )
        throws XMLStreamException
    {
        if ( !( xmlStreamReader.getLocalName().equals( tagName ) || xmlStreamReader.getLocalName().equals( alias ) ) )
        {
            return false;
        }
        if ( !parsed.add( tagName ) )
        {
            throw new XMLStreamException( "Duplicated tag: '" + tagName + "'", xmlStreamReader.getLocation() );
        }
        return true;
    } //-- boolean checkFieldWithDuplicate( XMLStreamReader, String, String, java.util.Set )

    /**
     * Method checkUnknownElement.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws XMLStreamException XMLStreamException if any.
     */
    private void checkUnknownElement( XMLStreamReader xmlStreamReader, boolean strict )
        throws XMLStreamException
    {
        if ( strict )
        {
            throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
        }
        int unrecognizedTagCount = 1;
        while( unrecognizedTagCount != 0 )
        {
            xmlStreamReader.next();
            if ( xmlStreamReader.getEventType() == XMLStreamConstants.START_ELEMENT )
            {
                unrecognizedTagCount++;
            }
            else if ( xmlStreamReader.getEventType() == XMLStreamConstants.END_ELEMENT )
            {
                unrecognizedTagCount--;
            }
        }
    } //-- void checkUnknownElement( XMLStreamReader, boolean )

    /**
     * Method getBooleanValue.
     * 
     * @param s a s object.
     * @param xmlStreamReader a xmlStreamReader object.
     * @param attribute a attribute object.
     * @throws XMLStreamException XMLStreamException if any.
     * @return boolean
     */
    private boolean getBooleanValue( String s, String attribute, XMLStreamReader xmlStreamReader )
        throws XMLStreamException
    {
        if ( s != null )
        {
            return Boolean.valueOf( s ).booleanValue();
        }
        return false;
    } //-- boolean getBooleanValue( String, String, XMLStreamReader )

    /**
     * Method getByteValue.
     * 
     * @param s a s object.
     * @param strict a strict object.
     * @param xmlStreamReader a xmlStreamReader object.
     * @param attribute a attribute object.
     * @throws XMLStreamException XMLStreamException if any.
     * @return byte
     */
    private byte getByteValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
        throws XMLStreamException
    {
        if ( s != null )
        {
            try
            {
                return Byte.valueOf( s ).byteValue();
            }
            catch ( NumberFormatException nfe )
            {
                if ( strict )
                {
                    throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a byte but was '" + s + "'", xmlStreamReader.getLocation(), nfe );
                }
            }
        }
        return 0;
    } //-- byte getByteValue( String, String, XMLStreamReader, boolean )

    /**
     * Method getCharacterValue.
     * 
     * @param s a s object.
     * @param xmlStreamReader a xmlStreamReader object.
     * @param attribute a attribute object.
     * @throws XMLStreamException XMLStreamException if any.
     * @return char
     */
    private char getCharacterValue( String s, String attribute, XMLStreamReader xmlStreamReader )
        throws XMLStreamException
    {
        if ( s != null )
        {
            return s.charAt( 0 );
        }
        return 0;
    } //-- char getCharacterValue( String, String, XMLStreamReader )

    /**
     * Method getDateValue.
     * 
     * @param s a s object.
     * @param xmlStreamReader a xmlStreamReader object.
     * @param dateFormat a dateFormat object.
     * @param attribute a attribute object.
     * @throws XMLStreamException XMLStreamException if any.
     * @return Date
     */
    private java.util.Date getDateValue( String s, String attribute, String dateFormat, XMLStreamReader xmlStreamReader )
        throws XMLStreamException
    {
        if ( s != null )
        {
            String effectiveDateFormat = dateFormat;
            if ( dateFormat == null )
            {
                effectiveDateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSS";
            }
            if ( "long".equals( effectiveDateFormat ) )
            {
                try
                {
                    return new java.util.Date( Long.parseLong( s ) );
                }
                catch ( NumberFormatException e )
                {
                    throw new XMLStreamException( e.getMessage(), xmlStreamReader.getLocation(), e );
                }
            }
            else
            {
                try
                {
                    DateFormat dateParser = new java.text.SimpleDateFormat( effectiveDateFormat, java.util.Locale.US );
                    return dateParser.parse( s );
                }
                catch ( java.text.ParseException e )
                {
                    throw new XMLStreamException( e.getMessage(), xmlStreamReader.getLocation(), e );
                }
            }
        }
        return null;
    } //-- java.util.Date getDateValue( String, String, String, XMLStreamReader )

    /**
     * Method getDefaultValue.
     * 
     * @param s a s object.
     * @param v a v object.
     * @return String
     */
    private String getDefaultValue( String s, String v )
    {
        if ( s == null )
        {
            s = v;
        }
        return s;
    } //-- String getDefaultValue( String, String )

    /**
     * Method getDoubleValue.
     * 
     * @param s a s object.
     * @param strict a strict object.
     * @param xmlStreamReader a xmlStreamReader object.
     * @param attribute a attribute object.
     * @throws XMLStreamException XMLStreamException if any.
     * @return double
     */
    private double getDoubleValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
        throws XMLStreamException
    {
        if ( s != null )
        {
            try
            {
                return Double.valueOf( s ).doubleValue();
            }
            catch ( NumberFormatException nfe )
            {
                if ( strict )
                {
                    throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a floating point number but was '" + s + "'", xmlStreamReader.getLocation(), nfe );
                }
            }
        }
        return 0;
    } //-- double getDoubleValue( String, String, XMLStreamReader, boolean )

    /**
     * Method getFloatValue.
     * 
     * @param s a s object.
     * @param strict a strict object.
     * @param xmlStreamReader a xmlStreamReader object.
     * @param attribute a attribute object.
     * @throws XMLStreamException XMLStreamException if any.
     * @return float
     */
    private float getFloatValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
        throws XMLStreamException
    {
        if ( s != null )
        {
            try
            {
                return Float.valueOf( s ).floatValue();
            }
            catch ( NumberFormatException nfe )
            {
                if ( strict )
                {
                    throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a floating point number but was '" + s + "'", xmlStreamReader.getLocation(), nfe );
                }
            }
        }
        return 0;
    } //-- float getFloatValue( String, String, XMLStreamReader, boolean )

    /**
     * Method getIntegerValue.
     * 
     * @param s a s object.
     * @param strict a strict object.
     * @param xmlStreamReader a xmlStreamReader object.
     * @param attribute a attribute object.
     * @throws XMLStreamException XMLStreamException if any.
     * @return int
     */
    private int getIntegerValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
        throws XMLStreamException
    {
        if ( s != null )
        {
            try
            {
                return Integer.valueOf( s ).intValue();
            }
            catch ( NumberFormatException nfe )
            {
                if ( strict )
                {
                    throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be an integer but was '" + s + "'", xmlStreamReader.getLocation(), nfe );
                }
            }
        }
        return 0;
    } //-- int getIntegerValue( String, String, XMLStreamReader, boolean )

    /**
     * Method getLongValue.
     * 
     * @param s a s object.
     * @param strict a strict object.
     * @param xmlStreamReader a xmlStreamReader object.
     * @param attribute a attribute object.
     * @throws XMLStreamException XMLStreamException if any.
     * @return long
     */
    private long getLongValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
        throws XMLStreamException
    {
        if ( s != null )
        {
            try
            {
                return Long.valueOf( s ).longValue();
            }
            catch ( NumberFormatException nfe )
            {
                if ( strict )
                {
                    throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a long integer but was '" + s + "'", xmlStreamReader.getLocation(), nfe );
                }
            }
        }
        return 0;
    } //-- long getLongValue( String, String, XMLStreamReader, boolean )

    /**
     * Method getRequiredAttributeValue.
     * 
     * @param s a s object.
     * @param strict a strict object.
     * @param xmlStreamReader a xmlStreamReader object.
     * @param attribute a attribute object.
     * @throws XMLStreamException XMLStreamException if any.
     * @return String
     */
    private String getRequiredAttributeValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
        throws XMLStreamException
    {
        if ( s == null )
        {
            if ( strict )
            {
                throw new XMLStreamException( "Missing required value for attribute '" + attribute + "'", xmlStreamReader.getLocation() );
            }
        }
        return s;
    } //-- String getRequiredAttributeValue( String, String, XMLStreamReader, boolean )

    /**
     * Method getShortValue.
     * 
     * @param s a s object.
     * @param strict a strict object.
     * @param xmlStreamReader a xmlStreamReader object.
     * @param attribute a attribute object.
     * @throws XMLStreamException XMLStreamException if any.
     * @return short
     */
    private short getShortValue( String s, String attribute, XMLStreamReader xmlStreamReader, boolean strict )
        throws XMLStreamException
    {
        if ( s != null )
        {
            try
            {
                return Short.valueOf( s ).shortValue();
            }
            catch ( NumberFormatException nfe )
            {
                if ( strict )
                {
                    throw new XMLStreamException( "Unable to parse element '" + attribute + "', must be a short integer but was '" + s + "'", xmlStreamReader.getLocation(), nfe );
                }
            }
        }
        return 0;
    } //-- short getShortValue( String, String, XMLStreamReader, boolean )

    /**
     * Method getTrimmedValue.
     * 
     * @param s a s object.
     * @return String
     */
    private String getTrimmedValue( String s )
    {
        if ( s != null )
        {
            s = s.trim();
        }
        return s;
    } //-- String getTrimmedValue( String )

    /**
     * Method nextTag.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @throws XMLStreamException XMLStreamException if any.
     * @return int
     */
    private int nextTag( XMLStreamReader xmlStreamReader )
        throws XMLStreamException
    {
        while ( true )
        {
            int eventType = xmlStreamReader.next();
            switch ( eventType )
            {
                case XMLStreamConstants.CHARACTERS:
                case XMLStreamConstants.CDATA:
                case XMLStreamConstants.SPACE:
                case XMLStreamConstants.PROCESSING_INSTRUCTION:
                case XMLStreamConstants.COMMENT:
                    break;
                case XMLStreamConstants.START_ELEMENT:
                case XMLStreamConstants.END_ELEMENT:
                    return eventType;
                default:
                    throw new XMLStreamException( "expected start or end tag", xmlStreamReader.getLocation() );
            }
        }
    } //-- int nextTag( XMLStreamReader )

    /**
     * Method parseAction.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return Action
     */
    private Action parseAction( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        Action action = new Action();
        action.setDev( getTrimmedValue( xmlStreamReader.getAttributeValue( null, "dev" ) ) );
        action.setAction( getTrimmedValue( xmlStreamReader.getElementText() ) );
        return action;
    } //-- Action parseAction( XMLStreamReader, boolean )

    /**
     * Method parseAnnotationTest.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return AnnotationTest
     */
    private AnnotationTest parseAnnotationTest( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        AnnotationTest annotationTest = new AnnotationTest();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "anyField", null, parsed ) )
            {
                annotationTest.setAnyField( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return annotationTest;
    } //-- AnnotationTest parseAnnotationTest( XMLStreamReader, boolean )

    /**
     * Method parseArrayFeatures.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return ArrayFeatures
     */
    private ArrayFeatures parseArrayFeatures( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        ArrayFeatures arrayFeatures = new ArrayFeatures();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            checkUnknownElement( xmlStreamReader, strict );
        }
        return arrayFeatures;
    } //-- ArrayFeatures parseArrayFeatures( XMLStreamReader, boolean )

    /**
     * Method parseAssociationFeatures.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return AssociationFeatures
     */
    private AssociationFeatures parseAssociationFeatures( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        AssociationFeatures associationFeatures = new AssociationFeatures();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "listReferences", null, parsed ) )
            {
                java.util.List listReferences = new java.util.ArrayList/*<Reference>*/();
                associationFeatures.setListReferences( listReferences );
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    if ( "listReference".equals( xmlStreamReader.getLocalName() ) )
                    {
                        associationFeatures.addListReference( parseReference( xmlStreamReader, strict ) );
                    }
                    else
                    {
                        throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
                    }
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "setReferences", null, parsed ) )
            {
                java.util.Set setReferences = new java.util.HashSet/*<Reference>*/();
                associationFeatures.setSetReferences( setReferences );
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    if ( "setReference".equals( xmlStreamReader.getLocalName() ) )
                    {
                        associationFeatures.addSetReference( parseReference( xmlStreamReader, strict ) );
                    }
                    else
                    {
                        throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
                    }
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "listStrings", null, parsed ) )
            {
                java.util.List listStrings = new java.util.ArrayList/*<String>*/();
                associationFeatures.setListStrings( listStrings );
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    if ( "listString".equals( xmlStreamReader.getLocalName() ) )
                    {
                        listStrings.add( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "new java.util.ArrayList/*<String>*/()" ) ) );
                    }
                    else
                    {
                        throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
                    }
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "setStrings", null, parsed ) )
            {
                java.util.Set setStrings = new java.util.HashSet/*<String>*/();
                associationFeatures.setSetStrings( setStrings );
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    if ( "setString".equals( xmlStreamReader.getLocalName() ) )
                    {
                        setStrings.add( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "new java.util.HashSet/*<String>*/()" ) ) );
                    }
                    else
                    {
                        throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
                    }
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "properties", null, parsed ) )
            {
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    String key = xmlStreamReader.getLocalName();
                    String value = xmlStreamReader.getElementText().trim();
                    associationFeatures.addProperty( key, value );
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "bidi", null, parsed ) )
            {
                associationFeatures.setBidi( parseBidirectional( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "listOfBidis", null, parsed ) )
            {
                java.util.List listOfBidis = new java.util.ArrayList/*<BidiInList>*/();
                associationFeatures.setListOfBidis( listOfBidis );
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    if ( "listOfBidi".equals( xmlStreamReader.getLocalName() ) )
                    {
                        associationFeatures.addListOfBidi( parseBidiInList( xmlStreamReader, strict ) );
                    }
                    else
                    {
                        throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
                    }
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "setOfBidis", null, parsed ) )
            {
                java.util.Set setOfBidis = new java.util.HashSet/*<BidiInSet>*/();
                associationFeatures.setSetOfBidis( setOfBidis );
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    if ( "setOfBidi".equals( xmlStreamReader.getLocalName() ) )
                    {
                        associationFeatures.addSetOfBidi( parseBidiInSet( xmlStreamReader, strict ) );
                    }
                    else
                    {
                        throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
                    }
                }
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return associationFeatures;
    } //-- AssociationFeatures parseAssociationFeatures( XMLStreamReader, boolean )

    /**
     * Method parseBaseClass.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return BaseClass
     */
    private BaseClass parseBaseClass( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        BaseClass baseClass = new BaseClass();
        java.util.Set parsed = new java.util.HashSet();
        baseClass.setBaseAttribute( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "baseAttribute" ), "0" ) ), "baseAttribute", xmlStreamReader, strict ) );
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "baseElement", null, parsed ) )
            {
                baseClass.setBaseElement( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "baseElement", xmlStreamReader, strict ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return baseClass;
    } //-- BaseClass parseBaseClass( XMLStreamReader, boolean )

    /**
     * Method parseBidiInList.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return BidiInList
     */
    private BidiInList parseBidiInList( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        BidiInList bidiInList = new BidiInList();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "parent", null, parsed ) )
            {
                bidiInList.setParent( parseAssociationFeatures( xmlStreamReader, strict ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return bidiInList;
    } //-- BidiInList parseBidiInList( XMLStreamReader, boolean )

    /**
     * Method parseBidiInSet.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return BidiInSet
     */
    private BidiInSet parseBidiInSet( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        BidiInSet bidiInSet = new BidiInSet();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "parent", null, parsed ) )
            {
                bidiInSet.setParent( parseAssociationFeatures( xmlStreamReader, strict ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return bidiInSet;
    } //-- BidiInSet parseBidiInSet( XMLStreamReader, boolean )

    /**
     * Method parseBidirectional.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return Bidirectional
     */
    private Bidirectional parseBidirectional( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        Bidirectional bidirectional = new Bidirectional();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "parent", null, parsed ) )
            {
                bidirectional.setParent( parseAssociationFeatures( xmlStreamReader, strict ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return bidirectional;
    } //-- Bidirectional parseBidirectional( XMLStreamReader, boolean )

    /**
     * Method parseContentTest.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return ContentTest
     */
    private ContentTest parseContentTest( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        ContentTest contentTest = new ContentTest();
        contentTest.setAttr( getTrimmedValue( xmlStreamReader.getAttributeValue( null, "attr" ) ) );
        contentTest.setAttr2( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "attr2" ), "0" ) ), "attr2", xmlStreamReader, strict ) );
        contentTest.setContent( getTrimmedValue( xmlStreamReader.getElementText() ) );
        return contentTest;
    } //-- ContentTest parseContentTest( XMLStreamReader, boolean )

    /**
     * Method parseDueTo.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return DueTo
     */
    private DueTo parseDueTo( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        DueTo dueTo = new DueTo();
        java.util.Set parsed = new java.util.HashSet();
        dueTo.setName( getTrimmedValue( xmlStreamReader.getAttributeValue( null, "name" ) ) );
        dueTo.setEmail( getTrimmedValue( xmlStreamReader.getAttributeValue( null, "email" ) ) );
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            checkUnknownElement( xmlStreamReader, strict );
        }
        return dueTo;
    } //-- DueTo parseDueTo( XMLStreamReader, boolean )

    /**
     * Method parseFeatures.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return Features
     */
    private Features parseFeatures( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        Features features = new Features();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "versionField", null, parsed ) )
            {
                features.setVersionField( getTrimmedValue( xmlStreamReader.getElementText() ) );
                String modelVersion = features.getVersionField();
                // legacy hack for pomVersion == 3
                if ( "3".equals( modelVersion ) )
                {
                    modelVersion = "3.0.0";
                }
                if ( !"1.0.0".equals( modelVersion ) )
                {
                    throw new XMLStreamException( "Document model version of '" + modelVersion + "' doesn't match reader version of '1.0.0'", xmlStreamReader.getLocation() );
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "comment", null, parsed ) )
            {
                features.setComment( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "description", null, parsed ) )
            {
                features.setDescription( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "required", null, parsed ) )
            {
                features.setRequired( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "identifier", null, parsed ) )
            {
                features.setIdentifier( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "identifierPart2", null, parsed ) )
            {
                features.setIdentifierPart2( parseReference( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "simpleTypes", null, parsed ) )
            {
                features.setSimpleTypes( parseSimpleTypes( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "defaultValues", null, parsed ) )
            {
                features.setDefaultValues( parseSimpleTypes( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "arrays", null, parsed ) )
            {
                features.setArrays( parseArrayFeatures( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "associationFeatures", null, parsed ) )
            {
                features.setAssociationFeatures( parseAssociationFeatures( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "javaFeatures", null, parsed ) )
            {
                features.setJavaFeatures( parseJavaFeatures( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "xmlFeatures", null, parsed ) )
            {
                features.setXmlFeatures( parseXmlFeatures( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "xdocFeatures", null, parsed ) )
            {
                features.setXdocFeatures( parseXdocFeatures( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "node", null, parsed ) )
            {
                features.setNode( parseNodeItem( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "cloneable", null, parsed ) )
            {
                features.setCloneable( parseThing( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "file", null, parsed ) )
            {
                features.setFile( parseFile( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "action", null, parsed ) )
            {
                features.setAction( parseAction( xmlStreamReader, strict ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return features;
    } //-- Features parseFeatures( XMLStreamReader, boolean )

    /**
     * Method parseFile.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return File
     */
    private File parseFile( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        File file = new File();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "file", null, parsed ) )
            {
                file.setFile( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return file;
    } //-- File parseFile( XMLStreamReader, boolean )

    /**
     * Method parseInterfacesFeature.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return InterfacesFeature
     */
    private InterfacesFeature parseInterfacesFeature( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        InterfacesFeature interfacesFeature = new InterfacesFeature();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "id", null, parsed ) )
            {
                interfacesFeature.setId( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return interfacesFeature;
    } //-- InterfacesFeature parseInterfacesFeature( XMLStreamReader, boolean )

    /**
     * Method parseJavaFeatures.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return JavaFeatures
     */
    private JavaFeatures parseJavaFeatures( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        JavaFeatures javaFeatures = new JavaFeatures();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "interfaces", null, parsed ) )
            {
                javaFeatures.setInterfaces( parseInterfacesFeature( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "packageName", null, parsed ) )
            {
                javaFeatures.setPackageName( parsePackageNameFeature( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "base", null, parsed ) )
            {
                javaFeatures.setBase( parseBaseClass( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "subClass", null, parsed ) )
            {
                javaFeatures.setSubClass( parseSubClassLevel1( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "subClass2", null, parsed ) )
            {
                javaFeatures.setSubClass2( parseSubClassLevel2( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "subClass3", null, parsed ) )
            {
                javaFeatures.setSubClass3( parseSubClassLevel3( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "annotation", null, parsed ) )
            {
                javaFeatures.setAnnotation( parseAnnotationTest( xmlStreamReader, strict ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return javaFeatures;
    } //-- JavaFeatures parseJavaFeatures( XMLStreamReader, boolean )

    /**
     * Method parseNodeItem.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return NodeItem
     */
    private NodeItem parseNodeItem( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        NodeItem nodeItem = new NodeItem();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "value", null, parsed ) )
            {
                nodeItem.setValue( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "child", null, parsed ) )
            {
                nodeItem.setChild( parseNodeItem( xmlStreamReader, strict ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return nodeItem;
    } //-- NodeItem parseNodeItem( XMLStreamReader, boolean )

    /**
     * Method parsePackageNameFeature.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return PackageNameFeature
     */
    private PackageNameFeature parsePackageNameFeature( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        PackageNameFeature packageNameFeature = new PackageNameFeature();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "reference", null, parsed ) )
            {
                packageNameFeature.setReference( parseReference( xmlStreamReader, strict ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return packageNameFeature;
    } //-- PackageNameFeature parsePackageNameFeature( XMLStreamReader, boolean )

    /**
     * Method parseReference.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return Reference
     */
    private Reference parseReference( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        Reference reference = new Reference();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "id", "key", parsed ) )
            {
                reference.setId( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return reference;
    } //-- Reference parseReference( XMLStreamReader, boolean )

    /**
     * Method parseSimpleTypes.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return SimpleTypes
     */
    private SimpleTypes parseSimpleTypes( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        SimpleTypes simpleTypes = new SimpleTypes();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "primitiveBoolean", null, parsed ) )
            {
                simpleTypes.setPrimitiveBoolean( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "true" ) ), "primitiveBoolean", xmlStreamReader ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "primitiveChar", null, parsed ) )
            {
                simpleTypes.setPrimitiveChar( getCharacterValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "H" ) ), "primitiveChar", xmlStreamReader ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "primitiveByte", null, parsed ) )
            {
                simpleTypes.setPrimitiveByte( getByteValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "12" ) ), "primitiveByte", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "primitiveShort", null, parsed ) )
            {
                simpleTypes.setPrimitiveShort( getShortValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "1212" ) ), "primitiveShort", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "primitiveInt", null, parsed ) )
            {
                simpleTypes.setPrimitiveInt( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "121212" ) ), "primitiveInt", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "primitiveLong", null, parsed ) )
            {
                simpleTypes.setPrimitiveLong( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "1234567890123" ) ), "primitiveLong", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "primitiveFloat", null, parsed ) )
            {
                simpleTypes.setPrimitiveFloat( getFloatValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "12.12" ) ), "primitiveFloat", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "primitiveDouble", null, parsed ) )
            {
                simpleTypes.setPrimitiveDouble( getDoubleValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "12.12" ) ), "primitiveDouble", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "objectString", null, parsed ) )
            {
                simpleTypes.setObjectString( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "default value" ) ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "objectDate", null, parsed ) )
            {
                String dateFormat = null;
                simpleTypes.setObjectDate( getDateValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "2012-12-24T22:12:12.012" ) ), "objectDate", dateFormat, xmlStreamReader ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "primitiveBooleanNoDefault", null, parsed ) )
            {
                simpleTypes.setPrimitiveBooleanNoDefault( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "primitiveBooleanNoDefault", xmlStreamReader ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "primitiveCharNoDefault", null, parsed ) )
            {
                simpleTypes.setPrimitiveCharNoDefault( getCharacterValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "" ) ), "primitiveCharNoDefault", xmlStreamReader ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "primitiveByteNoDefault", null, parsed ) )
            {
                simpleTypes.setPrimitiveByteNoDefault( getByteValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "primitiveByteNoDefault", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "primitiveShortNoDefault", null, parsed ) )
            {
                simpleTypes.setPrimitiveShortNoDefault( getShortValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "primitiveShortNoDefault", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "primitiveIntNoDefault", null, parsed ) )
            {
                simpleTypes.setPrimitiveIntNoDefault( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "primitiveIntNoDefault", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "primitiveLongNoDefault", null, parsed ) )
            {
                simpleTypes.setPrimitiveLongNoDefault( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "primitiveLongNoDefault", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "primitiveFloatNoDefault", null, parsed ) )
            {
                simpleTypes.setPrimitiveFloatNoDefault( getFloatValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0.0" ) ), "primitiveFloatNoDefault", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "primitiveDoubleNoDefault", null, parsed ) )
            {
                simpleTypes.setPrimitiveDoubleNoDefault( getDoubleValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0.0" ) ), "primitiveDoubleNoDefault", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "objectStringNoDefault", null, parsed ) )
            {
                simpleTypes.setObjectStringNoDefault( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "objectDateNoDefault", null, parsed ) )
            {
                String dateFormat = null;
                simpleTypes.setObjectDateNoDefault( getDateValue( getTrimmedValue( xmlStreamReader.getElementText() ), "objectDateNoDefault", dateFormat, xmlStreamReader ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "dom", null, parsed ) )
            {
                simpleTypes.setDom( buildDom( xmlStreamReader, true ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "content", null, parsed ) )
            {
                simpleTypes.setContent( parseContentTest( xmlStreamReader, strict ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return simpleTypes;
    } //-- SimpleTypes parseSimpleTypes( XMLStreamReader, boolean )

    /**
     * Method parseSubClassLevel1.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return SubClassLevel1
     */
    private SubClassLevel1 parseSubClassLevel1( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        SubClassLevel1 subClassLevel1 = new SubClassLevel1();
        java.util.Set parsed = new java.util.HashSet();
        subClassLevel1.setSubAttribute1( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "subAttribute1" ), "0" ) ), "subAttribute1", xmlStreamReader, strict ) );
        subClassLevel1.setBaseAttribute( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "baseAttribute" ), "0" ) ), "baseAttribute", xmlStreamReader, strict ) );
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "subElement1", null, parsed ) )
            {
                subClassLevel1.setSubElement1( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "subElement1", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "baseElement", null, parsed ) )
            {
                subClassLevel1.setBaseElement( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "baseElement", xmlStreamReader, strict ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return subClassLevel1;
    } //-- SubClassLevel1 parseSubClassLevel1( XMLStreamReader, boolean )

    /**
     * Method parseSubClassLevel2.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return SubClassLevel2
     */
    private SubClassLevel2 parseSubClassLevel2( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        SubClassLevel2 subClassLevel2 = new SubClassLevel2();
        java.util.Set parsed = new java.util.HashSet();
        subClassLevel2.setSubAttribute2( getFloatValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "subAttribute2" ), "0.0" ) ), "subAttribute2", xmlStreamReader, strict ) );
        subClassLevel2.setSubAttribute1( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "subAttribute1" ), "0" ) ), "subAttribute1", xmlStreamReader, strict ) );
        subClassLevel2.setBaseAttribute( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "baseAttribute" ), "0" ) ), "baseAttribute", xmlStreamReader, strict ) );
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "subElement2", null, parsed ) )
            {
                subClassLevel2.setSubElement2( getFloatValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0.0" ) ), "subElement2", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "subElement1", null, parsed ) )
            {
                subClassLevel2.setSubElement1( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "subElement1", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "baseElement", null, parsed ) )
            {
                subClassLevel2.setBaseElement( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "baseElement", xmlStreamReader, strict ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return subClassLevel2;
    } //-- SubClassLevel2 parseSubClassLevel2( XMLStreamReader, boolean )

    /**
     * Method parseSubClassLevel3.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return SubClassLevel3
     */
    private SubClassLevel3 parseSubClassLevel3( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        SubClassLevel3 subClassLevel3 = new SubClassLevel3();
        java.util.Set parsed = new java.util.HashSet();
        subClassLevel3.setSubAttribute3( getDoubleValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "subAttribute3" ), "0.0" ) ), "subAttribute3", xmlStreamReader, strict ) );
        subClassLevel3.setSubAttribute2( getFloatValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "subAttribute2" ), "0.0" ) ), "subAttribute2", xmlStreamReader, strict ) );
        subClassLevel3.setSubAttribute1( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "subAttribute1" ), "0" ) ), "subAttribute1", xmlStreamReader, strict ) );
        subClassLevel3.setBaseAttribute( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "baseAttribute" ), "0" ) ), "baseAttribute", xmlStreamReader, strict ) );
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "subElement3", null, parsed ) )
            {
                subClassLevel3.setSubElement3( getDoubleValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0.0" ) ), "subElement3", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "subElement2", null, parsed ) )
            {
                subClassLevel3.setSubElement2( getFloatValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0.0" ) ), "subElement2", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "subElement1", null, parsed ) )
            {
                subClassLevel3.setSubElement1( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "subElement1", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "baseElement", null, parsed ) )
            {
                subClassLevel3.setBaseElement( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "baseElement", xmlStreamReader, strict ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return subClassLevel3;
    } //-- SubClassLevel3 parseSubClassLevel3( XMLStreamReader, boolean )

    /**
     * Method parseSuperThing.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return SuperThing
     */
    private SuperThing parseSuperThing( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        SuperThing superThing = new SuperThing();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            checkUnknownElement( xmlStreamReader, strict );
        }
        return superThing;
    } //-- SuperThing parseSuperThing( XMLStreamReader, boolean )

    /**
     * Method parseThing.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return Thing
     */
    private Thing parseThing( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        Thing thing = new Thing();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "someBoolean", null, parsed ) )
            {
                thing.setSomeBoolean( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "false" ) ), "someBoolean", xmlStreamReader ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "someChar", null, parsed ) )
            {
                thing.setSomeChar( getCharacterValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "" ) ), "someChar", xmlStreamReader ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "someByte", null, parsed ) )
            {
                thing.setSomeByte( getByteValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "someByte", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "someShort", null, parsed ) )
            {
                thing.setSomeShort( getShortValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "someShort", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "someInt", null, parsed ) )
            {
                thing.setSomeInt( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "someInt", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "someLong", null, parsed ) )
            {
                thing.setSomeLong( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0" ) ), "someLong", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "someFloat", null, parsed ) )
            {
                thing.setSomeFloat( getFloatValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0.0" ) ), "someFloat", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "someDouble", null, parsed ) )
            {
                thing.setSomeDouble( getDoubleValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "0.0" ) ), "someDouble", xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "someString", null, parsed ) )
            {
                thing.setSomeString( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "someDate", null, parsed ) )
            {
                String dateFormat = null;
                thing.setSomeDate( getDateValue( getTrimmedValue( xmlStreamReader.getElementText() ), "someDate", dateFormat, xmlStreamReader ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "someDom", null, parsed ) )
            {
                thing.setSomeDom( buildDom( xmlStreamReader, true ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "someProperties", null, parsed ) )
            {
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    String key = xmlStreamReader.getLocalName();
                    String value = xmlStreamReader.getElementText().trim();
                    thing.addSomeProperty( key, value );
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "someStringList", null, parsed ) )
            {
                java.util.List someStringList = new java.util.ArrayList/*<String>*/();
                thing.setSomeStringList( someStringList );
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    if ( "someStringList".equals( xmlStreamReader.getLocalName() ) )
                    {
                        someStringList.add( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "new java.util.ArrayList/*<String>*/()" ) ) );
                    }
                    else
                    {
                        throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
                    }
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "someStringSet", null, parsed ) )
            {
                java.util.Set someStringSet = new java.util.HashSet/*<String>*/();
                thing.setSomeStringSet( someStringSet );
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    if ( "someStringSet".equals( xmlStreamReader.getLocalName() ) )
                    {
                        someStringSet.add( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "new java.util.HashSet/*<String>*/()" ) ) );
                    }
                    else
                    {
                        throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
                    }
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "deepThingy", null, parsed ) )
            {
                thing.setDeepThingy( parseThingy( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "deepThingyList", null, parsed ) )
            {
                java.util.List deepThingyList = new java.util.ArrayList/*<Thingy>*/();
                thing.setDeepThingyList( deepThingyList );
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    if ( "deepThingyList".equals( xmlStreamReader.getLocalName() ) )
                    {
                        thing.addDeepThingyList( parseThingy( xmlStreamReader, strict ) );
                    }
                    else
                    {
                        throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
                    }
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "deepThingySet", null, parsed ) )
            {
                java.util.Set deepThingySet = new java.util.HashSet/*<Thingy>*/();
                thing.setDeepThingySet( deepThingySet );
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    if ( "deepThingySet".equals( xmlStreamReader.getLocalName() ) )
                    {
                        thing.addDeepThingySet( parseThingy( xmlStreamReader, strict ) );
                    }
                    else
                    {
                        throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
                    }
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "shallowThingy", null, parsed ) )
            {
                thing.setShallowThingy( parseThingy( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "shallowThingyList", null, parsed ) )
            {
                java.util.List shallowThingyList = new java.util.ArrayList/*<Thingy>*/();
                thing.setShallowThingyList( shallowThingyList );
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    if ( "shallowThingyList".equals( xmlStreamReader.getLocalName() ) )
                    {
                        thing.addShallowThingyList( parseThingy( xmlStreamReader, strict ) );
                    }
                    else
                    {
                        throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
                    }
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "shallowThingySet", null, parsed ) )
            {
                java.util.Set shallowThingySet = new java.util.HashSet/*<Thingy>*/();
                thing.setShallowThingySet( shallowThingySet );
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    if ( "shallowThingySet".equals( xmlStreamReader.getLocalName() ) )
                    {
                        thing.addShallowThingySet( parseThingy( xmlStreamReader, strict ) );
                    }
                    else
                    {
                        throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
                    }
                }
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return thing;
    } //-- Thing parseThing( XMLStreamReader, boolean )

    /**
     * Method parseThingy.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return Thingy
     */
    private Thingy parseThingy( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        Thingy thingy = new Thingy();
        thingy.setSomeContent( getTrimmedValue( xmlStreamReader.getElementText() ) );
        return thingy;
    } //-- Thingy parseThingy( XMLStreamReader, boolean )

    /**
     * Method parseXdocFeatures.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return XdocFeatures
     */
    private XdocFeatures parseXdocFeatures( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        XdocFeatures xdocFeatures = new XdocFeatures();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "field", null, parsed ) )
            {
                xdocFeatures.setField( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "xdocSeparatorNone", null, parsed ) )
            {
                xdocFeatures.setXdocSeparatorNone( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "xdocSeparatorBlank", null, parsed ) )
            {
                xdocFeatures.setXdocSeparatorBlank( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return xdocFeatures;
    } //-- XdocFeatures parseXdocFeatures( XMLStreamReader, boolean )

    /**
     * Method parseXmlAttributes.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return XmlAttributes
     */
    private XmlAttributes parseXmlAttributes( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        XmlAttributes xmlAttributes = new XmlAttributes();
        java.util.Set parsed = new java.util.HashSet();
        xmlAttributes.setPrimitiveBoolean( getBooleanValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "primitiveBoolean" ), "true" ) ), "primitiveBoolean", xmlStreamReader ) );
        xmlAttributes.setPrimitiveChar( getCharacterValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "primitiveChar" ), "H" ) ), "primitiveChar", xmlStreamReader ) );
        xmlAttributes.setPrimitiveByte( getByteValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "primitiveByte" ), "12" ) ), "primitiveByte", xmlStreamReader, strict ) );
        xmlAttributes.setPrimitiveShort( getShortValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "primitiveShort" ), "1212" ) ), "primitiveShort", xmlStreamReader, strict ) );
        xmlAttributes.setPrimitiveInt( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "primitiveInt" ), "121212" ) ), "primitiveInt", xmlStreamReader, strict ) );
        xmlAttributes.setPrimitiveLong( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "primitiveLong" ), "1234567890123" ) ), "primitiveLong", xmlStreamReader, strict ) );
        xmlAttributes.setPrimitiveFloat( getFloatValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "primitiveFloat" ), "12.12" ) ), "primitiveFloat", xmlStreamReader, strict ) );
        xmlAttributes.setPrimitiveDouble( getDoubleValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "primitiveDouble" ), "12.12" ) ), "primitiveDouble", xmlStreamReader, strict ) );
        xmlAttributes.setObjectString( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "objectString" ), "default value" ) ) );
        String dateFormat = null;
        xmlAttributes.setObjectDate( getDateValue( getTrimmedValue( xmlStreamReader.getAttributeValue( null, "objectDate" ) ), "objectDate", dateFormat, xmlStreamReader ) );
        xmlAttributes.setAttribute( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "tag-name" ), "default" ) ) );
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            checkUnknownElement( xmlStreamReader, strict );
        }
        return xmlAttributes;
    } //-- XmlAttributes parseXmlAttributes( XMLStreamReader, boolean )

    /**
     * Method parseXmlContent.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return XmlContent
     */
    private XmlContent parseXmlContent( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        XmlContent xmlContent = new XmlContent();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "content.long", null, parsed ) )
            {
                xmlContent.setLongContent( parseXmlContentLong( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "content.long-with-attributes", null, parsed ) )
            {
                xmlContent.setLongContentWithAttributes( parseXmlContentLongWithAttributes( xmlStreamReader, strict ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return xmlContent;
    } //-- XmlContent parseXmlContent( XMLStreamReader, boolean )

    /**
     * Method parseXmlContentLong.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return XmlContentLong
     */
    private XmlContentLong parseXmlContentLong( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        XmlContentLong xmlContentLong = new XmlContentLong();
        xmlContentLong.setContent( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "12121212" ) ), "content", xmlStreamReader, strict ) );
        return xmlContentLong;
    } //-- XmlContentLong parseXmlContentLong( XMLStreamReader, boolean )

    /**
     * Method parseXmlContentLongWithAttributes.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return XmlContentLongWithAttributes
     */
    private XmlContentLongWithAttributes parseXmlContentLongWithAttributes( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        XmlContentLongWithAttributes xmlContentLongWithAttributes = new XmlContentLongWithAttributes();
        xmlContentLongWithAttributes.setAttr( getTrimmedValue( xmlStreamReader.getAttributeValue( null, "attr" ) ) );
        xmlContentLongWithAttributes.setAttr2( getIntegerValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getAttributeValue( null, "attr2" ), "0" ) ), "attr2", xmlStreamReader, strict ) );
        xmlContentLongWithAttributes.setContent( getLongValue( getTrimmedValue( getDefaultValue( xmlStreamReader.getElementText(), "12121212" ) ), "content", xmlStreamReader, strict ) );
        return xmlContentLongWithAttributes;
    } //-- XmlContentLongWithAttributes parseXmlContentLongWithAttributes( XMLStreamReader, boolean )

    /**
     * Method parseXmlFeatures.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return XmlFeatures
     */
    private XmlFeatures parseXmlFeatures( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        XmlFeatures xmlFeatures = new XmlFeatures();
        java.util.Set parsed = new java.util.HashSet();
        xmlFeatures.setFieldNameAttribute( getTrimmedValue( xmlStreamReader.getAttributeValue( null, "tag-name.attribute" ) ) );
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "attributes", null, parsed ) )
            {
                xmlFeatures.setAttributes( parseXmlAttributes( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "attributesDefault", null, parsed ) )
            {
                xmlFeatures.setAttributesDefault( parseXmlAttributes( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "content", null, parsed ) )
            {
                xmlFeatures.setContent( parseXmlContent( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "fieldTrim", null, parsed ) )
            {
                xmlFeatures.setFieldTrim( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "fieldNoTrim", null, parsed ) )
            {
                xmlFeatures.setFieldNoTrim( xmlStreamReader.getElementText() );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "dom", null, parsed ) )
            {
                xmlFeatures.setDom( buildDom( xmlStreamReader, true ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "domNoTrim", null, parsed ) )
            {
                xmlFeatures.setDomNoTrim( buildDom( xmlStreamReader, false ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "tag-name", null, parsed ) )
            {
                xmlFeatures.setFieldName( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "dateXmlFormat", null, parsed ) )
            {
                String dateFormat = "yyyy-MM-dd'T'HH:mm:ss";
                xmlFeatures.setDateXmlFormat( getDateValue( getTrimmedValue( xmlStreamReader.getElementText() ), "dateXmlFormat", dateFormat, xmlStreamReader ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "dateLong", null, parsed ) )
            {
                String dateFormat = "long";
                xmlFeatures.setDateLong( getDateValue( getTrimmedValue( xmlStreamReader.getElementText() ), "dateLong", dateFormat, xmlStreamReader ) );
            }
            else if ( "xmlItemsStyleFlat".equals( xmlStreamReader.getLocalName() ) )
            {
                java.util.List xmlItemsStyleFlats = xmlFeatures.getXmlItemsStyleFlats();
                if ( xmlItemsStyleFlats == null )
                {
                    xmlItemsStyleFlats = new java.util.ArrayList/*<Reference>*/();
                    xmlFeatures.setXmlItemsStyleFlats( xmlItemsStyleFlats );
                }
                xmlFeatures.addXmlItemsStyleFlat( parseReference( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "xmlAssociationTagNames", null, parsed ) )
            {
                java.util.List xmlAssociationTagNames = new java.util.ArrayList/*<Reference>*/();
                xmlFeatures.setXmlAssociationTagNames( xmlAssociationTagNames );
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    if ( "association.tag-name".equals( xmlStreamReader.getLocalName() ) )
                    {
                        xmlFeatures.addXmlAssociationTagName( parseReference( xmlStreamReader, strict ) );
                    }
                    else
                    {
                        throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
                    }
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "field.tag-names", null, parsed ) )
            {
                java.util.List xmlTagNameAssociation = new java.util.ArrayList/*<Reference>*/();
                xmlFeatures.setXmlTagNameAssociation( xmlTagNameAssociation );
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    if ( "field.tag-name".equals( xmlStreamReader.getLocalName() ) )
                    {
                        xmlFeatures.addXmlTagNameAssociation( parseReference( xmlStreamReader, strict ) );
                    }
                    else
                    {
                        throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
                    }
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "field.tag-name", null, parsed ) )
            {
                java.util.List xmlTagNameAssociationTagNames = new java.util.ArrayList/*<Reference>*/();
                xmlFeatures.setXmlTagNameAssociationTagNames( xmlTagNameAssociationTagNames );
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    if ( "association.tag-name".equals( xmlStreamReader.getLocalName() ) )
                    {
                        xmlFeatures.addXmlTagNameAssociationTagName( parseReference( xmlStreamReader, strict ) );
                    }
                    else
                    {
                        throw new XMLStreamException( "Unrecognised tag: '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation() );
                    }
                }
            }
            else if ( "association.tag-name".equals( xmlStreamReader.getLocalName() ) )
            {
                java.util.List xmlFlatAssociationTagNames = xmlFeatures.getXmlFlatAssociationTagNames();
                if ( xmlFlatAssociationTagNames == null )
                {
                    xmlFlatAssociationTagNames = new java.util.ArrayList/*<Reference>*/();
                    xmlFeatures.setXmlFlatAssociationTagNames( xmlFlatAssociationTagNames );
                }
                xmlFeatures.addXmlFlatAssociationTagName( parseReference( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "explodeProperties", null, parsed ) )
            {
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    if ( "explodeProperty".equals( xmlStreamReader.getLocalName() ) )
                    {
                        String key = null;
                        String value = null;
                        // explode mode.
                        while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                        {
                            if ( "key".equals( xmlStreamReader.getLocalName() ) )
                            {
                                key = xmlStreamReader.getElementText();
                            }
                            else if ( "value".equals( xmlStreamReader.getLocalName() ) )
                            {
                                value = xmlStreamReader.getElementText().trim();
                            }
                            else
                            {
                                xmlStreamReader.getText();
                            }
                        }
                        xmlFeatures.addExplodeProperty( key, value );
                    }
                    xmlStreamReader.next();
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "inlineProperties", null, parsed ) )
            {
                while ( xmlStreamReader.nextTag() == XMLStreamConstants.START_ELEMENT )
                {
                    String key = xmlStreamReader.getLocalName();
                    String value = xmlStreamReader.getElementText().trim();
                    xmlFeatures.addInlineProperty( key, value );
                }
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "xmlTransientFields", null, parsed ) )
            {
                xmlFeatures.setXmlTransientFields( parseXmlTransientFields( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "xmlFieldsOrder", null, parsed ) )
            {
                xmlFeatures.setXmlFieldsOrder( parseXmlFieldsOrder( xmlStreamReader, strict ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "xsdFeatures", null, parsed ) )
            {
                xmlFeatures.setXsdFeatures( parseXsdFeatures( xmlStreamReader, strict ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return xmlFeatures;
    } //-- XmlFeatures parseXmlFeatures( XMLStreamReader, boolean )

    /**
     * Method parseXmlFieldsOrder.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return XmlFieldsOrder
     */
    private XmlFieldsOrder parseXmlFieldsOrder( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        XmlFieldsOrder xmlFieldsOrder = new XmlFieldsOrder();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "field1", null, parsed ) )
            {
                xmlFieldsOrder.setField1( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "field3", null, parsed ) )
            {
                xmlFieldsOrder.setField3( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "field6", null, parsed ) )
            {
                xmlFieldsOrder.setField6( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "field4", null, parsed ) )
            {
                xmlFieldsOrder.setField4( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "field5", null, parsed ) )
            {
                xmlFieldsOrder.setField5( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "field7", null, parsed ) )
            {
                xmlFieldsOrder.setField7( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "field-2", null, parsed ) )
            {
                xmlFieldsOrder.setField( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return xmlFieldsOrder;
    } //-- XmlFieldsOrder parseXmlFieldsOrder( XMLStreamReader, boolean )

    /**
     * Method parseXmlFieldsOrderParent.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return XmlFieldsOrderParent
     */
    private XmlFieldsOrderParent parseXmlFieldsOrderParent( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        XmlFieldsOrderParent xmlFieldsOrderParent = new XmlFieldsOrderParent();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "field4", null, parsed ) )
            {
                xmlFieldsOrderParent.setField4( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "field5", null, parsed ) )
            {
                xmlFieldsOrderParent.setField5( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "field7", null, parsed ) )
            {
                xmlFieldsOrderParent.setField7( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else if ( checkFieldWithDuplicate( xmlStreamReader, "field-2", null, parsed ) )
            {
                xmlFieldsOrderParent.setField( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return xmlFieldsOrderParent;
    } //-- XmlFieldsOrderParent parseXmlFieldsOrderParent( XMLStreamReader, boolean )

    /**
     * Method parseXmlFieldsOrderParent2.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return XmlFieldsOrderParent2
     */
    private XmlFieldsOrderParent2 parseXmlFieldsOrderParent2( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        XmlFieldsOrderParent2 xmlFieldsOrderParent2 = new XmlFieldsOrderParent2();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "field-2", null, parsed ) )
            {
                xmlFieldsOrderParent2.setField( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return xmlFieldsOrderParent2;
    } //-- XmlFieldsOrderParent2 parseXmlFieldsOrderParent2( XMLStreamReader, boolean )

    /**
     * Method parseXmlTransientFields.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return XmlTransientFields
     */
    private XmlTransientFields parseXmlTransientFields( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        XmlTransientFields xmlTransientFields = new XmlTransientFields();
        java.util.Set parsed = new java.util.HashSet();
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            if ( checkFieldWithDuplicate( xmlStreamReader, "persistentField", null, parsed ) )
            {
                xmlTransientFields.setPersistentField( getTrimmedValue( xmlStreamReader.getElementText() ) );
            }
            else
            {
                checkUnknownElement( xmlStreamReader, strict );
            }
        }
        return xmlTransientFields;
    } //-- XmlTransientFields parseXmlTransientFields( XMLStreamReader, boolean )

    /**
     * Method parseXsdFeatures.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return XsdFeatures
     */
    private XsdFeatures parseXsdFeatures( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        XsdFeatures xsdFeatures = new XsdFeatures();
        java.util.Set parsed = new java.util.HashSet();
        xsdFeatures.setAttribute( getTrimmedValue( xmlStreamReader.getAttributeValue( null, "attribute" ) ) );
        while ( ( strict ? xmlStreamReader.nextTag() : nextTag( xmlStreamReader ) ) == XMLStreamConstants.START_ELEMENT )
        {
            checkUnknownElement( xmlStreamReader, strict );
        }
        return xsdFeatures;
    } //-- XsdFeatures parseXsdFeatures( XMLStreamReader, boolean )

    /**
     * Method read.
     * 
     * @param xmlStreamReader a xmlStreamReader object.
     * @param strict a strict object.
     * @throws IOException IOException if any.
     * @throws XMLStreamException XMLStreamException if any.
     * @return Features
     */
    private Features read( XMLStreamReader xmlStreamReader, boolean strict )
        throws IOException, XMLStreamException
    {
        int eventType = xmlStreamReader.getEventType();
        String encoding = null;
        while ( eventType != XMLStreamConstants.END_DOCUMENT )
        {
            if ( eventType == XMLStreamConstants.START_DOCUMENT )
            {
                encoding = xmlStreamReader.getCharacterEncodingScheme();
            }
            if ( eventType == XMLStreamConstants.START_ELEMENT )
            {
                if ( strict && ! "features-demo".equals( xmlStreamReader.getLocalName() ) )
                {
                    throw new XMLStreamException( "Expected root element 'features-demo' but found '" + xmlStreamReader.getLocalName() + "'", xmlStreamReader.getLocation(), null );
                }
                Features features = parseFeatures( xmlStreamReader, strict );
                features.setModelEncoding( encoding );
                resolveReferences( features );
                return features;
            }
            eventType = xmlStreamReader.next();
        }
        throw new XMLStreamException( "Expected root element 'features-demo' but found no element at all: invalid XML document", xmlStreamReader.getLocation(), null );
    } //-- Features read( XMLStreamReader, boolean )

    /**
     * Method resolveReferences.
     * 
     * @param value a value object.
     */
    private void resolveReferences( Features value )
    {
        java.util.Map refs;
    } //-- void resolveReferences( Features )

}