FileDocCategorySizeDatePackage
NamespaceMappings.javaAPI DocJava SE 6 API10398Tue Jun 10 00:23:06 BST 2008com.sun.org.apache.xml.internal.serializer

NamespaceMappings

public class NamespaceMappings extends Object
This class keeps track of the currently defined namespaces. Conceptually the prefix/uri/depth triplets are pushed on a stack pushed on a stack. The depth indicates the nesting depth of the element for which the mapping was made.

For example:
When the element is encounted the prefix "p1" associated with uri "def" is pushed on the stack with depth 1. When the first is encountered "p2" and "ghi" are pushed with depth 2. When the is encountered "p3" and "jkl" are pushed with depth 3. When occurs the popNamespaces(3) will pop "p3"/"jkl" off the stack. Of course popNamespaces(2) would pop anything with depth 2 or greater. So prefix/uri pairs are pushed and poped off the stack as elements are processed. At any given moment of processing the currently visible prefixes are on the stack and a prefix can be found given a uri, or a uri can be found given a prefix. This class is public only because it is used by Xalan. It is not a public API
xsl.usage
internal

Fields Summary
private int
count
This member is continually incremented when new prefixes need to be generated. ("ns0" "ns1" ...)
private Hashtable
m_namespaces
Each entry (prefix) in this hashtable points to a Stack of URIs This table maps a prefix (String) to a Stack of prefix mappings. All mappings in that retrieved stack have the same prefix, though possibly different URI's or depths. Such a stack must have mappings at deeper depths push later on such a stack. Mappings pushed earlier on the stack will have smaller values for MappingRecord.m_declarationDepth.
private Stack
m_nodeStack
The top of this stack contains the MapRecord of the last declared a namespace. Used to know how many prefix mappings to pop when leaving the current element depth. For every prefix mapping the current element depth is pushed on this stack. That way all prefixes pushed at the current depth can be removed at the same time. Used to ensure prefix/uri map scopes are closed correctly
private static final String
EMPTYSTRING
private static final String
XML_PREFIX
Constructors Summary
public NamespaceMappings()
Default constructor

see
java.lang.Object#Object()

 // was "xmlns"

             
     
    
        initNamespaces();
Methods Summary
public java.lang.Objectclone()
This method makes a clone of this object.

        NamespaceMappings clone = new NamespaceMappings();
        clone.m_nodeStack = (Stack) m_nodeStack.clone();
        clone.m_namespaces = (Hashtable) m_namespaces.clone();
        
        clone.count = count;
        return clone;
public java.lang.StringgenerateNextPrefix()
Generate a new namespace prefix ( ns0, ns1 ...) not used before

return
String a new namespace prefix ( ns0, ns1, ns2 ...)

        return "ns" + (count++);
com.sun.org.apache.xml.internal.serializer.NamespaceMappings$MappingRecordgetMappingFromPrefix(java.lang.String prefix)

        final Stack stack = (Stack) m_namespaces.get(prefix);
        return stack != null && !stack.isEmpty() ? 
            ((MappingRecord) stack.peek()) : null;
com.sun.org.apache.xml.internal.serializer.NamespaceMappings$MappingRecordgetMappingFromURI(java.lang.String uri)

        MappingRecord foundMap = null;
        Enumeration prefixes = m_namespaces.keys();
        while (prefixes.hasMoreElements())
        {
            String prefix = (String) prefixes.nextElement();
            MappingRecord map2 = getMappingFromPrefix(prefix);
            if (map2 != null && (map2.m_uri).equals(uri))
            {
                foundMap = map2;
                break;
            }
        }
        return foundMap;
