com.sun.xml.xsom.impl.util.SchemaWriter Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jaxb-xjc
Old JAXB Binding Compiler. Contains source code needed for binding customization files into java sources. In other words: the *tool* to generate java classes for the given xml representation.
There is a newer version: 4.0.5
Show newest version
/*
 * The contents of this file are subject to the terms
 * of the Common Development and Distribution License
 * (the "License").  You may not use this file except
 * in compliance with the License.
 * 
 * You can obtain a copy of the license at
 * https://jwsdp.dev.java.net/CDDLv1.0.html
 * See the License for the specific language governing
 * permissions and limitations under the License.
 * 
 * When distributing Covered Code, include this CDDL
 * HEADER in each file and include the License file at
 * https://jwsdp.dev.java.net/CDDLv1.0.html  If applicable,
 * add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your
 * own identifying information: Portions Copyright [yyyy]
 * [name of copyright owner]
 */
package com.sun.xml.xsom.impl.util;

import com.sun.xml.xsom.XSAnnotation;
import com.sun.xml.xsom.XSAttGroupDecl;
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.XSElementDecl;
import com.sun.xml.xsom.XSFacet;
import com.sun.xml.xsom.XSIdentityConstraint;
import com.sun.xml.xsom.XSListSimpleType;
import com.sun.xml.xsom.XSModelGroup;
import com.sun.xml.xsom.XSModelGroupDecl;
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.XSType;
import com.sun.xml.xsom.XSUnionSimpleType;
import com.sun.xml.xsom.XSWildcard;
import com.sun.xml.xsom.XSXPath;
import com.sun.xml.xsom.impl.Const;
import com.sun.xml.xsom.visitor.XSSimpleTypeVisitor;
import com.sun.xml.xsom.visitor.XSTermVisitor;
import com.sun.xml.xsom.visitor.XSVisitor;

import java.io.IOException;
import java.io.Writer;
import java.text.MessageFormat;
import java.util.Iterator;

/**
 * Generates approximated XML Schema representation from
 * a schema component. This is not intended to be a fully-fledged
 * round-trippable schema writer.
 *
 * Usage of this class
 * 
 *  Create a new instance with whatever Writer
 *      you'd like to send the output to.
 *  
Call one of the overloaded dump methods.
 *      You can repeat this process as many times as you want.
 * 
 *
 * @author Kohsuke Kawaguchi ([email protected])
 * @author Kirill Grouchnikov ([email protected])
 */
public class SchemaWriter implements XSVisitor, XSSimpleTypeVisitor {
    public SchemaWriter( Writer _out ) {
        this.out=_out;
    }

    /** output is sent to this object. */
    private final Writer out;

    /** indentation. */
    private int indent;

    private void println(String s) {
        try {
            for( int i=0; i",
            new Object[]{
                s.getTargetNamespace(),
            }));
        indent++;

        Iterator itr;

        itr = s.iterateAttGroupDecls();
        while(itr.hasNext())
            attGroupDecl( (XSAttGroupDecl)itr.next() );

        itr = s.iterateAttributeDecls();
        while(itr.hasNext())
            attributeDecl( (XSAttributeDecl)itr.next() );

        itr = s.iterateComplexTypes();
        while(itr.hasNext())
            complexType( (XSComplexType)itr.next() );

        itr = s.iterateElementDecls();
        while(itr.hasNext())
            elementDecl( (XSElementDecl)itr.next() );

        itr = s.iterateModelGroupDecls();
        while(itr.hasNext())
            modelGroupDecl( (XSModelGroupDecl)itr.next() );

        itr = s.iterateSimpleTypes();
        while(itr.hasNext())
            simpleType( (XSSimpleType)itr.next() );

        indent--;
        println("");
    }

    public void attGroupDecl( XSAttGroupDecl decl ) {
        Iterator itr;

        println(MessageFormat.format("",
            new Object[]{ decl.getName() }));
        indent++;
        
        // TODO: wildcard
        
        itr = decl.iterateAttGroups();
        while(itr.hasNext())
            dumpRef( (XSAttGroupDecl)itr.next() );

        itr = decl.iterateDeclaredAttributeUses();
        while(itr.hasNext())
            attributeUse( (XSAttributeUse)itr.next() );

        indent--;
        println("");
    }

    public void dumpRef( XSAttGroupDecl decl ) {
        println(MessageFormat.format("",
            new Object[]{ decl.getTargetNamespace(), decl.getName() }));
    }

