content: /*
   *  This file is part of AndroidIDE.
   *
   *  AndroidIDE is free software: you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation, either version 3 of the License, or
   *  (at your option) any later version.
   *
   *  AndroidIDE is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *   along with AndroidIDE.  If not, see <https://www.gnu.org/licenses/>.
   */
  
  /*
   * reserved comment block
   * DO NOT REMOVE OR ALTER!
   */
  /*
   * Copyright 1999-2004 The Apache Software Foundation.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /*
   * $Id: DTMManager.java,v 1.2.4.1 2005/09/15 08:14:54 suresh_emailid Exp $
   */
  package jaxp.sun.org.apache.xml.internal.dtm;
  
  import jaxp.sun.org.apache.xml.internal.utils.PrefixResolver;
  import jaxp.sun.org.apache.xml.internal.utils.XMLStringFactory;
  
  import jaxp.sun.org.apache.xalan.internal.utils.SecuritySupport;
  
  import jaxp.sun.org.apache.xml.internal.dtm.ref.DTMManagerDefault;
  import jaxp.xml.transform.Source;
  
  /**
   * A DTMManager instance can be used to create DTM and
   * DTMIterator objects, and manage the DTM objects in the system.
   *
   * <p>The system property that determines which Factory implementation
   * to create is named "jaxp.sun.org.apache.xml.internalutils.DTMFactory". This
   * property names a concrete subclass of the DTMFactory abstract
   *  class. If the property is not defined, a platform default is be used.</p>
   *
   * <p>An instance of this class <emph>must</emph> be safe to use across
   * thread instances.  It is expected that a client will create a single instance
   * of a DTMManager to use across multiple threads.  This will allow sharing
   * of DTMs across multiple processes.</p>
   *
   * <p>Note: this class is incomplete right now.  It will be pretty much
   * modeled after javax.xml.transform.TransformerFactory in terms of its
   * factory support.</p>
   *
   * <p>State: In progress!!</p>
   */
  public abstract class DTMManager
  {
  
    /**
     * Factory for creating XMLString objects.
     *  %TBD% Make this set by the caller.
     */
    protected XMLStringFactory m_xsf = null;
  
    private boolean _useServicesMechanism;
    /**
     * Default constructor is protected on purpose.
     */
    protected DTMManager(){}
  
    /**
     * Get the XMLStringFactory used for the DTMs.
     *
     *
     * @return a valid XMLStringFactory object, or null if it hasn't been set yet.
     */
    public XMLStringFactory getXMLStringFactory()
    {
      return m_xsf;
    }
  
    /**
     * Set the XMLStringFactory used for the DTMs.
     *
     *
     * @param xsf a valid XMLStringFactory object, should not be null.
     */
    public void setXMLStringFactory(XMLStringFactory xsf)
    {
      m_xsf = xsf;
    }
  
    /**
     * Obtain a new instance of a <code>DTMManager</code>.
     * This static method creates a new factory instance
     * using the default <code>DTMManager</code> implementation, which is
     * <code>com.sun.org.apache.xml.internal.dtm.ref.DTMManagerDefault</code>.
     * </li>
     * </ul>
     *
     * Once an application has obtained a reference to a <code>
     * DTMManager</code> it can use the factory to configure
     * and obtain parser instances.
     *
     * @return new DTMManager instance, never null.
     *
     * @throws DTMConfigurationException
     * if the implementation is not available or cannot be instantiated.
     */
    public static DTMManager newInstance(XMLStringFactory xsf)
             throws DTMConfigurationException
    {
        final DTMManager factoryImpl = new DTMManagerDefault();
        factoryImpl.setXMLStringFactory(xsf);
  
        return factoryImpl;
    }
  
    /**
     * Get an instance of a DTM, loaded with the content from the
     * specified source.  If the unique flag is true, a new instance will
     * always be returned.  Otherwise it is up to the DTMManager to return a
     * new instance or an instance that it already created and may be being used
     * by someone else.
     *
     * (More parameters may eventually need to be added for error handling
     * and entity resolution, and to better control selection of implementations.)
     *
     * @param source the specification of the source object, which may be null,
     *               in which case it is assumed that node construction will take
     *               by some other means.
     * @param unique true if the returned DTM must be unique, probably because it
     * is going to be mutated.
     * @param whiteSpaceFilter Enables filtering of whitespace nodes, and may
     *                         be null.
     * @param incremental true if the DTM should be built incrementally, if
     *                    possible.
     * @param doIndexing true if the caller considers it worth it to use
     *                   indexing schemes.
     *
     * @return a non-null DTM reference.
     */
    public abstract DTM getDTM(Source source,
                               boolean unique, DTMWSFilter whiteSpaceFilter,
                               boolean incremental, boolean doIndexing);
  
    /**
     * Get the instance of DTM that "owns" a node handle.
     *
     * @param nodeHandle the nodeHandle.
     *
     * @return a non-null DTM reference.
     */
    public abstract DTM getDTM(int nodeHandle);
  
    /**
     * Given a W3C DOM node, try and return a DTM handle.
     * Note: calling this may be non-optimal.
     *
     * @param node Non-null reference to a DOM node.
     *
     * @return a valid DTM handle.
     */
    public abstract int getDTMHandleFromNode(org.w3c.dom.Node node);
  
    /**
     * Creates a DTM representing an empty <code>DocumentFragment</code> object.
     * @return a non-null DTM reference.
     */
    public abstract DTM createDocumentFragment();
  
    /**
     * Release a DTM either to a lru pool, or completely remove reference.
     * DTMs without system IDs are always hard deleted.
     * State: experimental.
     *
     * @param dtm The DTM to be released.
     * @param shouldHardDelete True if the DTM should be removed no matter what.
     * @return true if the DTM was removed, false if it was put back in a lru pool.
     */
    public abstract boolean release(DTM dtm, boolean shouldHardDelete);
  
    /**
     * Create a new <code>DTMIterator</code> based on an XPath
     * <a href="http://www.w3.org/TR/xpath#NT-LocationPath>LocationPath</a> or
     * a <a href="http://www.w3.org/TR/xpath#NT-UnionExpr">UnionExpr</a>.
     *
     * @param xpathCompiler ??? Somehow we need to pass in a subpart of the
     * expression.  I hate to do this with strings, since the larger expression
     * has already been parsed.
     *
     * @param pos The position in the expression.
     * @return The newly created <code>DTMIterator</code>.
     */
    public abstract DTMIterator createDTMIterator(Object xpathCompiler,
            int pos);
  
    /**
     * Create a new <code>DTMIterator</code> based on an XPath
     * <a href="http://www.w3.org/TR/xpath#NT-LocationPath>LocationPath</a> or
     * a <a href="http://www.w3.org/TR/xpath#NT-UnionExpr">UnionExpr</a>.
     *
     * @param xpathString Must be a valid string expressing a
     * <a href="http://www.w3.org/TR/xpath#NT-LocationPath>LocationPath</a> or
     * a <a href="http://www.w3.org/TR/xpath#NT-UnionExpr">UnionExpr</a>.
     *
     * @param presolver An object that can resolve prefixes to namespace URLs.
     *
     * @return The newly created <code>DTMIterator</code>.
     */
    public abstract DTMIterator createDTMIterator(String xpathString,
            PrefixResolver presolver);
  
    /**
     * Create a new <code>DTMIterator</code> based only on a whatToShow
     * and a DTMFilter.  The traversal semantics are defined as the
     * descendant access.
     * <p>
     * Note that DTMIterators may not be an exact match to DOM
     * NodeIterators. They are initialized and used in much the same way
     * as a NodeIterator, but their response to document mutation is not
     * currently defined.
     *
     * @param whatToShow This flag specifies which node types may appear in
     *   the logical view of the tree presented by the iterator. See the
     *   description of <code>NodeFilter</code> for the set of possible
     *   <code>SHOW_</code> values.These flags can be combined using
     *   <code>OR</code>.
     * @param filter The <code>NodeFilter</code> to be used with this
     *   <code>DTMFilter</code>, or <code>null</code> to indicate no filter.
     * @param entityReferenceExpansion The value of this flag determines
     *   whether entity reference nodes are expanded.
     *
     * @return The newly created <code>DTMIterator</code>.
     */
    public abstract DTMIterator createDTMIterator(int whatToShow,
            DTMFilter filter, boolean entityReferenceExpansion);
  
    /**
     * Create a new <code>DTMIterator</code> that holds exactly one node.
     *
     * @param node The node handle that the DTMIterator will iterate to.
     *
     * @return The newly created <code>DTMIterator</code>.
     */
    public abstract DTMIterator createDTMIterator(int node);
  
    /* Flag indicating whether an incremental transform is desired */
    public boolean m_incremental = false;
  
    /*
     * Flag set by FEATURE_SOURCE_LOCATION.
     * This feature specifies whether the transformation phase should
     * keep track of line and column numbers for the input source
     * document.
     */
    public boolean m_source_location = false;
  
    /**
     * Get a flag indicating whether an incremental transform is desired
     * @return incremental boolean.
     *
     */
    public boolean getIncremental()
    {
      return m_incremental;
    }
  
    /**
     * Set a flag indicating whether an incremental transform is desired
     * This flag should have the same value as the FEATURE_INCREMENTAL feature
     * which is set by the TransformerFactory.setAttribut() method before a
     * DTMManager is created
     * @param incremental boolean to use to set m_incremental.
     *
     */
    public void setIncremental(boolean incremental)
    {
      m_incremental = incremental;
    }
  
    /**
     * Get a flag indicating whether the transformation phase should
     * keep track of line and column numbers for the input source
     * document.
     * @return source location boolean
     *
     */
    public boolean getSource_location()
    {
      return m_source_location;
    }
  
    /**
     * Set a flag indicating whether the transformation phase should
     * keep track of line and column numbers for the input source
     * document.
     * This flag should have the same value as the FEATURE_SOURCE_LOCATION feature
     * which is set by the TransformerFactory.setAttribut() method before a
     * DTMManager is created
     * @param sourceLocation boolean to use to set m_source_location
     */
    public void setSource_location(boolean sourceLocation){
      m_source_location = sourceLocation;
    }
  
      /**
       * Return the state of the services mechanism feature.
       */
      public boolean useServicesMechnism() {
          return _useServicesMechanism;
      }
  
      /**
       * Set the state of the services mechanism feature.
       */
      public void setServicesMechnism(boolean flag) {
          _useServicesMechanism = flag;
      }
  
    // -------------------- private methods --------------------
  
     /**
     * Temp debug code - this will be removed after we test everything
     */
    private static boolean debug;
  
    static
    {
      try
      {
        debug = SecuritySupport.getSystemProperty("dtm.debug") != null;
      }
      catch (SecurityException ex){}
    }
  
    /** This value, set at compile time, controls how many bits of the
     * DTM node identifier numbers are used to identify a node within a
     * document, and thus sets the maximum number of nodes per
     * document. The remaining bits are used to identify the DTM
     * document which contains this node.
     *
     * If you change IDENT_DTM_NODE_BITS, be sure to rebuild _ALL_ the
     * files which use it... including the IDKey testcases.
     *
     * (FuncGenerateKey currently uses the node identifier directly and
     * thus is affected when this changes. The IDKEY results will still be
     * _correct_ (presuming no other breakage), but simple equality
     * comparison against the previous "golden" files will probably
     * complain.)
     * */
    public static final int IDENT_DTM_NODE_BITS = 16;
  
  
    /** When this bitmask is ANDed with a DTM node handle number, the result
     * is the low bits of the node's index number within that DTM. To obtain
     * the high bits, add the DTM ID portion's offset as assigned in the DTM
     * Manager.
     */
    public static final int IDENT_NODE_DEFAULT = (1<<IDENT_DTM_NODE_BITS)-1;
  
  
    /** When this bitmask is ANDed with a DTM node handle number, the result
     * is the DTM's document identity number.
     */
    public static final int IDENT_DTM_DEFAULT = ~IDENT_NODE_DEFAULT;
  
    /** This is the maximum number of DTMs available.  The highest DTM is
      * one less than this.
     */
    public static final int IDENT_MAX_DTMS = (IDENT_DTM_DEFAULT >>> IDENT_DTM_NODE_BITS) + 1;
  
  
    /**
     * %TBD% Doc
     *
     * NEEDSDOC @param dtm
     *
     * NEEDSDOC ($objectName$) @return
     */
    public abstract int getDTMIdentity(DTM dtm);
  
    /**
     * %TBD% Doc
     *
     * NEEDSDOC ($objectName$) @return
     */
    public int getDTMIdentityMask()
    {
      return IDENT_DTM_DEFAULT;
    }
  
    /**
     * %TBD% Doc
     *
     * NEEDSDOC ($objectName$) @return
     */
    public int getNodeIdentityMask()
    {
      return IDENT_NODE_DEFAULT;
    }
  
      //
      // Classes
      //
  
      /**
       * A configuration error.
       * Originally in ObjectFactory. This is the only portion used in this package
       */
      static class ConfigurationError
          extends Error {
                  static final long serialVersionUID = 5122054096615067992L;
          //
          // Data
          //
  
          /** Exception. */
          private Exception exception;
  
          //
          // Constructors
          //
  
          /**
           * Construct a new instance with the specified detail string and
           * exception.
           */
          ConfigurationError(String msg, Exception x) {
              super(msg);
              this.exception = x;
          } // <init>(String,Exception)
  
          //
          // Public methods
          //
  
          /** Returns the exception associated to this error. */
          Exception getException() {
              return exception;
          } // getException():Exception
  
      } // class ConfigurationError
  
  }
  