jdk8-mips64-public/jaxws: comparison src/share/jaxws_classes/com/sun/tools/internal/xjc/reader/xmlschema/BGMBuilder.java

--1:000000000000
+:373ffda63c9a
+/*
+* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+*
+* This code is free software; you can redistribute it and/or modify it
+* under the terms of the GNU General Public License version 2 only, as
+* published by the Free Software Foundation.  Oracle designates this
+* particular file as subject to the "Classpath" exception as provided
+* by Oracle in the LICENSE file that accompanied this code.
+*
+* This code is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+* version 2 for more details (a copy is included in the LICENSE file that
+* accompanied this code).
+*
+* You should have received a copy of the GNU General Public License version
+* 2 along with this work; if not, write to the Free Software Foundation,
+* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+*
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+* or visit www.oracle.com if you need additional information or have any
+* questions.
+*/
+package com.sun.tools.internal.xjc.reader.xmlschema;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.xml.namespace.QName;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerFactory;
+import com.sun.codemodel.internal.JCodeModel;
+import com.sun.codemodel.internal.fmt.JTextFile;
+import com.sun.istack.internal.NotNull;
+import com.sun.istack.internal.Nullable;
+import com.sun.tools.internal.xjc.ErrorReceiver;
+import com.sun.tools.internal.xjc.Options;
+import com.sun.tools.internal.xjc.Plugin;
+import com.sun.tools.internal.xjc.generator.bean.field.FieldRendererFactory;
+import com.sun.tools.internal.xjc.model.CClassInfoParent;
+import com.sun.tools.internal.xjc.model.Model;
+import com.sun.tools.internal.xjc.reader.ModelChecker;
+import com.sun.tools.internal.xjc.reader.Ring;
+import com.sun.tools.internal.xjc.reader.xmlschema.bindinfo.BIDeclaration;
+import com.sun.tools.internal.xjc.reader.xmlschema.bindinfo.BIDom;
+import com.sun.tools.internal.xjc.reader.xmlschema.bindinfo.BIGlobalBinding;
+import com.sun.tools.internal.xjc.reader.xmlschema.bindinfo.BISchemaBinding;
+import com.sun.tools.internal.xjc.reader.xmlschema.bindinfo.BISerializable;
+import com.sun.tools.internal.xjc.reader.xmlschema.bindinfo.BindInfo;
+import com.sun.tools.internal.xjc.util.CodeModelClassFactory;
+import com.sun.tools.internal.xjc.util.ErrorReceiverFilter;
+import com.sun.xml.internal.bind.api.impl.NameConverter;
+import com.sun.xml.internal.bind.v2.util.XmlFactory;
+import com.sun.xml.internal.xsom.XSAnnotation;
+import com.sun.xml.internal.xsom.XSAttributeUse;
+import com.sun.xml.internal.xsom.XSComponent;
+import com.sun.xml.internal.xsom.XSDeclaration;
+import com.sun.xml.internal.xsom.XSParticle;
+import com.sun.xml.internal.xsom.XSSchema;
+import com.sun.xml.internal.xsom.XSSchemaSet;
+import com.sun.xml.internal.xsom.XSSimpleType;
+import com.sun.xml.internal.xsom.XSTerm;
+import com.sun.xml.internal.xsom.XSType;
+import com.sun.xml.internal.xsom.XSWildcard;
+import com.sun.xml.internal.xsom.util.XSFinder;
+import org.xml.sax.Locator;
+/**
+* Root of the XML Schema binder.
+*
+* <div><img src="doc-files/binding_chart.png"/></div>
+*
+* @author Kohsuke Kawaguchi
+*/
+public class BGMBuilder extends BindingComponent {
+/**
+* Entry point.
+*/
+public static Model build( XSSchemaSet _schemas, JCodeModel codeModel,
+ErrorReceiver _errorReceiver, Options opts ) {
+// set up a ring
+final Ring old = Ring.begin();
+try {
+ErrorReceiverFilter ef = new ErrorReceiverFilter(_errorReceiver);
+Ring.add(XSSchemaSet.class,_schemas);
+Ring.add(codeModel);
+Model model = new Model(opts, codeModel, null/*set later*/, opts.classNameAllocator, _schemas);
+Ring.add(model);
+Ring.add(ErrorReceiver.class,ef);
+Ring.add(CodeModelClassFactory.class,new CodeModelClassFactory(ef));
+BGMBuilder builder = new BGMBuilder(opts.defaultPackage,opts.defaultPackage2,
+opts.isExtensionMode(),opts.getFieldRendererFactory(), opts.activePlugins);
+builder._build();
+if(ef.hadError())   return null;
+else                return model;
+} finally {
+Ring.end(old);
+}
+}
+/**
+* True if the compiler is running in the extension mode
+* (as opposed to the strict conformance mode.)
+*/
+public final boolean inExtensionMode;
+/**
+* If this is non-null, this package name takes over
+* all the schema customizations.
+*/
+public final String defaultPackage1;
+/**
+* If this is non-null, this package name will be
+* used when no customization is specified.
+*/
+public final String defaultPackage2;
+private final BindGreen green = Ring.get(BindGreen.class);
+private final BindPurple purple = Ring.get(BindPurple.class);
+public final Model model = Ring.get(Model.class);
+public final FieldRendererFactory fieldRendererFactory;
+/**
+* Lazily computed {@link RefererFinder}.
+*
+* @see #getReferer
+*/
+private RefererFinder refFinder;
+private List<Plugin> activePlugins;
+protected BGMBuilder(String defaultPackage1, String defaultPackage2,
+boolean _inExtensionMode, FieldRendererFactory fieldRendererFactory,
+List<Plugin> activePlugins) {
+this.inExtensionMode = _inExtensionMode;
+this.defaultPackage1 = defaultPackage1;
+this.defaultPackage2 = defaultPackage2;
+this.fieldRendererFactory = fieldRendererFactory;
+this.activePlugins = activePlugins;
+promoteGlobalBindings();
+}
+private void _build() {
+// do the binding
+buildContents();
+getClassSelector().executeTasks();
+// additional error check
+// Reports unused customizations to the user as errors.
+Ring.get(UnusedCustomizationChecker.class).run();
+Ring.get(ModelChecker.class).check();
+for( Plugin ma : activePlugins )
+ma.postProcessModel(model, Ring.get(ErrorReceiver.class));
+}
+/** List up all the global bindings. */
+private void promoteGlobalBindings() {
+// promote any global bindings in the schema
+XSSchemaSet schemas = Ring.get(XSSchemaSet.class);
+for( XSSchema s : schemas.getSchemas() ) {
+BindInfo bi = getBindInfo(s);
+// collect all global customizations
+model.getCustomizations().addAll(bi.toCustomizationList());
+BIGlobalBinding gb = bi.get(BIGlobalBinding.class);
+if(gb==null)
+continue;
+gb.markAsAcknowledged();
+if(globalBinding==null) {
+globalBinding = gb;
+} else {
+if (!globalBinding.isEqual(gb)) { // see Issue 687 - this may happen with syntactically imported documents
+// acknowledge this customization and report an error
+// otherwise the user will see "customization is attached to a wrong place" error,
+// which is incorrect
+getErrorReporter().error( gb.getLocation(),
+Messages.ERR_MULTIPLE_GLOBAL_BINDINGS);
+getErrorReporter().error( globalBinding.getLocation(),
+Messages.ERR_MULTIPLE_GLOBAL_BINDINGS_OTHER);
+}
+}
+}
+if( globalBinding==null ) {
+// no global customization is present.
+// use the default one
+globalBinding = new BIGlobalBinding();
+BindInfo big = new BindInfo();
+big.addDecl(globalBinding);
+big.setOwner(this,null);
+}
+// code generation mode
+model.strategy = globalBinding.getCodeGenerationStrategy();
+model.rootClass = globalBinding.getSuperClass();
+model.rootInterface = globalBinding.getSuperInterface();
+particleBinder = globalBinding.isSimpleMode() ? new ExpressionParticleBinder() : new DefaultParticleBinder();
+// check XJC extensions and realize them
+BISerializable serial = globalBinding.getSerializable();
+if(serial!=null) {
+model.serializable = true;
+model.serialVersionUID = serial.uid;
+}
+// obtain the name conversion mode
+if (globalBinding.nameConverter!=null)
+model.setNameConverter(globalBinding.nameConverter);
+// attach global conversions to the appropriate simple types
+globalBinding.dispatchGlobalConversions(schemas);
+globalBinding.errorCheck();
+}
+/**
+* Global bindings.
+*
+* The empty global binding is set as the default, so that
+* there will be no need to test if the value is null.
+*/
+private BIGlobalBinding globalBinding;
+/**
+* Gets the global bindings.
+*/
+public @NotNull BIGlobalBinding getGlobalBinding() { return globalBinding; }
+private ParticleBinder particleBinder;
+/**
+* Gets the particle binder for this binding.
+*/
+public @NotNull ParticleBinder getParticleBinder() { return particleBinder; }
+/**
+* Name converter that implements "XML->Java name conversion"
+* as specified in the spec.
+*
+* This object abstracts the detail that we use different name
+* conversion depending on the customization.
+*
+* <p>
+* This object should be used to perform any name conversion
+* needs, instead of the JJavaName class in CodeModel.
+*/
+public NameConverter getNameConverter() { return model.getNameConverter(); }
+/** Fill-in the contents of each classes. */
+private void buildContents() {
+ClassSelector cs = getClassSelector();
+SimpleTypeBuilder stb = Ring.get(SimpleTypeBuilder.class);
+for( XSSchema s : Ring.get(XSSchemaSet.class).getSchemas() ) {
+BISchemaBinding sb = getBindInfo(s).get(BISchemaBinding.class);
+if(sb!=null && !sb.map) {
+sb.markAsAcknowledged();
+continue;       // no mapping for this package
+}
+getClassSelector().pushClassScope( new CClassInfoParent.Package(
+getClassSelector().getPackage(s.getTargetNamespace())) );
+checkMultipleSchemaBindings(s);
+processPackageJavadoc(s);
+populate(s.getAttGroupDecls(),s);
+populate(s.getAttributeDecls(),s);
+populate(s.getElementDecls(),s);
+populate(s.getModelGroupDecls(),s);
+// fill in typeUses
+for (XSType t : s.getTypes().values()) {
+stb.refererStack.push(t);
+model.typeUses().put( getName(t), cs.bindToType(t,s) );
+stb.refererStack.pop();
+}
+getClassSelector().popClassScope();
+}
+}
+/** Reports an error if there are more than one jaxb:schemaBindings customization. */
+private void checkMultipleSchemaBindings( XSSchema schema ) {
+ArrayList<Locator> locations = new ArrayList<Locator>();
+BindInfo bi = getBindInfo(schema);
+for( BIDeclaration bid : bi ) {
+if( bid.getName()==BISchemaBinding.NAME )
+locations.add( bid.getLocation() );
+}
+if(locations.size()<=1)    return; // OK
+// error
+getErrorReporter().error( locations.get(0),
+Messages.ERR_MULTIPLE_SCHEMA_BINDINGS,
+schema.getTargetNamespace() );
+for( int i=1; i<locations.size(); i++ )
+getErrorReporter().error( (Locator)locations.get(i),
+Messages.ERR_MULTIPLE_SCHEMA_BINDINGS_LOCATION);
+}
+/**
+* Calls {@link ClassSelector} for each item in the iterator
+* to populate class items if there is any.
+*/
+private void populate( Map<String,? extends XSComponent> col, XSSchema schema ) {
+ClassSelector cs = getClassSelector();
+for( XSComponent sc : col.values() )
+cs.bindToType(sc,schema);
+}
+/**
+* Generates <code>package.html</code> if the customization
+* says so.
+*/
+private void processPackageJavadoc( XSSchema s ) {
+// look for the schema-wide customization
+BISchemaBinding cust = getBindInfo(s).get(BISchemaBinding.class);
+if(cust==null)      return; // not present
+cust.markAsAcknowledged();
+if( cust.getJavadoc()==null )   return;     // no javadoc customization
+// produce a HTML file
+JTextFile html = new JTextFile("package.html");
+html.setContents(cust.getJavadoc());
+getClassSelector().getPackage(s.getTargetNamespace()).addResourceFile(html);
+}
+/**
+* Gets or creates the BindInfo object associated to a schema component.
+*
+* @return
+*      Always return a non-null valid BindInfo object.
+*      Even if no declaration was specified, this method creates
+*      a new BindInfo so that new decls can be added.
+*/
+public BindInfo getOrCreateBindInfo( XSComponent schemaComponent ) {
+BindInfo bi = _getBindInfoReadOnly(schemaComponent);
+if(bi!=null)    return bi;
+// XSOM is read-only, so we cannot add new annotations.
+// for components that didn't have annotations,
+// we maintain an external map.
+bi = new BindInfo();
+bi.setOwner(this,schemaComponent);
+externalBindInfos.put(schemaComponent,bi);
+return bi;
+}
+/**
+* Used as a constant instance to represent the empty {@link BindInfo}.
+*/
+private final BindInfo emptyBindInfo = new BindInfo();
+/**
+* Gets the BindInfo object associated to a schema component.
+*
+* @return
+*      always return a valid {@link BindInfo} object. If none
+*      is specified for the given component, a dummy empty BindInfo
+*      will be returned.
+*/
+public BindInfo getBindInfo( XSComponent schemaComponent ) {
+BindInfo bi = _getBindInfoReadOnly(schemaComponent);
+if(bi!=null)    return bi;
+else            return emptyBindInfo;
+}
+/**
+* Gets the BindInfo object associated to a schema component.
+*
+* @return
+*      null if no bind info is associated to this schema component.
+*/
+private BindInfo _getBindInfoReadOnly( XSComponent schemaComponent ) {
+BindInfo bi = externalBindInfos.get(schemaComponent);
+if(bi!=null)    return bi;
+XSAnnotation annon = schemaComponent.getAnnotation();
+if(annon!=null) {
+bi = (BindInfo)annon.getAnnotation();
+if(bi!=null) {
+if(bi.getOwner()==null)
+bi.setOwner(this,schemaComponent);
+return bi;
+}
+}
+return null;
+}
+/**
+* A map that stores binding declarations augmented by XJC.
+*/
+private final Map<XSComponent,BindInfo> externalBindInfos = new HashMap<XSComponent,BindInfo>();
+/**
+* Gets the {@link BIDom} object that applies to the given particle.
+*/
+protected final BIDom getLocalDomCustomization( XSParticle p ) {
+if (p == null) {
+return null;
+}
+BIDom dom = getBindInfo(p).get(BIDom.class);
+if(dom!=null)  return dom;
+// if not, the term might have one.
+dom = getBindInfo(p.getTerm()).get(BIDom.class);
+if(dom!=null)  return dom;
+XSTerm t = p.getTerm();
+// type could also have one, in case of the dom customization
+if(t.isElementDecl())
+return getBindInfo(t.asElementDecl().getType()).get(BIDom.class);
+// similarly the model group in a model group definition may have one.
+if(t.isModelGroupDecl())
+return getBindInfo(t.asModelGroupDecl().getModelGroup()).get(BIDom.class);
+return null;
+}
+/**
+* Returns true if the component should be processed by purple.
+*/
+private final XSFinder toPurple = new XSFinder() {
+@Override
+public Boolean attributeUse(XSAttributeUse use) {
+// attribute use always maps to a property
+return true;
+}
+@Override
+public Boolean simpleType(XSSimpleType xsSimpleType) {
+// simple type always maps to a type, hence we should take purple
+return true;
+}
+@Override
+public Boolean wildcard(XSWildcard xsWildcard) {
+// attribute wildcards always maps to a property.
+// element wildcards should have been processed with particle binders
+return true;
+}
+};
+/**
+* If the component maps to a property, forwards to purple, otherwise to green.
+*
+* If the component is mapped to a type, this method needs to return true.
+* See the chart at the class javadoc.
+*/
+public void ying( XSComponent sc, @Nullable XSComponent referer ) {
+if(sc.apply(toPurple)==true || getClassSelector().bindToType(sc,referer)!=null)
+sc.visit(purple);
+else
+sc.visit(green);
+}
+private Transformer identityTransformer;
+/**
+* Gets the shared instance of the identity transformer.
+*/
+public Transformer getIdentityTransformer() {
+try {
+if(identityTransformer==null) {
+TransformerFactory tf = XmlFactory.createTransformerFactory(model.options.disableXmlSecurity);
+identityTransformer = tf.newTransformer();
+}
+return identityTransformer;
+} catch (TransformerConfigurationException e) {
+throw new Error(e); // impossible
+}
+}
+/**
+* Find all types that refer to the given complex type.
+*/
+public Set<XSComponent> getReferer(XSType c) {
+if(refFinder==null) {
+refFinder = new RefererFinder();
+refFinder.schemaSet(Ring.get(XSSchemaSet.class));
+}
+return refFinder.getReferer(c);
+}
+/**
+* Returns the QName of the declaration.
+* @return null
+*      if the declaration is anonymous.
+*/
+public static QName getName(XSDeclaration decl) {
+String local = decl.getName();
+if(local==null) return null;
+return new QName(decl.getTargetNamespace(),local);
+}
+/**
+* Derives a name from a schema component.
+*
+* This method handles prefix/suffix modification and
+* XML-to-Java name conversion.
+*
+* @param name
+*      The base name. This should be things like element names
+*      or type names.
+* @param comp
+*      The component from which the base name was taken.
+*      Used to determine how names are modified.
+*/
+public String deriveName( String name, XSComponent comp ) {
+XSSchema owner = comp.getOwnerSchema();
+name = getNameConverter().toClassName(name);
+if( owner!=null ) {
+BISchemaBinding sb = getBindInfo(owner).get(BISchemaBinding.class);
+if(sb!=null)    name = sb.mangleClassName(name,comp);
+}
+return name;
+}
+public boolean isGenerateMixedExtensions() {
+if (globalBinding != null) {
+return globalBinding.isGenerateMixedExtensions();
+}
+return false;
+}
+}

Mercurial > jdk8-mips64-public > jaxws / file comparison

comparison: src/share/jaxws_classes/com/sun/tools/internal/xjc/reader/xmlschema/BGMBuilder.java

src/share/jaxws_classes/com/sun/tools/internal/xjc/reader/xmlschema/BGMBuilder.java