com.sun.tools.txw2.builder.xsd.XmlSchemaBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of txwc2 Show documentation
The newest version!
/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 2005-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License.  You can
 * obtain a copy of the License at
 * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
 * or packager/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at packager/legal/LICENSE.txt.
 *
 * GPL Classpath Exception:
 * Oracle designates this particular file as subject to the "Classpath"
 * exception as provided by Oracle in the GPL Version 2 section of the License
 * file that accompanied this code.
 *
 * Modifications:
 * If applicable, add the following below the License Header, with the fields
 * enclosed by brackets [] replaced by your own identifying information:
 * "Portions Copyright [year] [name of copyright owner]"
 *
 * Contributor(s):
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

package com.sun.tools.txw2.builder.xsd;

import com.sun.codemodel.JType;
import com.sun.tools.txw2.TxwOptions;
import com.sun.tools.txw2.builder.relaxng.DatatypeFactory;
import com.sun.tools.txw2.model.Attribute;
import com.sun.tools.txw2.model.Data;
import com.sun.tools.txw2.model.Define;
import com.sun.tools.txw2.model.Empty;
import com.sun.tools.txw2.model.Grammar;
import com.sun.tools.txw2.model.Leaf;
import com.sun.tools.txw2.model.List;
import com.sun.tools.txw2.model.NodeSet;
import com.sun.tools.txw2.model.Element;
import com.sun.tools.txw2.model.Ref;
import com.sun.xml.xsom.XSAnnotation;
import com.sun.xml.xsom.XSAttributeDecl;
import com.sun.xml.xsom.XSAttributeUse;
import com.sun.xml.xsom.XSComplexType;
import com.sun.xml.xsom.XSContentType;
import com.sun.xml.xsom.XSDeclaration;
import com.sun.xml.xsom.XSFacet;
import com.sun.xml.xsom.XSIdentityConstraint;
import com.sun.xml.xsom.XSListSimpleType;
import com.sun.xml.xsom.XSNotation;
import com.sun.xml.xsom.XSParticle;
import com.sun.xml.xsom.XSRestrictionSimpleType;
import com.sun.xml.xsom.XSSchema;
import com.sun.xml.xsom.XSSchemaSet;
import com.sun.xml.xsom.XSSimpleType;
import com.sun.xml.xsom.XSUnionSimpleType;
import com.sun.xml.xsom.XSXPath;
import com.sun.xml.xsom.XSWildcard;
import com.sun.xml.xsom.XSModelGroupDecl;
import com.sun.xml.xsom.XSModelGroup;
import com.sun.xml.xsom.XSElementDecl;
import com.sun.xml.xsom.XSType;
import com.sun.xml.xsom.XSAttContainer;
import com.sun.xml.xsom.XSAttGroupDecl;
import com.sun.xml.xsom.visitor.XSFunction;
import com.sun.xml.xsom.visitor.XSSimpleTypeFunction;

import javax.xml.namespace.QName;
import java.util.Map;
import java.util.HashMap;

/**
 * @author Kohsuke Kawaguchi
 */
public final class XmlSchemaBuilder implements XSFunction, XSSimpleTypeFunction {
    public static NodeSet build( XSSchemaSet xs, TxwOptions opts ) {
        XmlSchemaBuilder builder = new XmlSchemaBuilder(xs,opts);
        builder.build(xs);
        return builder.nodeSet;
    }

    private void build(XSSchemaSet xs) {
        // make sure that we bind all complex types
        for( XSSchema s : xs.getSchemas() ) {
            for( XSComplexType t : s.getComplexTypes().values() ) {
                t.apply(this);
            }
        }

        nodeSet.addAll(complexTypes.values());
        nodeSet.addAll(modelGroups.values());
        nodeSet.addAll(attGroups.values());
    }

    public Leaf simpleType(XSSimpleType simpleType) {
        return simpleType.apply((XSSimpleTypeFunction)this);
    }

    public Leaf particle(XSParticle particle) {
        return particle.getTerm().apply(this);
    }

    public Leaf empty(XSContentType empty) {
        return new Empty(empty.getLocator());
    }

    public Attribute attributeDecl(XSAttributeDecl decl) {
        return new Attribute(decl.getLocator(),
                        getQName(decl),
                        simpleType(decl.getType()));
    }

    public Attribute attributeUse(XSAttributeUse use) {
        return attributeDecl(use.getDecl());
    }

    public Leaf wildcard(XSWildcard wc) {
        // wildcard can be always written through the well-formedness method.
        // no need to generate anything for this.
        return new Empty(wc.getLocator());
    }

    public Leaf modelGroupDecl(XSModelGroupDecl mg) {
        Define def = modelGroups.get(mg);
        if(def==null) {
            def = grammar.get(mg.getName()); // TODO: name collision detection and avoidance
            modelGroups.put(mg,def);

            def.addChild(mg.getModelGroup().apply(this));
        }
        return new Ref(mg.getLocator(),def);
    }

    public Leaf modelGroup(XSModelGroup mg) {
        XSParticle[] children = mg.getChildren();
        if(children.length==0)  return new Empty(mg.getLocator());

        Leaf l = particle(children[0]);
        for( int i=1; i modelGroups = new HashMap();

    /**
     * We map complex types to interfaces.
     */
    private final Map complexTypes = new HashMap();

    /**
     * ... and attribute groups
     */
    private final Map attGroups = new HashMap();

    private final Grammar grammar = new Grammar();

    private XmlSchemaBuilder(XSSchemaSet xs,TxwOptions opts) {
        this.schemaSet = xs;
        grammar.addChild(new Empty(null));
        this.nodeSet = new NodeSet(opts,grammar);
        this.dtf = new DatatypeFactory(opts.codeModel);
    }



// won't be used
    public Leaf annotation(XSAnnotation xsAnnotation) {
        throw new IllegalStateException();
    }

    public Leaf schema(XSSchema xsSchema) {
        throw new IllegalStateException();
    }

    public Leaf facet(XSFacet xsFacet) {
        throw new IllegalStateException();
    }

    public Leaf notation(XSNotation xsNotation) {
        throw new IllegalStateException();
    }

    public Leaf identityConstraint(XSIdentityConstraint xsIdentityConstraint) {
        throw new IllegalStateException();
    }

    public Leaf xpath(XSXPath xsxPath) {
        throw new IllegalStateException();
    }
}