/**
   * Start a new Namespace context.
   *
   * <p>Normally, you should push a new context at the beginning of each XML element: the new
   * context will automatically inherit the declarations of its parent context, but it will also
   * keep track of which declarations were made within this context.
   *
   * <p>The Namespace support object always starts with a base context already in force: in this
   * context, only the "xml" prefix is declared.
   *
   * @see #popContext
   */
  public void pushContext() {
    // JJK: Context has a parent pointer.
    // That means we don't need a stack to pop.
    // We may want to retain for reuse, but that can be done via
    // a child pointer.

    Context2 parentContext = currentContext;
    currentContext = parentContext.getChild();
    if (currentContext == null) {
      currentContext = new Context2(parentContext);
    } else {
      // JJK: This will wipe out any leftover data
      // if we're reusing a previously allocated Context.
      currentContext.setParent(parentContext);
    }
  }
 /**
  * Reset this Namespace support object for reuse.
  *
  * <p>It is necessary to invoke this method before reusing the Namespace support object for a new
  * session.
  */
 public void reset() {
   // Discarding the whole stack doesn't save us a lot versus
   // creating a new NamespaceSupport. Do we care, or should we
   // change this to just reset the root context?
   currentContext = new Context2(null);
   currentContext.declarePrefix("xml", XMLNS);
 }
 /**
  * Declare a Namespace prefix.
  *
  * <p>This method declares a prefix in the current Namespace context; the prefix will remain in
  * force until this context is popped, unless it is shadowed in a descendant context.
  *
  * <p>To declare a default Namespace, use the empty string. The prefix must not be "xml" or
  * "xmlns".
  *
  * <p>Note that you must <em>not</em> declare a prefix after you've pushed and popped another
  * Namespace.
  *
  * <p>Note that there is an asymmetry in this library: while {@link #getPrefix getPrefix} will not
  * return the default "" prefix, even if you have declared one; to check for a default prefix, you
  * have to look it up explicitly using {@link #getURI getURI}. This asymmetry exists to make it
  * easier to look up prefixes for attribute names, where the default prefix is not allowed.
  *
  * @param prefix The prefix to declare, or null for the empty string.
  * @param uri The Namespace URI to associate with the prefix.
  * @return true if the prefix was legal, false otherwise
  * @see #processName
  * @see #getURI
  * @see #getPrefix
  */
 public boolean declarePrefix(String prefix, String uri) {
   if (prefix.equals("xml") || prefix.equals("xmlns")) {
     return false;
   } else {
     currentContext.declarePrefix(prefix, uri);
     return true;
   }
 }
  /**
   * Process a raw XML 1.0 name.
   *
   * <p>This method processes a raw XML 1.0 name in the current context by removing the prefix and
   * looking it up among the prefixes currently declared. The return value will be the array
   * supplied by the caller, filled in as follows:
   *
   * <dl>
   *   <dt>parts[0]
   *   <dd>The Namespace URI, or an empty string if none is in use.
   *   <dt>parts[1]
   *   <dd>The local name (without prefix).
   *   <dt>parts[2]
   *   <dd>The original raw name.
   * </dl>
   *
   * <p>All of the strings in the array will be internalized. If the raw name has a prefix that has
   * not been declared, then the return value will be null.
   *
   * <p>Note that attribute names are processed differently than element names: an unprefixed
   * element name will received the default Namespace (if any), while an unprefixed element name
   * will not.
   *
   * @param qName The raw XML 1.0 name to be processed.
   * @param parts A string array supplied by the caller, capable of holding at least three members.
   * @param isAttribute A flag indicating whether this is an attribute name (true) or an element
   *     name (false).
   * @return The supplied array holding three internalized strings representing the Namespace URI
   *     (or empty string), the local name, and the raw XML 1.0 name; or null if there is an
   *     undeclared prefix.
   * @see #declarePrefix
   * @see java.lang.String#intern
   */
  public String[] processName(String qName, String[] parts, boolean isAttribute) {
    String[] name = currentContext.processName(qName, isAttribute);
    if (name == null) return null;

    // JJK: This recopying is required because processName may return
    // a cached result. I Don't Like It. *****
    System.arraycopy(name, 0, parts, 0, 3);
    return parts;
  }
 /**
  * (Re)set the parent of this Namespace context. This is separate from the c'tor because it's
  * re-applied when a Context2 is reused by push-after-pop.
  *
  * @param parent The parent Namespace context object.
  */
 void setParent(Context2 parent) {
   this.parent = parent;
   parent.child = this; // JJK: Doubly-linked
   declarations = null;
   prefixTable = parent.prefixTable;
   uriTable = parent.uriTable;
   elementNameTable = parent.elementNameTable;
   attributeNameTable = parent.attributeNameTable;
   defaultNS = parent.defaultNS;
   tablesDirty = false;
 }
 /**
  * Return an enumeration of all prefixes declared in this context.
  *
  * <p>The empty (default) prefix will be included in this enumeration; note that this behaviour
  * differs from that of {@link #getPrefix} and {@link #getPrefixes}.
  *
  * @return An enumeration of all prefixes declared in this context.
  * @see #getPrefixes
  * @see #getURI
  */
 public Enumeration getDeclaredPrefixes() {
   return currentContext.getDeclaredPrefixes();
 }
 /**
  * Return one of the prefixes mapped to a Namespace URI.
  *
  * <p>If more than one prefix is currently mapped to the same URI, this method will make an
  * arbitrary selection; if you want all of the prefixes, use the {@link #getPrefixes} method
  * instead.
  *
  * <p><strong>Note:</strong> this will never return the empty (default) prefix; to check for a
  * default prefix, use the {@link #getURI getURI} method with an argument of "".
  *
  * @param uri The Namespace URI.
  * @return One of the prefixes currently mapped to the URI supplied, or null if none is mapped or
  *     if the URI is assigned to the default Namespace.
  * @see #getPrefixes(java.lang.String)
  * @see #getURI
  */
 public String getPrefix(String uri) {
   return currentContext.getPrefix(uri);
 }
 /**
  * Look up a prefix and get the currently-mapped Namespace URI.
  *
  * <p>This method looks up the prefix in the current context. Use the empty string ("") for the
  * default Namespace.
  *
  * @param prefix The prefix to look up.
  * @return The associated Namespace URI, or null if the prefix is undeclared in this context.
  * @see #getPrefix
  * @see #getPrefixes
  */
 public String getURI(String prefix) {
   return currentContext.getURI(prefix);
 }
 /**
  * Revert to the previous Namespace context.
  *
  * <p>Normally, you should pop the context at the end of each XML element. After popping the
  * context, all Namespace prefix mappings that were previously in force are restored.
  *
  * <p>You must not attempt to declare additional Namespace prefixes after popping a context,
  * unless you push another context first.
  *
  * @see #pushContext
  */
 public void popContext() {
   Context2 parentContext = currentContext.getParent();
   if (parentContext == null) throw new EmptyStackException();
   else currentContext = parentContext;
 }