use generics instead of rawtypes
git-svn-id: https://svn.apache.org/repos/asf/xmlbeans/trunk@1881161 13f79535-47bb-0310-9956-ffa450edef68
diff --git a/src/main/java/org/apache/xmlbeans/impl/schema/SchemaContainer.java b/src/main/java/org/apache/xmlbeans/impl/schema/SchemaContainer.java
index e3fe3f5..7a48ead 100644
--- a/src/main/java/org/apache/xmlbeans/impl/schema/SchemaContainer.java
+++ b/src/main/java/org/apache/xmlbeans/impl/schema/SchemaContainer.java
@@ -15,34 +15,24 @@
package org.apache.xmlbeans.impl.schema;
+import org.apache.xmlbeans.*;
+
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.stream.Collectors;
-import org.apache.xmlbeans.SchemaAnnotation;
-import org.apache.xmlbeans.SchemaAttributeGroup;
-import org.apache.xmlbeans.SchemaComponent;
-import org.apache.xmlbeans.SchemaGlobalAttribute;
-import org.apache.xmlbeans.SchemaGlobalElement;
-import org.apache.xmlbeans.SchemaIdentityConstraint;
-import org.apache.xmlbeans.SchemaModelGroup;
-import org.apache.xmlbeans.SchemaType;
-import org.apache.xmlbeans.SchemaTypeSystem;
-
-/*package*/ class SchemaContainer
-{
+/*package*/ class SchemaContainer {
// The namespace that this is the container for
// TODO(radup) In the future, I think the right approach is one container
// per file instead of per namespace, but per namespace is easier for now
- private String _namespace;
+ private final String _namespace;
- SchemaContainer(String namespace)
- {
+ SchemaContainer(String namespace) {
_namespace = namespace;
}
- String getNamespace()
- {
+ String getNamespace() {
return _namespace;
}
@@ -55,13 +45,11 @@
// at the same time providing the mechanism through which
// we can "move" SchemaTypes from one SchemaTypeSystem to another
// via incremental compilation
- synchronized SchemaTypeSystem getTypeSystem()
- {
+ synchronized SchemaTypeSystem getTypeSystem() {
return _typeSystem;
}
- synchronized void setTypeSystem(SchemaTypeSystem typeSystem)
- {
+ synchronized void setTypeSystem(SchemaTypeSystem typeSystem) {
_typeSystem = typeSystem;
}
@@ -73,138 +61,164 @@
// between typesystems.
boolean _immutable;
- synchronized void setImmutable()
- {
+ synchronized void setImmutable() {
_immutable = true;
}
- synchronized void unsetImmutable()
- {
+ synchronized void unsetImmutable() {
_immutable = false;
}
- private void check_immutable()
- {
- if (_immutable)
+ private void check_immutable() {
+ if (_immutable) {
throw new IllegalStateException("Cannot add components to immutable SchemaContainer");
+ }
}
// Data
// TODO(radup) unmodifiableList() is not really necessary, since this
// is package-level access and code in this package should do the "right thing"
// Global Elements
- private List/*<SchemaGlobalElement.Ref>*/ _globalElements = new ArrayList();
+ private final List<SchemaGlobalElement.Ref> _globalElements = new ArrayList<>();
- void addGlobalElement(SchemaGlobalElement.Ref e)
- { check_immutable(); _globalElements.add(e); }
+ void addGlobalElement(SchemaGlobalElement.Ref e) {
+ check_immutable();
+ _globalElements.add(e);
+ }
- List globalElements()
- { return getComponentList(_globalElements); }
+ List<SchemaGlobalElement> globalElements() {
+ return _globalElements.stream().map(SchemaGlobalElement.Ref::get).collect(Collectors.toList());
+ }
// Global Attributes
- private List/*<SchemaGlobalAttribute.Ref>*/ _globalAttributes = new ArrayList();
+ private final List<SchemaGlobalAttribute.Ref> _globalAttributes = new ArrayList<>();
- void addGlobalAttribute(SchemaGlobalAttribute.Ref a)
- { check_immutable(); _globalAttributes.add(a); }
+ void addGlobalAttribute(SchemaGlobalAttribute.Ref a) {
+ check_immutable();
+ _globalAttributes.add(a);
+ }
- List globalAttributes()
- { return getComponentList(_globalAttributes); }
+ List<SchemaGlobalAttribute> globalAttributes() {
+ return _globalAttributes.stream().map(SchemaGlobalAttribute.Ref::get).collect(Collectors.toList());
+ }
// Model Groups
- private List/*<SchemaModelGroup.Ref>*/ _modelGroups = new ArrayList();
+ private final List<SchemaModelGroup.Ref> _modelGroups = new ArrayList<>();
- void addModelGroup(SchemaModelGroup.Ref g)
- { check_immutable(); _modelGroups.add(g); }
+ void addModelGroup(SchemaModelGroup.Ref g) {
+ check_immutable();
+ _modelGroups.add(g);
+ }
- List modelGroups()
- { return getComponentList(_modelGroups); }
+ List<SchemaModelGroup> modelGroups() {
+ return _modelGroups.stream().map(SchemaModelGroup.Ref::get).collect(Collectors.toList());
+ }
// Redefined Model Groups
- private List/*<SchemaModelGroup.Ref>*/ _redefinedModelGroups = new ArrayList();
+ private final List<SchemaModelGroup.Ref> _redefinedModelGroups = new ArrayList<>();
- void addRedefinedModelGroup(SchemaModelGroup.Ref g)
- { check_immutable(); _redefinedModelGroups.add(g); }
+ void addRedefinedModelGroup(SchemaModelGroup.Ref g) {
+ check_immutable();
+ _redefinedModelGroups.add(g);
+ }
- List redefinedModelGroups()
- { return getComponentList(_redefinedModelGroups); }
+ List<SchemaModelGroup> redefinedModelGroups() {
+ return _redefinedModelGroups.stream().map(SchemaModelGroup.Ref::get).collect(Collectors.toList());
+ }
// Attribute Groups
- private List/*<SchemaAttributeGroup.Ref>*/ _attributeGroups = new ArrayList();
+ private final List<SchemaAttributeGroup.Ref> _attributeGroups = new ArrayList<>();
- void addAttributeGroup(SchemaAttributeGroup.Ref g)
- { check_immutable(); _attributeGroups.add(g); }
+ void addAttributeGroup(SchemaAttributeGroup.Ref g) {
+ check_immutable();
+ _attributeGroups.add(g);
+ }
- List attributeGroups()
- { return getComponentList(_attributeGroups); }
+ List<SchemaAttributeGroup> attributeGroups() {
+ return _attributeGroups.stream().map(SchemaAttributeGroup.Ref::get).collect(Collectors.toList());
+ }
// Redefined Attribute Groups
- private List/*<SchemaAttributeGroup.Ref>*/ _redefinedAttributeGroups = new ArrayList();
+ private final List<SchemaAttributeGroup.Ref> _redefinedAttributeGroups = new ArrayList<>();
- void addRedefinedAttributeGroup(SchemaAttributeGroup.Ref g)
- { check_immutable(); _redefinedAttributeGroups.add(g); }
+ void addRedefinedAttributeGroup(SchemaAttributeGroup.Ref g) {
+ check_immutable();
+ _redefinedAttributeGroups.add(g);
+ }
- List redefinedAttributeGroups()
- { return getComponentList(_redefinedAttributeGroups); }
+ List<SchemaAttributeGroup> redefinedAttributeGroups() {
+ return _redefinedAttributeGroups.stream().map(SchemaAttributeGroup.Ref::get).collect(Collectors.toList());
+ }
// Global Types
- private List/*<SchemaType.Ref>*/ _globalTypes = new ArrayList();
+ private final List<SchemaType.Ref> _globalTypes = new ArrayList<>();
- void addGlobalType(SchemaType.Ref t)
- { check_immutable(); _globalTypes.add(t); }
+ void addGlobalType(SchemaType.Ref t) {
+ check_immutable();
+ _globalTypes.add(t);
+ }
- List globalTypes()
- { return getComponentList(_globalTypes); }
+ List<SchemaType> globalTypes() {
+ return _globalTypes.stream().map(SchemaType.Ref::get).collect(Collectors.toList());
+ }
// Redefined Global Types
- private List/*<SchemaType.Ref>*/ _redefinedGlobalTypes = new ArrayList();
+ private final List<SchemaType.Ref> _redefinedGlobalTypes = new ArrayList<>();
- void addRedefinedType(SchemaType.Ref t)
- { check_immutable(); _redefinedGlobalTypes.add(t); }
+ void addRedefinedType(SchemaType.Ref t) {
+ check_immutable();
+ _redefinedGlobalTypes.add(t);
+ }
- List redefinedGlobalTypes()
- { return getComponentList(_redefinedGlobalTypes); }
+ List<SchemaType> redefinedGlobalTypes() {
+ return _redefinedGlobalTypes.stream().map(SchemaType.Ref::get).collect(Collectors.toList());
+ }
// Document Types
- private List/*<SchemaType.Ref>*/ _documentTypes = new ArrayList();
+ private final List<SchemaType.Ref> _documentTypes = new ArrayList<>();
- void addDocumentType(SchemaType.Ref t)
- { check_immutable(); _documentTypes.add(t); }
+ void addDocumentType(SchemaType.Ref t) {
+ check_immutable();
+ _documentTypes.add(t);
+ }
- List documentTypes()
- { return getComponentList(_documentTypes); }
+ List<SchemaType> documentTypes() {
+ return _documentTypes.stream().map(SchemaType.Ref::get).collect(Collectors.toList());
+ }
// Attribute Types
- private List/*<SchemaType.Ref>*/ _attributeTypes = new ArrayList();
+ private final List<SchemaType.Ref> _attributeTypes = new ArrayList<>();
- void addAttributeType(SchemaType.Ref t)
- { check_immutable(); _attributeTypes.add(t); }
+ void addAttributeType(SchemaType.Ref t) {
+ check_immutable();
+ _attributeTypes.add(t);
+ }
- List attributeTypes()
- { return getComponentList(_attributeTypes); }
+ List<SchemaType> attributeTypes() {
+ return _attributeTypes.stream().map(SchemaType.Ref::get).collect(Collectors.toList());
+ }
// Identity Constraints
- private List/*<SchemaIdentityConstraint.Ref>*/ _identityConstraints = new ArrayList();
+ private final List<SchemaIdentityConstraint.Ref> _identityConstraints = new ArrayList<>();
- void addIdentityConstraint(SchemaIdentityConstraint.Ref c)
- { check_immutable(); _identityConstraints.add(c); }
+ void addIdentityConstraint(SchemaIdentityConstraint.Ref c) {
+ check_immutable();
+ _identityConstraints.add(c);
+ }
- List identityConstraints()
- { return getComponentList(_identityConstraints); }
+ List<SchemaIdentityConstraint> identityConstraints() {
+ return _identityConstraints.stream().map(SchemaIdentityConstraint.Ref::get).collect(Collectors.toList());
+ }
// Annotations
- private List/*<SchemaAnnotation>*/ _annotations = new ArrayList();
+ private final List<SchemaAnnotation> _annotations = new ArrayList<>();
- void addAnnotation(SchemaAnnotation a)
- { check_immutable(); _annotations.add(a); }
+ void addAnnotation(SchemaAnnotation a) {
+ check_immutable();
+ _annotations.add(a);
+ }
- List annotations()
- { return Collections.unmodifiableList(_annotations); }
-
- private List getComponentList(List referenceList)
- {
- List result = new ArrayList();
- for (int i = 0; i < referenceList.size(); i ++)
- result.add(((SchemaComponent.Ref) referenceList.get(i)).getComponent());
- return Collections.unmodifiableList(result);
+ List<SchemaAnnotation> annotations() {
+ return Collections.unmodifiableList(_annotations);
}
}
diff --git a/src/main/java/org/apache/xmlbeans/impl/schema/StscChecker.java b/src/main/java/org/apache/xmlbeans/impl/schema/StscChecker.java
index caf6ceb..375f37f 100644
--- a/src/main/java/org/apache/xmlbeans/impl/schema/StscChecker.java
+++ b/src/main/java/org/apache/xmlbeans/impl/schema/StscChecker.java
@@ -15,39 +15,16 @@
package org.apache.xmlbeans.impl.schema;
-import org.apache.xmlbeans.SchemaType;
-import org.apache.xmlbeans.SchemaParticle;
-import org.apache.xmlbeans.XmlError;
-import org.apache.xmlbeans.XmlObject;
-import org.apache.xmlbeans.XmlOptions;
-import org.apache.xmlbeans.SchemaLocalElement;
-import org.apache.xmlbeans.SchemaIdentityConstraint;
-import org.apache.xmlbeans.SchemaAttributeModel;
-import org.apache.xmlbeans.SchemaLocalAttribute;
-import org.apache.xmlbeans.SchemaGlobalElement;
-import org.apache.xmlbeans.XmlID;
-import org.apache.xmlbeans.XmlAnySimpleType;
-import org.apache.xmlbeans.XmlErrorCodes;
-import org.apache.xmlbeans.XmlNOTATION;
-import org.apache.xmlbeans.XmlString;
-import org.apache.xmlbeans.impl.common.XBeanDebug;
+import org.apache.xmlbeans.*;
import org.apache.xmlbeans.impl.common.QNameHelper;
+import org.apache.xmlbeans.impl.common.XBeanDebug;
import javax.xml.namespace.QName;
-import java.util.List;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Set;
import java.math.BigInteger;
+import java.util.*;
-public class StscChecker
-{
- public static void checkAll()
- {
+public class StscChecker {
+ public static void checkAll() {
// walk the tree of types
StscState state = StscState.get();
@@ -57,138 +34,123 @@
allSeenTypes.addAll(Arrays.asList(state.redefinedGlobalTypes()));
allSeenTypes.addAll(Arrays.asList(state.globalTypes()));
- for (int i = 0; i < allSeenTypes.size(); i++)
- {
- SchemaType gType = (SchemaType)allSeenTypes.get(i);
+ for (int i = 0; i < allSeenTypes.size(); i++) {
+ SchemaType gType = (SchemaType) allSeenTypes.get(i);
if (!state.noPvr() && // option to turn off particle restriction checking
- !gType.isDocumentType()) // Don't check doc types for restriction.
+ !gType.isDocumentType()) // Don't check doc types for restriction.
{
- checkRestriction((SchemaTypeImpl)gType);
+ checkRestriction((SchemaTypeImpl) gType);
}
- checkFields((SchemaTypeImpl)gType);
+ checkFields((SchemaTypeImpl) gType);
allSeenTypes.addAll(Arrays.asList(gType.getAnonymousTypes()));
}
checkSubstitutionGroups(state.globalElements());
}
-
+
/**
* The following code checks rule #5 of http://www.w3.org/TR/xmlschema-1/#coss-ct
* as well as attribute + element default/fixed validity. <p/>
* Checks that xs:NOTATION is not used directly
*/
- public static void checkFields(SchemaTypeImpl sType)
- {
- if (sType.isSimpleType())
+ public static void checkFields(SchemaTypeImpl sType) {
+ if (sType.isSimpleType()) {
return;
-
+ }
+
XmlObject location = sType.getParseObject();
-
+
SchemaAttributeModel sAttrModel = sType.getAttributeModel();
- if (sAttrModel != null)
- {
- SchemaLocalAttribute[] sAttrs = sAttrModel.getAttributes();
+ if (sAttrModel != null) {
+ SchemaLocalAttribute[] sAttrs = sAttrModel.getAttributes();
QName idAttr = null;
- for (int i = 0; i < sAttrs.length; i++)
- {
- XmlObject attrLocation = ((SchemaLocalAttributeImpl)sAttrs[i])._parseObject;
- if (XmlID.type.isAssignableFrom(sAttrs[i].getType()))
- {
- if (idAttr == null)
- {
+ for (int i = 0; i < sAttrs.length; i++) {
+ XmlObject attrLocation = ((SchemaLocalAttributeImpl) sAttrs[i])._parseObject;
+ if (XmlID.type.isAssignableFrom(sAttrs[i].getType())) {
+ if (idAttr == null) {
idAttr = sAttrs[i].getName();
- }
- else
- {
+ } else {
StscState.get().error(XmlErrorCodes.ATTR_GROUP_PROPERTIES$TWO_IDS,
- new Object[]{ QNameHelper.pretty(idAttr), sAttrs[i].getName() },
+ new Object[]{QNameHelper.pretty(idAttr), sAttrs[i].getName()},
attrLocation != null ? attrLocation : location);
}
- if (sAttrs[i].getDefaultText() != null)
- {
+ if (sAttrs[i].getDefaultText() != null) {
StscState.get().error(XmlErrorCodes.ATTR_PROPERTIES$ID_FIXED_OR_DEFAULT,
null, attrLocation != null ? attrLocation : location);
}
- }
- else if (XmlNOTATION.type.isAssignableFrom(sAttrs[i].getType()))
- {
- if (sAttrs[i].getType().getBuiltinTypeCode() == SchemaType.BTC_NOTATION)
- {
+ } else if (XmlNOTATION.type.isAssignableFrom(sAttrs[i].getType())) {
+ if (sAttrs[i].getType().getBuiltinTypeCode() == SchemaType.BTC_NOTATION) {
StscState.get().recover(XmlErrorCodes.ATTR_NOTATION_TYPE_FORBIDDEN,
- new Object[]{ QNameHelper.pretty(sAttrs[i].getName()) },
+ new Object[]{QNameHelper.pretty(sAttrs[i].getName())},
attrLocation != null ? attrLocation : location);
- }
- else
- {
- if (sAttrs[i].getType().getSimpleVariety() == SchemaType.UNION)
- {
+ } else {
+ if (sAttrs[i].getType().getSimpleVariety() == SchemaType.UNION) {
SchemaType[] members = sAttrs[i].getType().getUnionConstituentTypes();
- for (int j = 0; j < members.length; j++)
- if (members[j].getBuiltinTypeCode() == SchemaType.BTC_NOTATION)
+ for (int j = 0; j < members.length; j++) {
+ if (members[j].getBuiltinTypeCode() == SchemaType.BTC_NOTATION) {
StscState.get().recover(XmlErrorCodes.ATTR_NOTATION_TYPE_FORBIDDEN,
- new Object[]{ QNameHelper.pretty(sAttrs[i].getName()) },
+ new Object[]{QNameHelper.pretty(sAttrs[i].getName())},
attrLocation != null ? attrLocation : location);
+ }
+ }
}
// Check that the Schema in which this is present doesn't have a targetNS
boolean hasNS;
- if (sType.isAttributeType())
+ if (sType.isAttributeType()) {
hasNS = sAttrs[i].getName().getNamespaceURI().length() > 0;
- else
- {
+ } else {
SchemaType t = sType;
- while (t.getOuterType() != null)
+ while (t.getOuterType() != null) {
t = t.getOuterType();
- if (t.isDocumentType())
+ }
+ if (t.isDocumentType()) {
hasNS = t.getDocumentElementName().getNamespaceURI().length() > 0;
- else hasNS = t.getName().getNamespaceURI().length() > 0;
- }
- if (hasNS)
- StscState.get().warning(XmlErrorCodes.ATTR_COMPATIBILITY_TARGETNS,
- new Object[] {QNameHelper.pretty(sAttrs[i].getName()) },
- attrLocation != null ? attrLocation : location);
- }
- }
- else
- {
- String valueConstraint = sAttrs[i].getDefaultText();
- if (valueConstraint != null)
- {
- try
- {
- XmlAnySimpleType val = sAttrs[i].getDefaultValue();
- if (!val.validate())
- throw new Exception();
-
- SchemaPropertyImpl sProp = (SchemaPropertyImpl)sType.getAttributeProperty(sAttrs[i].getName());
- if (sProp != null && sProp.getDefaultText() != null)
- {
- sProp.setDefaultValue(new XmlValueRef(val));
+ } else {
+ hasNS = t.getName().getNamespaceURI().length() > 0;
}
}
- catch (Exception e)
- {
+ if (hasNS) {
+ StscState.get().warning(XmlErrorCodes.ATTR_COMPATIBILITY_TARGETNS,
+ new Object[]{QNameHelper.pretty(sAttrs[i].getName())},
+ attrLocation != null ? attrLocation : location);
+ }
+ }
+ } else {
+ String valueConstraint = sAttrs[i].getDefaultText();
+ if (valueConstraint != null) {
+ try {
+ XmlAnySimpleType val = sAttrs[i].getDefaultValue();
+ if (!val.validate()) {
+ throw new Exception();
+ }
+
+ SchemaPropertyImpl sProp = (SchemaPropertyImpl) sType.getAttributeProperty(sAttrs[i].getName());
+ if (sProp != null && sProp.getDefaultText() != null) {
+ sProp.setDefaultValue(new XmlValueRef(val));
+ }
+ } catch (Exception e) {
// move to 'fixed' or 'default' attribute on the attribute definition
String constraintName = (sAttrs[i].isFixed() ? "fixed" : "default");
XmlObject constraintLocation = location;
- if (attrLocation != null)
- {
+ if (attrLocation != null) {
constraintLocation = attrLocation.selectAttribute("", constraintName);
- if (constraintLocation == null)
+ if (constraintLocation == null) {
constraintLocation = attrLocation;
+ }
}
StscState.get().error(XmlErrorCodes.ATTR_PROPERTIES$CONSTRAINT_VALID,
- new Object[] { QNameHelper.pretty(sAttrs[i].getName()),
- constraintName,
- valueConstraint,
- QNameHelper.pretty(sAttrs[i].getType().getName()) },
+ new Object[]{QNameHelper.pretty(sAttrs[i].getName()),
+ constraintName,
+ valueConstraint,
+ QNameHelper.pretty(sAttrs[i].getType().getName())},
constraintLocation);
}
}
}
}
}
-
+
checkElementDefaults(sType.getContentModel(), location, sType);
}
@@ -196,134 +158,115 @@
* Checks the default values of elements.<p/>
* Also checks that the type of elements is not one of ID, IDREF, IDREFS, ENTITY, ENTITIES or
* NOTATION as per XMLSchema part 2.
+ *
* @param model
* @param location
* @param parentType
*/
- private static void checkElementDefaults(SchemaParticle model, XmlObject location, SchemaType parentType)
- {
- if (model == null)
+ private static void checkElementDefaults(SchemaParticle model, XmlObject location, SchemaType parentType) {
+ if (model == null) {
return;
- switch (model.getParticleType())
- {
+ }
+ switch (model.getParticleType()) {
case SchemaParticle.SEQUENCE:
case SchemaParticle.CHOICE:
case SchemaParticle.ALL:
SchemaParticle[] children = model.getParticleChildren();
- for (int i = 0; i < children.length; i++)
- {
+ for (int i = 0; i < children.length; i++) {
checkElementDefaults(children[i], location, parentType);
}
break;
- case SchemaParticle.ELEMENT:
+ case SchemaParticle.ELEMENT:
String valueConstraint = model.getDefaultText();
- if (valueConstraint != null)
- {
- if (model.getType().isSimpleType() || model.getType().getContentType() == SchemaType.SIMPLE_CONTENT)
- {
- try
- {
+ if (valueConstraint != null) {
+ if (model.getType().isSimpleType() || model.getType().getContentType() == SchemaType.SIMPLE_CONTENT) {
+ try {
XmlAnySimpleType val = model.getDefaultValue();
XmlOptions opt = new XmlOptions();
opt.put(XmlOptions.VALIDATE_TEXT_ONLY);
- if (!val.validate(opt))
+ if (!val.validate(opt)) {
throw new Exception();
+ }
- SchemaPropertyImpl sProp = (SchemaPropertyImpl)parentType.getElementProperty(model.getName());
- if (sProp != null && sProp.getDefaultText() != null)
- {
+ SchemaPropertyImpl sProp = (SchemaPropertyImpl) parentType.getElementProperty(model.getName());
+ if (sProp != null && sProp.getDefaultText() != null) {
sProp.setDefaultValue(new XmlValueRef(val));
}
- }
- catch (Exception e)
- {
+ } catch (Exception e) {
// move to 'fixed' or 'default' attribute on the element definition
String constraintName = (model.isFixed() ? "fixed" : "default");
XmlObject constraintLocation = location.selectAttribute("", constraintName);
StscState.get().error(XmlErrorCodes.ELEM_PROPERTIES$CONSTRAINT_VALID,
- new Object[] { QNameHelper.pretty(model.getName()),
- constraintName,
- valueConstraint,
- QNameHelper.pretty(model.getType().getName()) },
- (constraintLocation==null ? location : constraintLocation));
+ new Object[]{QNameHelper.pretty(model.getName()),
+ constraintName,
+ valueConstraint,
+ QNameHelper.pretty(model.getType().getName())},
+ (constraintLocation == null ? location : constraintLocation));
}
- }
- else if (model.getType().getContentType() == SchemaType.MIXED_CONTENT)
- {
- if (!model.getType().getContentModel().isSkippable())
- {
+ } else if (model.getType().getContentType() == SchemaType.MIXED_CONTENT) {
+ if (!model.getType().getContentModel().isSkippable()) {
String constraintName = (model.isFixed() ? "fixed" : "default");
XmlObject constraintLocation = location.selectAttribute("", constraintName);
StscState.get().error(XmlErrorCodes.ELEM_DEFAULT_VALID$MIXED_AND_EMPTIABLE,
- new Object[] { QNameHelper.pretty(model.getName()),
- constraintName,
- valueConstraint },
- (constraintLocation==null ? location : constraintLocation));
- }
- else
- {
+ new Object[]{QNameHelper.pretty(model.getName()),
+ constraintName,
+ valueConstraint},
+ (constraintLocation == null ? location : constraintLocation));
+ } else {
// Element Default Valid (Immediate): cos-valid-default.2.2.2
// no need to validate the value; type is a xs:string
- SchemaPropertyImpl sProp = (SchemaPropertyImpl)parentType.getElementProperty(model.getName());
- if (sProp != null && sProp.getDefaultText() != null)
- {
+ SchemaPropertyImpl sProp = (SchemaPropertyImpl) parentType.getElementProperty(model.getName());
+ if (sProp != null && sProp.getDefaultText() != null) {
sProp.setDefaultValue(new XmlValueRef(XmlString.type.newValue(valueConstraint)));
}
}
- }
- else if (model.getType().getContentType() == SchemaType.ELEMENT_CONTENT)
- {
+ } else if (model.getType().getContentType() == SchemaType.ELEMENT_CONTENT) {
XmlObject constraintLocation = location.selectAttribute("", "default");
StscState.get().error(XmlErrorCodes.ELEM_DEFAULT_VALID$SIMPLE_TYPE_OR_MIXED,
- new Object[] { QNameHelper.pretty(model.getName()),
- valueConstraint,
- "element" },
- (constraintLocation==null ? location : constraintLocation));
- }
- else if (model.getType().getContentType() == SchemaType.EMPTY_CONTENT)
- {
+ new Object[]{QNameHelper.pretty(model.getName()),
+ valueConstraint,
+ "element"},
+ (constraintLocation == null ? location : constraintLocation));
+ } else if (model.getType().getContentType() == SchemaType.EMPTY_CONTENT) {
XmlObject constraintLocation = location.selectAttribute("", "default");
StscState.get().error(XmlErrorCodes.ELEM_DEFAULT_VALID$SIMPLE_TYPE_OR_MIXED,
- new Object[] { QNameHelper.pretty(model.getName()),
- valueConstraint,
- "empty" },
- (constraintLocation==null ? location : constraintLocation));
+ new Object[]{QNameHelper.pretty(model.getName()),
+ valueConstraint,
+ "empty"},
+ (constraintLocation == null ? location : constraintLocation));
}
}
// Checks if the type is one of the "attribute-specific" types
String warningType = null;
- if (BuiltinSchemaTypeSystem.ST_ID.isAssignableFrom(model.getType()))
+ if (BuiltinSchemaTypeSystem.ST_ID.isAssignableFrom(model.getType())) {
warningType = BuiltinSchemaTypeSystem.ST_ID.getName().getLocalPart();
- else if (BuiltinSchemaTypeSystem.ST_IDREF.isAssignableFrom(model.getType()))
+ } else if (BuiltinSchemaTypeSystem.ST_IDREF.isAssignableFrom(model.getType())) {
warningType = BuiltinSchemaTypeSystem.ST_IDREF.getName().getLocalPart();
- else if (BuiltinSchemaTypeSystem.ST_IDREFS.isAssignableFrom(model.getType()))
+ } else if (BuiltinSchemaTypeSystem.ST_IDREFS.isAssignableFrom(model.getType())) {
warningType = BuiltinSchemaTypeSystem.ST_IDREFS.getName().getLocalPart();
- else if (BuiltinSchemaTypeSystem.ST_ENTITY.isAssignableFrom(model.getType()))
+ } else if (BuiltinSchemaTypeSystem.ST_ENTITY.isAssignableFrom(model.getType())) {
warningType = BuiltinSchemaTypeSystem.ST_ENTITY.getName().getLocalPart();
- else if (BuiltinSchemaTypeSystem.ST_ENTITIES.isAssignableFrom(model.getType()))
+ } else if (BuiltinSchemaTypeSystem.ST_ENTITIES.isAssignableFrom(model.getType())) {
warningType = BuiltinSchemaTypeSystem.ST_ENTITIES.getName().getLocalPart();
- else if (BuiltinSchemaTypeSystem.ST_NOTATION.isAssignableFrom(model.getType()))
- {
- if (model.getType().getBuiltinTypeCode() == SchemaType.BTC_NOTATION)
- {
+ } else if (BuiltinSchemaTypeSystem.ST_NOTATION.isAssignableFrom(model.getType())) {
+ if (model.getType().getBuiltinTypeCode() == SchemaType.BTC_NOTATION) {
StscState.get().recover(XmlErrorCodes.ELEM_NOTATION_TYPE_FORBIDDEN,
- new Object[]{ QNameHelper.pretty(model.getName()) },
+ new Object[]{QNameHelper.pretty(model.getName())},
((SchemaLocalElementImpl) model)._parseObject == null ? location :
- ((SchemaLocalElementImpl) model)._parseObject.selectAttribute("", "type"));
- }
- else
- {
- if (model.getType().getSimpleVariety() == SchemaType.UNION)
- {
+ ((SchemaLocalElementImpl) model)._parseObject.selectAttribute("", "type"));
+ } else {
+ if (model.getType().getSimpleVariety() == SchemaType.UNION) {
SchemaType[] members = model.getType().getUnionConstituentTypes();
- for (int i = 0; i < members.length; i++)
- if (members[i].getBuiltinTypeCode() == SchemaType.BTC_NOTATION)
+ for (int i = 0; i < members.length; i++) {
+ if (members[i].getBuiltinTypeCode() == SchemaType.BTC_NOTATION) {
StscState.get().recover(XmlErrorCodes.ELEM_NOTATION_TYPE_FORBIDDEN,
- new Object[]{ QNameHelper.pretty(model.getName()) },
+ new Object[]{QNameHelper.pretty(model.getName())},
((SchemaLocalElementImpl) model)._parseObject == null ? location :
- ((SchemaLocalElementImpl) model)._parseObject.selectAttribute("", "type"));
+ ((SchemaLocalElementImpl) model)._parseObject.selectAttribute("", "type"));
+ }
+ }
}
warningType = BuiltinSchemaTypeSystem.ST_NOTATION.getName().getLocalPart();
}
@@ -331,195 +274,185 @@
// Check that the Schema in which this is present doesn't have a targetNS
boolean hasNS;
SchemaType t = parentType;
- while (t.getOuterType() != null)
+ while (t.getOuterType() != null) {
t = t.getOuterType();
- if (t.isDocumentType())
+ }
+ if (t.isDocumentType()) {
hasNS = t.getDocumentElementName().getNamespaceURI().length() > 0;
- else
+ } else {
hasNS = t.getName().getNamespaceURI().length() > 0;
- if (hasNS)
+ }
+ if (hasNS) {
StscState.get().warning(XmlErrorCodes.ELEM_COMPATIBILITY_TARGETNS,
- new Object[] {QNameHelper.pretty(model.getName()) },
+ new Object[]{QNameHelper.pretty(model.getName())},
((SchemaLocalElementImpl) model)._parseObject == null ? location :
- ((SchemaLocalElementImpl) model)._parseObject);
+ ((SchemaLocalElementImpl) model)._parseObject);
+ }
}
- if (warningType != null)
+ if (warningType != null) {
StscState.get().warning(XmlErrorCodes.ELEM_COMPATIBILITY_TYPE, new Object[]
- { QNameHelper.pretty(model.getName()), warningType },
+ {QNameHelper.pretty(model.getName()), warningType},
((SchemaLocalElementImpl) model)._parseObject == null ? location :
- ((SchemaLocalElementImpl) model)._parseObject.selectAttribute("", "type"));
+ ((SchemaLocalElementImpl) model)._parseObject.selectAttribute("", "type"));
+ }
break;
- default:
+ default:
// nothing to do.
break;
}
}
-
+
/**
* The following code only checks rule #5 of http://www.w3.org/TR/xmlschema-1/#derivation-ok-restriction
- * (Everything else can and should be done in StscResolver, because we can give more detailed line # info there
+ * (Everything else can and should be done in StscResolver, because we can give more detailed line # info there
*/
- public static boolean checkRestriction(SchemaTypeImpl sType)
- {
- if (sType.getDerivationType() == SchemaType.DT_RESTRICTION && !sType.isSimpleType())
- {
+ public static boolean checkRestriction(SchemaTypeImpl sType) {
+ if (sType.getDerivationType() == SchemaType.DT_RESTRICTION && !sType.isSimpleType()) {
StscState state = StscState.get();
-
+
// we don't remember very precise line number information, but it's better than nothin.
XmlObject location = sType.getParseObject();
-
+
SchemaType baseType = sType.getBaseType();
- if (baseType.isSimpleType())
- {
+ if (baseType.isSimpleType()) {
state.error(XmlErrorCodes.SCHEMA_COMPLEX_TYPE$COMPLEX_CONTENT,
- new Object[] { QNameHelper.pretty(baseType.getName()) },
+ new Object[]{QNameHelper.pretty(baseType.getName())},
location);
return false;
}
-
+
// 5 The appropriate case among the following must be true:
- switch (sType.getContentType())
- {
+ switch (sType.getContentType()) {
case SchemaType.SIMPLE_CONTENT:
// 5.1 If the {content type} of the complex type definition is a simple type definition, then one of the following must be true:
- switch (baseType.getContentType())
- {
+ switch (baseType.getContentType()) {
case SchemaType.SIMPLE_CONTENT:
// 5.1.1 The {content type} of the {base type definition} must be a simple type definition of which the {content type} is a �valid restriction� as defined in Derivation Valid (Restriction, Simple) (�3.14.6).
SchemaType cType = sType.getContentBasedOnType();
- if (cType != baseType)
- {
+ if (cType != baseType) {
// We have to check that the contentType is legally derived
// from the base simple type in the hierarchy
SchemaType bType = baseType;
- while (bType != null && !bType.isSimpleType())
+ while (bType != null && !bType.isSimpleType()) {
bType = bType.getContentBasedOnType();
- if (bType != null && !bType.isAssignableFrom(cType))
- {
+ }
+ if (bType != null && !bType.isAssignableFrom(cType)) {
state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$SC_NOT_DERIVED,
null, location);
return false;
}
}
break;
-
+
case SchemaType.MIXED_CONTENT:
// 5.1.2 The {base type definition} must be mixed and have a particle which is �emptiable� as defined in Particle Emptiable (�3.9.6).
- if (baseType.getContentModel() != null && !baseType.getContentModel().isSkippable())
- {
+ if (baseType.getContentModel() != null && !baseType.getContentModel().isSkippable()) {
state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$SC_AND_MIXED_EMPTIABLE,
null, location);
return false;
}
break;
-
+
default:
state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$SC_AND_SIMPLE_TYPE_OR_MIXED,
null, location);
return false;
}
break;
-
+
case SchemaType.EMPTY_CONTENT:
// 5.2 If the {content type} of the complex type itself is empty , then one of the following must be true:
- switch (baseType.getContentType())
- {
+ switch (baseType.getContentType()) {
case SchemaType.EMPTY_CONTENT:
// 5.2.1 The {content type} of the {base type definition} must also be empty.
break;
case SchemaType.MIXED_CONTENT:
case SchemaType.ELEMENT_CONTENT:
// 5.2.2 The {content type} of the {base type definition} must be elementOnly or mixed and have a particle which is �emptiable� as defined in Particle Emptiable (�3.9.6).
- if (baseType.getContentModel() != null && !baseType.getContentModel().isSkippable())
- {
+ if (baseType.getContentModel() != null && !baseType.getContentModel().isSkippable()) {
state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$EMPTY_AND_ELEMENT_OR_MIXED_EMPTIABLE,
null, location);
return false;
}
break;
- default:
+ default:
state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$EMPTY_AND_NOT_SIMPLE,
null, location);
return false;
}
break;
-
+
case SchemaType.MIXED_CONTENT:
// 5.3 If the {content type} of the {base type definition} is mixed...
- if (baseType.getContentType() != SchemaType.MIXED_CONTENT)
- {
+ if (baseType.getContentType() != SchemaType.MIXED_CONTENT) {
state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$ELEMENT_OR_MIXED_AND_MIXED,
null, location);
return false;
}
-
+
// FALLTHROUGH
case SchemaType.ELEMENT_CONTENT:
// 5.3 ... or the {content type} of the complex type definition itself is element-only,...
- if (baseType.getContentType() == SchemaType.EMPTY_CONTENT)
- {
+ if (baseType.getContentType() == SchemaType.EMPTY_CONTENT) {
state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$ELEMENT_OR_MIXED_AND_EMPTY,
null, location);
return false;
}
- if (baseType.getContentType() == SchemaType.SIMPLE_CONTENT)
- {
+ if (baseType.getContentType() == SchemaType.SIMPLE_CONTENT) {
state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$ELEMENT_OR_MIXED_AND_SIMPLE,
null, location);
return false;
}
-
+
// 5.3 ... then the particle of the complex type definition itself must be a �valid restriction� of the particle of the {content type} of the {base type definition}
SchemaParticle baseModel = baseType.getContentModel();
SchemaParticle derivedModel = sType.getContentModel();
-
- if ( derivedModel == null && sType.getDerivationType()==SchemaType.DT_RESTRICTION )
- {
+
+ if (derivedModel == null && sType.getDerivationType() == SchemaType.DT_RESTRICTION) {
// it is ok to have an empty contentModel if it's a restriction
// see Particle Valid (Restriction) (3.9.6) all three bulets 2.2.1
return true;
- }
- else if (baseModel == null || derivedModel == null)
- {
+ } else if (baseModel == null || derivedModel == null) {
XBeanDebug.logStackTrace("Null models that weren't caught by EMPTY_CONTENT: " + baseType + " (" + baseModel + "), " + sType + " (" + derivedModel + ")");
state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$ELEMENT_OR_MIXED_AND_VALID, null, location);
return false;
}
-
+
// 5.3 ... as defined in Particle Valid (Restriction) (�3.9.6).
- List errors = new ArrayList();
+ List<XmlError> errors = new ArrayList<>();
boolean isValid = isParticleValidRestriction(baseModel, derivedModel, errors, location);
- if (!isValid)
- {
+ if (!isValid) {
// we only add the last error, because isParticleValidRestriction may add errors
// to the collection that it later changes its mind about, or it may (inadvertently)
// forget to describe an error into the collection....
- if (errors.size() == 0)
+ if (errors.size() == 0) {
state.error(XmlErrorCodes.COMPLEX_TYPE_RESTRICTION$ELEMENT_OR_MIXED_AND_VALID, null, location);
- else
+ } else {
state.getErrorListener().add(errors.get(errors.size() - 1));
- //state.getErrorListener().addAll(errors);
+ }
+ //state.getErrorListener().addAll(errors);
return false; // KHK: should return false, right?
}
}
}
return true;
}
-
+
/**
* This function takes in two schema particle types, a baseModel, and a derived model and returns true if the
* derivedModel can be egitimately be used for restriction. Errors are put into the errors collections.
- * @param baseModel - The base schema particle
+ *
+ * @param baseModel - The base schema particle
* @param derivedModel - The derived (restricted) schema particle
- * @param errors - Invalid restriction errors are put into this collection
+ * @param errors - Invalid restriction errors are put into this collection
* @param context
* @return boolean, true if valid restruction, false if invalid restriction
* @
*/
- public static boolean isParticleValidRestriction(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context) {
+ public static boolean isParticleValidRestriction(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
boolean restrictionValid = false;
// 1 They are the same particle.
if (baseModel.equals(derivedModel)) {
@@ -538,7 +471,7 @@
case SchemaParticle.CHOICE:
case SchemaParticle.SEQUENCE:
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION$INVALID_RESTRICTION,
- new Object[] { printParticle(derivedModel), printParticle(baseModel) }, context));
+ new Object[]{printParticle(derivedModel), printParticle(baseModel)}, context));
restrictionValid = false;
break;
default:
@@ -574,7 +507,7 @@
case SchemaParticle.WILDCARD:
case SchemaParticle.CHOICE:
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION$INVALID_RESTRICTION,
- new Object[] { printParticle(derivedModel), printParticle(baseModel) }, context));
+ new Object[]{printParticle(derivedModel), printParticle(baseModel)}, context));
restrictionValid = false;
break;
case SchemaParticle.ALL:
@@ -595,7 +528,7 @@
case SchemaParticle.WILDCARD:
case SchemaParticle.ALL:
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION$INVALID_RESTRICTION,
- new Object[] { printParticle(derivedModel), printParticle(baseModel) }, context));
+ new Object[]{printParticle(derivedModel), printParticle(baseModel)}, context));
restrictionValid = false;
break;
case SchemaParticle.CHOICE:
@@ -617,7 +550,7 @@
case SchemaParticle.ALL:
case SchemaParticle.CHOICE:
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION$INVALID_RESTRICTION,
- new Object[] { printParticle(derivedModel), printParticle(baseModel) }, context));
+ new Object[]{printParticle(derivedModel), printParticle(baseModel)}, context));
restrictionValid = false;
break;
case SchemaParticle.SEQUENCE:
@@ -636,7 +569,7 @@
return restrictionValid;
}
- private static boolean mapAndSum(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context) {
+ private static boolean mapAndSum(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
// mapAndSum is call if base: CHOICE, derived: SEQUENCE
assert baseModel.getParticleType() == SchemaParticle.CHOICE;
assert derivedModel.getParticleType() == SchemaParticle.SEQUENCE;
@@ -675,7 +608,7 @@
if (!foundMatch) {
mapAndSumValid = false;
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_MAP_AND_SUM$MAP,
- new Object[] { printParticle(derivedParticle) },
+ new Object[]{printParticle(derivedParticle)},
context));
// KHK: if we don't return false now, this error may get swallowed by an error produced below
return false;
@@ -704,26 +637,26 @@
if (derivedRangeMin.compareTo(baseModel.getMinOccurs()) < 0) {
mapAndSumValid = false;
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_MAP_AND_SUM$SUM_MIN_OCCURS_GTE_MIN_OCCURS,
- new Object[] { derivedRangeMin.toString(), baseModel.getMinOccurs().toString() },
+ new Object[]{derivedRangeMin.toString(), baseModel.getMinOccurs().toString()},
context));
} else if (baseModel.getMaxOccurs() != UNBOUNDED && (derivedRangeMax == UNBOUNDED || derivedRangeMax.compareTo(baseModel.getMaxOccurs()) > 0)) {
mapAndSumValid = false;
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_MAP_AND_SUM$SUM_MAX_OCCURS_LTE_MAX_OCCURS,
- new Object[] { derivedRangeMax == UNBOUNDED ? "unbounded" : derivedRangeMax.toString(), baseModel.getMaxOccurs().toString() },
+ new Object[]{derivedRangeMax == UNBOUNDED ? "unbounded" : derivedRangeMax.toString(), baseModel.getMaxOccurs().toString()},
context));
}
return mapAndSumValid;
}
- private static boolean recurseAsIfGroup(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context) {
+ private static boolean recurseAsIfGroup(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
// recurseAsIfGroup is called if:
// base: ALL, derived: ELEMENT
// base: CHOICE, derived: ELEMENT
// base: SEQUENCE, derived: ELEMENT
assert (baseModel.getParticleType() == SchemaParticle.ALL && derivedModel.getParticleType() == SchemaParticle.ELEMENT)
- || (baseModel.getParticleType() == SchemaParticle.CHOICE && derivedModel.getParticleType() == SchemaParticle.ELEMENT)
- || (baseModel.getParticleType() == SchemaParticle.SEQUENCE && derivedModel.getParticleType() == SchemaParticle.ELEMENT);
+ || (baseModel.getParticleType() == SchemaParticle.CHOICE && derivedModel.getParticleType() == SchemaParticle.ELEMENT)
+ || (baseModel.getParticleType() == SchemaParticle.SEQUENCE && derivedModel.getParticleType() == SchemaParticle.ELEMENT);
// Schema Component Constraint: Particle Derivation OK (Elt:All/Choice/Sequence -- RecurseAsIfGroup)
// For an element declaration particle to be a �valid restriction� of a group particle
@@ -739,13 +672,13 @@
asIfPart.setParticleType(baseModel.getParticleType());
asIfPart.setMinOccurs(BigInteger.ONE);
asIfPart.setMaxOccurs(BigInteger.ONE);
- asIfPart.setParticleChildren(new SchemaParticle[] { derivedModel });
-
+ asIfPart.setParticleChildren(new SchemaParticle[]{derivedModel});
+
// the recurse
- return isParticleValidRestriction(baseModel, asIfPart, errors, context);
+ return isParticleValidRestriction(baseModel, asIfPart, errors, context);
}
- private static boolean recurseLax(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context) {
+ private static boolean recurseLax(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
// recurseLax is called if base: CHOICE, derived: CHOICE
assert baseModel.getParticleType() == SchemaParticle.CHOICE && derivedModel.getParticleType() == SchemaParticle.CHOICE;
boolean recurseLaxValid = true;
@@ -773,7 +706,7 @@
SchemaParticle[] derivedParticleArray = derivedModel.getParticleChildren();
SchemaParticle[] baseParticleArray = baseModel.getParticleChildren();
int i = 0, j = 0;
- for (; i < derivedParticleArray.length && j < baseParticleArray.length;) {
+ for (; i < derivedParticleArray.length && j < baseParticleArray.length; ) {
SchemaParticle derivedParticle = derivedParticleArray[i];
SchemaParticle baseParticle = baseParticleArray[j];
// try to match the two particles by recursing
@@ -796,7 +729,7 @@
//String message = "Found derived particles that are not matched in the base content model.";
//errors.add(XmlError.forObject(formatDerivedMappingError(message, baseModel, derivedModel), context));
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_RECURSE_LAX$MAP,
- new Object[] { printParticles(baseParticleArray, i) },
+ new Object[]{printParticles(baseParticleArray, i)},
context));
}
@@ -804,7 +737,7 @@
return recurseLaxValid;
}
- private static boolean recurseUnordered(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context) {
+ private static boolean recurseUnordered(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
// recurseUnorder is called when base: ALL and derived: SEQ
assert baseModel.getParticleType() == SchemaParticle.ALL && derivedModel.getParticleType() == SchemaParticle.SEQUENCE;
boolean recurseUnorderedValid = true;
@@ -834,9 +767,10 @@
HashMap baseParticleMap = new HashMap(10);
Object MAPPED = new Object();
// Initialize the hashmap
- for (int i = 0; i < baseParticles.length; i++)
+ for (int i = 0; i < baseParticles.length; i++) {
baseParticleMap.put(baseParticles[i].getName(), baseParticles[i]);
-
+ }
+
// go thru the sequence (derived model's children) and check off from base particle map
SchemaParticle[] derivedParticles = derivedModel.getParticleChildren();
for (int i = 0; i < derivedParticles.length; i++) {
@@ -844,7 +778,7 @@
if (baseParticle == null) {
recurseUnorderedValid = false;
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_RECURSE_UNORDERED$MAP,
- new Object[] { printParticle(derivedParticles[i]) }, context ));
+ new Object[]{printParticle(derivedParticles[i])}, context));
break;
} else {
// got a match
@@ -852,21 +786,20 @@
// whoa, this base particle has already been matched (see 2.1 above)
recurseUnorderedValid = false;
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_RECURSE_UNORDERED$MAP_UNIQUE,
- new Object[] { printParticle(derivedParticles[i]) }, context ));
+ new Object[]{printParticle(derivedParticles[i])}, context));
break;
} else {
- SchemaParticle matchedBaseParticle = (SchemaParticle)baseParticle;
+ SchemaParticle matchedBaseParticle = (SchemaParticle) baseParticle;
if (derivedParticles[i].getMaxOccurs() == null ||
- derivedParticles[i].getMaxOccurs().compareTo(BigInteger.ONE) > 0) {
+ derivedParticles[i].getMaxOccurs().compareTo(BigInteger.ONE) > 0) {
// no derived particles can have a max occurs greater than 1
recurseUnorderedValid = false;
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_RECURSE_UNORDERED$MAP_MAX_OCCURS_1,
- new Object[] { printParticle(derivedParticles[i]), printMaxOccurs(derivedParticles[i].getMinOccurs()) },
+ new Object[]{printParticle(derivedParticles[i]), printMaxOccurs(derivedParticles[i].getMinOccurs())},
context));
break;
}
- if (!isParticleValidRestriction(matchedBaseParticle, derivedParticles[i], errors, context))
- {
+ if (!isParticleValidRestriction(matchedBaseParticle, derivedParticles[i], errors, context)) {
// already have an error
recurseUnorderedValid = false;
break;
@@ -881,13 +814,13 @@
if (recurseUnorderedValid) {
// get all the hashmap keys and loop thru looking for NOT_MAPPED
Set baseParticleCollection = baseParticleMap.keySet();
- for (Iterator iterator = baseParticleCollection.iterator(); iterator.hasNext();) {
+ for (Iterator iterator = baseParticleCollection.iterator(); iterator.hasNext(); ) {
QName baseParticleQName = (QName) iterator.next();
- if (baseParticleMap.get(baseParticleQName) != MAPPED && !((SchemaParticle)baseParticleMap.get(baseParticleQName)).isSkippable()) {
+ if (baseParticleMap.get(baseParticleQName) != MAPPED && !((SchemaParticle) baseParticleMap.get(baseParticleQName)).isSkippable()) {
// this base particle was not mapped and is not "particle emptiable" (skippable)
recurseUnorderedValid = false;
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_RECURSE_UNORDERED$UNMAPPED_ARE_EMPTIABLE,
- new Object[] { printParticle((SchemaParticle)baseParticleMap.get(baseParticleQName)) },
+ new Object[]{printParticle((SchemaParticle) baseParticleMap.get(baseParticleQName))},
context));
}
}
@@ -896,7 +829,7 @@
return recurseUnorderedValid;
}
- private static boolean recurse(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context) {
+ private static boolean recurse(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
// recurse is called when base: ALL derived: ALL or base: SEQUENCE derived: SEQUENCE
boolean recurseValid = true;
// For an all or sequence group particle to be a �valid restriction� of another group particle with the same
@@ -930,7 +863,7 @@
SchemaParticle[] derivedParticleArray = derivedModel.getParticleChildren();
SchemaParticle[] baseParticleArray = baseModel.getParticleChildren();
int i = 0, j = 0;
- for (; i < derivedParticleArray.length && j < baseParticleArray.length;) {
+ for (; i < derivedParticleArray.length && j < baseParticleArray.length; ) {
SchemaParticle derivedParticle = derivedParticleArray[i];
SchemaParticle baseParticle = baseParticleArray[j];
// try to match the two particles by recursing
@@ -948,8 +881,8 @@
// whoa, particles are not valid restrictions and base is not skippable - ERROR
recurseValid = false;
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_RECURSE$MAP_VALID,
- new Object[] { printParticle(derivedParticle), printParticle(derivedModel),
- printParticle(baseParticle), printParticle(baseModel) },
+ new Object[]{printParticle(derivedParticle), printParticle(derivedModel),
+ printParticle(baseParticle), printParticle(baseModel)},
context));
break;
}
@@ -962,7 +895,7 @@
if (i < derivedParticleArray.length) {
recurseValid = false;
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_RECURSE$MAP,
- new Object[] { printParticle(derivedModel), printParticle(baseModel), printParticles(derivedParticleArray, i) },
+ new Object[]{printParticle(derivedModel), printParticle(baseModel), printParticles(derivedParticleArray, i)},
context));
} else {
// if at end of derived particle array and not at end of base particle array then chck remaining
@@ -974,11 +907,10 @@
particles.add(baseParticleArray[k]);
}
}
- if (particles.size() > 0)
- {
+ if (particles.size() > 0) {
recurseValid = false;
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_RECURSE$UNMAPPED_ARE_EMPTIABLE,
- new Object[] { printParticle(baseModel), printParticle(derivedModel), printParticles(particles)}, context));
+ new Object[]{printParticle(baseModel), printParticle(derivedModel), printParticles(particles)}, context));
}
}
}
@@ -986,22 +918,22 @@
return recurseValid;
}
- private static boolean nsRecurseCheckCardinality(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context) {
+ private static boolean nsRecurseCheckCardinality(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
// nsRecurseCheckCardinality is called when:
// base: ANY, derived: ALL
// base: ANY, derived: CHOICE
// base: ANY, derived: SEQUENCE
assert baseModel.getParticleType() == SchemaParticle.WILDCARD;
assert (derivedModel.getParticleType() == SchemaParticle.ALL)
- || (derivedModel.getParticleType() == SchemaParticle.CHOICE)
- || (derivedModel.getParticleType() == SchemaParticle.SEQUENCE);
+ || (derivedModel.getParticleType() == SchemaParticle.CHOICE)
+ || (derivedModel.getParticleType() == SchemaParticle.SEQUENCE);
boolean nsRecurseCheckCardinality = true;
// For a group particle to be a �valid restriction� of a wildcard particle all of the following must be true:
// 1 Every member of the {particles} of the group is a �valid restriction� of the wildcard as defined by Particle Valid (Restriction) (�3.9.6).
// Note: not positive what this means. Interpreting to mean that every particle of the group must adhere to wildcard derivation rules
// in a recursive manner
// Loop thru the children particles of the group and invoke the appropriate function to check for wildcard restriction validity
-
+
// BAU - an errata should be submitted on this clause of the spec, because the
// spec makes no sense, as the xstc particlesR013.xsd test exemplifies.
// what we _should_ so is an "as if" on the wildcard, allowing it minOccurs="0" maxOccurs="unbounded"
@@ -1051,7 +983,7 @@
return nsRecurseCheckCardinality;
}
- private static boolean checkGroupOccurrenceOK(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context) {
+ private static boolean checkGroupOccurrenceOK(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
boolean groupOccurrenceOK = true;
BigInteger minRange = BigInteger.ZERO;
BigInteger maxRange = BigInteger.ZERO;
@@ -1072,7 +1004,7 @@
if (minRange.compareTo(baseModel.getMinOccurs()) < 0) {
groupOccurrenceOK = false;
errors.add(XmlError.forObject(XmlErrorCodes.OCCURRENCE_RANGE$MIN_GTE_MIN,
- new Object[] { printParticle(derivedModel), printParticle(baseModel) },
+ new Object[]{printParticle(derivedModel), printParticle(baseModel)},
context));
}
// Check max occurs for validity
@@ -1084,20 +1016,20 @@
if (maxRange == UNBOUNDED) {
groupOccurrenceOK = false;
errors.add(XmlError.forObject(XmlErrorCodes.OCCURRENCE_RANGE$MAX_LTE_MAX,
- new Object[] { printParticle(derivedModel), printParticle(baseModel) },
+ new Object[]{printParticle(derivedModel), printParticle(baseModel)},
context));
} else {
if (maxRange.compareTo(baseModel.getMaxOccurs()) > 0) {
groupOccurrenceOK = false;
errors.add(XmlError.forObject(XmlErrorCodes.OCCURRENCE_RANGE$MAX_LTE_MAX,
- new Object[] { printParticle(derivedModel), printParticle(baseModel) },
+ new Object[]{printParticle(derivedModel), printParticle(baseModel)},
context));
}
}
}
return groupOccurrenceOK;
}
-
+
private static BigInteger getEffectiveMaxRangeChoice(SchemaParticle derivedModel) {
BigInteger maxRange = BigInteger.ZERO;
BigInteger UNBOUNDED = null;
@@ -1270,8 +1202,9 @@
// declaration particle in the group's {particles} and the minimum part of the effective total range of each of
// the group particles in the group's {particles} (or 0 if there are no {particles}).
SchemaParticle[] particleChildren = derivedModel.getParticleChildren();
- if (particleChildren.length == 0)
+ if (particleChildren.length == 0) {
return BigInteger.ZERO;
+ }
BigInteger minRange = null;
// get the minimum of every wildcard or element
// total up the effective total range for each group
@@ -1299,8 +1232,9 @@
break;
}
}
- if (minRange == null)
+ if (minRange == null) {
minRange = BigInteger.ZERO;
+ }
// calculate the total
minRange = derivedModel.getMinOccurs().multiply(minRange);
@@ -1342,7 +1276,7 @@
return minRange;
}
- private static boolean nsSubset(SchemaParticle baseModel, SchemaParticle derivedModel, Collection errors, XmlObject context) {
+ private static boolean nsSubset(SchemaParticle baseModel, SchemaParticle derivedModel, Collection<XmlError> errors, XmlObject context) {
// nsSubset is called when base: ANY, derived: ANY
assert baseModel.getParticleType() == SchemaParticle.WILDCARD;
assert derivedModel.getParticleType() == SchemaParticle.WILDCARD;
@@ -1357,7 +1291,7 @@
} else {
nsSubset = false;
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_NS_SUBST$WILDCARD_SUBSET,
- new Object[] { printParticle(derivedModel), printParticle(baseModel) }, context));
+ new Object[]{printParticle(derivedModel), printParticle(baseModel)}, context));
}
} else {
nsSubset = false;
@@ -1369,7 +1303,7 @@
return nsSubset;
}
- private static boolean nsCompat(SchemaParticle baseModel, SchemaLocalElement derivedElement, Collection errors, XmlObject context) {
+ private static boolean nsCompat(SchemaParticle baseModel, SchemaLocalElement derivedElement, Collection<XmlError> errors, XmlObject context) {
// nsCompat is called when base: ANY, derived: ELEMENT
assert baseModel.getParticleType() == SchemaParticle.WILDCARD;
boolean nsCompat = false;
@@ -1387,7 +1321,7 @@
} else {
nsCompat = false;
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_DERIVATION_NS_COMPAT$WILDCARD_VALID,
- new Object[] { printParticle((SchemaParticle)derivedElement), printParticle(baseModel) },
+ new Object[]{printParticle((SchemaParticle) derivedElement), printParticle(baseModel)},
context));
}
@@ -1395,90 +1329,82 @@
return nsCompat;
}
- private static boolean nameAndTypeOK(SchemaLocalElement baseElement, SchemaLocalElement derivedElement, Collection errors, XmlObject context) {
+ private static boolean nameAndTypeOK(SchemaLocalElement baseElement, SchemaLocalElement derivedElement, Collection<XmlError> errors, XmlObject context) {
// nameAndTypeOK called when base: ELEMENT and derived: ELEMENT
-
+
// Schema Component Constraint: Particle Restriction OK (Elt:Elt -- NameAndTypeOK)
// 1 The declarations' {name}s and {target namespace}s are the same.
- if (!((SchemaParticle)baseElement).canStartWithElement(derivedElement.getName())) {
+ if (!((SchemaParticle) baseElement).canStartWithElement(derivedElement.getName())) {
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$NAME,
- new Object[] { printParticle((SchemaParticle)derivedElement), printParticle((SchemaParticle)baseElement) }, context));
+ new Object[]{printParticle((SchemaParticle) derivedElement), printParticle((SchemaParticle) baseElement)}, context));
return false;
}
-
+
// 2 Either B's {nillable} is true or R's {nillable} is false.
if (!baseElement.isNillable() && derivedElement.isNillable()) {
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$NILLABLE,
- new Object[] { printParticle((SchemaParticle)derivedElement), printParticle((SchemaParticle)baseElement) }, context));
+ new Object[]{printParticle((SchemaParticle) derivedElement), printParticle((SchemaParticle) baseElement)}, context));
return false;
}
-
+
// 3 R's occurrence range is a valid restriction of B's occurrence range as defined by Occurrence Range OK (�3.9.6).
if (!occurrenceRangeOK((SchemaParticle) baseElement, (SchemaParticle) derivedElement, errors, context)) {
// error already produced
return false;
}
-
+
// 4 either B's declaration's {value constraint} is absent, or is not fixed,
// or R's declaration's {value constraint} is fixed with the same value.
- if (!checkFixed(baseElement, derivedElement, errors, context))
- {
+ if (!checkFixed(baseElement, derivedElement, errors, context)) {
// error already produced
return false;
}
-
+
// 5 R's declaration's {identity-constraint definitions} is a subset of B's declaration's {identity-constraint definitions}, if any.
- if (!checkIdentityConstraints(baseElement, derivedElement, errors, context))
- {
+ if (!checkIdentityConstraints(baseElement, derivedElement, errors, context)) {
// error already produced
return false;
}
-
+
// 7 R's {type definition} is validly derived given {extension, list, union} from B's {type definition} as
// defined by Type Derivation OK (Complex) (�3.4.6) or Type Derivation OK (Simple) (�3.14.6), as appropriate.
- if (!typeDerivationOK(baseElement.getType(), derivedElement.getType(), errors, context))
- {
+ if (!typeDerivationOK(baseElement.getType(), derivedElement.getType(), errors, context)) {
// error already produced
return false;
}
-
+
// 6 R's declaration's {disallowed substitutions} is a superset of B's declaration's {disallowed substitutions}.
- if (!blockSetOK(baseElement, derivedElement, errors, context))
- {
+ if (!blockSetOK(baseElement, derivedElement, errors, context)) {
// error already produced
- return false;
+ return false;
}
return true;
}
-
- private static boolean blockSetOK(SchemaLocalElement baseElement, SchemaLocalElement derivedElement, Collection errors, XmlObject context)
- {
- if (baseElement.blockRestriction() && !derivedElement.blockRestriction())
- {
+
+ private static boolean blockSetOK(SchemaLocalElement baseElement, SchemaLocalElement derivedElement, Collection<XmlError> errors, XmlObject context) {
+ if (baseElement.blockRestriction() && !derivedElement.blockRestriction()) {
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$DISALLOWED_SUBSTITUTIONS,
- new Object[] { printParticle((SchemaParticle)derivedElement), "restriction", printParticle((SchemaParticle)baseElement) },
+ new Object[]{printParticle((SchemaParticle) derivedElement), "restriction", printParticle((SchemaParticle) baseElement)},
context));
return false;
}
- if (baseElement.blockExtension() && !derivedElement.blockExtension())
- {
+ if (baseElement.blockExtension() && !derivedElement.blockExtension()) {
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$DISALLOWED_SUBSTITUTIONS,
- new Object[] { printParticle((SchemaParticle)derivedElement), "extension", printParticle((SchemaParticle)baseElement) },
+ new Object[]{printParticle((SchemaParticle) derivedElement), "extension", printParticle((SchemaParticle) baseElement)},
context));
return false;
}
- if (baseElement.blockSubstitution() && !derivedElement.blockSubstitution())
- {
+ if (baseElement.blockSubstitution() && !derivedElement.blockSubstitution()) {
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$DISALLOWED_SUBSTITUTIONS,
- new Object[] { printParticle((SchemaParticle)derivedElement), "substitution", printParticle((SchemaParticle)baseElement) },
+ new Object[]{printParticle((SchemaParticle) derivedElement), "substitution", printParticle((SchemaParticle) baseElement)},
context));
return false;
}
- return true;
+ return true;
}
- private static boolean typeDerivationOK(SchemaType baseType, SchemaType derivedType, Collection errors, XmlObject context){
+ private static boolean typeDerivationOK(SchemaType baseType, SchemaType derivedType, Collection<XmlError> errors, XmlObject context) {
boolean typeDerivationOK = false;
// 1 If B and D are not the same type definition, then the {derivation method} of D must not be in the subset.
// 2 One of the following must be true:
@@ -1498,38 +1424,39 @@
// derived type is not a sub-type of base type
typeDerivationOK = false;
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$TYPE_VALID,
- new Object[] { printType(derivedType), printType(baseType) }, context));
+ new Object[]{printType(derivedType), printType(baseType)}, context));
}
return typeDerivationOK;
}
- private static boolean checkAllDerivationsForRestriction(SchemaType baseType, SchemaType derivedType, Collection errors, XmlObject context) {
+ private static boolean checkAllDerivationsForRestriction(SchemaType baseType, SchemaType derivedType, Collection<XmlError> errors, XmlObject context) {
boolean allDerivationsAreRestrictions = true;
SchemaType currentType = derivedType;
// XMLBEANS-66: if baseType is a union, check restriction is of one of the constituant types
Set possibleTypes = null;
- if (baseType.getSimpleVariety() == SchemaType.UNION)
+ if (baseType.getSimpleVariety() == SchemaType.UNION) {
possibleTypes = new HashSet(Arrays.asList(baseType.getUnionConstituentTypes()));
+ }
// run up the types hierarchy from derived Type to base Type and make sure that all are derived by
// restriction. If any are not then this is not a valid restriction.
while (!baseType.equals(currentType) &&
- possibleTypes != null && !possibleTypes.contains(currentType)) {
+ possibleTypes != null && !possibleTypes.contains(currentType)) {
if (currentType.getDerivationType() == SchemaType.DT_RESTRICTION) {
currentType = currentType.getBaseType();
} else {
allDerivationsAreRestrictions = false;
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$TYPE_RESTRICTED,
- new Object[] { printType(derivedType), printType(baseType), printType(currentType) }, context));
+ new Object[]{printType(derivedType), printType(baseType), printType(currentType)}, context));
break;
}
}
return allDerivationsAreRestrictions;
}
- private static boolean checkIdentityConstraints(SchemaLocalElement baseElement, SchemaLocalElement derivedElement, Collection errors, XmlObject context) {
+ private static boolean checkIdentityConstraints(SchemaLocalElement baseElement, SchemaLocalElement derivedElement, Collection<XmlError> errors, XmlObject context) {
// 5 R's declaration's {identity-constraint definitions} is a subset of B's declaration's {identity-constraint definitions}, if any.
boolean identityConstraintsOK = true;
@@ -1541,7 +1468,7 @@
if (checkForIdentityConstraintExistence(baseConstraints, derivedConstraint)) {
identityConstraintsOK = false;
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$IDENTITY_CONSTRAINTS,
- new Object[] { printParticle((SchemaParticle)derivedElement), printParticle((SchemaParticle)baseElement) },
+ new Object[]{printParticle((SchemaParticle) derivedElement), printParticle((SchemaParticle) baseElement)},
context));
break;
}
@@ -1563,7 +1490,7 @@
}
- private static boolean checkFixed(SchemaLocalElement baseModel, SchemaLocalElement derivedModel, Collection errors, XmlObject context) {
+ private static boolean checkFixed(SchemaLocalElement baseModel, SchemaLocalElement derivedModel, Collection<XmlError> errors, XmlObject context) {
// 4 either B's declaration's {value constraint} is absent, or is not fixed,
// or R's declaration's {value constraint} is fixed with the same value.
boolean checkFixed = false;
@@ -1574,8 +1501,8 @@
} else {
// The derived element has a fixed value that is different than the base element
errors.add(XmlError.forObject(XmlErrorCodes.PARTICLE_RESTRICTION_NAME_AND_TYPE$FIXED,
- new Object[] { printParticle((SchemaParticle)derivedModel), derivedModel.getDefaultText(),
- printParticle((SchemaParticle)baseModel), baseModel.getDefaultText() },
+ new Object[]{printParticle((SchemaParticle) derivedModel), derivedModel.getDefaultText(),
+ printParticle((SchemaParticle) baseModel), baseModel.getDefaultText()},
context));
checkFixed = false;
}
@@ -1586,7 +1513,7 @@
return checkFixed;
}
- private static boolean occurrenceRangeOK(SchemaParticle baseParticle, SchemaParticle derivedParticle, Collection errors, XmlObject context) {
+ private static boolean occurrenceRangeOK(SchemaParticle baseParticle, SchemaParticle derivedParticle, Collection<XmlError> errors, XmlObject context) {
boolean occurrenceRangeOK = false;
// Note: in the following comments (from the schema spec) other is the baseModel
// 1 Its {min occurs} is greater than or equal to the other's {min occurs}.
@@ -1598,55 +1525,50 @@
} else {
// 2.2 Both {max occurs} are numbers, and the particle's is less than or equal to the other's.
if (derivedParticle.getMaxOccurs() != null && baseParticle.getMaxOccurs() != null &&
- derivedParticle.getMaxOccurs().compareTo(baseParticle.getMaxOccurs()) <= 0) {
+ derivedParticle.getMaxOccurs().compareTo(baseParticle.getMaxOccurs()) <= 0) {
occurrenceRangeOK = true;
} else {
occurrenceRangeOK = false;
errors.add(XmlError.forObject(XmlErrorCodes.OCCURRENCE_RANGE$MAX_LTE_MAX,
- new Object[] { printParticle(derivedParticle), printMaxOccurs(derivedParticle.getMaxOccurs()),
- printParticle(baseParticle), printMaxOccurs(baseParticle.getMaxOccurs()) },
+ new Object[]{printParticle(derivedParticle), printMaxOccurs(derivedParticle.getMaxOccurs()),
+ printParticle(baseParticle), printMaxOccurs(baseParticle.getMaxOccurs())},
context));
}
}
} else {
occurrenceRangeOK = false;
errors.add(XmlError.forObject(XmlErrorCodes.OCCURRENCE_RANGE$MIN_GTE_MIN,
- new Object[] { printParticle(derivedParticle), derivedParticle.getMinOccurs().toString(),
- printParticle(baseParticle), baseParticle.getMinOccurs().toString() },
+ new Object[]{printParticle(derivedParticle), derivedParticle.getMinOccurs().toString(),
+ printParticle(baseParticle), baseParticle.getMinOccurs().toString()},
context));
}
return occurrenceRangeOK;
}
- private static String printParticles(List parts)
- {
- return printParticles((SchemaParticle[])parts.toArray(new SchemaParticle[parts.size()]));
+ private static String printParticles(List parts) {
+ return printParticles((SchemaParticle[]) parts.toArray(new SchemaParticle[parts.size()]));
}
-
- private static String printParticles(SchemaParticle[] parts)
- {
+
+ private static String printParticles(SchemaParticle[] parts) {
return printParticles(parts, 0, parts.length);
}
-
- private static String printParticles(SchemaParticle[] parts, int start)
- {
+
+ private static String printParticles(SchemaParticle[] parts, int start) {
return printParticles(parts, start, parts.length);
}
-
- private static String printParticles(SchemaParticle[] parts, int start, int end)
- {
+
+ private static String printParticles(SchemaParticle[] parts, int start, int end) {
StringBuilder buf = new StringBuilder(parts.length * 30);
- for (int i = start; i < end; )
- {
+ for (int i = start; i < end; ) {
buf.append(printParticle(parts[i]));
- if (++i != end)
+ if (++i != end) {
buf.append(", ");
+ }
}
return buf.toString();
}
-
- private static String printParticle(SchemaParticle part)
- {
+
+ private static String printParticle(SchemaParticle part) {
switch (part.getParticleType()) {
case SchemaParticle.ALL:
return "<all>";
@@ -1658,71 +1580,60 @@
return "<sequence>";
case SchemaParticle.WILDCARD:
return "<any>";
- default :
+ default:
return "??";
}
}
-
- private static String printMaxOccurs(BigInteger bi)
- {
- if (bi == null)
+
+ private static String printMaxOccurs(BigInteger bi) {
+ if (bi == null) {
return "unbounded";
+ }
return bi.toString();
}
-
- private static String printType(SchemaType type)
- {
- if (type.getName() != null)
+
+ private static String printType(SchemaType type) {
+ if (type.getName() != null) {
return QNameHelper.pretty(type.getName());
+ }
return type.toString();
}
- private static void checkSubstitutionGroups(SchemaGlobalElement[] elts)
- {
+ private static void checkSubstitutionGroups(SchemaGlobalElement[] elts) {
StscState state = StscState.get();
- for (int i = 0 ; i < elts.length ; i++)
- {
+ for (int i = 0; i < elts.length; i++) {
SchemaGlobalElement elt = elts[i];
SchemaGlobalElement head = elt.substitutionGroup();
- if (head != null)
- {
+ if (head != null) {
SchemaType headType = head.getType();
SchemaType tailType = elt.getType();
- XmlObject parseTree = ((SchemaGlobalElementImpl)elt)._parseObject;
+ XmlObject parseTree = ((SchemaGlobalElementImpl) elt)._parseObject;
- if (! headType.isAssignableFrom(tailType))
- {
+ if (!headType.isAssignableFrom(tailType)) {
state.error(XmlErrorCodes.ELEM_PROPERTIES$SUBSTITUTION_VALID,
- new Object[] {QNameHelper.pretty(elt.getName()),
- QNameHelper.pretty(head.getName())},
+ new Object[]{QNameHelper.pretty(elt.getName()),
+ QNameHelper.pretty(head.getName())},
parseTree);
- }
- else if (head.finalExtension() && head.finalRestriction())
- {
+ } else if (head.finalExtension() && head.finalRestriction()) {
state.error(XmlErrorCodes.ELEM_PROPERTIES$SUBSTITUTION_FINAL,
- new Object[] {QNameHelper.pretty(elt.getName()),
- QNameHelper.pretty(head.getName()),
- "#all"}, parseTree);
- }
- else if (! headType.equals(tailType))
- {
- if (head.finalExtension() &&
- tailType.getDerivationType() == SchemaType.DT_EXTENSION)
- {
+ new Object[]{QNameHelper.pretty(elt.getName()),
+ QNameHelper.pretty(head.getName()),
+ "#all"}, parseTree);
+ } else if (!headType.equals(tailType)) {
+ if (head.finalExtension() &&
+ tailType.getDerivationType() == SchemaType.DT_EXTENSION) {
state.error(XmlErrorCodes.ELEM_PROPERTIES$SUBSTITUTION_FINAL,
- new Object[] {QNameHelper.pretty(elt.getName()),
- QNameHelper.pretty(head.getName()),
- "extension"}, parseTree);
- }
- else if (head.finalRestriction() &&
- tailType.getDerivationType() == SchemaType.DT_RESTRICTION)
- {
+ new Object[]{QNameHelper.pretty(elt.getName()),
+ QNameHelper.pretty(head.getName()),
+ "extension"}, parseTree);
+ } else if (head.finalRestriction() &&
+ tailType.getDerivationType() == SchemaType.DT_RESTRICTION) {
state.error(XmlErrorCodes.ELEM_PROPERTIES$SUBSTITUTION_FINAL,
- new Object[] {QNameHelper.pretty(elt.getName()),
- QNameHelper.pretty(head.getName()),
- "restriction"}, parseTree);
+ new Object[]{QNameHelper.pretty(elt.getName()),
+ QNameHelper.pretty(head.getName()),
+ "restriction"}, parseTree);
}
}
}
diff --git a/src/main/java/org/apache/xmlbeans/impl/schema/StscResolver.java b/src/main/java/org/apache/xmlbeans/impl/schema/StscResolver.java
index 0c96d66..5a945e5 100644
--- a/src/main/java/org/apache/xmlbeans/impl/schema/StscResolver.java
+++ b/src/main/java/org/apache/xmlbeans/impl/schema/StscResolver.java
@@ -15,37 +15,31 @@
package org.apache.xmlbeans.impl.schema;
-import org.apache.xmlbeans.SchemaType;
-import org.apache.xmlbeans.XmlObject;
-import org.apache.xmlbeans.SchemaParticle;
import org.apache.xmlbeans.QNameSet;
+import org.apache.xmlbeans.SchemaParticle;
+import org.apache.xmlbeans.SchemaType;
import org.apache.xmlbeans.XmlErrorCodes;
-
-import java.math.BigInteger;
-
-import java.util.*;
-
-import org.apache.xmlbeans.impl.xb.xsdschema.TopLevelElement;
-import org.apache.xmlbeans.impl.xb.xsdschema.TopLevelAttribute;
-import org.apache.xmlbeans.impl.xb.xsdschema.SimpleType;
import org.apache.xmlbeans.impl.xb.xsdschema.Attribute;
import org.apache.xmlbeans.impl.xb.xsdschema.Element;
import org.apache.xmlbeans.impl.xb.xsdschema.KeyrefDocument.Keyref;
-import javax.xml.namespace.QName;
+import org.apache.xmlbeans.impl.xb.xsdschema.TopLevelElement;
-public class StscResolver
-{
+import javax.xml.namespace.QName;
+import java.math.BigInteger;
+import java.util.*;
+
+public class StscResolver {
/**
* Does a topo walk of all the types to resolve them.
*/
- public static void resolveAll()
- {
+ public static void resolveAll() {
// resolve tree of types
StscState state = StscState.get();
SchemaType[] documentTypes = state.documentTypes();
- for (int i = 0 ; i < documentTypes.length ; i++)
- resolveSubstitutionGroup((SchemaTypeImpl)documentTypes[i]);
+ for (int i = 0; i < documentTypes.length; i++) {
+ resolveSubstitutionGroup((SchemaTypeImpl) documentTypes[i]);
+ }
List allSeenTypes = new ArrayList();
allSeenTypes.addAll(Arrays.asList(state.documentTypes()));
@@ -53,10 +47,9 @@
allSeenTypes.addAll(Arrays.asList(state.redefinedGlobalTypes()));
allSeenTypes.addAll(Arrays.asList(state.globalTypes()));
- for (int i = 0; i < allSeenTypes.size(); i++)
- {
- SchemaType gType = (SchemaType)allSeenTypes.get(i);
- resolveType((SchemaTypeImpl)gType);
+ for (int i = 0; i < allSeenTypes.size(); i++) {
+ SchemaType gType = (SchemaType) allSeenTypes.get(i);
+ resolveType((SchemaTypeImpl) gType);
allSeenTypes.addAll(Arrays.asList(gType.getAnonymousTypes()));
}
@@ -64,12 +57,11 @@
resolveIdentityConstraints();
}
- public static boolean resolveType(SchemaTypeImpl sImpl)
- {
- if (sImpl.isResolved())
+ public static boolean resolveType(SchemaTypeImpl sImpl) {
+ if (sImpl.isResolved()) {
return true;
- if (sImpl.isResolving())
- {
+ }
+ if (sImpl.isResolving()) {
StscState.get().error("Cyclic dependency error", XmlErrorCodes.CYCLIC_DEPENDENCY, sImpl.getParseObject());
return false; // cyclic dependency error
}
@@ -77,28 +69,28 @@
sImpl.startResolving();
- if (sImpl.isDocumentType())
+ if (sImpl.isDocumentType()) {
resolveDocumentType(sImpl);
- else if (sImpl.isAttributeType())
+ } else if (sImpl.isAttributeType()) {
resolveAttributeType(sImpl);
- else if (sImpl.isSimpleType())
+ } else if (sImpl.isSimpleType()) {
StscSimpleTypeResolver.resolveSimpleType(sImpl);
- else
+ } else {
StscComplexTypeResolver.resolveComplexType(sImpl);
+ }
sImpl.finishResolving();
// System.out.println("Finished resolving " + sImpl);
return true;
}
- public static boolean resolveSubstitutionGroup(SchemaTypeImpl sImpl)
- {
+ public static boolean resolveSubstitutionGroup(SchemaTypeImpl sImpl) {
assert sImpl.isDocumentType();
- if (sImpl.isSGResolved())
+ if (sImpl.isSGResolved()) {
return true;
- if (sImpl.isSGResolving())
- {
+ }
+ if (sImpl.isSGResolving()) {
StscState.get().error("Cyclic dependency error", XmlErrorCodes.CYCLIC_DEPENDENCY, sImpl.getParseObject());
return false; // cyclic dependency error
}
@@ -107,42 +99,44 @@
// Resolve substitution group
- TopLevelElement elt = (TopLevelElement)sImpl.getParseObject();
+ TopLevelElement elt = (TopLevelElement) sImpl.getParseObject();
SchemaTypeImpl substitutionGroup = null;
QName eltName = new QName(sImpl.getTargetNamespace(), elt.getName());
// BUG: How do I tell if the type is in this compilation unit?
- if (elt.isSetSubstitutionGroup())
- {
- substitutionGroup = StscState.get().findDocumentType(elt.getSubstitutionGroup(),
+ if (elt.isSetSubstitutionGroup()) {
+ substitutionGroup = StscState.get().findDocumentType(elt.getSubstitutionGroup(),
sImpl.getChameleonNamespace(), sImpl.getTargetNamespace());
- if (substitutionGroup == null)
+ if (substitutionGroup == null) {
StscState.get().notFoundError(elt.getSubstitutionGroup(), SchemaType.ELEMENT, elt.xgetSubstitutionGroup(), true);
- // recovery - ignore substitution group
- else if (! resolveSubstitutionGroup(substitutionGroup) )
+ }
+ // recovery - ignore substitution group
+ else if (!resolveSubstitutionGroup(substitutionGroup)) {
substitutionGroup = null;
- else
+ } else {
sImpl.setSubstitutionGroup(elt.getSubstitutionGroup());
+ }
}
// Walk up the chain of subtitution groups adding this schematype to each head's
// member list
- while (substitutionGroup != null)
- {
+ while (substitutionGroup != null) {
substitutionGroup.addSubstitutionGroupMember(eltName);
- if (substitutionGroup.getSubstitutionGroup() == null)
+ if (substitutionGroup.getSubstitutionGroup() == null) {
break;
+ }
substitutionGroup = StscState.get().findDocumentType(
substitutionGroup.getSubstitutionGroup(), substitutionGroup.getChameleonNamespace(), null/*no dependency added*/);
assert substitutionGroup != null : "Could not find document type for: " + substitutionGroup.getSubstitutionGroup();
- if (! resolveSubstitutionGroup(substitutionGroup) )
+ if (!resolveSubstitutionGroup(substitutionGroup)) {
substitutionGroup = null; // cyclic dependency - no subst group
+ }
}
@@ -151,150 +145,135 @@
}
- public static void resolveDocumentType ( SchemaTypeImpl sImpl )
- {
+ public static void resolveDocumentType(SchemaTypeImpl sImpl) {
assert sImpl.isResolving();
-
+
assert sImpl.isDocumentType();
-
+
// translate the global element associated with this document type
// and construct a content model which allows just that element
-
- List anonTypes = new ArrayList();
+
+ List<SchemaType> anonTypes = new ArrayList<>();
SchemaGlobalElementImpl element =
(SchemaGlobalElementImpl)
StscTranslator.translateElement(
(Element) sImpl.getParseObject(),
sImpl.getTargetNamespace(), sImpl.isChameleon(), null, null,
- anonTypes, sImpl );
+ anonTypes, sImpl);
SchemaLocalElementImpl contentModel = null;
- if (element != null)
- {
- StscState.get().addGlobalElement( element );
-
+ if (element != null) {
+ StscState.get().addGlobalElement(element);
+
contentModel = new SchemaLocalElementImpl();
-
- contentModel.setParticleType( SchemaParticle.ELEMENT );
- StscTranslator.copyGlobalElementToLocalElement( element, contentModel );
- contentModel.setMinOccurs( BigInteger.ONE );
- contentModel.setMaxOccurs( BigInteger.ONE );
+
+ contentModel.setParticleType(SchemaParticle.ELEMENT);
+ StscTranslator.copyGlobalElementToLocalElement(element, contentModel);
+ contentModel.setMinOccurs(BigInteger.ONE);
+ contentModel.setMaxOccurs(BigInteger.ONE);
contentModel.setTransitionNotes(QNameSet.EMPTY, true);
}
Map elementPropertyModel =
StscComplexTypeResolver.buildContentPropertyModelByQName(
- contentModel, sImpl );
+ contentModel, sImpl);
SchemaTypeImpl baseType = sImpl.getSubstitutionGroup() == null ?
BuiltinSchemaTypeSystem.ST_ANY_TYPE :
- StscState.get().findDocumentType(sImpl.getSubstitutionGroup(),
- sImpl.isChameleon() ? sImpl.getTargetNamespace() : null, null/*already added*/)
- ;
+ StscState.get().findDocumentType(sImpl.getSubstitutionGroup(),
+ sImpl.isChameleon() ? sImpl.getTargetNamespace() : null, null/*already added*/);
- sImpl.setBaseTypeRef( baseType.getRef() );
- sImpl.setBaseDepth( baseType.getBaseDepth() + 1 );
- sImpl.setDerivationType( SchemaType.DT_RESTRICTION );
- sImpl.setComplexTypeVariety( SchemaType.ELEMENT_CONTENT );
+ sImpl.setBaseTypeRef(baseType.getRef());
+ sImpl.setBaseDepth(baseType.getBaseDepth() + 1);
+ sImpl.setDerivationType(SchemaType.DT_RESTRICTION);
+ sImpl.setComplexTypeVariety(SchemaType.ELEMENT_CONTENT);
sImpl.setContentModel(
contentModel, new SchemaAttributeModelImpl(),
- elementPropertyModel, Collections.EMPTY_MAP, false );
-
+ elementPropertyModel, Collections.EMPTY_MAP, false);
+
sImpl.setWildcardSummary(
- QNameSet.EMPTY, false, QNameSet.EMPTY, false );
+ QNameSet.EMPTY, false, QNameSet.EMPTY, false);
- sImpl.setAnonymousTypeRefs( makeRefArray( anonTypes ) );
-
+ sImpl.setAnonymousTypeRefs(makeRefArray(anonTypes));
}
-
- public static void resolveAttributeType ( SchemaTypeImpl sImpl )
- {
+
+ public static void resolveAttributeType(SchemaTypeImpl sImpl) {
assert sImpl.isResolving();
assert sImpl.isAttributeType();
-
- List anonTypes = new ArrayList();
+
+ List<SchemaType> anonTypes = new ArrayList<>();
SchemaGlobalAttributeImpl attribute =
(SchemaGlobalAttributeImpl) StscTranslator.translateAttribute(
(Attribute) sImpl.getParseObject(), sImpl.getTargetNamespace(), null,
- sImpl.isChameleon(), anonTypes, sImpl, null, false );
+ sImpl.isChameleon(), anonTypes, sImpl, null, false);
SchemaAttributeModelImpl attributeModel = new SchemaAttributeModelImpl();
- if (attribute != null)
- {
- StscState.get().addGlobalAttribute( attribute );
-
+ if (attribute != null) {
+ StscState.get().addGlobalAttribute(attribute);
+
SchemaLocalAttributeImpl attributeCopy = new SchemaLocalAttributeImpl();
- StscTranslator.copyGlobalAttributeToLocalAttribute( attribute, attributeCopy );
- attributeModel.addAttribute( attributeCopy );
+ StscTranslator.copyGlobalAttributeToLocalAttribute(attribute, attributeCopy);
+ attributeModel.addAttribute(attributeCopy);
}
- sImpl.setBaseTypeRef( BuiltinSchemaTypeSystem.ST_ANY_TYPE.getRef() );
- sImpl.setBaseDepth( sImpl.getBaseDepth() + 1 );
- sImpl.setDerivationType( SchemaType.DT_RESTRICTION );
- sImpl.setComplexTypeVariety( SchemaType.EMPTY_CONTENT );
-
+ sImpl.setBaseTypeRef(BuiltinSchemaTypeSystem.ST_ANY_TYPE.getRef());
+ sImpl.setBaseDepth(sImpl.getBaseDepth() + 1);
+ sImpl.setDerivationType(SchemaType.DT_RESTRICTION);
+ sImpl.setComplexTypeVariety(SchemaType.EMPTY_CONTENT);
+
Map attributePropertyModel =
StscComplexTypeResolver.buildAttributePropertyModelByQName(
- attributeModel, sImpl );
+ attributeModel, sImpl);
sImpl.setContentModel(
- null, attributeModel, Collections.EMPTY_MAP, attributePropertyModel, false );
+ null, attributeModel, Collections.EMPTY_MAP, attributePropertyModel, false);
sImpl.setWildcardSummary(
- QNameSet.EMPTY, false, QNameSet.EMPTY, false );
-
- sImpl.setAnonymousTypeRefs( makeRefArray( anonTypes ) );
+ QNameSet.EMPTY, false, QNameSet.EMPTY, false);
+
+ sImpl.setAnonymousTypeRefs(makeRefArray(anonTypes));
}
-
- private static SchemaType.Ref[] makeRefArray(Collection typeList)
- {
- SchemaType.Ref[] result = new SchemaType.Ref[typeList.size()];
- int j = 0;
- for (Iterator i = typeList.iterator(); i.hasNext(); j++)
- result[j] = ((SchemaType)i.next()).getRef();
- return result;
+
+ private static SchemaType.Ref[] makeRefArray(Collection<SchemaType> typeList) {
+ return typeList.stream().map(SchemaType::getRef).toArray(SchemaType.Ref[]::new);
}
- public static void resolveIdentityConstraints()
- {
+ public static void resolveIdentityConstraints() {
StscState state = StscState.get();
SchemaIdentityConstraintImpl[] idcs = state.idConstraints();
- for (int i = 0 ; i < idcs.length ; i++)
- {
- if (!idcs[i].isResolved())
- {
- Keyref xsdkr = (Keyref)idcs[i].getParseObject();
+ for (SchemaIdentityConstraintImpl idc : idcs) {
+ if (!idc.isResolved()) {
+ Keyref xsdkr = (Keyref) idc.getParseObject();
QName keyName = xsdkr.getRefer();
SchemaIdentityConstraintImpl key = null;
- key = state.findIdConstraint(keyName, idcs[i].getChameleonNamespace(), idcs[i].getTargetNamespace());
- if (key == null)
- {
+ key = state.findIdConstraint(keyName, idc.getChameleonNamespace(), idc.getTargetNamespace());
+ if (key == null) {
state.notFoundError(keyName, SchemaType.IDENTITY_CONSTRAINT, xsdkr, true);
- }
- else
- {
- if (key.getConstraintCategory() == SchemaIdentityConstraintImpl.CC_KEYREF)
+ } else {
+ if (key.getConstraintCategory() == SchemaIdentityConstraintImpl.CC_KEYREF) {
state.error(XmlErrorCodes.IDENTITY_CONSTRAINT_PROPERTIES$KEYREF_REFERS_TO_KEYREF,
- null, idcs[i].getParseObject());
+ null, idc.getParseObject());
+ }
- if (key.getFields().length != idcs[i].getFields().length)
+ if (key.getFields().length != idc.getFields().length) {
state.error(XmlErrorCodes.IDENTITY_CONSTRAINT_PROPERTIES$KEY_KEYREF_FIELD_COUNT_EQ,
- null, idcs[i].getParseObject());
+ null, idc.getParseObject());
+ }
- idcs[i].setReferencedKey(key.getRef());
+ idc.setReferencedKey(key.getRef());
}
}
}
diff --git a/src/main/java/org/apache/xmlbeans/impl/schema/StscState.java b/src/main/java/org/apache/xmlbeans/impl/schema/StscState.java
index 55c292d..b3ed068 100644
--- a/src/main/java/org/apache/xmlbeans/impl/schema/StscState.java
+++ b/src/main/java/org/apache/xmlbeans/impl/schema/StscState.java
@@ -31,17 +31,44 @@
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.*;
+import java.util.function.Consumer;
/**
* This class represents the state of the SchemaTypeSystemCompiler as it's
* going.
*/
public class StscState {
+ private final static XmlValueRef XMLSTR_PRESERVE = buildString("preserve");
+ private final static XmlValueRef XMLSTR_REPLACE = buildString("preserve");
+ private final static XmlValueRef XMLSTR_COLLAPSE = buildString("preserve");
+
+ static final SchemaType[] EMPTY_ST_ARRAY = new SchemaType[0];
+
+ private static final XmlValueRef[] FACETS_NONE = new XmlValueRef[12];
+ private static final boolean[] FIXED_FACETS_NONE = new boolean[12];
+ private static final boolean[] FIXED_FACETS_WS = new boolean[12];
+
+ private static final XmlValueRef[] FACETS_WS_COLLAPSE = {
+ null, null, null, null, null, null, null, null, null,
+ build_wsstring(SchemaType.WS_COLLAPSE), null, null
+ };
+
+
+ final static XmlValueRef[] FACETS_UNION = FACETS_NONE;
+ final static boolean[] FIXED_FACETS_UNION = FIXED_FACETS_NONE;
+ final static XmlValueRef[] FACETS_LIST = FACETS_WS_COLLAPSE;
+ final static boolean[] FIXED_FACETS_LIST = FIXED_FACETS_WS;
+
+ private static final ThreadLocal<StscStack> tl_stscStack = new ThreadLocal<>();
+
+ private final static String PROJECT_URL_PREFIX = "project://local";
+
+
private String _givenStsName;
- private Collection _errorListener;
+ private Collection<XmlError> _errorListener;
private SchemaTypeSystemImpl _target;
private BindingConfig _config;
- private Map _compatMap;
+ private Map<QName, QName> _compatMap;
private boolean _doingDownloads;
private byte[] _digest = null;
private boolean _noDigest = false;
@@ -52,47 +79,45 @@
private SchemaTypeLoader _importingLoader;
- private Map _containers = new LinkedHashMap();
+ private final Map<String, SchemaContainer> _containers = new LinkedHashMap<>();
private SchemaDependencies _dependencies;
private Map _redefinedGlobalTypes = new LinkedHashMap();
private Map _redefinedModelGroups = new LinkedHashMap();
private Map _redefinedAttributeGroups = new LinkedHashMap();
- private Map _globalTypes = new LinkedHashMap();
- private Map _globalElements = new LinkedHashMap();
- private Map _globalAttributes = new LinkedHashMap();
- private Map _modelGroups = new LinkedHashMap();
- private Map _attributeGroups = new LinkedHashMap();
- private Map _documentTypes = new LinkedHashMap();
- private Map _attributeTypes = new LinkedHashMap();
- private Map _typesByClassname = new LinkedHashMap();
- private Map _misspelledNames = new HashMap();
- private Set _processingGroups = new LinkedHashSet();
- private Map _idConstraints = new LinkedHashMap();
- private Set _namespaces = new HashSet();
- private List _annotations = new ArrayList();
+ private final Map<QName, SchemaType> _globalTypes = new LinkedHashMap<>();
+ private final Map<QName, SchemaGlobalElement> _globalElements = new LinkedHashMap<>();
+ private final Map<QName, SchemaGlobalAttribute> _globalAttributes = new LinkedHashMap<>();
+ private final Map<QName, SchemaModelGroup> _modelGroups = new LinkedHashMap<>();
+ private final Map<QName, SchemaAttributeGroup> _attributeGroups = new LinkedHashMap<>();
+ private final Map<QName, SchemaType> _documentTypes = new LinkedHashMap<>();
+ private final Map<QName, SchemaType> _attributeTypes = new LinkedHashMap<>();
+ private final Map<String, SchemaType> _typesByClassname = new LinkedHashMap<>();
+ private final Map<String, SchemaComponent> _misspelledNames = new HashMap<>();
+ private final Set<SchemaComponent> _processingGroups = new LinkedHashSet<>();
+ private final Map<QName, SchemaIdentityConstraint> _idConstraints = new LinkedHashMap<>();
+ private final Set<String> _namespaces = new HashSet<>();
+ private final List<SchemaAnnotation> _annotations = new ArrayList<>();
private boolean _noUpa;
private boolean _noPvr;
private boolean _noAnn;
private boolean _mdefAll;
- private Set _mdefNamespaces = buildDefaultMdefNamespaces();
+ private final Set<String> _mdefNamespaces = buildDefaultMdefNamespaces();
private EntityResolver _entityResolver;
private File _schemasDir;
- private static Set buildDefaultMdefNamespaces() {
- // namespaces which are known to appear in WSDLs redundantly
- return new HashSet(
- Arrays.asList(new String[]{
- "http://www.openuri.org/2002/04/soap/conversation/",
- }));
- }
- /**
- * Used to store the new target namespace for a chameleon
- * included schema.
- */
- public static final Object CHAMELEON_INCLUDE_URI = new Object();
+ private final Map<String, String> _sourceForUri = new HashMap<>();
+ private URI _baseURI = URI.create(PROJECT_URL_PREFIX + "/");
+ private final SchemaTypeLoader _s4sloader = XmlBeans.typeLoaderForClassLoader(SchemaDocument.class.getClassLoader());
+
+
+ private static Set<String> buildDefaultMdefNamespaces() {
+ // namespaces which are known to appear in WSDLs redundantly
+ return new HashSet<>(
+ Collections.singletonList("http://www.openuri.org/2002/04/soap/conversation/"));
+ }
/**
* Only constructed via StscState.start().
@@ -103,14 +128,14 @@
/**
* Initializer for incremental compilation
*/
- public void initFromTypeSystem(SchemaTypeSystemImpl system, Set newNamespaces) {
+ public void initFromTypeSystem(SchemaTypeSystemImpl system, Set<String> newNamespaces) {
// setGivenTypeSystemName(system.getName().substring(14));
SchemaContainer[] containers = system.containers();
- for (int i = 0; i < containers.length; i++) {
- if (!newNamespaces.contains(containers[i].getNamespace())) {
+ for (SchemaContainer container : containers) {
+ if (!newNamespaces.contains(container.getNamespace())) {
// Copy data from the given container
- addContainer(containers[i]);
+ addContainer(container);
}
}
}
@@ -149,76 +174,37 @@
_redefinedGlobalTypes.put(name, redefTypes.get(i));
}
- List globalElems = container.globalElements();
- for (int i = 0; i < globalElems.size(); i++) {
- QName name = ((SchemaGlobalElement) globalElems.get(i)).getName();
- _globalElements.put(name, globalElems.get(i));
- }
+ container.globalElements().forEach(g -> _globalElements.put(g.getName(), g));
+ container.globalAttributes().forEach(g -> _globalAttributes.put(g.getName(), g));
+ container.modelGroups().forEach(g -> _modelGroups.put(g.getName(), g));
+ container.attributeGroups().forEach(g -> _attributeGroups.put(g.getName(), g));
- List globalAtts = container.globalAttributes();
- for (int i = 0; i < globalAtts.size(); i++) {
- QName name = ((SchemaGlobalAttribute) globalAtts.get(i)).getName();
- _globalAttributes.put(name, globalAtts.get(i));
- }
+ container.globalTypes().forEach(mapTypes(_globalTypes, false));
+ container.documentTypes().forEach(mapTypes(_documentTypes, true));
+ container.attributeTypes().forEach(mapTypes(_attributeTypes, true));
- List modelGroups = container.modelGroups();
- for (int i = 0; i < modelGroups.size(); i++) {
- QName name = ((SchemaModelGroup) modelGroups.get(i)).getName();
- _modelGroups.put(name, modelGroups.get(i));
- }
-
- List attrGroups = container.attributeGroups();
- for (int i = 0; i < attrGroups.size(); i++) {
- QName name = ((SchemaAttributeGroup) attrGroups.get(i)).getName();
- _attributeGroups.put(name, attrGroups.get(i));
- }
-
- List globalTypes = container.globalTypes();
- for (int i = 0; i < globalTypes.size(); i++) {
- SchemaType t = (SchemaType) globalTypes.get(i);
- QName name = t.getName();
- _globalTypes.put(name, t);
- if (t.getFullJavaName() != null) {
- addClassname(t.getFullJavaName(), t);
- }
- }
-
- List documentTypes = container.documentTypes();
- for (int i = 0; i < documentTypes.size(); i++) {
- SchemaType t = (SchemaType) documentTypes.get(i);
- QName name = t.getProperties()[0].getName();
- _documentTypes.put(name, t);
- if (t.getFullJavaName() != null) {
- addClassname(t.getFullJavaName(), t);
- }
- }
-
- List attributeTypes = container.attributeTypes();
- for (int i = 0; i < attributeTypes.size(); i++) {
- SchemaType t = (SchemaType) attributeTypes.get(i);
- QName name = t.getProperties()[0].getName();
- _attributeTypes.put(name, t);
- if (t.getFullJavaName() != null) {
- addClassname(t.getFullJavaName(), t);
- }
- }
-
- List identityConstraints = container.identityConstraints();
- for (int i = 0; i < identityConstraints.size(); i++) {
- QName name = ((SchemaIdentityConstraint) identityConstraints.get(i)).getName();
- _idConstraints.put(name, identityConstraints.get(i));
- }
+ container.identityConstraints().forEach(g -> _idConstraints.put(g.getName(), g));
_annotations.addAll(container.annotations());
_namespaces.add(container.getNamespace());
container.unsetImmutable();
}
- SchemaContainer getContainer(String namespace) {
- return (SchemaContainer) _containers.get(namespace);
+ private Consumer<SchemaType> mapTypes(Map<QName, SchemaType> map, boolean useProperties) {
+ return (t) -> {
+ QName name = useProperties ? t.getProperties()[0].getName() : t.getName();
+ map.put(name, t);
+ if (t.getFullJavaName() != null) {
+ addClassname(t.getFullJavaName(), t);
+ }
+ };
}
- Map getContainerMap() {
+ SchemaContainer getContainer(String namespace) {
+ return _containers.get(namespace);
+ }
+
+ Map<String, SchemaContainer> getContainerMap() {
return Collections.unmodifiableMap(_containers);
}
@@ -255,7 +241,7 @@
/**
* Initializer for error handling.
*/
- public void setErrorListener(Collection errorListener) {
+ public void setErrorListener(Collection<XmlError> errorListener) {
_errorListener = errorListener;
}
@@ -318,7 +304,7 @@
}
// KHK: remove this
- public static void addError(Collection errorListener, String message, int code, XmlObject location) {
+ public static void addError(Collection<XmlError> errorListener, String message, int code, XmlObject location) {
XmlError err =
XmlError.forObject(
message,
@@ -327,7 +313,7 @@
errorListener.add(err);
}
- public static void addError(Collection errorListener, String code, Object[] args, XmlObject location) {
+ public static void addError(Collection<XmlError> errorListener, String code, Object[] args, XmlObject location) {
XmlError err =
XmlError.forObject(
code,
@@ -337,7 +323,7 @@
errorListener.add(err);
}
- public static void addError(Collection errorListener, String code, Object[] args, File location) {
+ public static void addError(Collection<XmlError> errorListener, String code, Object[] args, File location) {
XmlError err =
XmlError.forLocation(
code,
@@ -347,7 +333,7 @@
errorListener.add(err);
}
- public static void addError(Collection errorListener, String code, Object[] args, URL location) {
+ public static void addError(Collection<XmlError> errorListener, String code, Object[] args, URL location) {
XmlError err =
XmlError.forLocation(
code,
@@ -358,7 +344,7 @@
}
// KHK: remove this
- public static void addWarning(Collection errorListener, String message, int code, XmlObject location) {
+ public static void addWarning(Collection<XmlError> errorListener, String message, int code, XmlObject location) {
XmlError err =
XmlError.forObject(
message,
@@ -367,7 +353,7 @@
errorListener.add(err);
}
- public static void addWarning(Collection errorListener, String code, Object[] args, XmlObject location) {
+ public static void addWarning(Collection<XmlError> errorListener, String code, Object[] args, XmlObject location) {
XmlError err =
XmlError.forObject(
code,
@@ -377,12 +363,12 @@
errorListener.add(err);
}
- public static void addInfo(Collection errorListener, String message) {
+ public static void addInfo(Collection<XmlError> errorListener, String message) {
XmlError err = XmlError.forMessage(message, XmlError.SEVERITY_INFO);
errorListener.add(err);
}
- public static void addInfo(Collection errorListener, String code, Object[] args) {
+ public static void addInfo(Collection<XmlError> errorListener, String code, Object[] args) {
XmlError err = XmlError.forMessage(code, args, XmlError.SEVERITY_INFO);
errorListener.add(err);
}
@@ -574,7 +560,7 @@
return name;
}
- QName subst = (QName) _compatMap.get(name);
+ QName subst = _compatMap.get(name);
if (subst == null) {
return name;
}
@@ -646,7 +632,7 @@
}
SchemaComponent findSpelling(QName name) {
- return (SchemaComponent) _misspelledNames.get(crunchName(name));
+ return _misspelledNames.get(crunchName(name));
}
/* NAMESPACES ======================================================*/
@@ -656,7 +642,7 @@
}
String[] getNamespaces() {
- return (String[]) _namespaces.toArray(new String[_namespaces.size()]);
+ return _namespaces.toArray(new String[0]);
}
boolean linkerDefinesNamespace(String namespace) {
@@ -722,11 +708,11 @@
if (!ignoreMdef(name)) {
if (_mdefAll) {
warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
- new Object[]{"global type", QNameHelper.pretty(name), ((SchemaType) _globalTypes.get(name)).getSourceName()},
+ new Object[]{"global type", QNameHelper.pretty(name), _globalTypes.get(name).getSourceName()},
type.getParseObject());
} else {
error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
- new Object[]{"global type", QNameHelper.pretty(name), ((SchemaType) _globalTypes.get(name)).getSourceName()},
+ new Object[]{"global type", QNameHelper.pretty(name), _globalTypes.get(name).getSourceName()},
type.getParseObject());
}
}
@@ -744,11 +730,11 @@
}
SchemaType[] globalTypes() {
- return (SchemaType[]) _globalTypes.values().toArray(new SchemaType[_globalTypes.size()]);
+ return _globalTypes.values().toArray(new SchemaType[0]);
}
SchemaType[] redefinedGlobalTypes() {
- return (SchemaType[]) _redefinedGlobalTypes.values().toArray(new SchemaType[_redefinedGlobalTypes.size()]);
+ return (SchemaType[]) _redefinedGlobalTypes.values().toArray(new SchemaType[0]);
}
/* DOCUMENT TYPES =================================================*/
@@ -772,11 +758,11 @@
if (!ignoreMdef(name)) {
if (_mdefAll) {
warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
- new Object[]{"global element", QNameHelper.pretty(name), ((SchemaComponent) _documentTypes.get(name)).getSourceName()},
+ new Object[]{"global element", QNameHelper.pretty(name), _documentTypes.get(name).getSourceName()},
type.getParseObject());
} else {
error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
- new Object[]{"global element", QNameHelper.pretty(name), ((SchemaComponent) _documentTypes.get(name)).getSourceName()},
+ new Object[]{"global element", QNameHelper.pretty(name), _documentTypes.get(name).getSourceName()},
type.getParseObject());
}
}
@@ -789,7 +775,7 @@
}
SchemaType[] documentTypes() {
- return (SchemaType[]) _documentTypes.values().toArray(new SchemaType[_documentTypes.size()]);
+ return _documentTypes.values().toArray(new SchemaType[0]);
}
/* ATTRIBUTE TYPES =================================================*/
@@ -813,11 +799,11 @@
if (!ignoreMdef(name)) {
if (_mdefAll) {
warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
- new Object[]{"global attribute", QNameHelper.pretty(name), ((SchemaComponent) _attributeTypes.get(name)).getSourceName()},
+ new Object[]{"global attribute", QNameHelper.pretty(name), _attributeTypes.get(name).getSourceName()},
type.getParseObject());
} else {
error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
- new Object[]{"global attribute", QNameHelper.pretty(name), ((SchemaComponent) _attributeTypes.get(name)).getSourceName()},
+ new Object[]{"global attribute", QNameHelper.pretty(name), _attributeTypes.get(name).getSourceName()},
type.getParseObject());
}
}
@@ -830,7 +816,7 @@
}
SchemaType[] attributeTypes() {
- return (SchemaType[]) _attributeTypes.values().toArray(new SchemaType[_attributeTypes.size()]);
+ return _attributeTypes.values().toArray(new SchemaType[0]);
}
/* ATTRIBUTES =====================================================*/
@@ -861,7 +847,7 @@
}
SchemaGlobalAttribute[] globalAttributes() {
- return (SchemaGlobalAttribute[]) _globalAttributes.values().toArray(new SchemaGlobalAttribute[_globalAttributes.size()]);
+ return _globalAttributes.values().toArray(new SchemaGlobalAttribute[0]);
}
/* ELEMENTS =======================================================*/
@@ -892,7 +878,7 @@
}
SchemaGlobalElement[] globalElements() {
- return (SchemaGlobalElement[]) _globalElements.values().toArray(new SchemaGlobalElement[_globalElements.size()]);
+ return _globalElements.values().toArray(new SchemaGlobalElement[0]);
}
/* ATTRIBUTE GROUPS ===============================================*/
@@ -952,11 +938,11 @@
if (!ignoreMdef(name)) {
if (_mdefAll) {
warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
- new Object[]{"attribute group", QNameHelper.pretty(name), ((SchemaComponent) _attributeGroups.get(name)).getSourceName()},
+ new Object[]{"attribute group", QNameHelper.pretty(name), _attributeGroups.get(name).getSourceName()},
attributeGroup.getParseObject());
} else {
error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
- new Object[]{"attribute group", QNameHelper.pretty(name), ((SchemaComponent) _attributeGroups.get(name)).getSourceName()},
+ new Object[]{"attribute group", QNameHelper.pretty(name), _attributeGroups.get(name).getSourceName()},
attributeGroup.getParseObject());
}
}
@@ -970,11 +956,11 @@
}
SchemaAttributeGroup[] attributeGroups() {
- return (SchemaAttributeGroup[]) _attributeGroups.values().toArray(new SchemaAttributeGroup[_attributeGroups.size()]);
+ return _attributeGroups.values().toArray(new SchemaAttributeGroup[0]);
}
SchemaAttributeGroup[] redefinedAttributeGroups() {
- return (SchemaAttributeGroup[]) _redefinedAttributeGroups.values().toArray(new SchemaAttributeGroup[_redefinedAttributeGroups.size()]);
+ return (SchemaAttributeGroup[]) _redefinedAttributeGroups.values().toArray(new SchemaAttributeGroup[0]);
}
/* MODEL GROUPS ===================================================*/
@@ -1034,11 +1020,11 @@
if (!ignoreMdef(name)) {
if (_mdefAll) {
warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
- new Object[]{"model group", QNameHelper.pretty(name), ((SchemaComponent) _modelGroups.get(name)).getSourceName()},
+ new Object[]{"model group", QNameHelper.pretty(name), _modelGroups.get(name).getSourceName()},
modelGroup.getParseObject());
} else {
error(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
- new Object[]{"model group", QNameHelper.pretty(name), ((SchemaComponent) _modelGroups.get(name)).getSourceName()},
+ new Object[]{"model group", QNameHelper.pretty(name), _modelGroups.get(name).getSourceName()},
modelGroup.getParseObject());
}
}
@@ -1052,11 +1038,11 @@
}
SchemaModelGroup[] modelGroups() {
- return (SchemaModelGroup[]) _modelGroups.values().toArray(new SchemaModelGroup[_modelGroups.size()]);
+ return _modelGroups.values().toArray(new SchemaModelGroup[0]);
}
SchemaModelGroup[] redefinedModelGroups() {
- return (SchemaModelGroup[]) _redefinedModelGroups.values().toArray(new SchemaModelGroup[_redefinedModelGroups.size()]);
+ return (SchemaModelGroup[]) _redefinedModelGroups.values().toArray(new SchemaModelGroup[0]);
}
/* IDENTITY CONSTRAINTS ===========================================*/
@@ -1077,7 +1063,7 @@
if (_idConstraints.containsKey(name)) {
if (!ignoreMdef(name)) {
warning(XmlErrorCodes.SCHEMA_PROPERTIES$DUPLICATE,
- new Object[]{"identity constraint", QNameHelper.pretty(name), ((SchemaComponent) _idConstraints.get(name)).getSourceName()},
+ new Object[]{"identity constraint", QNameHelper.pretty(name), _idConstraints.get(name).getSourceName()},
idc.getParseObject());
}
} else {
@@ -1089,7 +1075,7 @@
}
SchemaIdentityConstraintImpl[] idConstraints() {
- return (SchemaIdentityConstraintImpl[]) _idConstraints.values().toArray(new SchemaIdentityConstraintImpl[_idConstraints.size()]);
+ return _idConstraints.values().toArray(new SchemaIdentityConstraintImpl[0]);
}
/* ANNOTATIONS ===========================================*/
@@ -1103,32 +1089,32 @@
}
}
- List annotations() {
+ List<SchemaAnnotation> annotations() {
return _annotations;
}
/* RECURSION AVOIDANCE ============================================*/
- boolean isProcessing(Object obj) {
+ boolean isProcessing(SchemaComponent obj) {
return _processingGroups.contains(obj);
}
- void startProcessing(Object obj) {
+ void startProcessing(SchemaComponent obj) {
assert (!_processingGroups.contains(obj));
_processingGroups.add(obj);
}
- void finishProcessing(Object obj) {
+ void finishProcessing(SchemaComponent obj) {
assert (_processingGroups.contains(obj));
_processingGroups.remove(obj);
}
- Object[] getCurrentProcessing() {
- return _processingGroups.toArray();
+ SchemaComponent[] getCurrentProcessing() {
+ return _processingGroups.toArray(new SchemaComponent[0]);
}
/* JAVAIZATION ====================================================*/
- Map typesByClassname() {
+ Map<String, SchemaType> typesByClassname() {
return Collections.unmodifiableMap(_typesByClassname);
}
@@ -1143,7 +1129,7 @@
*/
private static final class StscStack {
StscState current;
- ArrayList stack = new ArrayList();
+ List<StscState> stack = new ArrayList<>();
final StscState push() {
stack.add(current);
@@ -1152,19 +1138,17 @@
}
final void pop() {
- current = (StscState) stack.get(stack.size() - 1);
+ current = stack.get(stack.size() - 1);
stack.remove(stack.size() - 1);
}
}
- private static ThreadLocal tl_stscStack = new ThreadLocal();
-
public static void clearThreadLocals() {
tl_stscStack.remove();
}
public static StscState start() {
- StscStack stscStack = (StscStack) tl_stscStack.get();
+ StscStack stscStack = tl_stscStack.get();
if (stscStack == null) {
stscStack = new StscStack();
@@ -1174,11 +1158,11 @@
}
public static StscState get() {
- return ((StscStack) tl_stscStack.get()).current;
+ return tl_stscStack.get().current;
}
public static void end() {
- StscStack stscStack = (StscStack) tl_stscStack.get();
+ StscStack stscStack = tl_stscStack.get();
stscStack.pop();
if (stscStack.stack.size() == 0) {
tl_stscStack.set(null); // this is required to release all the references in this classloader
@@ -1186,33 +1170,6 @@
// which will enable class unloading and avoid OOM in PermGen
}
- private final static XmlValueRef XMLSTR_PRESERVE = buildString("preserve");
- private final static XmlValueRef XMLSTR_REPLACE = buildString("preserve");
- private final static XmlValueRef XMLSTR_COLLAPSE = buildString("preserve");
-
- static final SchemaType[] EMPTY_ST_ARRAY = new SchemaType[0];
- static final SchemaType.Ref[] EMPTY_STREF_ARRAY = new SchemaType.Ref[0];
-
- private final static XmlValueRef[] FACETS_NONE = new XmlValueRef[]
- {null, null, null, null, null, null, null, null, null,
- null, null, null};
-
- private final static boolean[] FIXED_FACETS_NONE = new boolean[]
- {false, false, false, false, false, false, false, false, false,
- false, false, false};
-
- private final static XmlValueRef[] FACETS_WS_COLLAPSE = new XmlValueRef[]
- {null, null, null, null, null, null, null, null, null,
- build_wsstring(SchemaType.WS_COLLAPSE), null, null};
-
- private final static boolean[] FIXED_FACETS_WS = new boolean[]
- {false, false, false, false, false, false, false, false, false,
- true, false, false};
-
- final static XmlValueRef[] FACETS_UNION = FACETS_NONE;
- final static boolean[] FIXED_FACETS_UNION = FIXED_FACETS_NONE;
- final static XmlValueRef[] FACETS_LIST = FACETS_WS_COLLAPSE;
- final static boolean[] FIXED_FACETS_LIST = FIXED_FACETS_WS;
static XmlValueRef build_wsstring(int wsr) {
switch (wsr) {
@@ -1285,15 +1242,15 @@
switch (foundComponent.getComponentType()) {
case SchemaComponent.TYPE:
found = "type";
- sourceName = ((SchemaType) foundComponent).getSourceName();
+ sourceName = foundComponent.getSourceName();
break;
case SchemaComponent.ELEMENT:
found = "element";
- sourceName = ((SchemaGlobalElement) foundComponent).getSourceName();
+ sourceName = foundComponent.getSourceName();
break;
case SchemaComponent.ATTRIBUTE:
found = "attribute";
- sourceName = ((SchemaGlobalAttribute) foundComponent).getSourceName();
+ sourceName = foundComponent.getSourceName();
break;
case SchemaComponent.ATTRIBUTE_GROUP:
found = "attribute group";
@@ -1341,7 +1298,7 @@
* Returns null if none.
*/
public String sourceNameForUri(String uri) {
- return (String) _sourceForUri.get(uri);
+ return _sourceForUri.get(uri);
}
/**
@@ -1349,7 +1306,7 @@
* been read to "sourceName" local names that have been used
* to tag the types.
*/
- public Map sourceCopyMap() {
+ public Map<String, String> sourceCopyMap() {
return Collections.unmodifiableMap(_sourceForUri);
}
@@ -1360,8 +1317,6 @@
_baseURI = uri;
}
- private final static String PROJECT_URL_PREFIX = "project://local";
-
public String relativize(String uri) {
return relativize(uri, false);
}
@@ -1411,7 +1366,7 @@
return dir + "/" + uri.substring(lastslash + 1);
}
- String query = QNameHelper.hexsafe(question == -1 ? "" : uri.substring(question));
+ String query = QNameHelper.hexsafe(uri.substring(question));
// if encoded query part is longer than 64 characters, just drop it
if (query.startsWith(QNameHelper.URI_SHA1_PREFIX)) {
@@ -1440,7 +1395,7 @@
/**
* Returns the error listener being filled in during this compilation
*/
- public Collection getErrorListener() {
+ public Collection<XmlError> getErrorListener() {
return _errorListener;
}
@@ -1451,10 +1406,6 @@
return _s4sloader;
}
- Map _sourceForUri = new HashMap();
- URI _baseURI = URI.create(PROJECT_URL_PREFIX + "/");
- SchemaTypeLoader _s4sloader = XmlBeans.typeLoaderForClassLoader(SchemaDocument.class.getClassLoader());
-
public File getSchemasDir() {
return _schemasDir;
}
