/**
    * Redistribution and use of this software and associated documentation
    * ("Software"), with or without modification, are permitted provided
    * that the following conditions are met:
    *
    * 1. Redistributions of source code must retain copyright
    *    statements and notices.  Redistributions must also contain a
    *    copy of this document.
    *
   * 2. Redistributions in binary form must reproduce the
   *    above copyright notice, this list of conditions and the
   *    following disclaimer in the documentation and/or other
   *    materials provided with the distribution.
   *
   * 3. The name "Exolab" must not be used to endorse or promote
   *    products derived from this Software without prior written
   *    permission of Intalio, Inc.  For written permission,
   *    please contact info@exolab.org.
   *
   * 4. Products derived from this Software may not be called "Exolab"
   *    nor may "Exolab" appear in their names without prior written
   *    permission of Intalio, Inc. Exolab is a registered
   *    trademark of Intalio, Inc.
   *
   * 5. Due credit should be given to the Exolab Project
   *    (http://www.exolab.org/).
   *
   * THIS SOFTWARE IS PROVIDED BY INTALIO, INC. AND CONTRIBUTORS
   * ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
   * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
   * INTALIO, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
   * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
   * OF THE POSSIBILITY OF SUCH DAMAGE.
   *
   * Copyright 1999-2004 (C) Intalio, Inc. All Rights Reserved.
   *
   * $Id$
   */
  
  package org.exolab.castor.xml;
  
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Set;
  import java.util.Vector;
  
  import org.castor.xml.BackwardCompatibilityContext;
  import org.castor.xml.InternalContext;
  import org.castor.xml.AbstractInternalContext;
  import org.castor.xml.JavaNaming;
  import org.exolab.castor.mapping.ClassDescriptor;
  import org.exolab.castor.mapping.CollectionHandler;
  import org.exolab.castor.mapping.FieldDescriptor;
  import org.exolab.castor.mapping.MappingException;
  import org.exolab.castor.mapping.loader.CollectionHandlers;
  import org.exolab.castor.util.ReflectionUtil;
  
  
  /**
   * A core class for common code shared throughout the
   * Marshalling Framework
   * 
   * @author <a href="mailto:kvisco-at-intalio.com">Keith Visco</a>
   * @version $Revision$ $Date: 2005-12-13 14:58:48 -0700 (Tue, 13 Dec 2005) $
   */
  abstract class MarshalFramework {
  
      
      
      //--------------------------/
      //- Public class variables -/
      //--------------------------/
  
      /**
       * JDK version 1.5 .
       */
      private static final double JDK_VERSION_1_5 = 1.5;
  
      /**
       * The XSI Namespace URI.
      **/
      public static final String XSI_NAMESPACE
          = "http://www.w3.org/2001/XMLSchema-instance";
  
      /**
       * The name of the Schema location attribute.
      **/
      public static final String XSI_SCHEMA_LOCATION = "schemaLocation";
  
      /**
       * The name of the no namespace schema location attribute.
     **/
     public static final String XSI_NO_NAMESPACE_SCHEMA_LOCATION 
         = "noNamespaceSchemaLocation";
    
     /**
      * The xml:lang attribute name.
      */
     public static final String XML_LANG_ATTR = "xml:lang";
     
     /**
      * The xml:lang attribute, without the "xml:" prefix.
      */
     public static final String LANG_ATTR = "lang";
     
     /**
      * The xsi:nil attribute, without the "xsi:" prefix.
      */
     public static final String NIL_ATTR = "nil";
     
     /**
      * The xsi:nil attribute.
      */
     public static final String XSI_NIL_ATTR = "xsi:nil";
     
     /**
      * The xml:space attribute name.
      */    
     public static final String XML_SPACE_ATTR = "xml:space";
     
     /**
      * The xml:space attribute name, without the "xml:" prefix.
      */    
     public static final String SPACE_ATTR = "space";
     
     /**
      * The xsi:type attribute name, without the "xsi:" prefix.
      */    
     public static final String TYPE_ATTR = "type";
     
     /**
      * The value of 'true'.
      */
     public static final String TRUE_VALUE = "true";
     
     //-----------------------------/
     //- Protected class variables -/
     //-----------------------------/
 
     /**
      * A constant to indicate a wrong name without setting null.
      */
     static final String INTERNAL_XML_NAME = "-error-if-this-is-used-";
 
     /**
      * The default prefix used for specifying the
      * xsi:type as a classname instead of a schema name.
      * This is a Castor specific hack.
      */
     static final String JAVA_PREFIX = "java:";
 
     /**
      * The name of the QName type.
      */
     static final String QNAME_NAME = "QName";
     
     /**
      * An empty array of field descriptors.
      */
     static final XMLFieldDescriptor[] NO_FIELD_DESCRIPTORS 
         = new XMLFieldDescriptor[0];
 
     //-----------------------------/
     //- Private variables         -/
     //-----------------------------/
     
     /**
      * The {@link AbstractInternalContext} to use at all un-marshal actions.
      * @since 1.1.3
      */
     private InternalContext _internalContext;
     
     //-----------------------------/
     //- Public methods            -/
     //-----------------------------/
 
     /**
      * We need some stuff initialized here. MarshalFramework requires internally
      * an {@link InternalContext}, so either one is given or {@link BackwardCompatibilityContext}
      * is instantiated! Mind that instantiating {@link BackwardCompatibilityContext}
      * means to (re-)read configuration files.
      * @param internalContext either an {@link InternalContext} comes from outside
      *          or {@link BackwardCompatibilityContext} is instantiated
      */
     public MarshalFramework(final InternalContext internalContext) {
         if (internalContext == null) {
             _internalContext = new BackwardCompatibilityContext();
         } else {
             _internalContext = internalContext;
         }
     }
 
     /**
      * To get the {@link JavaNaming} instance to be used.
      * @return the JavaNaming to be used
      */
     public JavaNaming getJavaNaming() {
         return _internalContext.getJavaNaming();
     }
 
     /**
      * To set the {@link JavaNaming} instance to be used.
      * @param javaNaming the JavaNaming to be used
      * TODO: joachim remove me if possible!
      */
     private void setJavaNaming(final JavaNaming javaNaming) {
         _internalContext.setJavaNaming(javaNaming);
     }
     
     /**
      * To get the {@link AbstractInternalContext} to use.
      * @return the {@link AbstractInternalContext} to use
      */
     public InternalContext getInternalContext() {
         return _internalContext;
     }
     
     /**
      * To set the {@link AbstractInternalContext} to use.
      * @param internalContext the {@link AbstractInternalContext} to use
      */
     public void setInternalContext(final InternalContext internalContext) {
         _internalContext = internalContext;
     }
 
     /**
      * Returns true if the given Class is a considered a
      * collection by the marshalling framework.
      * @param clazz the Class to check
      * @return true if the given Class is considered a collection.
      * TODO: joachim: this code exists somewhere else too!!
      */
     public static boolean isCollection(final Class clazz) {
         return CollectionHandlers.hasHandler(clazz);
     } //-- isCollection
     
     /**
      * Returns the CollectionHandler associated with the
      * given collection, or null if no such handler exists.
      * @param clazz the Class to check
      * @return the CollectionHandler for the associated type.
      */
     public CollectionHandler getCollectionHandler(final Class clazz) {
         CollectionHandler handler = null;
         try {
             handler = CollectionHandlers.getHandler(clazz);
         }
         catch (MappingException mx) {
             //-- Not a collection, or no handler exists, return null.
         }
         return handler;
     } //-- getCollectionHandler
     
     
     /**
      * Returns true if the given class should be treated as a primitive
      * type. This method will return true for all Java primitive
      * types, the set of primitive object wrappers, as well
      * as Strings.
      * @param type the Class to check
      * @return true if the given class should be treated as a primitive type
      * TODO: joachim: this code exists somewhere else too!!
     **/
     static boolean isPrimitive(final Class type) {
 
         if (type == null) {
             return false;
         }
 
         //-- java primitive
         if (type.isPrimitive()) {
             return true;
         }
 
         //-- we treat strings as primitives
         if (type == String.class) {
             return true;
         }
 
         //-- primtive wrapper classes
         if ((type == Boolean.class) || (type == Character.class)) {
             return true;
         }
 
         Class superClass = type.getSuperclass();
         if (superClass == Number.class) {
             return true;
         }
 
         if (superClass != null) {
             return superClass.getName().equals("java.lang.Enum");
         }
         
         return false;
         
     } //-- isPrimitive
 
     /**
      * Returns true if the given class should be treated as an enum type. This method 
      * will return true for all Java 5 (or later) enums, and for enum-style
      * classes.
      * @param type the Class to check
      * @return true if the given class should be treated as an enum
      **/
     static boolean isEnum(final Class type) {
 
         if (type == null) {
             return false;
         }
 
         float javaVersion = 
             Float.valueOf(System.getProperty("java.specification.version")).floatValue();
         if (javaVersion >= JDK_VERSION_1_5) {
             try {
                 Boolean isEnum = ReflectionUtil.isEnumViaReflection(type);
                 return isEnum.booleanValue();
             } catch (Exception e) {
                 // nothing to report; implies that there's no such method
             }
         }
         
         // TODO: add code to cover 1.4 enum-stype classes as well.
         
         return false;
 
     } //-- isPrimitive
 
 //    /**
 //     * Calls isEnum() method on target class vi areflection to find out
 //     * whether the given type is a Java 5 enumeration.
 //     * @param type The type to analyze.
 //     * @return True if the type given is a Java 5.0 enum.
 //     * @throws NoSuchMethodException If the method can not be found.
 //     * @throws IllegalAccessException If access to this method is illegal
 //     * @throws InvocationTargetException If the target method can not be invoked.
 //     */
 //    private static Boolean isEnumViaReflection(Class type) 
 //    throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
 //        Method isEnumMethod = type.getClass().getMethod("isEnum", (Class[]) null);
 //        return (Boolean) isEnumMethod.invoke(type, (Object[]) null);
 //    }
 //    
 
     /**
      * Returns true if any of the fields associated with the given
      * XMLClassDescriptor are located at, or beneath, the given location.
      *
      * @param location the location to compare against
      * @param classDesc the XMLClassDescriptor in which to check the field 
      * locations
      * @return true if any of the fields has a location associated
      */
     static final boolean hasFieldsAtLocation
         (final String location, final XMLClassDescriptor classDesc) {
         //-- check elements
         XMLFieldDescriptor[] descriptors = classDesc.getElementDescriptors();
         for (int i = 0; i < descriptors.length; i++) {
             if (descriptors[i] == null) {
                 continue;
             }
             String tmpLocation = descriptors[i].getLocationPath();
             if ((tmpLocation != null) && (tmpLocation.startsWith(location))) {
                 return true;
             }
         }
         
         //-- check attributes
         descriptors = classDesc.getAttributeDescriptors();
         for (int i = 0; i < descriptors.length; i++) {
             if (descriptors[i] == null) {
                 continue;
             }
             String tmpLocation = descriptors[i].getLocationPath();
             if ((tmpLocation != null) && (tmpLocation.startsWith(location))) {
                 return true;
             }
         }
         
         //-- check content/text
         XMLFieldDescriptor content = classDesc.getContentDescriptor();
         if (content != null) {
             String tmpLocation = content.getLocationPath();
             if ((tmpLocation != null) && (tmpLocation.startsWith(location))) {
                 return true;
             }
         }
         return false;
     } //-- hasFieldsAtLocation
     
     /**
      * Compares the given namespaces (as strings) for equality.
      * null and empty values are considered equal.
      *
      * @param ns1 the namespace to compare to argument ns2
      * @param ns2 the namespace to compare to argument ns1
      * @return true if the namespaces are considert equal
      * TODO: joachim put it into XMLNaming!
      */
     public static boolean namespaceEquals(final String ns1, final String ns2) {
         if (ns1 == null) {
             return ((ns2 == null) || (ns2.length() == 0));
         }
         if (ns2 == null) {
             return (ns1.length() == 0);
         }
         return ns1.equals(ns2);
     } //-- namespaceEquals
     
     /**
      * Returns true if the given classes are both the same
      * primitive or primitive wrapper class. For exmaple, if 
      * class "a" is an int (Integer.TYPE) and class "b" is 
      * either an int or Integer.class then true will be
      * returned, otherwise false.
      * @param a compare a with b
      * @param b compare a with b
      * @return true if both a and b are considered equal
      */
     static boolean primitiveOrWrapperEquals(final Class a, final Class b) {
         if (!isPrimitive(a)) {
             return false;
         }
         if (!isPrimitive(b)) {
             return false;
         }
         
         if (a == b) {
             return true;
         }
         
         //-- Boolean/boolean
         if ((a == Boolean.class) || (a == Boolean.TYPE)) {
             return ((b == Boolean.class) || (b == Boolean.TYPE));
         }
         //-- Byte/byte
         else if ((a == Byte.class) || (a == Byte.TYPE)) {
             return ((b == Byte.class) || (b == Byte.TYPE));
         }
         //-- Character/char
         else if ((a == Character.class) || (a == Character.TYPE)) {
             return ((b == Character.class) || (b == Character.TYPE));
         }
         //-- Double/double
         else if ((a == Double.class) || (a == Double.TYPE)) {
             return ((b == Double.class) || (b == Double.TYPE));
         }
         else if ((a == Float.class) || (a == Float.TYPE)) {
             return ((b == Float.class) || (b == Float.TYPE));
         }
         //-- Integer/int
         else if ((a == Integer.class) || (a == Integer.TYPE)) {
             return ((b == Integer.class) || (b == Integer.TYPE));
         }
         //-- Long/long
         else if ((a == Long.class) || (a == Long.TYPE)) {
             return ((b == Long.class) || (b == Long.TYPE));
         }
         //-- Short/short
         else if ((a == Short.class) || (a == Short.TYPE)) {
             return ((b == Short.class) || (b == Short.TYPE));
         }
         
         return false;
     } //-- primitiveOrWrapperEquals
     
     /**
      * 
      */
     private static final InheritanceMatch[] NO_MATCH_ARRAY = new InheritanceMatch[0];
     
     /**
      * Search there is a field descriptor which can accept one of the class
      * descriptor which match the given name and namespace.
      * 
      * @param name XML name of the field
      * @param namespace namespace of the field
      * @param classDesc the class descriptor to match against
      * @param cdResolver the class descriptor resolver to use
      * @return An array of InheritanceMatch.
      * @throws MarshalException if the resolver called fails fatally
      */
     protected InheritanceMatch[] searchInheritance(final String name, 
             final String namespace,
             final XMLClassDescriptor classDesc)
     throws MarshalException {
         Iterator classDescriptorIterator = null;
         
         try {
             //-- A little required logic for finding Not-Yet-Loaded
             //-- descriptors
             String className = getJavaNaming().toJavaClassName(name);
             //-- should use namespace-to-prefix mappings, but
             //-- just create package for now.
             Class clazz = classDesc.getJavaClass();
             String pkg = null;
             if (clazz != null) {
                 while (clazz.getDeclaringClass() != null) {
                     clazz = clazz.getDeclaringClass();
                 }
                 pkg = clazz.getName();
                 int idx = pkg.lastIndexOf('.');
                 if (idx >= 0) {
                     pkg = pkg.substring(0, idx + 1);
                     className = pkg + className;
                 }
             }
             getInternalContext().getXMLClassDescriptorResolver().resolve(
                     className, classDesc.getClass().getClassLoader());
             //-- end Not-Yet-Loaded descriptor logic
             
             //-- resolve all by XML name + namespace URI
             classDescriptorIterator = 
                 getInternalContext().getXMLClassDescriptorResolver().resolveAllByXMLName(
                         name, namespace, null);
         }
         catch (ResolverException rx) {
             Throwable actual = rx.getCause();
             if (actual instanceof MarshalException) {
                 throw (MarshalException) actual;
             }
             if (actual != null) {
                 throw new MarshalException(actual);
             }
             throw new MarshalException(rx);
         }
 
         Vector inheritanceList = null;
         XMLFieldDescriptor descriptor  = null;
         XMLFieldDescriptor[] descriptors = classDesc.getElementDescriptors();
         XMLClassDescriptor cdInherited = null;
 
         if (classDescriptorIterator.hasNext()) {
             while (classDescriptorIterator.hasNext() && (descriptor == null)) {
                 cdInherited = (XMLClassDescriptor) classDescriptorIterator.next();
                 Class subclass = cdInherited.getJavaClass();
 
                 for (int i = 0; i < descriptors.length; i++) {
 
                     if (descriptors[i] == null) {
                         continue;
                     }
                     
                     //-- skip descriptors with special internal name
                     if (INTERNAL_XML_NAME.equals(descriptors[i].getXMLName())) {
                         continue;
                     }
                     
                     //-- check for inheritence
                     Class superclass = descriptors[i].getFieldType();
 
                     // It is possible that the superclass is of type object if we use any node.
                     if (superclass.isAssignableFrom(subclass) && (superclass != Object.class)) {
                         descriptor = descriptors[i];
                         if (inheritanceList == null) {
                             inheritanceList = new Vector(3);
                         }
                         inheritanceList.addElement(new InheritanceMatch(descriptor, cdInherited));
                     }
                 }
             }
             //-- reset inherited class descriptor, if necessary
             if (descriptor == null) {
                 cdInherited = null;
             }
         }
         
         if (inheritanceList != null) {
             InheritanceMatch[] result = new InheritanceMatch[inheritanceList.size()];
             inheritanceList.toArray(result);
             return result;
         }
         return NO_MATCH_ARRAY;
         
     }
 
      /**
      * Used to store the information when we find a possible inheritance. It
      * store the XMLClassDescriptor of the object to instantiate and the
      * XMLFieldDescriptor of the parent, where the instance of the
      * XMLClassDescriptor will be put.
      */
     public static class InheritanceMatch {
         /**
          * The field descriptor of the parent.
          */
         public XMLFieldDescriptor parentFieldDesc;
         /**
          * The class descriptor to instantiate.
          */
         public XMLClassDescriptor inheritedClassDesc;
 
         public InheritanceMatch(XMLFieldDescriptor fieldDesc, XMLClassDescriptor classDesc) {
             parentFieldDesc    = fieldDesc;
             inheritedClassDesc = classDesc;
         }
     }
 
 
 
     /**
      * An internal implementation of XMLClassDescriptor used by
      * the Unmarshaller and Marshaller...
      */
     class InternalXMLClassDescriptor implements XMLClassDescriptor {
 
         private XMLClassDescriptor _classDesc = null;
         
         /**
          * Cached arrays.
          */
         private XMLFieldDescriptor[] _attributes = null;
         /**
          * Cached arrays.
          */
         private XMLFieldDescriptor[] _elements   = null;
         /**
          * Cached arrays.
          */
         private FieldDescriptor[]    _fields     = null;
         
         /**
          * Map holding the properties set and read by Natures.
          */
         private Map _properties = new HashMap();
         
         /**
          * Map holding the available natures.
          */
         private Set _natures = new HashSet();
         
         /**
          * Creates a new InternalXMLClassDescriptor for the given
          * XMLClassDescriptor.
          */
         protected InternalXMLClassDescriptor(XMLClassDescriptor classDesc)
         {
             if (classDesc == null) {
                 String err = "The argument 'classDesc' must not be null.";
                 throw new IllegalArgumentException(err);
             }
             
             //-- prevent wrapping another InternalXMLClassDescriptor,
             while (classDesc instanceof InternalXMLClassDescriptor) {
                 classDesc = ((InternalXMLClassDescriptor) classDesc).getClassDescriptor();
             }
             _classDesc = classDesc;
         }
         
         /**
          * Returns the XMLClassDescriptor that this InternalXMLClassDescriptor
          * wraps.
          *
          * @return the XMLClassDescriptor
          */
         public XMLClassDescriptor getClassDescriptor() {
             return _classDesc;
         } //-- getClassDescriptor
         
         
         /**
          * Returns the set of XMLFieldDescriptors for all members
          * that should be marshalled as XML attributes. This
          * includes namespace nodes.
          *
          * @return an array of XMLFieldDescriptors for all members
          * that should be marshalled as XML attributes.
          */
         public XMLFieldDescriptor[]  getAttributeDescriptors() {
             if (_attributes == null) {
                 _attributes = _classDesc.getAttributeDescriptors();
             }
             return _attributes;
         } //-- getAttributeDescriptors
 
         /**
          * Returns the XMLFieldDescriptor for the member
          * that should be marshalled as text content.
          *
          * @return the XMLFieldDescriptor for the member
          * that should be marshalled as text content.
          */
         public XMLFieldDescriptor getContentDescriptor() {
             return _classDesc.getContentDescriptor();
         } //-- getContentDescriptor
 
 
         /**
          * Returns the XML field descriptor matching the given
          * xml name and nodeType. If NodeType is null, then
          * either an AttributeDescriptor, or ElementDescriptor
          * may be returned. Null is returned if no matching
          * descriptor is available.
          *
          * @param name the xml name to match against
          * @param namespace the xml namespace to match
          * @param nodeType the NodeType to match against, or null if
          * the node type is not known.
          * @return the matching descriptor, or null if no matching
          * descriptor is available.
          *
          */
         public XMLFieldDescriptor getFieldDescriptor
             (final String name, final String namespace, final NodeType nodeType) 
         {
             return _classDesc.getFieldDescriptor(name, namespace, nodeType);
         } //-- getFieldDescriptor
 
         /**
          * Returns the set of XMLFieldDescriptors for all members
          * that should be marshalled as XML elements.
          *
          * @return an array of XMLFieldDescriptors for all members
          * that should be marshalled as XML elements.
          */
         public XMLFieldDescriptor[]  getElementDescriptors() {
             if (_elements == null) {
                 _elements = _classDesc.getElementDescriptors();
             }
             return _elements;
         } //-- getElementDescriptors
 
         /**
          * @return the namespace prefix to use when marshalling as XML.
          */
         public String getNameSpacePrefix() {
             return _classDesc.getNameSpacePrefix();
         } //-- getNameSpacePrefix
 
         /**
          * @return the namespace URI used when marshalling and unmarshalling as XML.
          */
         public String getNameSpaceURI() {
             return _classDesc.getNameSpaceURI();
         } //-- getNameSpaceURI
 
         /**
          * Returns a specific validator for the class described by
          * this ClassDescriptor. A null value may be returned
          * if no specific validator exists.
          *
          * @return the type validator for the class described by this
          * ClassDescriptor.
          */
         public TypeValidator getValidator() {
             return _classDesc.getValidator();
         } //-- getValidator
 
         /**
          * Returns the XML Name for the Class being described.
          *
          * @return the XML name.
          */
         public String getXMLName() {
             return _classDesc.getXMLName();
         } //-- getXMLName
 
         /**
          * Returns true if the wrapped ClassDescriptor was created
          * by introspection.
          * 
          * @return true if the wrapped ClassDescriptor was created
          * by introspection.
          */
         public boolean introspected() {
             return Introspector.introspected(_classDesc);
         } //-- introspected
         
         /**
          * @see org.exolab.castor.xml.XMLClassDescriptor#canAccept(
          *      java.lang.String, java.lang.String, java.lang.Object)
          */
         public boolean canAccept(final String name, final String namespace, final Object object) {
             return _classDesc.canAccept(name, namespace, object);
         } //-- canAccept
 
         /** 
          * {@inheritDoc}
          * 
          * @see org.exolab.castor.xml.XMLClassDescriptor#checkDescriptorForCorrectOrderWithinSequence(org.exolab.castor.xml.XMLFieldDescriptor, org.exolab.castor.xml.UnmarshalState, java.lang.String)
          */
         public void checkDescriptorForCorrectOrderWithinSequence(
                 final XMLFieldDescriptor elementDescriptor, 
                 final UnmarshalState parentState, 
                 final String xmlName) 
             throws ValidationException {
             _classDesc.checkDescriptorForCorrectOrderWithinSequence(elementDescriptor, parentState, xmlName);
         }
 
         //-------------------------------------/
         //- Implementation of ClassDescriptor -/
         //-------------------------------------/
         
         /**
          * Returns the Java class represented by this descriptor.
          *
          * @return The Java class
          */
         public Class getJavaClass() {
             return _classDesc.getJavaClass();
         } //-- getJavaClass
 
 
         /**
          * Returns a list of fields represented by this descriptor.
          *
          * @return A list of fields
          */
         public FieldDescriptor[] getFields() {
             if (_fields == null) {
                 _fields = _classDesc.getFields();
             }
             return _fields;
         } //-- getFields
 
 
         /**
          * Returns the class descriptor of the class extended by this class.
          *
          * @return The extended class descriptor
          */
         public ClassDescriptor getExtends() {
             return _classDesc.getExtends();
         } //-- getExtends
 
 
         /**
          * Returns the identity field, null if this class has no identity.
          *
          * @return The identity field
          */
         public FieldDescriptor getIdentity() {
             return _classDesc.getIdentity();
         } //-- getIdentity
         
         /**
          * {@inheritDoc}
          * 
          * @see org.exolab.castor.xml.XMLClassDescriptor#isChoice()
          */
         public boolean isChoice() {
             return false;
         }
 
         /**
          * @see org.exolab.castor.builder.info.nature.PropertyHolder#
          *      getProperty(java.lang.String)
          * @param name
          *            of the property
          * @return value of the property
          */
         public Object getProperty(final String name) {
             return _properties.get(name);
         }
 
         /**
          * @see org.exolab.castor.builder.info.nature.PropertyHolder#
          *      setProperty(java.lang.String, java.lang.Object)
          * @param name
          *            of the property
          * @param value
          *            of the property
          */
         public void setProperty(final String name, final Object value) {
             _properties.put(name, value);
         }
 
         /**
          * @see org.exolab.castor.builder.info.nature.NatureExtendable#
          *      addNature(java.lang.String)
          * @param nature
          *            ID of the Nature
          */
         public void addNature(final String nature) {
             _natures.add(nature);
         }
 
         /**
          * @see org.exolab.castor.builder.info.nature.NatureExtendable#
          *      hasNature(java.lang.String)
          * @param nature
          *            ID of the Nature
          * @return true if the Nature ID was added.
          */
         public boolean hasNature(final String nature) {
             return _natures.contains(nature);
         }
 
     } //-- InternalXMLClassDescriptor
     
     
 } //-- MarshalFramework