moxy/org.eclipse.persistence.moxy/src/main/java/org/eclipse/persistence/jaxb/compiler/NamespaceInfo.java

/*
 * Copyright (c) 1998, 2020 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0,
 * or the Eclipse Distribution License v. 1.0 which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 */

// Contributors:
//     Oracle - initial API and implementation from Oracle TopLink
package org.eclipse.persistence.jaxb.compiler;

import java.util.Map;

import org.eclipse.persistence.oxm.NamespaceResolver;

/**
 *  INTERNAL:
 *  <p><b>Purpose:</b>To store some information about a schema's target namespace and some additional
 *  information gathered from XmlSchema annotation at the package (namespace) level
 *  <p><b>Responsibilities:</b><ul>
 *  <li>Store target namespace and namespace prefix information for a specific schema</li>
 *  <li>Store some additional Schema information (such as element/attribute form and XmlAccessType)</li>
 *  </ul>
 *
 *  @see org.eclipse.persistence.jaxb.compiler.AnnotationsProcessor
 *  @author mmacivor
 *  @since Oracle TopLink 11.1.1.0.0
 */

public class NamespaceInfo {
    private String namespace;
    private boolean attributeFormQualified = false;
    private boolean elementFormQualified = false;
    private NamespaceResolver namespaceResolver;
    private String location;
    private NamespaceResolver namespaceResolverForDescriptor;

    public String getNamespace() {
        return namespace;
    }

    public void setNamespace(String ns) {
        if(ns != null) {
            ns = ns.intern();
        }
        this.namespace = ns;
    }

    public boolean isAttributeFormQualified() {
        return attributeFormQualified;
    }

    public void setAttributeFormQualified(boolean b) {
        attributeFormQualified = b;
    }

    public boolean isElementFormQualified() {
        return elementFormQualified;
    }

    public void setElementFormQualified(boolean b) {
        elementFormQualified = b;
    }

    public NamespaceResolver getNamespaceResolver() {
        return namespaceResolver;
    }

    public void setNamespaceResolver(NamespaceResolver resolver) {
        namespaceResolver = resolver;
    }

    public String getLocation() {
        return location;
    }

    public void setLocation(String location) {
        this.location = location;
    }

    /** Provides a {@link NamespaceResolver} resolver for Descriptor.
     * <p>
     * The returned {@link NamespaceResolver} is consistent with {@code contextResolver}.
     * Should there be any clashes in prefix or default name-space assignments,
     * these will be re-mapped to another prefix in the resulting resolver.
     * Alongside, all new prefix or default name-space assignments are added to the {@code contextResolver}.
     * <p>
     * <b>IMPORTANT</b>: The first result is cached and re-used since then,
     * even if later calls are with different {@code contextResolver}.
     *
     * @param contextResolver context resolver
     * @param canUseDefaultNamespace indicates whether default name-space can be used
     * @return {@link NamespaceResolver}
     *
     * @throws NullPointerException if {@code contextResolver} is {@code null}
     */
    public NamespaceResolver getNamespaceResolverForDescriptor(
            NamespaceResolver contextResolver,
            boolean canUseDefaultNamespace) {
        if(this.namespaceResolverForDescriptor == null) {
            this.namespaceResolverForDescriptor = new NamespaceResolver();
            // initialize
            // prefixed name-spaces
            if(this.namespaceResolver.hasPrefixesToNamespaces()) {
                for(Map.Entry<String, String> entry: this.namespaceResolver.getPrefixesToNamespaces().entrySet()) {
                    final String namespace = entry.getValue();
                    if (namespace != null) {
                        addToDescriptorNamespaceResolver(false, entry.getKey(), namespace, contextResolver);
                    }
                }
            }
            // default name-space
            final String defaultNS = this.namespaceResolver.getDefaultNamespaceURI();
            if (defaultNS != null) {
                boolean isDefault = canUseDefaultNamespace || defaultNS.equals(namespace);
                addToDescriptorNamespaceResolver(isDefault, null, defaultNS, contextResolver);
            }
        }
        return this.namespaceResolverForDescriptor;
    }

    private void addToDescriptorNamespaceResolver(
            boolean asDefault,
            String prefix,
            String namespace,
            NamespaceResolver contextResolver) {
        String contextDefault = contextResolver.getDefaultNamespaceURI();
        if (asDefault && (contextDefault == null || contextDefault.equals(namespace))) {
            this.namespaceResolverForDescriptor.setDefaultNamespaceURI(namespace);
            contextResolver.setDefaultNamespaceURI(namespace);
        } else {
            String newPrefix = prefix == null
                    || contextResolver.hasPrefix(prefix)
                    || namespaceResolverForDescriptor.hasPrefix(prefix)
                ? getNamespacePrefixForDescriptorNamespaceResolver(namespace, contextResolver)
                : prefix;
            this.namespaceResolverForDescriptor.put(newPrefix, namespace);
            contextResolver.put(newPrefix, namespace);
        }
    }

    private String getNamespacePrefixForDescriptorNamespaceResolver(String namespace, NamespaceResolver contextResolver) {
        String prefix = contextResolver.resolveNamespaceURI(namespace);
        while (prefix == null
                || namespaceResolverForDescriptor.hasPrefix(prefix)) {
            prefix = contextResolver.generatePrefix();
        }
        return prefix;
    }
}