NamespaceHandling

package org.exolab.castor.xml.parsing;

import java.util.Enumeration;
import java.util.HashMap;

import org.apache.commons.lang.StringUtils;
import org.exolab.castor.mapping.FieldHandler;
import org.exolab.castor.mapping.MapItem;
import org.exolab.castor.xml.*;
import org.xml.sax.SAXException;

/**
 * This class is used by the {@link UnmarshalHandler} to handle name spaces. It
 * manages a stack of name spaces, keeps track of when an new name space scope
 * is needed and maps name space URIs to package names.
 *
 * @author <a href="mailto:philipp DOT erlacher AT gmail DOT com">Philipp
 *         Erlacher</a>
 *
 * @since 1.3.2
 */
public class NamespaceHandling {

    /**
     * Represents the namespace stack.
     */
    private NamespacesStack namespacesStack = new NamespacesStack();

    /**
     * A map of name space URIs to package names.
     */
    private HashMap<String, String> _namespaceToPackage = new HashMap<String, String>();

    /**
     * A flag to keep track of when a new name space scope is needed.
     */
    private boolean _createNamespaceScope = true;

    /**
     * The built-in XML prefix used for xml:space, xml:lang and, as the XML 1.0
     * Namespaces document specifies, are reserved for use by XML and XML
     * related specs.
     **/
    private static final String XML_PREFIX = "xml";

    /**
     * Adds a mapping from the given namespace URI to the given package name.
     *
     * @param nsURI
     *            the namespace URI to map from.
     * @param packageName
     *            the package name to map to.
     */
    public void addNamespaceToPackageMapping(String nsURI, String packageName) {
        _namespaceToPackage.put(StringUtils.defaultString(nsURI), StringUtils
                .defaultString(packageName));

    }

    /**
     * Looks up the package name from the given namespace URI.
     *
     * @param namespace
     *            the namespace URI to lookup
     * @return the package name or null.
     */
    public String getMappedPackage(final String namespace) {
        return _namespaceToPackage.get(StringUtils.defaultString(namespace));
    }

    /**
     * Saves local namespace declarations to the object model if necessary.
     *
     * @param classDesc
     *            the current ClassDescriptor.
     * @param object
     *            the Object of the current state
     **/
    public void processNamespaces(XMLClassDescriptor classDesc, Object object) {

        if (classDesc == null) {
            return;
        }

        // -- process namespace nodes
        XMLFieldDescriptor nsDescriptor = classDesc.getFieldDescriptor(null,
                null, NodeType.Namespace);

        if (nsDescriptor != null) {
            FieldHandler handler = nsDescriptor.getHandler();
            if (handler != null) {
                Enumeration<String> enumeration = namespacesStack
                        .getLocalNamespacePrefixes();
                while (enumeration.hasMoreElements()) {
                    String nsPrefix = StringUtils.defaultString(enumeration
                            .nextElement());
                    String nsURI = StringUtils.defaultString(namespacesStack
                            .getNamespaceURI(nsPrefix));
                    MapItem mapItem = new MapItem(nsPrefix, nsURI);
                    handler.setValue(object, mapItem);
                }
            }
        }
    }

    /**
     * Extracts the prefix and resolves it to it's associated namespace. If the
     * prefix is 'xml', then no resolution will occur, however in all other
     * cases the resolution will change the prefix:value as {NamespaceURI}value
     *
     * @param value
     *            the QName to resolve.
     * @return
     * @throws SAXException
     *             if the nammespace associated with the prefix is null
     */
    public Object resolveNamespace(Object value) throws SAXException {

        if ((value == null) || !(value instanceof String)) {
            return value;
        }

        String result = (String) value;
        int idx = result.indexOf(':');
        String prefix = null;
        if (idx > 0) {
            prefix = result.substring(0, idx);
            if (XML_PREFIX.equals(prefix)) {
                // -- Do NOT Resolve the 'xml' prefix.
                return value;
            }
            result = result.substring(idx + 1);
        }
        String namespace = getNamespaceURI(prefix);
        if (StringUtils.isNotEmpty(namespace)) {
            result = '{' + namespace + '}' + result;
            return result;
        } else if ((namespace == null) && (prefix != null)) {
            throw new SAXException(
                    "The namespace associated with the prefix: '" + prefix
                            + "' is null.");
        } else {
            return result;
        }

    }

    /**
     * Pops the current namespace instance
     */
    public void removeCurrentNamespaceInstance() {
        namespacesStack.removeNamespaceScope();
    }

    /**
     * Binds the namespaceURI to the default namespace.
     *
     * @param namespaceURI
     *            Namespace URI
     */
    public void addDefaultNamespace(String namespaceURI) {
        namespacesStack.addDefaultNamespace(namespaceURI);
    }

    /**
     * Binds the namespaceURI to the prefix
     *
     * @param prefix
     *            XML name space prefix
     * @param namespaceURI
     *            XML name space URI.
     */
    public void addNamespace(String prefix, String namespaceURI) {
        namespacesStack.addNamespace(prefix, namespaceURI);

    }

    /**
     * Gets the prefix that is bound to a namespaceURI.
     *
     * @param namespaceURI
     *            the namespaceURI to get the prefix from
     * @return prefix
     */
    public String getNamespacePrefix(String namespaceURI) {
        return namespacesStack.getNamespacePrefix(namespaceURI);
    }

    /**
     * Gets the namespaceURI that is bound to a prefix.
     *
     * @param prefix
     *            the prefix to get the namespaceURI from
     * @return namespaceURI The corresponding namespace URI.
     */
    public String getNamespaceURI(String prefix) {
        return namespacesStack.getNamespaceURI(prefix);
    }

    /**
     * Gets the namespace URI that is bound to the default name space.
     *
     * @return namespaceURI The namespace URI bound to the default namespace.
     */
    public String getDefaultNamespaceURI() {
        return namespacesStack.getDefaultNamespaceURI();
    }

    /**
     * Creates a new name space.
     */
    public void createNamespace() {
        namespacesStack.addNewNamespaceScope();
    }

    /**
     * Returns the namespace stack.
     * @return the namespace stack.
     */
    public NamespacesStack getNamespaceStack() {
        return namespacesStack;
    }

    /**
     * Indicates whether a new name space scope is needed.
     *
     * @return true if a new name space scope is necessary.
     */
    public boolean isNewNamespaceScopeNecessary() {
        if (_createNamespaceScope) {
            return true;
        }
        return false;
    }

    /**
     * Starts a new name space scope, and resets the corresponding flag.
     */
    public void startNamespaceScope() {
        createNamespace();
        _createNamespaceScope = true;
    }

    /**
     * Stops a name space scope, and resets the corresponding flag to false.
     */
    public void stopNamespaceScope() {
        createNamespace();
        _createNamespaceScope = false;
    }

    public void setNewNamespaceScopeNecessary(boolean value) {
        _createNamespaceScope = value;

    }
}