private voidinitNamespaces()
This method initializes the namespace object with appropriate stacks and predefines a few prefix/uri pairs which always exist.

 

        // Define the default namespace (initially maps to "" uri)
        Stack stack;
        m_namespaces.put(EMPTYSTRING, stack = new Stack());
        stack.push(new MappingRecord(EMPTYSTRING,EMPTYSTRING,0));

        m_namespaces.put(XML_PREFIX, stack = new Stack());
        stack.push(new MappingRecord( XML_PREFIX,
            "http://www.w3.org/XML/1998/namespace",0));

        m_nodeStack.push(new MappingRecord(null,null,-1));
public java.lang.StringlookupNamespace(java.lang.String prefix)
Use a namespace prefix to lookup a namespace URI.

param
prefix String the prefix of the namespace
return
the URI corresponding to the prefix

        final Stack stack = (Stack) m_namespaces.get(prefix);
        return stack != null && !stack.isEmpty() ? 
            ((MappingRecord) stack.peek()).m_uri : null;
public java.lang.StringlookupPrefix(java.lang.String uri)
Given a namespace uri, and the namespaces mappings for the current element, return the current prefix for that uri.

param
uri the namespace URI to be search for
return
an existing prefix that maps to the given URI, null if no prefix maps to the given namespace URI.

        String foundPrefix = null;
        Enumeration prefixes = m_namespaces.keys();
        while (prefixes.hasMoreElements())
        {
            String prefix = (String) prefixes.nextElement();
            String uri2 = lookupNamespace(prefix);
            if (uri2 != null && uri2.equals(uri))
            {
                foundPrefix = prefix;
                break;
            }
        }
        return foundPrefix;
booleanpopNamespace(java.lang.String prefix)
Undeclare the namespace that is currently pointed to by a given prefix

        // Prefixes "xml" and "xmlns" cannot be redefined
        if (prefix.startsWith(XML_PREFIX))
        {
            return false;
        }

        Stack stack;
        if ((stack = (Stack) m_namespaces.get(prefix)) != null)
        {
            stack.pop();
            return true;
        }
        return false;
voidpopNamespaces(int elemDepth, org.xml.sax.ContentHandler saxHandler)
Pop, or undeclare all namespace definitions that are currently declared at the given element depth, or deepter.

param
elemDepth the element depth for which mappings declared at this depth or deeper will no longer be valid
param
saxHandler The ContentHandler to notify of any endPrefixMapping() calls. This parameter can be null.

        while (true)
        {
            if (m_nodeStack.isEmpty())
                return;
            MappingRecord map = (MappingRecord)(m_nodeStack.peek());
            int depth = map.m_declarationDepth;
            if (depth < elemDepth)
                return;
            /* the depth of the declared mapping is elemDepth or deeper
             * so get rid of it
             */

            map = (MappingRecord) m_nodeStack.pop();
            final String prefix = map.m_prefix; 
            popNamespace(prefix);
            if (saxHandler != null)
            {
                try
                {
                    saxHandler.endPrefixMapping(prefix);
                }
                catch (SAXException e)
                {
                    // not much we can do if they aren't willing to listen
                }
            }
               
        }
booleanpushNamespace(java.lang.String prefix, java.lang.String uri, int elemDepth)
Declare a mapping of a prefix to namespace URI at the given element depth.

param
prefix a String with the prefix for a qualified name
param
uri a String with the uri to which the prefix is to map
param
elemDepth the depth of current declaration

        // Prefixes "xml" and "xmlns" cannot be redefined
        if (prefix.startsWith(XML_PREFIX))
        {
            return false;
        }

        Stack stack;
        // Get the stack that contains URIs for the specified prefix
        if ((stack = (Stack) m_namespaces.get(prefix)) == null)
        {
            m_namespaces.put(prefix, stack = new Stack());
        }

        if (!stack.empty() && uri.equals(((MappingRecord)stack.peek()).m_uri))
        {
            return false;
        }
        MappingRecord map = new MappingRecord(prefix,uri,elemDepth);
        stack.push(map);
        m_nodeStack.push(map);
        return true;
final voidreset()

        this.count = 0;
        this.m_namespaces.clear();
        this.m_nodeStack.clear();        
        initNamespaces();