| /* |
| * Copyright (c) 1997, 2011, 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.io.StringWriter; |
| import java.math.BigInteger; |
| import java.text.ParseException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.Stack; |
| |
| import javax.activation.MimeTypeParseException; |
| import javax.xml.bind.DatatypeConverter; |
| |
| import com.sun.codemodel.internal.JJavaName; |
| import com.sun.codemodel.internal.util.JavadocEscapeWriter; |
| import com.sun.xml.internal.bind.v2.WellKnownNamespace; |
| import com.sun.tools.internal.xjc.ErrorReceiver; |
| import com.sun.tools.internal.xjc.model.CBuiltinLeafInfo; |
| import com.sun.tools.internal.xjc.model.CClassInfo; |
| import com.sun.tools.internal.xjc.model.CClassInfoParent; |
| import com.sun.tools.internal.xjc.model.CClassRef; |
| import com.sun.tools.internal.xjc.model.CEnumConstant; |
| import com.sun.tools.internal.xjc.model.CEnumLeafInfo; |
| import com.sun.tools.internal.xjc.model.CNonElement; |
| import com.sun.tools.internal.xjc.model.Model; |
| import com.sun.tools.internal.xjc.model.TypeUse; |
| import com.sun.tools.internal.xjc.model.TypeUseFactory; |
| import com.sun.tools.internal.xjc.reader.Const; |
| import com.sun.tools.internal.xjc.reader.Ring; |
| import com.sun.tools.internal.xjc.reader.xmlschema.bindinfo.BIConversion; |
| import com.sun.tools.internal.xjc.reader.xmlschema.bindinfo.BIEnum; |
| import com.sun.tools.internal.xjc.reader.xmlschema.bindinfo.BIEnumMember; |
| import com.sun.tools.internal.xjc.reader.xmlschema.bindinfo.BIProperty; |
| import com.sun.tools.internal.xjc.reader.xmlschema.bindinfo.BindInfo; |
| import com.sun.tools.internal.xjc.reader.xmlschema.bindinfo.EnumMemberMode; |
| import com.sun.tools.internal.xjc.util.MimeTypeRange; |
| |
| import static com.sun.xml.internal.bind.v2.WellKnownNamespace.XML_MIME_URI; |
| |
| import com.sun.xml.internal.bind.v2.runtime.SwaRefAdapterMarker; |
| import com.sun.xml.internal.xsom.XSAttributeDecl; |
| import com.sun.xml.internal.xsom.XSComplexType; |
| import com.sun.xml.internal.xsom.XSComponent; |
| import com.sun.xml.internal.xsom.XSElementDecl; |
| import com.sun.xml.internal.xsom.XSFacet; |
| import com.sun.xml.internal.xsom.XSListSimpleType; |
| import com.sun.xml.internal.xsom.XSRestrictionSimpleType; |
| import com.sun.xml.internal.xsom.XSSimpleType; |
| import com.sun.xml.internal.xsom.XSUnionSimpleType; |
| import com.sun.xml.internal.xsom.XSVariety; |
| import com.sun.xml.internal.xsom.impl.util.SchemaWriter; |
| import com.sun.xml.internal.xsom.visitor.XSSimpleTypeFunction; |
| import com.sun.xml.internal.xsom.visitor.XSVisitor; |
| |
| import org.xml.sax.Locator; |
| |
| /** |
| * Builds {@link TypeUse} from simple types. |
| * |
| * <p> |
| * This code consists of two main portions. The {@link #compose(XSSimpleType)} method |
| * and {@link #composer} forms an outer cycle, which gradually ascends the type |
| * inheritance chain until it finds the suitable binding. When it does this |
| * {@link #initiatingType} is set to the type which started binding, so that we can refer |
| * to the actual constraint facets and such that are applicable on the type. |
| * |
| * <p> |
| * For each intermediate type in the chain, the {@link #find(XSSimpleType)} method |
| * is used to find the binding on that type, sine the outer loop is doing the ascending, |
| * this method only sees if the current type has some binding available. |
| * |
| * <p> |
| * There is at least one ugly code that you need to aware of |
| * when you are modifying the code. See the documentation |
| * about <a href="package.html#stref_cust"> |
| * "simple type customization at the point of reference."</a> |
| * |
| * |
| * @author |
| * Kohsuke Kawaguchi (kohsuke.kawaguchi@sun.com) |
| */ |
| public final class SimpleTypeBuilder extends BindingComponent { |
| |
| protected final BGMBuilder builder = Ring.get(BGMBuilder.class); |
| |
| private final Model model = Ring.get(Model.class); |
| |
| /** |
| * The component that is refering to the simple type |
| * which we are building. This is ugly but necessary |
| * to support the customization of simple types at |
| * its point of reference. See my comment at the header |
| * of this class for details. |
| * |
| * UGLY: Implemented as a Stack of XSComponent to fix a bug |
| */ |
| public final Stack<XSComponent> refererStack = new Stack<XSComponent>(); |
| |
| /** |
| * Records what xmime:expectedContentTypes annotations we honored and processed, |
| * so that we can later check if the user had these annotations in the places |
| * where we didn't anticipate them. |
| */ |
| private final Set<XSComponent> acknowledgedXmimeContentTypes = new HashSet<XSComponent>(); |
| |
| /** |
| * The type that was originally passed to this {@link SimpleTypeBuilder#build(XSSimpleType)}. |
| * Never null. |
| */ |
| private XSSimpleType initiatingType; |
| |
| /** {@link TypeUse}s for the built-in types. Read-only. */ |
| public static final Map<String,TypeUse> builtinConversions = new HashMap<String,TypeUse>(); |
| |
| |
| /** |
| * Entry point from outside. Builds a BGM type expression |
| * from a simple type schema component. |
| * |
| * @param type |
| * the simple type to be bound. |
| */ |
| public TypeUse build( XSSimpleType type ) { |
| XSSimpleType oldi = initiatingType; |
| this.initiatingType = type; |
| |
| TypeUse e = checkRefererCustomization(type); |
| if(e==null) |
| e = compose(type); |
| |
| initiatingType = oldi; |
| |
| return e; |
| } |
| |
| /** |
| * A version of the {@link #build(XSSimpleType)} method |
| * used to bind the definition of a class generated from |
| * the given simple type. |
| */ |
| public TypeUse buildDef( XSSimpleType type ) { |
| XSSimpleType oldi = initiatingType; |
| this.initiatingType = type; |
| |
| TypeUse e = type.apply(composer); |
| |
| initiatingType = oldi; |
| |
| return e; |
| } |
| |
| |
| /** |
| * Returns a javaType customization specified to the referer, if present. |
| * @return can be null. |
| */ |
| private BIConversion getRefererCustomization() { |
| BindInfo info = builder.getBindInfo(getReferer()); |
| BIProperty prop = info.get(BIProperty.class); |
| if(prop==null) return null; |
| return prop.getConv(); |
| } |
| |
| public XSComponent getReferer() { |
| return refererStack.peek(); |
| } |
| |
| /** |
| * Checks if the referer has a conversion customization or not. |
| * If it does, use it to bind this simple type. Otherwise |
| * return null; |
| */ |
| private TypeUse checkRefererCustomization( XSSimpleType type ) { |
| |
| // assertion check. referer must be set properly |
| // before the build method is called. |
| // since the handling of the simple type point-of-reference |
| // customization is very error prone, it deserves a strict |
| // assertion check. |
| // UGLY CODE WARNING |
| XSComponent top = getReferer(); |
| |
| if( top instanceof XSElementDecl ) { |
| // if the parent is element type, its content type must be us. |
| XSElementDecl eref = (XSElementDecl)top; |
| assert eref.getType()==type; |
| |
| // for elements, you can't use <property>, |
| // so we allow javaType to appear directly. |
| BindInfo info = builder.getBindInfo(top); |
| BIConversion conv = info.get(BIConversion.class); |
| if(conv!=null) { |
| conv.markAsAcknowledged(); |
| // the conversion is given. |
| return conv.getTypeUse(type); |
| } |
| detectJavaTypeCustomization(); |
| } else |
| if( top instanceof XSAttributeDecl ) { |
| XSAttributeDecl aref = (XSAttributeDecl)top; |
| assert aref.getType()==type; |
| detectJavaTypeCustomization(); |
| } else |
| if( top instanceof XSComplexType ) { |
| XSComplexType tref = (XSComplexType)top; |
| assert tref.getBaseType()==type || tref.getContentType()==type; |
| detectJavaTypeCustomization(); |
| } else |
| if( top == type ) { |
| // this means the simple type is built by itself and |
| // not because it's referenced by something. |
| } else |
| // unexpected referer type. |
| assert false; |
| |
| // now we are certain that the referer is OK. |
| // see if it has a conversion customization. |
| BIConversion conv = getRefererCustomization(); |
| if(conv!=null) { |
| conv.markAsAcknowledged(); |
| // the conversion is given. |
| return conv.getTypeUse(type); |
| } else |
| // not found |
| return null; |
| } |
| |
| /** |
| * Detect "javaType" customizations placed directly on simple types, rather |
| * than being enclosed by "property" and "baseType" customizations (see |
| * sec 6.8.1 of the spec). |
| * |
| * Report an error if any exist. |
| */ |
| private void detectJavaTypeCustomization() { |
| BindInfo info = builder.getBindInfo(getReferer()); |
| BIConversion conv = info.get(BIConversion.class); |
| |
| if( conv != null ) { |
| // ack this conversion to prevent further error messages |
| conv.markAsAcknowledged(); |
| |
| // report the error |
| getErrorReporter().error( conv.getLocation(), |
| Messages.ERR_UNNESTED_JAVATYPE_CUSTOMIZATION_ON_SIMPLETYPE ); |
| } |
| } |
| |
| /** |
| * Recursively decend the type inheritance chain to find a binding. |
| */ |
| TypeUse compose( XSSimpleType t ) { |
| TypeUse e = find(t); |
| if(e!=null) return e; |
| return t.apply(composer); |
| } |
| |
| public final XSSimpleTypeFunction<TypeUse> composer = new XSSimpleTypeFunction<TypeUse>() { |
| |
| public TypeUse listSimpleType(XSListSimpleType type) { |
| // bind item type individually and then compose them into a list |
| // facets on the list shouldn't be taken account when binding item types, |
| // so weed to call build(), not compose(). |
| XSSimpleType itemType = type.getItemType(); |
| refererStack.push(itemType); |
| TypeUse tu = TypeUseFactory.makeCollection(build(type.getItemType())); |
| refererStack.pop(); |
| return tu; |
| } |
| |
| public TypeUse unionSimpleType(XSUnionSimpleType type) { |
| boolean isCollection = false; |
| for( int i=0; i<type.getMemberSize(); i++ ) |
| if(type.getMember(i).getVariety()==XSVariety.LIST || type.getMember(i).getVariety()==XSVariety.UNION) { |
| isCollection = true; |
| break; |
| } |
| |
| TypeUse r = CBuiltinLeafInfo.STRING; |
| if(isCollection) |
| r = TypeUseFactory.makeCollection(r); |
| return r; |
| } |
| |
| public TypeUse restrictionSimpleType(XSRestrictionSimpleType type) { |
| // just process the base type. |
| return compose(type.getSimpleBaseType()); |
| } |
| }; |
| |
| |
| /** |
| * Checks if there's any binding available on the given type. |
| * |
| * @return |
| * null if not (which causes the {@link #compose(XSSimpleType)} method |
| * to do ascending. |
| */ |
| private TypeUse find( XSSimpleType type ) { |
| TypeUse r; |
| boolean noAutoEnum = false; |
| |
| // check for user specified conversion |
| BindInfo info = builder.getBindInfo(type); |
| BIConversion conv = info.get(BIConversion.class); |
| |
| if( conv!=null ) { |
| // a conversion was found |
| conv.markAsAcknowledged(); |
| return conv.getTypeUse(type); |
| } |
| |
| // look for enum customization, which is another user specified conversion |
| BIEnum en = info.get(BIEnum.class); |
| if( en!=null ) { |
| en.markAsAcknowledged(); |
| |
| if(!en.isMapped()) { |
| noAutoEnum = true; |
| } else { |
| // if an enum customization is specified, make sure |
| // the type is OK |
| if( !canBeMappedToTypeSafeEnum(type) ) { |
| getErrorReporter().error( en.getLocation(), |
| Messages.ERR_CANNOT_BE_TYPE_SAFE_ENUM ); |
| getErrorReporter().error( type.getLocator(), |
| Messages.ERR_CANNOT_BE_TYPE_SAFE_ENUM_LOCATION ); |
| // recover by ignoring this customization |
| return null; |
| } |
| |
| // reference? |
| if(en.ref!=null) { |
| if(!JJavaName.isFullyQualifiedClassName(en.ref)) { |
| Ring.get(ErrorReceiver.class).error( en.getLocation(), |
| Messages.format(Messages.ERR_INCORRECT_CLASS_NAME, en.ref) ); |
| // recover by ignoring @ref |
| return null; |
| } |
| |
| return new CClassRef(model, type, en, info.toCustomizationList() ); |
| } |
| |
| // list and union cannot be mapped to a type-safe enum, |
| // so in this stage we can safely cast it to XSRestrictionSimpleType |
| return bindToTypeSafeEnum( (XSRestrictionSimpleType)type, |
| en.className, en.javadoc, en.members, |
| getEnumMemberMode().getModeWithEnum(), |
| en.getLocation() ); |
| } |
| } |
| |
| |
| // if the type is built in, look for the default binding |
| if(type.getTargetNamespace().equals(WellKnownNamespace.XML_SCHEMA)) { |
| String name = type.getName(); |
| if(name!=null) { |
| r = lookupBuiltin(name); |
| if(r!=null) |
| return r; |
| } |
| } |
| |
| // also check for swaRef |
| if(type.getTargetNamespace().equals(WellKnownNamespace.SWA_URI)) { |
| String name = type.getName(); |
| if(name!=null && name.equals("swaRef")) |
| return CBuiltinLeafInfo.STRING.makeAdapted(SwaRefAdapterMarker.class,false); |
| } |
| |
| |
| // see if this type should be mapped to a type-safe enumeration by default. |
| // if so, built a EnumXDucer from it and return it. |
| if(type.isRestriction() && !noAutoEnum) { |
| XSRestrictionSimpleType rst = type.asRestriction(); |
| if(shouldBeMappedToTypeSafeEnumByDefault(rst)) { |
| r = bindToTypeSafeEnum(rst,null,null, Collections.<String, BIEnumMember>emptyMap(), |
| getEnumMemberMode(),null); |
| if(r!=null) |
| return r; |
| } |
| } |
| |
| return (CNonElement)getClassSelector()._bindToClass(type,null,false); |
| } |
| |
| private static Set<XSRestrictionSimpleType> reportedEnumMemberSizeWarnings; |
| |
| /** |
| * Returns true if a type-safe enum should be created from |
| * the given simple type by default without an explicit <jaxb:enum> customization. |
| */ |
| private boolean shouldBeMappedToTypeSafeEnumByDefault( XSRestrictionSimpleType type ) { |
| |
| // if not, there will be a problem wrt the class name of this type safe enum type. |
| if( type.isLocal() ) return false; |
| |
| // if redefined, we should map the new definition, not the old one. |
| if( type.getRedefinedBy()!=null ) return false; |
| |
| List<XSFacet> facets = type.getDeclaredFacets(XSFacet.FACET_ENUMERATION); |
| if( facets.isEmpty() ) |
| // if the type itself doesn't have the enumeration facet, |
| // it won't be mapped to a type-safe enum. |
| return false; |
| |
| if(facets.size() > builder.getGlobalBinding().getDefaultEnumMemberSizeCap()) { |
| // if there are too many facets, it's not very useful |
| // produce warning when simple type is not mapped to enum |
| // see issue https://jaxb.dev.java.net/issues/show_bug.cgi?id=711 |
| |
| if(reportedEnumMemberSizeWarnings == null) |
| reportedEnumMemberSizeWarnings = new HashSet<XSRestrictionSimpleType>(); |
| |
| if(!reportedEnumMemberSizeWarnings.contains(type)) { |
| getErrorReporter().warning(type.getLocator(), Messages.WARN_ENUM_MEMBER_SIZE_CAP, |
| type.getName(), facets.size(), builder.getGlobalBinding().getDefaultEnumMemberSizeCap()); |
| |
| reportedEnumMemberSizeWarnings.add(type); |
| } |
| |
| return false; |
| } |
| |
| if( !canBeMappedToTypeSafeEnum(type) ) |
| // we simply can't map this to an enumeration |
| return false; |
| |
| // check for collisions among constant names. if a collision will happen, |
| // don't try to bind it to an enum. |
| |
| // return true only when this type is derived from one of the "enum base type". |
| for( XSSimpleType t = type; t!=null; t=t.getSimpleBaseType() ) |
| if( t.isGlobal() && builder.getGlobalBinding().canBeMappedToTypeSafeEnum(t) ) |
| return true; |
| |
| return false; |
| } |
| |
| |
| private static final Set<String> builtinTypeSafeEnumCapableTypes; |
| |
| static { |
| Set<String> s = new HashSet<String>(); |
| |
| // see a bullet of 6.5.1 of the spec. |
| String[] typeNames = new String[] { |
| "string", "boolean", "float", "decimal", "double", "anyURI" |
| }; |
| s.addAll(Arrays.asList(typeNames)); |
| |
| builtinTypeSafeEnumCapableTypes = Collections.unmodifiableSet(s); |
| } |
| |
| |
| /** |
| * Returns true if the given simple type can be mapped to a |
| * type-safe enum class. |
| * |
| * <p> |
| * JAXB spec places a restrictrion as to what type can be |
| * mapped to a type-safe enum. This method enforces this |
| * constraint. |
| */ |
| public static boolean canBeMappedToTypeSafeEnum( XSSimpleType type ) { |
| do { |
| if( WellKnownNamespace.XML_SCHEMA.equals(type.getTargetNamespace()) ) { |
| // type must be derived from one of these types |
| String localName = type.getName(); |
| if( localName!=null ) { |
| if( localName.equals("anySimpleType") ) |
| return false; // catch all case |
| if( localName.equals("ID") || localName.equals("IDREF") ) |
| return false; // not ID/IDREF |
| |
| // other allowed list |
| if( builtinTypeSafeEnumCapableTypes.contains(localName) ) |
| return true; |
| } |
| } |
| |
| type = type.getSimpleBaseType(); |
| } while( type!=null ); |
| |
| return false; |
| } |
| |
| |
| |
| /** |
| * Builds a type-safe enum conversion from a simple type |
| * with enumeration facets. |
| * |
| * @param className |
| * The class name of the type-safe enum. Or null to |
| * create a default name. |
| * @param javadoc |
| * Additional javadoc that will be added at the beginning of the |
| * class, or null if none is necessary. |
| * @param members |
| * A map from enumeration values (as String) to BIEnumMember objects. |
| * if some of the value names need to be overrided. |
| * Cannot be null, but the map may not contain entries |
| * for all enumeration values. |
| * @param loc |
| * The source location where the above customizations are |
| * specified, or null if none is available. |
| */ |
| private TypeUse bindToTypeSafeEnum( XSRestrictionSimpleType type, |
| String className, String javadoc, Map<String,BIEnumMember> members, |
| EnumMemberMode mode, Locator loc ) { |
| |
| if( loc==null ) // use the location of the simple type as the default |
| loc = type.getLocator(); |
| |
| if( className==null ) { |
| // infer the class name. For this to be possible, |
| // the simple type must be a global one. |
| if( !type.isGlobal() ) { |
| getErrorReporter().error( loc, Messages.ERR_NO_ENUM_NAME_AVAILABLE ); |
| // recover by returning a meaningless conversion |
| return CBuiltinLeafInfo.STRING; |
| } |
| className = type.getName(); |
| } |
| |
| // we apply name conversion in any case |
| className = builder.deriveName(className,type); |
| |
| {// compute Javadoc |
| StringWriter out = new StringWriter(); |
| SchemaWriter sw = new SchemaWriter(new JavadocEscapeWriter(out)); |
| type.visit((XSVisitor)sw); |
| |
| if(javadoc!=null) javadoc += "\n\n"; |
| else javadoc = ""; |
| |
| javadoc += Messages.format( Messages.JAVADOC_HEADING, type.getName() ) |
| +"\n<p>\n<pre>\n"+out.getBuffer()+"</pre>"; |
| |
| } |
| |
| // build base type |
| refererStack.push(type.getSimpleBaseType()); |
| TypeUse use = build(type.getSimpleBaseType()); |
| refererStack.pop(); |
| |
| if(use.isCollection()) |
| return null; // can't bind a list to enum constant |
| |
| CNonElement baseDt = use.getInfo(); // for now just ignore that case |
| |
| if(baseDt instanceof CClassInfo) |
| return null; // can't bind to an enum if the base is a class, since we don't have the value constrctor |
| |
| // if the member names collide, re-generate numbered constant names. |
| XSFacet[] errorRef = new XSFacet[1]; |
| List<CEnumConstant> memberList = buildCEnumConstants(type, false, members, errorRef); |
| if(memberList==null || checkMemberNameCollision(memberList)!=null) { |
| switch(mode) { |
| case SKIP: |
| // abort |
| return null; |
| case ERROR: |
| // error |
| if(memberList==null) { |
| getErrorReporter().error( errorRef[0].getLocator(), |
| Messages.ERR_CANNOT_GENERATE_ENUM_NAME, |
| errorRef[0].getValue() ); |
| } else { |
| CEnumConstant[] collision = checkMemberNameCollision(memberList); |
| getErrorReporter().error( collision[0].getLocator(), |
| Messages.ERR_ENUM_MEMBER_NAME_COLLISION, |
| collision[0].getName() ); |
| getErrorReporter().error( collision[1].getLocator(), |
| Messages.ERR_ENUM_MEMBER_NAME_COLLISION_RELATED ); |
| } |
| return null; // recover from error |
| case GENERATE: |
| // generate |
| memberList = buildCEnumConstants(type,true,members,null); |
| break; |
| } |
| } |
| if(memberList.isEmpty()) { |
| getErrorReporter().error( loc, Messages.ERR_NO_ENUM_FACET ); |
| return null; |
| } |
| |
| // use the name of the simple type as the name of the class. |
| CClassInfoParent scope; |
| if(type.isGlobal()) |
| scope = new CClassInfoParent.Package(getClassSelector().getPackage(type.getTargetNamespace())); |
| else |
| scope = getClassSelector().getClassScope(); |
| CEnumLeafInfo xducer = new CEnumLeafInfo( model, BGMBuilder.getName(type), scope, |
| className, baseDt, memberList, type, |
| builder.getBindInfo(type).toCustomizationList(), loc ); |
| xducer.javadoc = javadoc; |
| |
| BIConversion conv = new BIConversion.Static( type.getLocator(),xducer); |
| conv.markAsAcknowledged(); |
| |
| // attach this new conversion object to this simple type |
| // so that successive look up will use the same object. |
| builder.getOrCreateBindInfo(type).addDecl(conv); |
| |
| return conv.getTypeUse(type); |
| } |
| |
| /** |
| * |
| * @param errorRef |
| * if constant names couldn't be generated, return a reference to that enum facet. |
| * @return |
| * null if unable to generate names for some of the constants. |
| */ |
| private List<CEnumConstant> buildCEnumConstants(XSRestrictionSimpleType type, boolean needsToGenerateMemberName, Map<String, BIEnumMember> members, XSFacet[] errorRef) { |
| List<CEnumConstant> memberList = new ArrayList<CEnumConstant>(); |
| int idx=1; |
| Set<String> enums = new HashSet<String>(); // to avoid duplicates. See issue #366 |
| |
| for( XSFacet facet : type.getDeclaredFacets(XSFacet.FACET_ENUMERATION)) { |
| String name=null; |
| String mdoc=builder.getBindInfo(facet).getDocumentation(); |
| |
| if(!enums.add(facet.getValue().value)) |
| continue; // ignore the 2nd occasion |
| |
| if( needsToGenerateMemberName ) { |
| // generate names for all member names. |
| // this will even override names specified by the user. that's crazy. |
| name = "VALUE_"+(idx++); |
| } else { |
| String facetValue = facet.getValue().value; |
| BIEnumMember mem = members.get(facetValue); |
| if( mem==null ) |
| // look at the one attached to the facet object |
| mem = builder.getBindInfo(facet).get(BIEnumMember.class); |
| |
| if (mem!=null) { |
| name = mem.name; |
| if (mdoc == null) { |
| mdoc = mem.javadoc; |
| } |
| } |
| |
| if(name==null) { |
| StringBuilder sb = new StringBuilder(); |
| for( int i=0; i<facetValue.length(); i++) { |
| char ch = facetValue.charAt(i); |
| if(Character.isJavaIdentifierPart(ch)) |
| sb.append(ch); |
| else |
| sb.append('_'); |
| } |
| name = model.getNameConverter().toConstantName(sb.toString()); |
| } |
| } |
| |
| if(!JJavaName.isJavaIdentifier(name)) { |
| if(errorRef!=null) errorRef[0] = facet; |
| return null; // unable to generate a name |
| } |
| |
| memberList.add(new CEnumConstant(name,mdoc,facet.getValue().value,facet,builder.getBindInfo(facet).toCustomizationList(),facet.getLocator())); |
| } |
| return memberList; |
| } |
| |
| /** |
| * Returns non-null if {@link CEnumConstant}s have name collisions among them. |
| * |
| * @return |
| * if there's a collision, return two {@link CEnumConstant}s that collided. |
| * otherwise return null. |
| */ |
| private CEnumConstant[] checkMemberNameCollision( List<CEnumConstant> memberList ) { |
| Map<String,CEnumConstant> names = new HashMap<String,CEnumConstant>(); |
| for (CEnumConstant c : memberList) { |
| CEnumConstant old = names.put(c.getName(),c); |
| if(old!=null) |
| // collision detected |
| return new CEnumConstant[]{old,c}; |
| } |
| return null; |
| } |
| |
| |
| |
| private EnumMemberMode getEnumMemberMode() { |
| return builder.getGlobalBinding().getEnumMemberMode(); |
| } |
| |
| private TypeUse lookupBuiltin( String typeLocalName ) { |
| if(typeLocalName.equals("integer") || typeLocalName.equals("long")) { |
| /* |
| attempt an optimization so that we can |
| improve the binding for types like this: |
| |
| <simpleType> |
| <restriciton baseType="integer"> |
| <maxInclusive value="100" /> |
| </ |
| </ |
| |
| ... to int, not BigInteger. |
| */ |
| |
| BigInteger xe = readFacet(XSFacet.FACET_MAXEXCLUSIVE,-1); |
| BigInteger xi = readFacet(XSFacet.FACET_MAXINCLUSIVE,0); |
| BigInteger max = min(xe,xi); // most restrictive one takes precedence |
| |
| if(max!=null) { |
| BigInteger ne = readFacet(XSFacet.FACET_MINEXCLUSIVE,+1); |
| BigInteger ni = readFacet(XSFacet.FACET_MININCLUSIVE,0); |
| BigInteger min = max(ne,ni); |
| |
| if(min!=null) { |
| if(min.compareTo(INT_MIN )>=0 && max.compareTo(INT_MAX )<=0) |
| typeLocalName = "int"; |
| else |
| if(min.compareTo(LONG_MIN)>=0 && max.compareTo(LONG_MAX)<=0) |
| typeLocalName = "long"; |
| } |
| } |
| } else |
| if(typeLocalName.equals("boolean") && isRestrictedTo0And1()) { |
| // this is seen in the SOAP schema and too common to ignore |
| return CBuiltinLeafInfo.BOOLEAN_ZERO_OR_ONE; |
| } else |
| if(typeLocalName.equals("base64Binary")) { |
| return lookupBinaryTypeBinding(); |
| } else |
| if(typeLocalName.equals("anySimpleType")) { |
| if(getReferer() instanceof XSAttributeDecl || getReferer() instanceof XSSimpleType) |
| return CBuiltinLeafInfo.STRING; |
| else |
| return CBuiltinLeafInfo.ANYTYPE; |
| } |
| return builtinConversions.get(typeLocalName); |
| } |
| |
| /** |
| * Decides the way xs:base64Binary binds. |
| * |
| * This method checks the expected media type. |
| */ |
| private TypeUse lookupBinaryTypeBinding() { |
| XSComponent referer = getReferer(); |
| String emt = referer.getForeignAttribute(XML_MIME_URI, Const.EXPECTED_CONTENT_TYPES); |
| if(emt!=null) { |
| acknowledgedXmimeContentTypes.add(referer); |
| try { |
| // see http://www.xml.com/lpt/a/2004/07/21/dive.html |
| List<MimeTypeRange> types = MimeTypeRange.parseRanges(emt); |
| MimeTypeRange mt = MimeTypeRange.merge(types); |
| |
| // see spec table I-1 in appendix I section 2.1.1 for bindings |
| if(mt.majorType.equalsIgnoreCase("image")) |
| return CBuiltinLeafInfo.IMAGE.makeMimeTyped(mt.toMimeType()); |
| |
| if(( mt.majorType.equalsIgnoreCase("application") || mt.majorType.equalsIgnoreCase("text")) |
| && isXml(mt.subType)) |
| return CBuiltinLeafInfo.XML_SOURCE.makeMimeTyped(mt.toMimeType()); |
| |
| if((mt.majorType.equalsIgnoreCase("text") && (mt.subType.equalsIgnoreCase("plain")) )) { |
| return CBuiltinLeafInfo.STRING.makeMimeTyped(mt.toMimeType()); |
| } |
| |
| return CBuiltinLeafInfo.DATA_HANDLER.makeMimeTyped(mt.toMimeType()); |
| } catch (ParseException e) { |
| getErrorReporter().error( referer.getLocator(), |
| Messages.format(Messages.ERR_ILLEGAL_EXPECTED_MIME_TYPE,emt, e.getMessage()) ); |
| // recover by using the default |
| } catch (MimeTypeParseException e) { |
| getErrorReporter().error( referer.getLocator(), |
| Messages.format(Messages.ERR_ILLEGAL_EXPECTED_MIME_TYPE,emt, e.getMessage()) ); |
| } |
| } |
| // default |
| return CBuiltinLeafInfo.BASE64_BYTE_ARRAY; |
| } |
| |
| public boolean isAcknowledgedXmimeContentTypes(XSComponent c) { |
| return acknowledgedXmimeContentTypes.contains(c); |
| } |
| |
| /** |
| * Returns true if the specified sub-type is an XML type. |
| */ |
| private boolean isXml(String subType) { |
| return subType.equals("xml") || subType.endsWith("+xml"); |
| } |
| |
| /** |
| * Returns true if the {@link #initiatingType} is restricted |
| * to '0' and '1'. This logic is not complete, but it at least |
| * finds the such definition in SOAP @mustUnderstand. |
| */ |
| private boolean isRestrictedTo0And1() { |
| XSFacet pattern = initiatingType.getFacet(XSFacet.FACET_PATTERN); |
| if(pattern!=null) { |
| String v = pattern.getValue().value; |
| if(v.equals("0|1") || v.equals("1|0") || v.equals("\\d")) |
| return true; |
| } |
| XSFacet enumf = initiatingType.getFacet(XSFacet.FACET_ENUMERATION); |
| if(enumf!=null) { |
| String v = enumf.getValue().value; |
| if(v.equals("0") || v.equals("1")) |
| return true; |
| } |
| return false; |
| } |
| |
| private BigInteger readFacet(String facetName,int offset) { |
| XSFacet me = initiatingType.getFacet(facetName); |
| if(me==null) |
| return null; |
| BigInteger bi = DatatypeConverter.parseInteger(me.getValue().value); |
| if(offset!=0) |
| bi = bi.add(BigInteger.valueOf(offset)); |
| return bi; |
| } |
| |
| private BigInteger min(BigInteger a, BigInteger b) { |
| if(a==null) return b; |
| if(b==null) return a; |
| return a.min(b); |
| } |
| |
| private BigInteger max(BigInteger a, BigInteger b) { |
| if(a==null) return b; |
| if(b==null) return a; |
| return a.max(b); |
| } |
| |
| private static final BigInteger LONG_MIN = BigInteger.valueOf(Long.MIN_VALUE); |
| private static final BigInteger LONG_MAX = BigInteger.valueOf(Long.MAX_VALUE); |
| private static final BigInteger INT_MIN = BigInteger.valueOf(Integer.MIN_VALUE); |
| private static final BigInteger INT_MAX = BigInteger.valueOf(Integer.MAX_VALUE); |
| |
| static { |
| // list of datatypes which have built-in conversions. |
| // note that although xs:token and xs:normalizedString are not |
| // specified in the spec, they need to be here because they |
| // have different whitespace normalization semantics. |
| Map<String,TypeUse> m = builtinConversions; |
| |
| // TODO: this is so dumb |
| m.put("string", CBuiltinLeafInfo.STRING); |
| m.put("anyURI", CBuiltinLeafInfo.STRING); |
| m.put("boolean", CBuiltinLeafInfo.BOOLEAN); |
| // we'll also look at the expected media type, so don't just add this to the map |
| // m.put("base64Binary", CBuiltinLeafInfo.BASE64_BYTE_ARRAY); |
| m.put("hexBinary", CBuiltinLeafInfo.HEXBIN_BYTE_ARRAY); |
| m.put("float", CBuiltinLeafInfo.FLOAT); |
| m.put("decimal", CBuiltinLeafInfo.BIG_DECIMAL); |
| m.put("integer", CBuiltinLeafInfo.BIG_INTEGER); |
| m.put("long", CBuiltinLeafInfo.LONG); |
| m.put("unsignedInt", CBuiltinLeafInfo.LONG); |
| m.put("int", CBuiltinLeafInfo.INT); |
| m.put("unsignedShort", CBuiltinLeafInfo.INT); |
| m.put("short", CBuiltinLeafInfo.SHORT); |
| m.put("unsignedByte", CBuiltinLeafInfo.SHORT); |
| m.put("byte", CBuiltinLeafInfo.BYTE); |
| m.put("double", CBuiltinLeafInfo.DOUBLE); |
| m.put("QName", CBuiltinLeafInfo.QNAME); |
| m.put("NOTATION", CBuiltinLeafInfo.QNAME); |
| m.put("dateTime", CBuiltinLeafInfo.CALENDAR); |
| m.put("date", CBuiltinLeafInfo.CALENDAR); |
| m.put("time", CBuiltinLeafInfo.CALENDAR); |
| m.put("gYearMonth", CBuiltinLeafInfo.CALENDAR); |
| m.put("gYear", CBuiltinLeafInfo.CALENDAR); |
| m.put("gMonthDay", CBuiltinLeafInfo.CALENDAR); |
| m.put("gDay", CBuiltinLeafInfo.CALENDAR); |
| m.put("gMonth", CBuiltinLeafInfo.CALENDAR); |
| m.put("duration", CBuiltinLeafInfo.DURATION); |
| m.put("token", CBuiltinLeafInfo.TOKEN); |
| m.put("normalizedString",CBuiltinLeafInfo.NORMALIZED_STRING); |
| m.put("ID", CBuiltinLeafInfo.ID); |
| m.put("IDREF", CBuiltinLeafInfo.IDREF); |
| // TODO: handling dateTime, time, and date type |
| // String[] names = { |
| // "date", "dateTime", "time", "hexBinary" }; |
| } |
| } |
