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