https://openjdk.java.net/ 
/*
 * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
 */
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */

package com.sun.org.apache.xml.internal.serializer;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Stack;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;


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.usageinternal
@LastModified: Nov 2017
/**
 * 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.
 *
 * <p>For example:
 * <pre>
 * <chapter xmlns:p1="def">
 *   <paragraph xmlns:p2="ghi">
 *      <sentance xmlns:p3="jkl">
 *      </sentance>
 *    </paragraph>
 *    <paragraph xlmns:p4="mno">
 *    </paragraph>
 * </chapter>
 * </pre>
 *
 * When the <chapter> element is encounted the prefix "p1" associated with uri
 * "def" is pushed on the stack with depth 1.
 * When the first <paragraph> is encountered "p2" and "ghi" are pushed with
 * depth 2.
 * When the <sentance> is encountered "p3" and "jkl" are pushed with depth 3.
 * When </sentance> 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
 * @LastModified: Nov 2017
 */
public class NamespaceMappings
{
    
This member is continually incremented when new prefixes need to be
generated. ("ns0"  "ns1" ...)

/**
     * This member is continually incremented when new prefixes need to be
     * generated. ("ns0"  "ns1" ...)
     */
    private int count;

    
Each entry (prefix) in this hashmap points to a Stack of URIs
This 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.

/**
     * Each entry (prefix) in this hashmap points to a Stack of URIs
     * This 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 HashMap<String, Stack<MappingRecord>> m_namespaces = new HashMap<>();

    
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

/**
     * 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 Stack<MappingRecord> m_nodeStack = new Stack<>();

    private static final String EMPTYSTRING = "";
    private static final String XML_PREFIX = "xml"; // was "xmlns"

    
Default constructor

See Also:
  • Object.Object()
/**
     * Default constructor
     * @see java.lang.Object#Object()
     */
    public NamespaceMappings()
    {
        initNamespaces();
    }

    
This method initializes the namespace object with appropriate stacks
and predefines a few prefix/uri pairs which always exist.

/**
     * This method initializes the namespace object with appropriate stacks
     * and predefines a few prefix/uri pairs which always exist.
     */
    private void initNamespaces()
    {


        // Define the default namespace (initially maps to "" uri)
        Stack<MappingRecord> 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));

    }

    
Use a namespace prefix to lookup a namespace URI.

Params:
  • prefix – String the prefix of the namespace
Returns:the URI corresponding to the 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
     */
    public String lookupNamespace(String prefix)
    {
        final Stack<MappingRecord> stack = m_namespaces.get(prefix);
        return stack != null && !stack.isEmpty() ? (stack.peek()).m_uri : null;
    }

    MappingRecord getMappingFromPrefix(String prefix) {
        final Stack<MappingRecord> stack = m_namespaces.get(prefix);
        return stack != null && !stack.isEmpty() ? (stack.peek()) : null;
    }

    
Given a namespace uri, and the namespaces mappings for the
current element, return the current prefix for that uri.

Params:
  • uri – the namespace URI to be search for
Returns:an existing prefix that maps to the given URI, null if no prefix
maps to the given namespace 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.
     */
    public String lookupPrefix(String uri)
    {
        String foundPrefix = null;
        Iterator<String> itr = m_namespaces.keySet().iterator();
        while (itr.hasNext()) {
            String prefix = itr.next();
            String uri2 = lookupNamespace(prefix);
            if (uri2 != null && uri2.equals(uri))
            {
                foundPrefix = prefix;
                break;
            }
        }
        return foundPrefix;
    }

    MappingRecord getMappingFromURI(String uri)
    {
        MappingRecord foundMap = null;
        Iterator<String> itr = m_namespaces.keySet().iterator();
        while (itr.hasNext())
        {
            String prefix = itr.next();
            MappingRecord map2 = getMappingFromPrefix(prefix);
            if (map2 != null && (map2.m_uri).equals(uri))
            {
                foundMap = map2;
                break;
            }
        }
        return foundMap;
    }

    
Undeclare the namespace that is currently pointed to by a given prefix

/**
     * Undeclare the namespace that is currently pointed to by a given prefix
     */
    boolean popNamespace(String prefix)
    {
        // Prefixes "xml" and "xmlns" cannot be redefined
        if (prefix.startsWith(XML_PREFIX))
        {
            return false;
        }

        Stack<MappingRecord> stack;
        if ((stack = m_namespaces.get(prefix)) != null)
        {
            stack.pop();
            return true;
        }
        return false;
    }

    
Declare a mapping of a prefix to namespace URI at the given element depth.

Params:
  • prefix – a String with the prefix for a qualified name
  • uri – a String with the uri to which the prefix is to map
  • elemDepth – the depth of current declaration
/**
     * 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
     */
    boolean pushNamespace(String prefix, String uri, int elemDepth)
    {
        // Prefixes "xml" and "xmlns" cannot be redefined
        if (prefix.startsWith(XML_PREFIX))
        {
            return false;
        }

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

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

    
Pop, or undeclare all namespace definitions that are currently
declared at the given element depth, or deepter.

Params:
  • elemDepth – the element depth for which mappings declared at this
depth or deeper will no longer be valid
  • saxHandler – The ContentHandler to notify of any endPrefixMapping()
calls.  This parameter can be null.
/**
     * 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.
     */
    void popNamespaces(int elemDepth, ContentHandler saxHandler)
    {
        while (true)
        {
            if (m_nodeStack.isEmpty())
                return;
            MappingRecord map = 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 = 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
                }
            }

        }
    }

    
Generate a new namespace prefix ( ns0, ns1 ...) not used before

Returns:String a new namespace prefix ( ns0, ns1, ns2 ...)
/**
     * Generate a new namespace prefix ( ns0, ns1 ...) not used before
     * @return String a new namespace prefix ( ns0, ns1, ns2 ...)
     */
    public String generateNextPrefix()
    {
        return "ns" + (count++);
    }


    
This method makes a clone of this object.

/**
     * This method makes a clone of this object.
     *
     */
    @SuppressWarnings("unchecked")
    public Object clone() throws CloneNotSupportedException {
        NamespaceMappings clone = new NamespaceMappings();
        clone.m_nodeStack = (Stack<MappingRecord>) m_nodeStack.clone();
        clone.m_namespaces = (HashMap<String, Stack<MappingRecord>>) m_namespaces.clone();
        clone.count = count;
        return clone;

    }

    final void reset()
    {
        this.count = 0;
        this.m_namespaces.clear();
        this.m_nodeStack.clear();
        initNamespaces();
    }

    class MappingRecord {
        final String m_prefix;  // the prefix
        final String m_uri;     // the uri
        // the depth of the element where declartion was made
        final int m_declarationDepth;
        MappingRecord(String prefix, String uri, int depth) {
            m_prefix = prefix;
            m_uri = uri;
            m_declarationDepth = depth;

        }
    }

}