/**
* 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;
}