}
}
} else if (item instanceof XmlSchemaGroupRef) {
XmlSchemaGroupRef xmlSchemaGroupRef = (XmlSchemaGroupRef) item;
QName groupQName = xmlSchemaGroupRef.getRefName();
if (groupQName != null){
if (!processedGroupTypeMap.containsKey(groupQName)){
// processe the schema here
XmlSchema resolvedParentSchema = getParentSchema(parentSchema,groupQName,COMPONENT_GROUP);
if (resolvedParentSchema == null){
throw new SchemaCompilationException("Can not find the group with the qname" +
groupQName + " from the parent schema " + parentSchema.getTargetNamespace());
} else {
XmlSchemaGroup xmlSchemaGroup =
(XmlSchemaGroup) resolvedParentSchema.getGroups().getItem(groupQName);
if (xmlSchemaGroup != null){
processGroup(xmlSchemaGroup, groupQName, resolvedParentSchema);
}
}
}
Boolean isArray = xmlSchemaGroupRef.getMaxOccurs() > 1 ? Boolean.TRUE : Boolean.FALSE;
processedElementArrayStatusMap.put(item,isArray);
particleQNameMap.put(item,groupQName);
if (order){
elementOrderMap.put(item, new Integer(sequenceCounter));
}
} else {
throw new SchemaCompilationException("Referenced name is null");
}
} else {
//there may be other types to be handled here. Add them
//when we are ready
}
sequenceCounter++;
}
// loop through the processed items and add them to the matainf object
Iterator processedElementsIterator = processedElementArrayStatusMap.keySet().iterator();
int startingItemNumberOrder = metainfHolder.getOrderStartPoint();
while (processedElementsIterator.hasNext()) {
Object child = processedElementsIterator.next();
// process the XmlSchemaElement
if (child instanceof XmlSchemaElement) {
XmlSchemaElement elt = (XmlSchemaElement) child;
QName referencedQName = null;
if (elt.getQName() != null) {
referencedQName = elt.getQName();
QName schemaTypeQName = elt.getSchemaType() != null ? elt.getSchemaType().getQName() : elt.getSchemaTypeName();
if (schemaTypeQName != null) {
String clazzName = (String) processedElementTypeMap.get(elt.getQName());
metainfHolder.registerMapping(referencedQName,
schemaTypeQName,
clazzName,
((Boolean) processedElementArrayStatusMap.get(elt)).booleanValue() ?
SchemaConstants.ARRAY_TYPE :
SchemaConstants.ELEMENT_TYPE);
if (innerChoiceElementList.contains(referencedQName)){
metainfHolder.addtStatus(referencedQName,SchemaConstants.INNER_CHOICE_ELEMENT);
}
// register the default value as well
if (elt.getDefaultValue() != null){
metainfHolder.registerDefaultValue(referencedQName,elt.getDefaultValue());
}
}
}
if (elt.getRefName() != null) { //probably this is referenced
referencedQName = elt.getRefName();
boolean arrayStatus = ((Boolean) processedElementArrayStatusMap.get(elt)).booleanValue();
String clazzName = findRefClassName(referencedQName, arrayStatus);
if (clazzName == null) {
clazzName = findClassName(referencedQName, arrayStatus);
}
XmlSchema resolvedParentSchema = getParentSchema(parentSchema,referencedQName,COMPONENT_ELEMENT);
if (resolvedParentSchema == null) {
throw new SchemaCompilationException("Can not find the element " + referencedQName +
" from the parent schema " + parentSchema.getTargetNamespace());
} else {
XmlSchemaElement refElement = resolvedParentSchema.getElementByName(referencedQName);
// register the mapping if we found the referenced element
// else throw an exception
if (refElement != null) {
metainfHolder.registerMapping(referencedQName,
refElement.getSchemaTypeName()
, clazzName,
arrayStatus ?
SchemaConstants.ARRAY_TYPE :
SchemaConstants.ELEMENT_TYPE);
} else {
if (referencedQName.equals(SchemaConstants.XSD_SCHEMA)) {
metainfHolder.registerMapping(referencedQName,
null,
writer.getDefaultClassName(),
SchemaConstants.ANY_TYPE);
} else {
throw new SchemaCompilationException(SchemaCompilerMessages.getMessage("schema.referencedElementNotFound", referencedQName.toString()));
}
}
}
}
if (referencedQName == null) {
throw new SchemaCompilationException(SchemaCompilerMessages.getMessage("schema.emptyName"));
}
//register the occurence counts
metainfHolder.addMaxOccurs(referencedQName, elt.getMaxOccurs());
// if the strict validation off then we consider all elements have minOccurs zero on it
if (this.options.isOffStrictValidation()){
metainfHolder.addMinOccurs(referencedQName, 0);
} else {
metainfHolder.addMinOccurs(referencedQName, elt.getMinOccurs());
}
//we need the order to be preserved. So record the order also
if (order) {
//record the order in the metainf holder
Integer integer = (Integer) elementOrderMap.get(elt);
metainfHolder.registerQNameIndex(referencedQName,
startingItemNumberOrder + integer.intValue());
}
//get the nillable state and register that on the metainf holder
if (localNillableList.contains(elt.getQName())) {
metainfHolder.registerNillableQName(elt.getQName());
}
//get the binary state and add that to the status map
if (isBinary(elt)) {
metainfHolder.addtStatus(elt.getQName(),
SchemaConstants.BINARY_TYPE);
}
// process the XMLSchemaAny
} else if (child instanceof XmlSchemaAny) {
XmlSchemaAny any = (XmlSchemaAny) child;
//since there is only one element here it does not matter
//for the constant. However the problem occurs if the users
//uses the same name for an element decalration
QName anyElementFieldName = new QName(ANY_ELEMENT_FIELD_NAME);
//this can be an array or a single element
boolean isArray = ((Boolean) processedElementArrayStatusMap.get(any)).booleanValue();
metainfHolder.registerMapping(anyElementFieldName,
null,
isArray ? writer.getDefaultClassArrayName() : writer.getDefaultClassName(),
SchemaConstants.ANY_TYPE);
//if it's an array register an extra status flag with the system
if (isArray) {
metainfHolder.addtStatus(anyElementFieldName,
SchemaConstants.ARRAY_TYPE);
}
metainfHolder.addMaxOccurs(anyElementFieldName, any.getMaxOccurs());
metainfHolder.addMinOccurs(anyElementFieldName, any.getMinOccurs());
if (order) {
//record the order in the metainf holder for the any
Integer integer = (Integer) elementOrderMap.get(any);
metainfHolder.registerQNameIndex(anyElementFieldName,
startingItemNumberOrder + integer.intValue());
}
} else if (child instanceof XmlSchemaSequence) {
XmlSchemaSequence xmlSchemaSequence = (XmlSchemaSequence) child;
QName sequenceQName = (QName) particleQNameMap.get(child);
boolean isArray = xmlSchemaSequence.getMaxOccurs() > 1;
// add this as an array to the original class
metainfHolder.registerMapping(sequenceQName,
sequenceQName,
findClassName(sequenceQName, isArray));
if (isArray) {
metainfHolder.addtStatus(sequenceQName, SchemaConstants.ARRAY_TYPE);
}
metainfHolder.addtStatus(sequenceQName, SchemaConstants.PARTICLE_TYPE_ELEMENT);
metainfHolder.addMaxOccurs(sequenceQName, xmlSchemaSequence.getMaxOccurs());
metainfHolder.addMinOccurs(sequenceQName, xmlSchemaSequence.getMinOccurs());
metainfHolder.setHasParticleType(true);
if (order) {
//record the order in the metainf holder for the any
Integer integer = (Integer) elementOrderMap.get(child);
metainfHolder.registerQNameIndex(sequenceQName,
startingItemNumberOrder + integer.intValue());
}
} else if (child instanceof XmlSchemaChoice) {
XmlSchemaChoice xmlSchemaChoice = (XmlSchemaChoice) child;
QName choiceQName = (QName) particleQNameMap.get(child);
boolean isArray = xmlSchemaChoice.getMaxOccurs() > 1;
// add this as an array to the original class
metainfHolder.registerMapping(choiceQName,
choiceQName,
findClassName(choiceQName, isArray));
if (isArray) {
metainfHolder.addtStatus(choiceQName, SchemaConstants.ARRAY_TYPE);
}
metainfHolder.addtStatus(choiceQName, SchemaConstants.PARTICLE_TYPE_ELEMENT);
metainfHolder.addMaxOccurs(choiceQName, xmlSchemaChoice.getMaxOccurs());
metainfHolder.addMinOccurs(choiceQName, xmlSchemaChoice.getMinOccurs());
metainfHolder.setHasParticleType(true);
if (order) {
//record the order in the metainf holder for the any
Integer integer = (Integer) elementOrderMap.get(child);
metainfHolder.registerQNameIndex(choiceQName,
startingItemNumberOrder + integer.intValue());
}
} else if (child instanceof XmlSchemaGroupRef) {
XmlSchemaGroupRef xmlSchemaGroupRef = (XmlSchemaGroupRef) child;
QName groupQName = (QName) particleQNameMap.get(child);
boolean isArray = xmlSchemaGroupRef.getMaxOccurs() > 1;
// add this as an array to the original class
String groupClassName = (String) processedGroupTypeMap.get(groupQName);
if (isArray){
groupClassName = groupClassName + "[]";
}
metainfHolder.registerMapping(groupQName,
groupQName,
groupClassName);
if (isArray) {
metainfHolder.addtStatus(groupQName, SchemaConstants.ARRAY_TYPE);
}
metainfHolder.addtStatus(groupQName, SchemaConstants.PARTICLE_TYPE_ELEMENT);
metainfHolder.addMaxOccurs(groupQName, xmlSchemaGroupRef.getMaxOccurs());
metainfHolder.addMinOccurs(groupQName, xmlSchemaGroupRef.getMinOccurs());
metainfHolder.setHasParticleType(true);
if (order) {
//record the order in the metainf holder for the any
Integer integer = (Integer) elementOrderMap.get(child);