/* 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.inst2xsd;
import org.apache.xmlbeans.*;
import org.apache.xmlbeans.impl.common.PrefixResolver;
import org.apache.xmlbeans.impl.common.ValidationContext;
import org.apache.xmlbeans.impl.common.XmlWhitespace;
import org.apache.xmlbeans.impl.inst2xsd.util.Attribute;
import org.apache.xmlbeans.impl.inst2xsd.util.Element;
import org.apache.xmlbeans.impl.inst2xsd.util.TypeSystemHolder;
import org.apache.xmlbeans.impl.inst2xsd.util.Type;
import org.apache.xmlbeans.impl.util.XsTypeConverter;
import org.apache.xmlbeans.impl.values.*;
import javax.xml.namespace.QName;
import java.util.*;
/**
* @author Cezar Andrei ( cezar.andrei at bea.com )
* Date: Jul 26, 2004
*/
public class RussianDollStrategy
implements XsdGenStrategy
{
static final String _xsi = "http://www.w3.org/2001/XMLSchema-instance";
static final QName _xsiNil = new QName( _xsi, "nil", "xsi" );
static final QName _xsiType = new QName( _xsi, "type", "xsi" );
public void processDoc(XmlObject[] instances, Inst2XsdOptions options, TypeSystemHolder typeSystemHolder)
{
for (int i = 0; i < instances.length; i++)
{
XmlObject instance = instances[i];
XmlCursor xc = instance.newCursor();
// xc on start doc
StringBuffer comment = new StringBuffer();
while( !xc.isStart() )
{
xc.toNextToken();
if( xc.isComment() )
comment.append(xc.getTextValue());
else if (xc.isEnddoc())
return;
}
// xc now on the root element
Element withElem = processElement(xc, comment.toString(), options, typeSystemHolder);
withElem.setGlobal(true);
addGlobalElement(withElem, typeSystemHolder, options);
}
}
protected Element addGlobalElement(Element withElem, TypeSystemHolder typeSystemHolder, Inst2XsdOptions options)
{
assert withElem.isGlobal();
Element intoElem = typeSystemHolder.getGlobalElement(withElem.getName());
if (intoElem==null)
{
typeSystemHolder.addGlobalElement(withElem);
return withElem;
}
else
{
combineTypes(intoElem.getType(), withElem.getType(), options);
combineElementComments(intoElem, withElem);
return intoElem;
}
}
protected Element processElement(XmlCursor xc, String comment,
Inst2XsdOptions options, TypeSystemHolder typeSystemHolder)
{
assert xc.isStart();
Element element = new Element();
element.setName(xc.getName());
element.setGlobal(false);
Type elemType = Type.createUnnamedType(Type.SIMPLE_TYPE_SIMPLE_CONTENT); //assume simple, set later
element.setType(elemType);
StringBuffer textBuff = new StringBuffer();
StringBuffer commentBuff = new StringBuffer();
List children = new ArrayList();
List attributes = new ArrayList();
loop: do
{
XmlCursor.TokenType tt = xc.toNextToken();
switch (tt.intValue())
{
case XmlCursor.TokenType.INT_ATTR:
// todo check for xsi:type
// ignore xsi:... attributes other than xsi:nil
QName attName = xc.getName();
if (!_xsiNil.getNamespaceURI().equals(attName.getNamespaceURI()))
attributes.add(processAttribute(xc, options, element.getName().getNamespaceURI(), typeSystemHolder));
else if (_xsiNil.equals(attName))
element.setNillable(true);
break;
case XmlCursor.TokenType.INT_START:
children.add(processElement(xc, commentBuff.toString(), options, typeSystemHolder));
commentBuff.delete(0, commentBuff.length());
break;
case XmlCursor.TokenType.INT_TEXT:
textBuff.append(xc.getChars());
break;
case XmlCursor.TokenType.INT_COMMENT:
commentBuff.append(xc.getTextValue());
break;
case XmlCursor.TokenType.INT_NAMESPACE:
// ignore,
// each element and attribute will take care to define itself in the right targetNamespace
break;
case XmlCursor.TokenType.INT_END:
break loop;
case XmlCursor.TokenType.INT_PROCINST:
// ignore
break;
case XmlCursor.TokenType.INT_ENDDOC:
break loop;
case XmlCursor.TokenType.INT_NONE:
break loop;
case XmlCursor.TokenType.INT_STARTDOC:
throw new IllegalStateException();
default:
throw new IllegalStateException("Unknown TokenType.");
}
}
while( true );
String collapsedText = XmlWhitespace.collapse(textBuff.toString(), XmlWhitespace.WS_COLLAPSE);
String commnetStr = (comment == null ?
( commentBuff.length() == 0 ? null : commentBuff.toString() ) :
( commentBuff.length() == 0 ? comment : commentBuff.insert(0, comment).toString()) );
element.setComment(commnetStr);
if (children.size()>0)
{
// complex content
if (collapsedText.length()>0)
{
elemType.setContentType(Type.COMPLEX_TYPE_MIXED_CONTENT);
}
else
{
elemType.setContentType(Type.COMPLEX_TYPE_COMPLEX_CONTENT);
}
processElementsInComplexType(elemType, children, element.getName().getNamespaceURI(), typeSystemHolder, options);
processAttributesInComplexType(elemType, attributes);
}
else
{
// simple content
// hack workaround for being able to call xc.getNamespaceForPrefix()
XmlCursor xcForNamespaces = xc.newCursor();
xcForNamespaces.toParent();
if (attributes.size()>0)
{
elemType.setContentType(Type.COMPLEX_TYPE_SIMPLE_CONTENT);
Type extendedType = Type.createNamedType(
processSimpleContentType(textBuff.toString(), options, xcForNamespaces), Type.SIMPLE_TYPE_SIMPLE_CONTENT);
elemType.setExtensionType(extendedType);
processAttributesInComplexType(elemType, attributes);
}
else
{
elemType.setContentType(Type.SIMPLE_TYPE_SIMPLE_CONTENT);
elemType.setName(processSimpleContentType(textBuff.toString(), options, xcForNamespaces));
// add enumeration value
String enumValue = XmlString.type.getName().equals(elemType.getName()) ? textBuff.toString() : collapsedText;
elemType.addEnumerationValue(enumValue, xcForNamespaces);
}
xcForNamespaces.dispose(); // end hack
}
checkIfReferenceToGlobalTypeIsNeeded( element, typeSystemHolder, options);
return element;
}
protected void processElementsInComplexType(Type elemType, List children, String parentNamespace,
TypeSystemHolder typeSystemHolder, Inst2XsdOptions options)
{
Map elemNamesToElements = new HashMap();
Element currentElem = null;
for (Iterator iterator = children.iterator(); iterator.hasNext();)
{
Element child = (Element) iterator.next();
if (currentElem==null)
{ // first element in this type
checkIfElementReferenceIsNeeded(child, parentNamespace, typeSystemHolder, options);
elemType.addElement(child);
elemNamesToElements.put(child.getName(), child);
currentElem = child;
continue;
}
if (currentElem.getName()==child.getName())
{ // same contiguos element
combineTypes(currentElem.getType(), child.getType(), options); // unify types
combineElementComments(currentElem, child);
// minOcc=0 maxOcc=unbounded
currentElem.setMinOccurs(0);
currentElem.setMaxOccurs(Element.UNBOUNDED);
}
else
{
Element sameElem = (Element)elemNamesToElements.get(child.getName());
if (sameElem==null)
{ // new element name
checkIfElementReferenceIsNeeded(child, parentNamespace, typeSystemHolder, options);
elemType.addElement(child);
elemNamesToElements.put(child.getName(), child);
}
else
{ //same non contiguos
combineTypes(currentElem.getType(), child.getType(), options);
combineElementComments(currentElem, child);
elemType.setTopParticleForComplexOrMixedContent(Type.PARTICLE_CHOICE_UNBOUNDED);
}
currentElem = child;
}
}
}
protected void checkIfElementReferenceIsNeeded(Element child, String parentNamespace,
TypeSystemHolder typeSystemHolder, Inst2XsdOptions options)
{
if (!child.getName().getNamespaceURI().equals(parentNamespace))
{
Element referencedElem = new Element();
referencedElem.setGlobal(true);
referencedElem.setName(child.getName());
referencedElem.setType(child.getType());
if (child.isNillable())
{
referencedElem.setNillable(true);
child.setNillable(false);
}
referencedElem = addGlobalElement(referencedElem, typeSystemHolder, options);
child.setRef(referencedElem); // clears child's type
}
}
protected void checkIfReferenceToGlobalTypeIsNeeded(Element elem, TypeSystemHolder typeSystemHolder,
Inst2XsdOptions options)
{
// RussianDollDesign doesn't define global types
}
protected void processAttributesInComplexType(Type elemType, List attributes)
{
assert elemType.isComplexType();
for (Iterator iterator = attributes.iterator(); iterator.hasNext();)
{
Attribute att = (Attribute) iterator.next();
elemType.addAttribute(att);
}
}
protected Attribute processAttribute(XmlCursor xc, Inst2XsdOptions options, String parentNamespace,
TypeSystemHolder typeSystemHolder)
{
assert xc.isAttr() : "xc not on attribute";
Attribute attribute = new Attribute();
QName attName = xc.getName();
attribute.setName(attName);
XmlCursor parent = xc.newCursor();
parent.toParent();
Type simpleContentType = Type.createNamedType(
processSimpleContentType(xc.getTextValue(), options, parent), Type.SIMPLE_TYPE_SIMPLE_CONTENT);
parent.dispose();
attribute.setType(simpleContentType);
checkIfAttributeReferenceIsNeeded(attribute, parentNamespace, typeSystemHolder);
return attribute;
}
protected void checkIfAttributeReferenceIsNeeded(Attribute attribute, String parentNamespace, TypeSystemHolder typeSystemHolder)
{
if (!attribute.getName().getNamespaceURI().equals("") &&
!attribute.getName().getNamespaceURI().equals(parentNamespace))
{
// make attribute be a reference to a top level attribute in a different targetNamespace
Attribute referencedAtt = new Attribute();
referencedAtt.setGlobal(true);
referencedAtt.setName(attribute.getName());
referencedAtt.setType(attribute.getType());
typeSystemHolder.addGlobalAttribute(referencedAtt);
attribute.setRef(referencedAtt);
}
}
protected class SCTValidationContext
implements ValidationContext
{
protected boolean valid = true;
public boolean isValid()
{
return valid;
}
public void resetToValid()
{
valid = true;
}
public void invalid(String message)
{
valid = false;
}
public void invalid(String code, Object[] args)
{
valid = false;
}
}
private SCTValidationContext _validationContext = new SCTValidationContext();
// List of precedence for smart simple primitive type determination
// byte, short, int, long, integer, float, double, decimal,
// boolean
// date, dateTime, time, gDuration,
// QName ?,
// anyUri ? - triggered only for http:// or www. constructs,
// list types ?
// string
protected QName processSimpleContentType(String lexicalValue, Inst2XsdOptions options, final XmlCursor xc)
{
// check options and return xsd:string or if smart is enabled, look for a better type
if (options.getSimpleContentTypes()==Inst2XsdOptions.SIMPLE_CONTENT_TYPES_STRING)
return XmlString.type.getName();
if (options.getSimpleContentTypes()!=Inst2XsdOptions.SIMPLE_CONTENT_TYPES_SMART)
throw new IllegalArgumentException("Unknown value for Inst2XsdOptions.getSimpleContentTypes() :" + options.getSimpleContentTypes());
// Inst2XsdOptions.SIMPLE_CONTENT_TYPES_SMART case
try
{
XsTypeConverter.lexByte(lexicalValue);
return XmlByte.type.getName();
}
catch (Exception e) {}
try
{
XsTypeConverter.lexShort(lexicalValue);
return XmlShort.type.getName();
}
catch (Exception e) {}
try
{
XsTypeConverter.lexInt(lexicalValue);
return XmlInt.type.getName();
}
catch (Exception e) {}
try
{
XsTypeConverter.lexLong(lexicalValue);
return XmlLong.type.getName();
}
catch (Exception e) {}
try
{
XsTypeConverter.lexInteger(lexicalValue);
return XmlInteger.type.getName();
}
catch (Exception e) {}
try
{
XsTypeConverter.lexFloat(lexicalValue);
return XmlFloat.type.getName();
}
catch (Exception e) {}
// // this not needed because it's lexical space is covered by float
// try
// {
// XsTypeConverter.lexDouble(lexicalValue);
// return XmlDouble.type.getName();
// }
// catch (Exception e) {}
//
// try
// {
// XsTypeConverter.lexDecimal(lexicalValue);
// return XmlDecimal.type.getName();
// }
// catch (Exception e) {}
XmlDateImpl.validateLexical(lexicalValue, XmlDate.type, _validationContext);
if (_validationContext.isValid())
return XmlDate.type.getName();
_validationContext.resetToValid();
XmlDateTimeImpl.validateLexical(lexicalValue, XmlDateTime.type, _validationContext);
if (_validationContext.isValid())
return XmlDateTime.type.getName();
_validationContext.resetToValid();
XmlTimeImpl.validateLexical(lexicalValue, XmlTime.type, _validationContext);
if (_validationContext.isValid())
return XmlTime.type.getName();
_validationContext.resetToValid();
XmlDurationImpl.validateLexical(lexicalValue, XmlDuration.type, _validationContext);
if (_validationContext.isValid())
return XmlDuration.type.getName();
_validationContext.resetToValid();
// check for uri
if (lexicalValue.startsWith("http://") || lexicalValue.startsWith("www."))
{
XmlAnyUriImpl.validateLexical(lexicalValue, _validationContext);
if (_validationContext.isValid())
return XmlAnyURI.type.getName();
_validationContext.resetToValid();
}
// check for QName
int idx = lexicalValue.indexOf(':');
if (idx>=0 && idx==lexicalValue.lastIndexOf(':') && idx+1<lexicalValue.length())
{
PrefixResolver prefixResolver = new PrefixResolver()
{
public String getNamespaceForPrefix(String prefix)
{ return xc.namespaceForPrefix(prefix); }
};
QName qname = XmlQNameImpl.validateLexical(lexicalValue, _validationContext, prefixResolver);
if (_validationContext.isValid())
return XmlQName.type.getName();
_validationContext.resetToValid();
}
//the check for lists is probably too expensive
return XmlString.type.getName();
}
protected void combineTypes(Type into, Type with, Inst2XsdOptions options)
{
if (into==with)
return;
if (into.isGlobal() && with.isGlobal() && into.getName().equals(with.getName()))
return;
if (into.getContentType()==Type.SIMPLE_TYPE_SIMPLE_CONTENT &&
with.getContentType()==Type.SIMPLE_TYPE_SIMPLE_CONTENT)
{
combineSimpleTypes(into, with, options);
return;
}
if ((into.getContentType()==Type.SIMPLE_TYPE_SIMPLE_CONTENT ||
into.getContentType()==Type.COMPLEX_TYPE_SIMPLE_CONTENT) &&
(with.getContentType()==Type.SIMPLE_TYPE_SIMPLE_CONTENT ||
with.getContentType()==Type.COMPLEX_TYPE_SIMPLE_CONTENT) )
{
// take the extension name if it's a complex type
QName intoTypeName = into.isComplexType() ? into.getExtensionType().getName() : into.getName();
QName withTypeName = with.isComplexType() ? with.getExtensionType().getName() : with.getName();
//complex type simple content
into.setContentType(Type.COMPLEX_TYPE_SIMPLE_CONTENT);
QName moreGeneralTypeName = combineToMoreGeneralSimpleType(intoTypeName, withTypeName);
if (into.isComplexType())
{
Type extendedType = Type.createNamedType(moreGeneralTypeName, Type.SIMPLE_TYPE_SIMPLE_CONTENT);
into.setExtensionType(extendedType);
}
else
into.setName(moreGeneralTypeName);
combineAttributesOfTypes(into, with);
return;
}
if (into.getContentType()==Type.COMPLEX_TYPE_COMPLEX_CONTENT &&
with.getContentType()==Type.COMPLEX_TYPE_COMPLEX_CONTENT)
{
combineAttributesOfTypes(into, with);
combineElementsOfTypes(into, with, false, options);
return;
}
if (into.getContentType()==Type.SIMPLE_TYPE_SIMPLE_CONTENT ||
into.getContentType()==Type.COMPLEX_TYPE_SIMPLE_CONTENT ||
with.getContentType()==Type.SIMPLE_TYPE_SIMPLE_CONTENT ||
with.getContentType()==Type.COMPLEX_TYPE_SIMPLE_CONTENT)
{
into.setContentType(Type.COMPLEX_TYPE_MIXED_CONTENT);
combineAttributesOfTypes(into, with);
combineElementsOfTypes(into, with, true, options);
return;
}
if ((into.getContentType()==Type.SIMPLE_TYPE_SIMPLE_CONTENT ||
into.getContentType()==Type.COMPLEX_TYPE_SIMPLE_CONTENT ||
into.getContentType()==Type.COMPLEX_TYPE_COMPLEX_CONTENT ||
into.getContentType()==Type.COMPLEX_TYPE_MIXED_CONTENT) &&
(with.getContentType()==Type.SIMPLE_TYPE_SIMPLE_CONTENT ||
with.getContentType()==Type.COMPLEX_TYPE_SIMPLE_CONTENT ||
with.getContentType()==Type.COMPLEX_TYPE_COMPLEX_CONTENT ||
with.getContentType()==Type.COMPLEX_TYPE_MIXED_CONTENT) )
{
into.setContentType(Type.COMPLEX_TYPE_MIXED_CONTENT);
combineAttributesOfTypes(into, with);
combineElementsOfTypes(into, with, false, options);
return;
}
throw new IllegalArgumentException("Unknown content type.");
}
protected void combineSimpleTypes(Type into, Type with, Inst2XsdOptions options)
{
assert (into.getContentType()==Type.SIMPLE_TYPE_SIMPLE_CONTENT &&
with.getContentType()==Type.SIMPLE_TYPE_SIMPLE_CONTENT) : "Invalid arguments";
//simple type simple content
into.setName(combineToMoreGeneralSimpleType(into.getName(), with.getName()));
// take care of enumeration values
if (options.isUseEnumerations())
{
into.addAllEnumerationsFrom(with);
if (into.getEnumerationValues().size()>options.getUseEnumerations())
{
into.closeEnumeration();
}
}
}
protected QName combineToMoreGeneralSimpleType(QName t1, QName t2)
{
if (t1.equals(t2))
return t1;
if (t2.equals(XmlShort.type.getName()) && t1.equals(XmlByte.type.getName()))
return t2;
if (t1.equals(XmlShort.type.getName()) && t2.equals(XmlByte.type.getName()))
return t1;
if (t2.equals(XmlInt.type.getName()) &&
(t1.equals(XmlShort.type.getName()) || t1.equals(XmlByte.type.getName())) )
return t2;
if (t1.equals(XmlInt.type.getName()) &&
(t2.equals(XmlShort.type.getName()) || t2.equals(XmlByte.type.getName())) )
return t1;
if (t2.equals(XmlLong.type.getName()) &&
(t1.equals(XmlInt.type.getName()) || t1.equals(XmlShort.type.getName()) || t1.equals(XmlByte.type.getName())) )
return t2;
if (t1.equals(XmlLong.type.getName()) &&
(t2.equals(XmlInt.type.getName()) || t2.equals(XmlShort.type.getName()) || t2.equals(XmlByte.type.getName())) )
return t1;
if (t2.equals(XmlInteger.type.getName()) &&
(t1.equals(XmlLong.type.getName()) || t1.equals(XmlInt.type.getName()) ||
t1.equals(XmlShort.type.getName()) || t1.equals(XmlByte.type.getName())) )
return t2;
if (t1.equals(XmlInteger.type.getName()) &&
(t2.equals(XmlLong.type.getName()) || t2.equals(XmlInt.type.getName()) ||
t2.equals(XmlShort.type.getName()) || t2.equals(XmlByte.type.getName())) )
return t1;
if (t2.equals(XmlFloat.type.getName()) &&
(t1.equals(XmlInteger.type.getName()) ||
t1.equals(XmlLong.type.getName()) || t1.equals(XmlInt.type.getName()) ||
t1.equals(XmlShort.type.getName()) || t1.equals(XmlByte.type.getName())) )
return t2;
if (t1.equals(XmlFloat.type.getName()) &&
(t2.equals(XmlInteger.type.getName()) ||
t2.equals(XmlLong.type.getName()) || t2.equals(XmlInt.type.getName()) ||
t2.equals(XmlShort.type.getName()) || t2.equals(XmlByte.type.getName())) )
return t1;
//double, decimal will never get here since they don't get generated
//the rest of the combinations are not compatible, so they will combine in xsd:string
return XmlString.type.getName();
}
protected void combineAttributesOfTypes(Type into, Type from)
{
// loop through attributes: add fromAtt if they don't exist, combine them if they exist
outterLoop:
for (int i = 0; i < from.getAttributes().size(); i++)
{
Attribute fromAtt = (Attribute)from.getAttributes().get(i);
for (int j = 0; j < into.getAttributes().size(); j++)
{
Attribute intoAtt = (Attribute)into.getAttributes().get(j);
if (intoAtt.getName().equals(fromAtt.getName()))
{
intoAtt.getType().setName(
combineToMoreGeneralSimpleType(intoAtt.getType().getName(), fromAtt.getType().getName()));
continue outterLoop;
}
}
// fromAtt doesn't exist in into type, will add it right now
into.addAttribute(fromAtt);
}
//optional attributes: if there are atts in into that are not in from, make them optional
outterLoop:
for (int i = 0; i < into.getAttributes().size(); i++)
{
Attribute intoAtt = (Attribute)into.getAttributes().get(i);
for (int j = 0; j < from.getAttributes().size(); j++)
{
Attribute fromAtt = (Attribute)from.getAttributes().get(j);
if (fromAtt.getName().equals(intoAtt.getName()))
{
continue;
}
}
// intoAtt doesn't exist in into type, will add it right now
intoAtt.setOptional(true);
}
}
protected void combineElementsOfTypes(Type into, Type from, boolean makeElementsOptional, Inst2XsdOptions options)
{
boolean needsUnboundedChoice = false;
if (into.getTopParticleForComplexOrMixedContent()!=Type.PARTICLE_SEQUENCE ||
from.getTopParticleForComplexOrMixedContent()!=Type.PARTICLE_SEQUENCE)
needsUnboundedChoice = true;
List res = new ArrayList();
int fromStartingIndex = 0;
int fromMatchedIndex = -1;
int intoMatchedIndex = -1;
// for each element in into
for (int i = 0; !needsUnboundedChoice && i < into.getElements().size(); i++)
{
// try to find one with same name in from
Element intoElement = (Element) into.getElements().get(i);
for (int j = fromStartingIndex; j < from.getElements().size(); j++)
{
Element fromElement = (Element) from.getElements().get(j);
if (intoElement.getName().equals(fromElement.getName()))
{
fromMatchedIndex = j;
break;
}
}
// if not found, it's safe to add this one to result 'res' (as optional) and continue
if ( fromMatchedIndex < fromStartingIndex )
{
res.add(intoElement);
intoElement.setMinOccurs(0);
continue;
}
// else try out all from elemens between fromStartingIndex to fromMatchedIndex
// to see if they match one of the into elements
intoMatchingLoop:
for (int j2 = fromStartingIndex; j2 < fromMatchedIndex; j2++)
{
Element fromCandidate = (Element) from.getElements().get(j2);
for (int i2 = i+1; i2 < into.getElements().size(); i2++)
{
Element intoCandidate = (Element) into.getElements().get(i2);
if (fromCandidate.getName().equals(intoCandidate.getName()))
{
intoMatchedIndex = i2;
break intoMatchingLoop;
}
}
}
if (intoMatchedIndex<i)
{
// if none matched they are safe to be added to res as optional
for (int j3 = fromStartingIndex; j3 < fromMatchedIndex; j3++)
{
Element fromCandidate = (Element) from.getElements().get(j3);
res.add(fromCandidate);
fromCandidate.setMinOccurs(0);
}
// also since into[i] == from[fromMatchedIndex] add it only once
res.add(intoElement);
Element fromMatchedElement = (Element)from.getElements().get(fromMatchedIndex);
if (fromMatchedElement.getMinOccurs()<=0)
intoElement.setMinOccurs(0);
if (fromMatchedElement.getMaxOccurs()==Element.UNBOUNDED)
intoElement.setMaxOccurs(Element.UNBOUNDED);
combineTypes(intoElement.getType(), fromMatchedElement.getType(), options);
combineElementComments(intoElement, fromMatchedElement);
fromStartingIndex = fromMatchedIndex + 1;
continue;
}
else
{
// if matched it means into type will transform into a choice unbounded type
needsUnboundedChoice = true;
}
}
for (int j = fromStartingIndex; j < from.getElements().size(); j++)
{
Element remainingFromElement = (Element) from.getElements().get(j);
res.add(remainingFromElement);
remainingFromElement.setMinOccurs(0);
}
// if choice was detected
if (needsUnboundedChoice)
{
into.setTopParticleForComplexOrMixedContent(Type.PARTICLE_CHOICE_UNBOUNDED);
outterLoop:
for (int j = 0; j < from.getElements().size(); j++)
{
Element fromElem = (Element) from.getElements().get(j);
for (int i = 0; i < into.getElements().size(); i++)
{
Element intoElem = (Element)into.getElements().get(i);
intoElem.setMinOccurs(1);
intoElem.setMaxOccurs(1);
if (intoElem==fromElem)
continue outterLoop;
if (intoElem.getName().equals(fromElem.getName()))
{
combineTypes(intoElem.getType(), fromElem.getType(), options);
combineElementComments(intoElem, fromElem);
continue outterLoop;
}
}
// fromElem doesn't exist in into type, will add it right now
into.addElement(fromElem);
fromElem.setMinOccurs(1);
fromElem.setMaxOccurs(1);
}
return;
}
else
{
// into remains sequence but will contain the new list of elements res
into.setElements(res);
return;
}
}
protected void combineElementComments(Element into, Element with)
{
if (with.getComment()!=null && with.getComment().length()>0)
{
if (into.getComment()==null)
into.setComment(with.getComment());
else
into.setComment(into.getComment() + with.getComment());
}
}
}