    public void attributeUse( XSAttributeUse use ) {
        XSAttributeDecl decl = use.getDecl();

        String additionalAtts="";

        if(use.isRequired())
            additionalAtts += " use=\"required\"";
        if(use.getFixedValue()!=null && use.getDecl().getFixedValue()==null)
            additionalAtts += " fixed=\""+use.getFixedValue()+'\"';
        if(use.getDefaultValue()!=null && use.getDecl().getDefaultValue()==null)
            additionalAtts += " default=\""+use.getDefaultValue()+'\"';

        if(decl.isLocal()) {
            // this is anonymous attribute use
            dump(decl,additionalAtts);
        } else {
            // reference to a global one
            println(MessageFormat.format("",
                new Object[]{ decl.getTargetNamespace(), decl.getName(),
                    additionalAtts }));
        }
    }

    public void attributeDecl( XSAttributeDecl decl ) {
        dump(decl,"");
    }

    private void dump( XSAttributeDecl decl, String additionalAtts ) {
        XSSimpleType type=decl.getType();

        println(MessageFormat.format("",
            new Object[]{
                decl.getName(),
                additionalAtts,
                type.isLocal()?"":
                MessageFormat.format(" type=\"'{'{0}'}'{1}\"",
                new Object[]{
                    type.getTargetNamespace(),
                    type.getName()
                }),
                decl.getFixedValue()==null ?
                    "":" fixed=\""+decl.getFixedValue()+'\"',
                decl.getDefaultValue()==null ?
                    "":" default=\""+decl.getDefaultValue()+'\"',
                type.isLocal()?"":" /"
            }));

        if(type.isLocal()) {
            indent++;
            simpleType(type);
            indent--;
            println("");
        }
    }

    public void simpleType( XSSimpleType type ) {
        println(MessageFormat.format("",
            new Object[]{
                type.isLocal()?"":" name=\""+type.getName()+'\"'
            }));
        indent++;

        type.visit((XSSimpleTypeVisitor)this);

        indent--;
        println("");
    }

    public void listSimpleType( XSListSimpleType type ) {
        XSSimpleType itemType = type.getItemType();

        if(itemType.isLocal()) {
            println("");
            indent++;
            simpleType(itemType);
            indent--;
            println("");
        } else {
            // global type
            println(MessageFormat.format("",
                new Object[]{
                    itemType.getTargetNamespace(),
                    itemType.getName()
                }));
        }
    }

