* <copyright>

*

* Copyright (c) 2002-2008 IBM Corporation, Embarcadero Technologies, and others.

* All rights reserved.   This program and the accompanying materials

* are made available under the terms of the Eclipse Public License v1.0

* which accompanies this distribution, and is available at

* http://www.eclipse.org/legal/epl-v10.html

*

* Contributors:

*   IBM - Initial API and implementation

*   Kenn Hussey (Embarcadero Technologies) - 218759

*

* </copyright>

*

* $Id: XMLHandler.java,v 1.94 2010/03/17 13:36:22 emerks Exp $

*/

* This class is a generic interface for loading XML files and

* creating EObjects from them. Its subclasses include the SAXXMLHandler

* class, which wraps this class in a SAX default handler.

*/

  protected static final String ERROR_TYPE = "error";

  protected static final String OBJECT_TYPE = "object";

  protected static final String UNKNOWN_FEATURE_TYPE = "unknownFeature";

  protected static final String DOCUMENT_ROOT_TYPE = "documentRoot";

  protected final static String TYPE_ATTRIB = XMLResource.XSI_NS + ":" + XMLResource.TYPE;

  protected final static String NIL_ATTRIB = XMLResource.XSI_NS + ":" + XMLResource.NIL;

  protected final static String SCHEMA_LOCATION_ATTRIB = XMLResource.XSI_NS + ":" + XMLResource.SCHEMA_LOCATION;

  protected final static String NO_NAMESPACE_SCHEMA_LOCATION_ATTRIB = XMLResource.XSI_NS + ":" + XMLResource.NO_NAMESPACE_SCHEMA_LOCATION;

  protected final static boolean DEBUG_DEMANDED_PACKAGES = false;

 

  protected static class MyStack<E> extends BasicEList<E>

  {

    private static final long serialVersionUID = 1L;

    public MyStack()

    {

      super();

    }

    @SuppressWarnings("unchecked")

    public final E peek()

    {

      return size == 0 ? null : (E)data[size - 1];

    }

    public final void push(E o)

    {

      grow(size + 1); 

      data[size++] = o;

    }

    @SuppressWarnings("unchecked")

    public final E pop()

    {

      return size == 0 ?  null : (E)data[--size];

    }

  }

  protected static class MyEObjectStack extends MyStack<EObject>

  {

    private static final long serialVersionUID = 1L;

    protected EObject [] eObjectData;

    public MyEObjectStack()

    {

      super();

    }

    @Override

    protected final Object[] newData(int capacity)

    {

      return eObjectData = new EObject[capacity];

    }

    public final EObject peekEObject()

    {

      return size == 0 ? null : eObjectData[size - 1];

    }

    public final EObject popEObject()

    {

      return size == 0 ?  null : eObjectData[--size];

    }

    @Override

    public void clear()

    {

      eObjectData = null;

      super.clear();

    }

  }

  /**

   * For unresolved forward references, the line number where the incorrect id

   * appeared in an XML resource is needed, so the Value for the forward reference

   * and the line number where the forward reference occurred must be saved until

   * the end of the XML resource is encountered.

   */

  protected static class SingleReference

  {

    private EObject object;

    private EStructuralFeature feature;

    private Object value;

    private int position;

    private int lineNumber;

    private int columnNumber;

    public SingleReference(EObject object,

                    EStructuralFeature feature,

                    Object value,

                    int position,

                    int lineNumber,

                    int columnNumber)

    {

      this.object       = object;

      this.feature      = feature;

      this.value        = value;

      this.position     = position;

      this.lineNumber   = lineNumber;

      this.columnNumber = columnNumber;

    }

    public EObject getObject()

    {

      return object;

    }

    public EStructuralFeature getFeature()

    {

      return feature;

    }

    public Object getValue()

    {

      return value;

    }

    public int getPosition()

    {

      return position;

    }

    public int getLineNumber()

    {

      return lineNumber;

    }

    public int getColumnNumber()

    {

      return columnNumber;

    }

  }

  protected static class ManyReference implements XMLHelper.ManyReference

  {

    private EObject object;

    private EStructuralFeature feature;

    private Object[] values;

    private int[] positions;

    private int lineNumber;

    private int columnNumber;

    public ManyReference(EObject object,

                  EStructuralFeature feature,

                  Object[] values,

                  int[] positions,

                  int lineNumber,

                  int columnNumber)

    {

      this.object       = object;

      this.feature      = feature;

      this.values       = values;

      this.positions    = positions;

      this.lineNumber   = lineNumber;

      this.columnNumber = columnNumber;

    }

    public EObject getObject()

    {

      return object;

    }

    public EStructuralFeature getFeature()

    {

      return feature;

    }

    public Object[] getValues()

    {

      return values;

    }

    public int[] getPositions()

    {

      return positions;

    }

    public int getLineNumber()

    {

      return lineNumber;

    }

    public int getColumnNumber()

    {

      return columnNumber;

    }

  }

  protected XMLResource xmlResource;

  protected XMLHelper helper;

  protected MyStack<String> elements;

  protected MyEObjectStack objects;

  protected MyStack<Object> types;

  protected MyStack<FeatureMap> mixedTargets;

  protected Map<String, EFactory> prefixesToFactories;

  protected Map<String, URI> urisToLocations;

  protected Map<String, URI> externalURIToLocations;

  protected boolean processSchemaLocations;

  protected InternalEList<EObject> extent;

  protected List<EObject> deferredExtent;

  protected ResourceSet resourceSet;

  protected EPackage.Registry packageRegistry;

  protected URI resourceURI;

  protected boolean resolve;

  protected boolean oldStyleProxyURIs;

  protected boolean disableNotify;

  protected StringBuffer text;

  protected boolean isIDREF;

  protected boolean isSimpleFeature;

  protected List<InternalEObject> sameDocumentProxies;

  protected List<SingleReference> forwardSingleReferences;

  protected List<ManyReference> forwardManyReferences;

  protected Object[] identifiers;

  protected int[] positions;

  protected static final int ARRAY_SIZE = 64;

  protected static final int REFERENCE_THRESHOLD = 5;

  protected int capacity;

  protected Set<String> notFeatures;

  protected String idAttribute;

  protected String hrefAttribute;

  protected XMLResource.XMLMap xmlMap;

  protected ExtendedMetaData extendedMetaData;

  protected EClass anyType;

  protected EClass anySimpleType;

  protected boolean recordUnknownFeature;

  protected boolean useNewMethods;

  protected boolean recordAnyTypeNSDecls;

  protected Map<EObject, AnyType> eObjectToExtensionMap;

  protected EStructuralFeature contextFeature;

  protected EPackage xmlSchemaTypePackage = XMLTypePackage.eINSTANCE;

  protected boolean deferIDREFResolution;

  protected boolean processAnyXML;

  protected EcoreBuilder ecoreBuilder;

  protected boolean isRoot;

  protected Locator locator;

  protected Attributes attribs;

  protected Map<EStructuralFeature, Integer> featuresToKinds;

  protected boolean useConfigurationCache;

  protected boolean needsPushContext;

  protected XMLResource.ResourceEntityHandler resourceEntityHandler;

  protected XMLResource.URIHandler uriHandler;

  protected EObject documentRoot;

  protected boolean usedNullNamespacePackage;

  protected boolean isNamespaceAware;

  protected boolean suppressDocumentRoot;

  protected boolean laxWildcardProcessing;

  /**

   */

  public XMLHandler(XMLResource xmlResource, XMLHelper helper, Map<?, ?> options)

  {

    this.xmlResource = xmlResource;

    this.helper = helper;

    elements = new MyStack<String>();

    objects  = new MyEObjectStack();

    mixedTargets = new MyStack<FeatureMap>();

    types    = new MyStack<Object>();

    prefixesToFactories = new HashMap<String, EFactory>();

    forwardSingleReferences = new ArrayList<SingleReference>();

    forwardManyReferences   = new ArrayList<ManyReference>();

    sameDocumentProxies = new ArrayList<InternalEObject>();

    identifiers = new Object[ARRAY_SIZE];

    positions   = new int[ARRAY_SIZE];

    capacity    = ARRAY_SIZE;

    resourceSet  = xmlResource.getResourceSet();

    packageRegistry = resourceSet == null ? EPackage.Registry.INSTANCE : resourceSet.getPackageRegistry();

    resourceURI  = xmlResource.getURI();

    extent       = (InternalEList<EObject>)xmlResource.getContents();

    if (Boolean.TRUE.equals(options.get(XMLResource.OPTION_DEFER_ATTACHMENT)))

    {

      deferredExtent = new ArrayList<EObject>();

    }

    resolve      = resourceURI != null && resourceURI.isHierarchical() && !resourceURI.isRelative();

    eObjectToExtensionMap = xmlResource.getEObjectToExtensionMap();

    eObjectToExtensionMap.clear();

   

    helper.setOptions(options);

    if (Boolean.TRUE.equals(options.get(XMLResource.OPTION_DISABLE_NOTIFY)))

      disableNotify = true;

    notFeatures = new HashSet<String>();

    notFeatures.add(TYPE_ATTRIB);

    notFeatures.add(SCHEMA_LOCATION_ATTRIB);

    notFeatures.add(NO_NAMESPACE_SCHEMA_LOCATION_ATTRIB);

    xmlMap = (XMLResource.XMLMap) options.get(XMLResource.OPTION_XML_MAP);

    helper.setXMLMap(xmlMap);

    if (xmlMap != null)

    {

      idAttribute = xmlMap.getIDAttributeName();

    }

    Object extendedMetaDataOption = options.get(XMLResource.OPTION_EXTENDED_META_DATA);

    setExtendedMetaDataOption(extendedMetaDataOption);

    recordUnknownFeature = Boolean.TRUE.equals(options.get(XMLResource.OPTION_RECORD_UNKNOWN_FEATURE)); 

    if (recordUnknownFeature && extendedMetaData == null)

    {

      setExtendedMetaDataOption(Boolean.TRUE);

    }

   

    useNewMethods = Boolean.FALSE.equals(options.get(XMLResource.OPTION_USE_DEPRECATED_METHODS)); 

   

    XMLOptions xmlOptions = (XMLOptions)options.get(XMLResource.OPTION_XML_OPTIONS);

    if (xmlOptions != null)

    {

      processSchemaLocations = xmlOptions.isProcessSchemaLocations();

      externalURIToLocations = xmlOptions.getExternalSchemaLocations();

      if (processSchemaLocations || externalURIToLocations != null)

      {

        if (extendedMetaData == null)

        {

          setExtendedMetaDataOption(Boolean.TRUE);

        }

        ecoreBuilder = xmlOptions.getEcoreBuilder();

        if (ecoreBuilder == null)

        {

          ecoreBuilder = createEcoreBuilder(options, extendedMetaData);

        }

        else

        {

          ecoreBuilder.setExtendedMetaData(extendedMetaData);

        }

      }

      processAnyXML = xmlOptions.isProcessAnyXML();

      if (processAnyXML && extendedMetaData == null)

      {

        setExtendedMetaDataOption(Boolean.TRUE);

      }

    }

    if (extendedMetaData != null)

    {

      AnyType anyType = XMLTypeFactory.eINSTANCE.createAnyType();

      mixedTargets.push(anyType.getMixed());

      text = new StringBuffer();

    }

   

    anyType = (EClass)options.get(XMLResource.OPTION_ANY_TYPE);

    anySimpleType = (EClass)options.get(XMLResource.OPTION_ANY_SIMPLE_TYPE);

    if (anyType == null)

    {

      anyType = XMLTypePackage.eINSTANCE.getAnyType();

      anySimpleType = XMLTypePackage.eINSTANCE.getSimpleAnyType();

    }

   

    helper.setAnySimpleType(anySimpleType);

   

    @SuppressWarnings("unchecked") Map<EClassFeatureNamePair, EStructuralFeature> newEClassFeatureNamePairToEStructuralFeatureMap =

      (Map<EClassFeatureNamePair, EStructuralFeature>)options.get(XMLResource.OPTION_USE_XML_NAME_TO_FEATURE_MAP);

    eClassFeatureNamePairToEStructuralFeatureMap =  newEClassFeatureNamePairToEStructuralFeatureMap;

    if (eClassFeatureNamePairToEStructuralFeatureMap == null)

    {

      eClassFeatureNamePairToEStructuralFeatureMap = new HashMap<EClassFeatureNamePair, EStructuralFeature>();

    }

    else

    {

      isOptionUseXMLNameToFeatureSet = true;

    }

   

    recordAnyTypeNSDecls = Boolean.TRUE.equals(options.get(XMLResource.OPTION_RECORD_ANY_TYPE_NAMESPACE_DECLARATIONS));

   

    hrefAttribute = XMLResource.HREF;

   

    if (Boolean.TRUE.equals(options.get(XMLResource.OPTION_USE_ENCODED_ATTRIBUTE_STYLE)))

    {

      hrefAttribute = null;

    }

   

    if (Boolean.TRUE.equals(options.get(XMLResource.OPTION_DEFER_IDREF_RESOLUTION)))

    {

      helper.setCheckForDuplicates(deferIDREFResolution = true);

    }

   

    if (Boolean.TRUE.equals(options.get(XMLResource.OPTION_CONFIGURATION_CACHE)))

    {

      useConfigurationCache = true;

    }

  

    // The entity handler is the best place to resolve and deresolve URIs since it can do it there just once to produce the entity.

    // So most often the entity handler will be a URI handler as well and when used as a URI handler will be an identity handler.

    //

    uriHandler = (XMLResource.URIHandler)options.get(XMLResource.OPTION_URI_HANDLER);

    resourceEntityHandler = (XMLResource.ResourceEntityHandler)options.get(XMLResource.OPTION_RESOURCE_ENTITY_HANDLER);

    if (resourceEntityHandler != null)

    {

      resourceEntityHandler.reset();

      if (uriHandler == null && resourceEntityHandler instanceof XMLResource.URIHandler)

      {

        uriHandler = (XMLResource.URIHandler)resourceEntityHandler;

        uriHandler.setBaseURI(resourceURI);

      }

    }

    if (Boolean.TRUE.equals(options.get(XMLResource.OPTION_SUPPRESS_DOCUMENT_ROOT)))

    {

      suppressDocumentRoot = true;

    }

    if (Boolean.TRUE.equals(options.get(XMLResource.OPTION_LAX_WILDCARD_PROCESSING)))

    {

      laxWildcardProcessing = true;

    }

  }

  protected void setExtendedMetaDataOption(Object extendedMetaDataOption)

  {

    if (extendedMetaDataOption instanceof Boolean)

    {

      if (extendedMetaDataOption.equals(Boolean.TRUE))

      {

        extendedMetaData =

          resourceSet == null ?

            ExtendedMetaData.INSTANCE :

            new BasicExtendedMetaData(resourceSet.getPackageRegistry());

        if (xmlResource != null)

        {

          xmlResource.getDefaultSaveOptions().put(XMLResource.OPTION_EXTENDED_META_DATA, extendedMetaData);

        }

      }

      else

      {

        extendedMetaData = null;

      }

    }

    else

    {

      extendedMetaData = (ExtendedMetaData)extendedMetaDataOption;