org.apache.xmlbeans.impl.schema.StscJavaizer Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of commons-xmlbeans Show documentation
Show all versions of commons-xmlbeans Show documentation
The Apache Commons Codec package contains simple encoder and decoders for
various formats such as Base64 and Hexadecimal. In addition to these
widely used encoders and decoders, the codec package also maintains a
collection of phonetic encoding utilities.
The newest version!
/* Copyright 2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.xmlbeans.impl.schema;
import org.apache.xmlbeans.impl.common.NameUtil;
import org.apache.xmlbeans.QNameSetBuilder;
import org.apache.xmlbeans.SchemaField;
import org.apache.xmlbeans.SchemaType;
import org.apache.xmlbeans.SchemaParticle;
import org.apache.xmlbeans.SchemaProperty;
import org.apache.xmlbeans.QNameSet;
import org.apache.xmlbeans.UserType;
import org.apache.xmlbeans.XmlAnySimpleType;
import org.apache.xmlbeans.SchemaStringEnumEntry;
import org.apache.xmlbeans.XmlByte;
import org.apache.xmlbeans.XmlShort;
import org.apache.xmlbeans.InterfaceExtension;
import org.apache.xmlbeans.XmlError;
import org.apache.xmlbeans.PrePostExtension;
import org.apache.xmlbeans.BindingConfig;
import java.util.*;
import java.math.BigInteger;
import javax.xml.namespace.QName;
public class StscJavaizer
{
/**
* XMLBEANS-307
* if enumeration count is greater than 3668,
* xmlbeans scomp will fail with a code too large error
*/
private static final int MAX_ENUM_COUNT = 3668;
/**
* Does a topo walk of all the types to resolve them.
*/
public static void javaizeAllTypes(boolean javaize)
{
StscState state = StscState.get();
List allSeenTypes = new ArrayList();
allSeenTypes.addAll(Arrays.asList(state.documentTypes()));
allSeenTypes.addAll(Arrays.asList(state.attributeTypes()));
allSeenTypes.addAll(Arrays.asList(state.globalTypes()));
// First distribute the global names among the top entities.
if (javaize)
assignGlobalJavaNames(allSeenTypes);
// now fully javaize everything deeply.
for (int i = 0; i < allSeenTypes.size(); i++)
{
SchemaType gType = (SchemaType)allSeenTypes.get(i);
if (javaize)
{
javaizeType((SchemaTypeImpl)gType);
String className = gType.getFullJavaName();
if (className != null)
state.addClassname(className.replace('$', '.'), gType);
}
else
skipJavaizingType((SchemaTypeImpl)gType);
allSeenTypes.addAll(Arrays.asList(gType.getAnonymousTypes()));
// We need to javaize the anonymous types defined inside redefined types
// since redefined type do not get a Java class of their own.
// The exception is complex types derived by restriction, since in this case
// anonymous types are not inherited
addAnonymousTypesFromRedefinition(gType, allSeenTypes);
}
}
static void assignGlobalJavaNames(Collection schemaTypes)
{
HashSet usedNames = new HashSet();
StscState state = StscState.get();
for (Iterator i = schemaTypes.iterator(); i.hasNext(); )
{
SchemaTypeImpl sImpl = (SchemaTypeImpl)i.next();
QName topName = findTopName(sImpl);
String pickedName = state.getJavaname(topName, sImpl.isDocumentType() ?
BindingConfig.QNAME_DOCUMENT_TYPE : BindingConfig.QNAME_TYPE);
if (sImpl.isUnjavaized())
{
sImpl.setFullJavaName(pickFullJavaClassName(usedNames, findTopName(sImpl), pickedName, sImpl.isDocumentType(), sImpl.isAttributeType()));
sImpl.setFullJavaImplName(pickFullJavaImplName(usedNames, sImpl.getFullJavaName()));
setUserTypes(sImpl, state);
setExtensions(sImpl, state);
}
}
verifyInterfaceNameCollisions(usedNames, state);
}
private static void verifyInterfaceNameCollisions(Set usedNames, StscState state)
{
BindingConfig config = state.getBindingConfig();
if (config == null)
return;
InterfaceExtension[] exts = config.getInterfaceExtensions();
for (int i = 0; i < exts.length; i++)
{
if (usedNames.contains(exts[i].getInterface().toLowerCase()))
state.error("InterfaceExtension interface '" + exts[i].getInterface() + "' creates a name collision with one of the generated interfaces or classes.", XmlError.SEVERITY_ERROR, null);
String handler = exts[i].getStaticHandler();
if (handler != null && usedNames.contains(handler.toLowerCase()))
state.error("InterfaceExtension handler class '" + handler + "' creates a name collision with one of the generated interfaces or classes.", XmlError.SEVERITY_ERROR, null);
}
PrePostExtension[] prepost = config.getPrePostExtensions();
for (int i = 0; i < prepost.length; i++)
{
String handler = prepost[i].getStaticHandler();
if (handler != null && usedNames.contains(handler.toLowerCase()))
state.error("PrePostExtension handler class '" + handler + "' creates a name collision with one of the generated interfaces or classes.", XmlError.SEVERITY_ERROR, null);
}
}
private static void setUserTypes(SchemaTypeImpl sImpl, StscState state)
{
BindingConfig config = state.getBindingConfig();
if (config != null)
{
UserType utype = config.lookupUserTypeForQName(sImpl.getName());
if (utype != null)
{
sImpl.setUserTypeName(utype.getJavaName());
sImpl.setUserTypeHandlerName(utype.getStaticHandler());
}
}
}
private static void setExtensions(SchemaTypeImpl sImpl, StscState state)
{
String javaName = sImpl.getFullJavaName();
BindingConfig config = state.getBindingConfig();
if (javaName != null && config != null)
{
sImpl.setInterfaceExtensions(config.getInterfaceExtensions(javaName));
sImpl.setPrePostExtension(config.getPrePostExtension(javaName));
}
}
private static boolean isStringType(SchemaType type)
{
if (type == null || type.getSimpleVariety() != SchemaType.ATOMIC)
return false;
return (type.getPrimitiveType().getBuiltinTypeCode() == SchemaType.BTC_STRING);
}
static String pickConstantName(Set usedNames, String words)
{
String base = NameUtil.upperCaseUnderbar(words);
if (base.length() == 0)
{
base = "X";
}
if (base.startsWith("INT_")) // reserved for int codes
{
base = "X_" + base;
}
String uniqName;
int index = 1;
for (uniqName = base; usedNames.contains(uniqName); )
{
index++;
uniqName = base + "_" + index;
}
usedNames.add(uniqName);
return uniqName;
}
static void skipJavaizingType(SchemaTypeImpl sImpl)
{
if (sImpl.isJavaized())
return;
SchemaTypeImpl baseType = (SchemaTypeImpl)sImpl.getBaseType();
if (baseType != null)
skipJavaizingType(baseType);
sImpl.startJavaizing();
secondPassProcessType(sImpl);
sImpl.finishJavaizing();
}
static void secondPassProcessType(SchemaTypeImpl sImpl)
{
if (isStringType(sImpl))
{
XmlAnySimpleType[] enumVals = sImpl.getEnumerationValues();
// if this is an enumerated string type, values are to be
// javaized as constants.
if (enumVals != null)
{
//ERROR is found at > 3668
if (enumVals.length > MAX_ENUM_COUNT)
{
StscState.get().warning("SchemaType Enumeration found with too many enumeration values " +
"to create a Java enumeration. The base SchemaType \"" +
sImpl.getBaseEnumType() + "\" will be used instead", XmlError.SEVERITY_WARNING, null);
sImpl = (SchemaTypeImpl) sImpl.getBaseEnumType();
}
else
{
SchemaStringEnumEntry[] entryArray = new SchemaStringEnumEntry[enumVals.length];
SchemaType basedOn = sImpl.getBaseEnumType();
if (basedOn == sImpl)
{
Set usedNames = new HashSet();
for (int i = 0; i < enumVals.length; i++)
{
String val = enumVals[i].getStringValue();
entryArray[i] = new SchemaStringEnumEntryImpl(val, i + 1, pickConstantName(usedNames, val));
}
}
else
{
for (int i = 0; i < enumVals.length; i++)
{
String val = enumVals[i].getStringValue();
entryArray[i] = basedOn.enumEntryForString(val);
}
}
sImpl.setStringEnumEntries(entryArray);
}
}
}
}
static void javaizeType(SchemaTypeImpl sImpl)
{
if (sImpl.isJavaized())
return;
SchemaTypeImpl baseType = (SchemaTypeImpl)sImpl.getBaseType();
if (baseType != null)
javaizeType(baseType);
if (sImpl.getContentBasedOnType() != null && sImpl.getContentBasedOnType() != baseType)
javaizeType((SchemaTypeImpl) sImpl.getContentBasedOnType());
sImpl.startJavaizing();
sImpl.setCompiled(true);
secondPassProcessType(sImpl);
if (!sImpl.isSimpleType())
{
SchemaProperty[] eltProps = sImpl.getElementProperties();
SchemaProperty[] attrProps = sImpl.getAttributeProperties();
// Handing out java names - this permits us to avoid collisions.
Set usedPropNames = new HashSet();
// First, copy all used property names from base, since these
// cannnot be changed at this point and they may be arbitrary
// because of derivation by restriction and the "nopvr" switch
SchemaProperty[] baseProps = baseType.getProperties();
for (int i = 0; i < baseProps.length; i++)
{
String name = baseProps[i].getJavaPropertyName();
assert !usedPropNames.contains(name);
usedPropNames.add(name);
}
// count in the methods from extension interfaces
avoidExtensionMethods(usedPropNames, sImpl);
// Assign names in two passes: first inherited names, then others.
for (boolean doInherited = true; ; doInherited = false)
{
if (eltProps.length > 0)
assignJavaPropertyNames(usedPropNames, eltProps, baseType, doInherited);
assignJavaPropertyNames(usedPropNames, attrProps, baseType, doInherited);
if (doInherited == false)
break;
}
SchemaProperty[] allprops = sImpl.getProperties();
// determine whether order insensitive
boolean insensitive = isPropertyModelOrderInsensitive(allprops);
// Fill in the java type codes now.
// This depends on recursive type information, so it's done in typechecking
assignJavaTypeCodes(allprops);
sImpl.setOrderSensitive(!insensitive);
}
// assign java type names to anonymous types
// for redefined types, this step was performed when javaizing the redefinition
if (sImpl.getFullJavaName() != null || sImpl.getOuterType() != null)
assignJavaAnonymousTypeNames(sImpl);
sImpl.finishJavaizing();
}
private static final String[] PREFIXES = new String[]{"get", "xget", "isNil", "isSet", "sizeOf", "set",
"xset", "addNew", "setNil", "unset", "insert", "add", "insertNew", "addNew", "remove"};
private static void avoidExtensionMethods(Set usedPropNames, SchemaTypeImpl sImpl)
{
InterfaceExtension[] exts = sImpl.getInterfaceExtensions();
if (exts != null) for (int i = 0; i < exts.length; i++)
{
InterfaceExtension ext = exts[i];
InterfaceExtension.MethodSignature[] methods = ext.getMethods();
for (int j = 0; j < methods.length; j++)
{
String methodName = methods[j].getName();
for (int k = 0; k < PREFIXES.length; k++)
{
String prefix = PREFIXES[k];
if (methodName.startsWith(prefix))
usedPropNames.add(methodName.substring(prefix.length()));
}
}
}
}
static void assignJavaAnonymousTypeNames(SchemaTypeImpl outerType)
{
Set usedTypeNames = new HashSet();
SchemaType[] anonymousTypes = outerType.getAnonymousTypes();
StscState state = StscState.get();
int nrOfAnonTypes = anonymousTypes.length;
if (outerType.isRedefinition())
{
// We have to add the anonymous types for redefinitions to the list
// since they don't have another outer class
ArrayList list = new ArrayList();
addAnonymousTypesFromRedefinition(outerType, list);
if (list.size() > 0)
{
SchemaType[] temp = new SchemaType[nrOfAnonTypes + list.size()];
list.toArray(temp);
System.arraycopy(anonymousTypes, 0, temp, list.size(), nrOfAnonTypes);
anonymousTypes = temp;
}
}
// Because we generate nested java interfaces, and nested
// interface names must not be the same as an ancestor, use up
// the ancestors
for ( SchemaType scanOuterType = outerType ;
scanOuterType != null ;
scanOuterType = scanOuterType.getOuterType() )
{
usedTypeNames.add( scanOuterType.getShortJavaName() );
}
for ( SchemaType scanOuterType = outerType ;
scanOuterType != null ;
scanOuterType = scanOuterType.getOuterType() )
{
usedTypeNames.add( scanOuterType.getShortJavaImplName() );
}
// and because things are problematic if an inner type name
// is the same as a top-level package name, also get rid of that
// collision
usedTypeNames.add(getOutermostPackage(outerType.getFullJavaName()));
// assign names
for (int i = 0; i < anonymousTypes.length; i++)
{
SchemaTypeImpl sImpl = (SchemaTypeImpl)anonymousTypes[i];
if (sImpl == null) // already handled in first pass
continue;
if (sImpl.isSkippedAnonymousType())
continue;
String localname = null;
String javaname = null;
SchemaField containerField = sImpl.getContainerField();
if (containerField != null)
{
QName qname = sImpl.getContainerField().getName();
localname = qname.getLocalPart();
javaname = state.getJavaname(sImpl.getContainerField().getName(), BindingConfig.QNAME_TYPE);
}
else
{
// not defined inside an Elt or Attr: must be a nested simple type
switch (sImpl.getOuterType().getSimpleVariety())
{
case SchemaType.UNION:
javaname = "Member"; break;
case SchemaType.LIST:
javaname = "Item"; break;
case SchemaType.ATOMIC:
default:
assert(false) : "Weird type " + sImpl.toString();
javaname = "Base"; break;
}
}
if (i < nrOfAnonTypes)
{
sImpl.setShortJavaName(
pickInnerJavaClassName(usedTypeNames, localname, javaname));
sImpl.setShortJavaImplName(
pickInnerJavaImplName(usedTypeNames, localname, javaname == null ? null : javaname + "Impl"));
}
else
{
// This comes from redefined types, so we have to compute the
// full name here
sImpl.setFullJavaName(outerType.getFullJavaName() + "$" +
pickInnerJavaClassName(usedTypeNames, localname, javaname));
sImpl.setFullJavaImplName(outerType.getFullJavaImplName() + "$" +
pickInnerJavaImplName(usedTypeNames, localname, javaname == null ? null : javaname + "Impl"));
}
// TODO(radup) why is this inside this loop here?
setExtensions(sImpl, state);
}
}
static void assignJavaPropertyNames(Set usedNames, SchemaProperty[] props, SchemaType baseType, boolean doInherited)
{
StscState state = StscState.get();
// two passes: first deal with inherited properties, then with new ones.
// this ensures that we match up with base class definitions cleanly
// BUGBUG(radup) We have to look for particles that have been removed
// in the derivation tree for this type using derivation by restriction,
// because they have not been removed in Java and may collide with
// this type's properties.
for (int i = 0; i < props.length; i++)
{
SchemaPropertyImpl sImpl = (SchemaPropertyImpl)props[i];
SchemaProperty baseProp =
(sImpl.isAttribute() ?
baseType.getAttributeProperty(sImpl.getName()) :
baseType.getElementProperty(sImpl.getName()));
if ((baseProp != null) != doInherited)
continue;
QName propQName = sImpl.getName();
String theName;
if (baseProp == null)
theName = pickJavaPropertyName(usedNames, propQName.getLocalPart(),
state.getJavaname(propQName, sImpl.isAttribute() ? BindingConfig.QNAME_ACCESSOR_ATTRIBUTE :
BindingConfig.QNAME_ACCESSOR_ELEMENT));
else
theName = baseProp.getJavaPropertyName();
sImpl.setJavaPropertyName(theName);
boolean isArray = (sImpl.getMaxOccurs() == null ||
sImpl.getMaxOccurs().compareTo(BigInteger.ONE) > 0);
boolean isSingleton = !isArray && (sImpl.getMaxOccurs().signum() > 0);
boolean isOption = isSingleton && (sImpl.getMinOccurs().signum() == 0);
SchemaType javaBasedOnType = sImpl.getType();
if (baseProp != null)
{
if (baseProp.extendsJavaArray())
{
isSingleton = false;
isOption = false;
isArray = true;
}
if (baseProp.extendsJavaSingleton())
{
isSingleton = true;
}
if (baseProp.extendsJavaOption())
{
isOption = true;
}
javaBasedOnType = baseProp.javaBasedOnType();
}
sImpl.setExtendsJava(javaBasedOnType.getRef(), isSingleton, isOption, isArray);
}
}
static void assignJavaTypeCodes(SchemaProperty[] properties)
{
for (int i = 0; i < properties.length; i++)
{
SchemaPropertyImpl sImpl = (SchemaPropertyImpl)properties[i];
SchemaType sType = sImpl.javaBasedOnType();
sImpl.setJavaTypeCode(javaTypeCodeForType(sType));
}
}
static int javaTypeCodeInCommon(SchemaType[] types)
{
if (types == null || types.length == 0)
return SchemaProperty.XML_OBJECT;
int code = javaTypeCodeForType(types[0]);
if (code == SchemaProperty.JAVA_OBJECT)
return code;
for (int i = 1; i < types.length; i++)
{
// if any two are different, the answer is java.lang.Object
if (code != javaTypeCodeForType(types[i]))
return SchemaProperty.JAVA_OBJECT;
}
return code;
}
static int javaTypeCodeForType(SchemaType sType)
{
if (!sType.isSimpleType())
return SchemaProperty.XML_OBJECT;
if (((SchemaTypeImpl)sType).getUserTypeHandlerName() != null)
return SchemaProperty.JAVA_USER;
if (sType.getSimpleVariety() == SchemaType.UNION)
{
// see if we can find an interesting common base type, e.g., for string enums
SchemaType baseType = sType.getUnionCommonBaseType();
if (baseType != null && !baseType.isURType())
sType = baseType;
else
return javaTypeCodeInCommon(sType.getUnionConstituentTypes());
}
if (sType.getSimpleVariety() == SchemaType.LIST)
return SchemaProperty.JAVA_LIST;
if (sType.isURType())
return SchemaProperty.XML_OBJECT;
switch (sType.getPrimitiveType().getBuiltinTypeCode())
{
case SchemaType.BTC_ANY_SIMPLE:
// return SchemaProperty.XML_OBJECT;
return SchemaProperty.JAVA_STRING;
case SchemaType.BTC_BOOLEAN:
return SchemaProperty.JAVA_BOOLEAN;
case SchemaType.BTC_BASE_64_BINARY:
return SchemaProperty.JAVA_BYTE_ARRAY;
case SchemaType.BTC_HEX_BINARY:
return SchemaProperty.JAVA_BYTE_ARRAY;
case SchemaType.BTC_ANY_URI:
return SchemaProperty.JAVA_STRING;
case SchemaType.BTC_QNAME:
return SchemaProperty.JAVA_QNAME;
case SchemaType.BTC_NOTATION:
return SchemaProperty.XML_OBJECT;
case SchemaType.BTC_FLOAT:
return SchemaProperty.JAVA_FLOAT;
case SchemaType.BTC_DOUBLE:
return SchemaProperty.JAVA_DOUBLE;
case SchemaType.BTC_DECIMAL:
switch (sType.getDecimalSize())
{
case SchemaType.SIZE_BYTE:
return SchemaProperty.JAVA_BYTE;
case SchemaType.SIZE_SHORT:
return SchemaProperty.JAVA_SHORT;
case SchemaType.SIZE_INT:
return SchemaProperty.JAVA_INT;
case SchemaType.SIZE_LONG:
return SchemaProperty.JAVA_LONG;
case SchemaType.SIZE_BIG_INTEGER:
return SchemaProperty.JAVA_BIG_INTEGER;
case SchemaType.SIZE_BIG_DECIMAL:
default:
return SchemaProperty.JAVA_BIG_DECIMAL;
}
case SchemaType.BTC_STRING:
if (isStringType(sType.getBaseEnumType()))
{
// This is necessary for local types, etc.
// schema enums with > ~3668 cause a Java Src file to be created
// that cannot be compiled due to JVM restrictions
// FIXFIX: http://issues.apache.org/jira/browse/XMLBEANS-307
// FIXFIX: XMLBeans scomp throws error "code too large"
if (sType.getEnumerationValues() != null &&
sType.getEnumerationValues().length > MAX_ENUM_COUNT)
{
return SchemaProperty.JAVA_STRING;
}
else
{
return SchemaProperty.JAVA_ENUM;
}
}
return SchemaProperty.JAVA_STRING;
case SchemaType.BTC_DURATION:
return SchemaProperty.JAVA_GDURATION;
case SchemaType.BTC_DATE_TIME:
case SchemaType.BTC_DATE:
// return SchemaProperty.JAVA_DATE; // converted to calendar
case SchemaType.BTC_TIME:
case SchemaType.BTC_G_YEAR_MONTH:
case SchemaType.BTC_G_YEAR:
case SchemaType.BTC_G_MONTH_DAY:
case SchemaType.BTC_G_DAY:
case SchemaType.BTC_G_MONTH:
// return SchemaProperty.JAVA_GDATE; // converted to calendar (JAX-B)
return SchemaProperty.JAVA_CALENDAR;
default:
assert(false) : "unrecognized code " + sType.getPrimitiveType().getBuiltinTypeCode();
throw new IllegalStateException("unrecognized code " + sType.getPrimitiveType().getBuiltinTypeCode() + " of " + sType.getPrimitiveType().getName());
}
}
static boolean isPropertyModelOrderInsensitive(SchemaProperty[] properties)
{
for (int i = 0; i < properties.length; i++)
{
SchemaProperty prop = properties[i];
if (prop.hasNillable() == SchemaProperty.VARIABLE)
return false;
if (prop.hasDefault() == SchemaProperty.VARIABLE)
return false;
if (prop.hasFixed() == SchemaProperty.VARIABLE)
return false;
if (prop.hasDefault() != SchemaProperty.NEVER &&
prop.getDefaultText() == null)
return false;
}
return true;
}
static boolean protectReservedGlobalClassNames(String name)
{
int i = name.lastIndexOf('.');
String lastSegment = name.substring(i + 1);
if (lastSegment.endsWith("Document") && !lastSegment.equals("Document"))
return true;
return false;
}
static boolean protectReservedInnerClassNames(String name)
{
return (name.equals("Enum") || name.equals("Factory"));
}
static String[] PROTECTED_PROPERTIES = {
"StringValue",
"BooleanValue",
"ByteValue",
"ShortValue",
"IntValue",
"LongValue",
"BigIntegerValue",
"BigDecimalValue",
"FloatValue",
"DoubleValue",
"ByteArrayValue",
"EnumValue",
"CalendarValue",
"DateValue",
"GDateValue",
"GDurationValue",
"QNameValue",
"ListValue",
"ObjectValue",
"Class",
};
static Set PROTECTED_PROPERTIES_SET = new HashSet(Arrays.asList(PROTECTED_PROPERTIES));
static boolean protectReservedPropertyNames(String name)
{
return PROTECTED_PROPERTIES_SET.contains(name) ||
(name.endsWith("Array") && !name.equals("Array"));
}
static String pickFullJavaClassName(Set usedNames, QName qName, String configname, boolean isDocument, boolean isAttrType)
{
String base;
boolean protect;
if (configname != null && configname.indexOf('.') >= 0)
{
// a configname with dots defines the fully qualified java class name
base = configname;
protect = protectReservedGlobalClassNames(base);
}
else
{
StscState state = StscState.get();
String uri = qName.getNamespaceURI();
base = NameUtil.getClassNameFromQName(qName);
// Check to see if we have a mapping from namespace URI to Java package
// name. If so, apply the mapped package prefix at the beginning of
// the base name
String pkgPrefix = state.getPackageOverride(uri);
if (pkgPrefix != null)
{
// Form the new qualified class name from the new package name
// and the old class name
base = pkgPrefix + "." + base.substring(base.lastIndexOf('.') + 1);
}
// See if there is a prefix...
String javaPrefix = state.getJavaPrefix(uri);
if (javaPrefix != null)
base = base.substring(0, base.lastIndexOf('.') + 1) + javaPrefix + base.substring(base.lastIndexOf('.') + 1);
// a configname without dots may override the shortname part.
if (configname != null)
{
base = base.substring(0, base.lastIndexOf('.') + 1) + configname;
}
protect = protectReservedGlobalClassNames(base);
if (configname == null)
{
// add special suffix
if (isDocument)
base = base + "Document";
else if (isAttrType)
base = base + "Attribute";
// add configured suffix
String javaSuffix = state.getJavaSuffix(uri);
if (javaSuffix != null)
base = base + javaSuffix;
}
}
String outermostPkg = getOutermostPackage(base);
int index = 1;
String uniqName;
if (protect)
uniqName = base + index;
else
uniqName = base;
while (usedNames.contains(uniqName.toLowerCase()) || uniqName.equals(outermostPkg))
{
index++;
uniqName = base + index;
}
usedNames.add(uniqName.toLowerCase());
return uniqName;
}
static String getOutermostPackage(String fqcn)
{
if (fqcn == null)
return "";
// remove class name
int lastdot = fqcn.indexOf('.');
if (lastdot < 0)
return "";
// remove outer package names
return fqcn.substring(0, lastdot);
}
static String pickFullJavaImplName(Set usedNames, String intfName)
{
// Strip off the package from the class name so we can replace it
String className = intfName;
String pkgName = null;
int index = intfName.lastIndexOf('.');
if (index >= 0)
{
className = intfName.substring(index + 1);
pkgName = intfName.substring(0, index);
}
// Form the new qualified class name from the new package name
// and the old class name
String base = pkgName + ".impl." + className + "Impl";
index = 1;
String uniqName = base;
while (usedNames.contains(uniqName.toLowerCase()))
{
index++;
uniqName = base + index;
}
usedNames.add(uniqName.toLowerCase());
return uniqName;
}
static String pickJavaPropertyName(Set usedNames, String localName, String javaName)
{
if (javaName == null)
javaName = NameUtil.upperCamelCase(localName);
boolean protect = protectReservedPropertyNames(javaName);
String uniqName;
int index = 1;
if (protect)
uniqName = javaName + index;
else
uniqName = javaName;
while (usedNames.contains(uniqName))
{
index++;
uniqName = javaName + index;
}
usedNames.add(uniqName);
return uniqName;
}
static String pickInnerJavaClassName(Set usedNames, String localName, String javaName)
{
if (javaName == null)
javaName = NameUtil.upperCamelCase(localName);
boolean protect = protectReservedInnerClassNames(javaName);
String uniqName;
int index = 1;
if (protect)
uniqName = javaName + index;
else
uniqName = javaName;
while (usedNames.contains(uniqName))
{
index++;
uniqName = javaName + index;
}
usedNames.add(uniqName);
return uniqName;
}
static String pickInnerJavaImplName(Set usedNames, String localName, String javaName)
{
if (javaName == null)
javaName = NameUtil.upperCamelCase(localName) + "Impl";
String uniqName = javaName;
int index = 1;
while (usedNames.contains(uniqName))
{
index++;
uniqName = javaName + index;
}
usedNames.add(uniqName);
return uniqName;
}
static QName findTopName(SchemaType sType)
{
if (sType.getName() != null)
return sType.getName();
if (sType.isDocumentType())
{
// A document type must have a content model consisting of a single elt
if (sType.getContentModel() == null || sType.getContentModel().getParticleType() != SchemaParticle.ELEMENT)
throw new IllegalStateException();
return (sType.getDocumentElementName());
}
if (sType.isAttributeType())
{
if (sType.getAttributeModel() == null || sType.getAttributeModel().getAttributes().length != 1)
throw new IllegalStateException();
return sType.getAttributeTypeAttributeName();
}
SchemaField sElt = sType.getContainerField();
assert(sElt != null);
assert(sType.getOuterType() == null);
return sElt.getName();
}
static void addAnonymousTypesFromRedefinition(SchemaType sType, List result)
{
while (((SchemaTypeImpl)sType).isRedefinition() &&
(sType.getDerivationType() == SchemaType.DT_EXTENSION ||
sType.isSimpleType()))
{
sType = sType.getBaseType();
SchemaType[] newAnonTypes = sType.getAnonymousTypes();
if (newAnonTypes.length > 0)
result.addAll(Arrays.asList(newAnonTypes));
}
}
}