    public void unionSimpleType( XSUnionSimpleType type ) {
        final int len = type.getMemberSize();
        StringBuffer ref = new StringBuffer();

        for( int i=0; i");
        else
            println("");
        indent++;

        for( int i=0; i");
    }

    public void restrictionSimpleType( XSRestrictionSimpleType type ) {

        if(type.getBaseType()==null) {
            // don't print anySimpleType
            if(!type.getName().equals("anySimpleType"))
                throw new InternalError();
            if(!Const.schemaNamespace.equals(type.getTargetNamespace()))
                throw new InternalError();
            return;
        }

        XSSimpleType baseType = type.getSimpleBaseType();

        println(MessageFormat.format("",
            new Object[]{
                baseType.isLocal()?"":" base=\"{"+
                baseType.getTargetNamespace()+'}'+
                baseType.getName()+'\"'
            }));
        indent++;

        if(baseType.isLocal())
            simpleType(baseType);

        Iterator itr = type.iterateDeclaredFacets();
        while(itr.hasNext())
            facet( (XSFacet)itr.next() );

        indent--;
        println("");
    }

    public void facet( XSFacet facet ) {
        println(MessageFormat.format("<{0} value=\"{1}\"/>",
            new Object[]{
                facet.getName(), facet.getValue(),
            }));
    }

    public void notation( XSNotation notation ) {
        println(MessageFormat.format("");
            indent++;

            XSType baseType = type.getBaseType();

            if(type.getDerivationMethod()==XSType.RESTRICTION) {
                // restriction
                println(MessageFormat.format("{1}\">",
                    new Object[]{
                        baseType.getTargetNamespace(),
                        baseType.getName() }));
                indent++;

                dumpComplexTypeAttribute(type);

                indent--;
                println("");
            } else {
                // extension
                println(MessageFormat.format("{1}\">",
                    new Object[]{
                        baseType.getTargetNamespace(),
                        baseType.getName() }));

                // check if have redefine tag - Kirill
                if( type.isGlobal()
                && type.getTargetNamespace().equals(baseType.getTargetNamespace())
                && type.getName().equals(baseType.getName())) {
                    indent++;
                    println("");
                    indent++;
                    baseType.visit(this);
                    indent--;
                    println("");
                    indent--;
                }

                indent++;

                dumpComplexTypeAttribute(type);

                indent--;
                println("");
            }

            indent--;
            println("");
        } else {
            // complex content
            println("");
            indent++;

            XSComplexType baseType = type.getBaseType().asComplexType();

            if(type.getDerivationMethod()==XSType.RESTRICTION) {
                // restriction
                println(MessageFormat.format("",
                    new Object[]{
                        baseType.getTargetNamespace(),
                        baseType.getName() }));
                indent++;

                type.getContentType().visit(this);
                dumpComplexTypeAttribute(type);

                indent--;
                println("");
            } else {
                // extension
                println(MessageFormat.format("",
                    new Object[]{
                        baseType.getTargetNamespace(),
                        baseType.getName() }));

                // check if have redefine - Kirill
                if( type.isGlobal()
                && type.getTargetNamespace().equals(baseType.getTargetNamespace())
                && type.getName().equals(baseType.getName())) {
                    indent++;
                    println("");
                    indent++;
                    baseType.visit(this);
                    indent--;
                    println("");
                    indent--;
                }

                indent++;

                type.getExplicitContent().visit(this);
                dumpComplexTypeAttribute(type);

                indent--;
                println("");
            }

            indent--;
            println("");
        }

        indent--;
        println("");
    }

    private void dumpComplexTypeAttribute( XSComplexType type ) {
        Iterator itr;

        itr = type.iterateAttGroups();
        while(itr.hasNext())
            dumpRef( (XSAttGroupDecl)itr.next() );

        itr = type.iterateDeclaredAttributeUses();
        while(itr.hasNext())
            attributeUse( (XSAttributeUse)itr.next() );
    }

    public void elementDecl( XSElementDecl decl ) {
        elementDecl(decl,"");
    }
    private void elementDecl( XSElementDecl decl, String extraAtts ) {
        XSType type = decl.getType();
        
        // TODO: various other attributes 
        
        println(MessageFormat.format("",
            new Object[]{
                decl.getName(),
                type.isLocal()?"":" type=\"{"+
                    type.getTargetNamespace()+'}'+
                    type.getName()+'\"',
                extraAtts,
                type.isLocal()?"":"/"
            }));

        if(type.isLocal()) {
            indent++;

            if(type.isLocal())  type.visit(this);

            indent--;
            println("");
        }
    }

    public void modelGroupDecl( XSModelGroupDecl decl ) {
        println(MessageFormat.format("",
            new Object[]{
                decl.getName()
            }));
        indent++;

        modelGroup(decl.getModelGroup());

        indent--;
        println("");
    }

    public void modelGroup( XSModelGroup group ) {
        modelGroup(group,"");
    }
    private void modelGroup( XSModelGroup group, String extraAtts ) {
        println(MessageFormat.format("<{0}{1}>",
            new Object[]{ group.getCompositor(), extraAtts }));
        indent++;

        final int len = group.getSize();
        for( int i=0; i",
            new Object[]{ group.getCompositor() }));
    }

    public void particle( XSParticle part ) {
        int i;

        StringBuffer buf = new StringBuffer();

        i = part.getMaxOccurs();
        if(i==XSParticle.UNBOUNDED)
            buf.append(" maxOccurs=\"unbounded\"");
        else if(i!=1)
            buf.append(" maxOccurs=\""+i+'\"');

        i = part.getMinOccurs();
        if(i!=1)
            buf.append(" minOccurs=\""+i+'\"');

        final String extraAtts = buf.toString();

        part.getTerm().visit(new XSTermVisitor(){
            public void elementDecl( XSElementDecl decl ) {
                if(decl.isLocal())
                    SchemaWriter.this.elementDecl(decl,extraAtts);
                else {
                    // reference
                    println(MessageFormat.format("",
                        new Object[]{
                            decl.getTargetNamespace(),
                            decl.getName(),
                            extraAtts
                        }));
                }
            }
            public void modelGroupDecl( XSModelGroupDecl decl ) {
                // reference
                println(MessageFormat.format("",
                    new Object[]{
                        decl.getTargetNamespace(),
                        decl.getName(),
                        extraAtts
                    }));
            }
            public void modelGroup( XSModelGroup group ) {
                SchemaWriter.this.modelGroup(group,extraAtts);
            }
            public void wildcard( XSWildcard wc ) {
                SchemaWriter.this.wildcard(wc,extraAtts);
            }
        });
    }

    public void wildcard( XSWildcard wc ) {
        wildcard(wc,"");
    }

    private void wildcard( XSWildcard wc, String extraAtts ) {
        // TODO
        println(MessageFormat.format("", new Object[]{extraAtts}));
    }

    public void annotation( XSAnnotation ann ) {
        // TODO: it would be nice even if we just put 
    }

    public void identityConstraint(XSIdentityConstraint decl) {
        // TODO
    }

    public void xpath(XSXPath xp) {
        // TODO
    }

    public void empty( XSContentType t ) {}
}