org.apache.xmlbeans.impl.validator.Validator Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aem-sdk-api Show documentation
Show all versions of aem-sdk-api Show documentation
The Adobe Experience Manager SDK
/* Copyright 2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.xmlbeans.impl.validator;
import org.apache.xmlbeans.*;
import org.apache.xmlbeans.impl.common.*;
import org.apache.xmlbeans.impl.schema.SchemaTypeImpl;
import org.apache.xmlbeans.impl.schema.SchemaTypeVisitorImpl;
import org.apache.xmlbeans.impl.util.XsTypeConverter;
import org.apache.xmlbeans.impl.values.*;
import javax.xml.namespace.QName;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
import java.util.stream.Collectors;
public final class Validator
implements ValidatorListener {
public Validator(
SchemaType type, SchemaField field, SchemaTypeLoader globalLoader,
XmlOptions options, Collection defaultErrorListener) {
options = XmlOptions.maskNull(options);
_errorListener = options.getErrorListener();
_treatLaxAsSkip = options.isValidateTreatLaxAsSkip();
_strict = options.isValidateStrict();
if (_errorListener == null) {
_errorListener = defaultErrorListener;
}
_constraintEngine = new IdentityConstraint(_errorListener, type.isDocumentType());
_globalTypes = globalLoader;
_rootType = type;
_rootField = field;
_vc = new ValidatorVC();
}
private class ValidatorVC implements ValidationContext {
// KHK: remove this
public void invalid(String message) {
// TODO (dutta) Additional Attributes for validation error have limited information
//at this time but will be a part of the second round of refactoring
Validator.this.emitError(_event, message, null, null,
XmlValidationError.ATTRIBUTE_TYPE_INVALID);
}
public void invalid(String code, Object[] args) {
// TODO (dutta) Additional Attributes for validation error have limited information
//at this time but will be a part of the second round of refactoring
Validator.this.emitError(_event, code, args, null, null,
XmlValidationError.ATTRIBUTE_TYPE_INVALID, null);
}
Event _event;
}
public boolean isValid() {
return !_invalid && _constraintEngine.isValid();
}
// KHK: remove this
private void emitError(Event event, String message, QName offendingQName,
SchemaType expectedSchemaType,
int errorType) {
emitError(event, message, null, null, XmlError.SEVERITY_ERROR, null, offendingQName, expectedSchemaType,
null, errorType, null);
}
private void emitError(Event event, String code, Object[] args, QName offendingQName,
SchemaType expectedSchemaType,
int errorType, SchemaType badSchemaType) {
emitError(event, null, code, args, XmlError.SEVERITY_ERROR, null, offendingQName, expectedSchemaType,
null, errorType, badSchemaType);
}
// KHK: remove 'message' parameter
private void emitError(Event event, String message, String code, Object[] args, int severity,
QName fieldName, QName offendingQName,
SchemaType expectedSchemaType, List expectedQNames,
int errorType, SchemaType badSchemaType) {
_errorState++;
if (_suspendErrors == 0) {
if (severity == XmlError.SEVERITY_ERROR) {
_invalid = true;
}
if (_errorListener != null) {
assert event != null;
XmlError error;
XmlCursor curs = event.getLocationAsCursor();
if (curs != null) {
// non-streaming validation uses XmlCursor
error = XmlValidationError.forCursorWithDetails(message, code, args, severity,
curs, fieldName, offendingQName, expectedSchemaType, expectedQNames,
errorType, badSchemaType);
} else {
// streaming validation uses Location
error = XmlValidationError.forLocationWithDetails(message, code, args, severity,
event.getLocation(), fieldName, offendingQName, expectedSchemaType, expectedQNames,
errorType, badSchemaType);
}
_errorListener.add(error);
}
}
}
private void emitFieldError(Event event, String code, Object[] args, QName offendingQName,
SchemaType expectedSchemaType, List expectedQNames,
int errorType, SchemaType badSchemaType) {
QName fieldName = null;
if (_stateStack != null && _stateStack._field != null) {
fieldName = _stateStack._field.getName();
}
Validator.this.emitError(event, null, code, args, XmlError.SEVERITY_ERROR, fieldName, offendingQName, expectedSchemaType,
expectedQNames, errorType, badSchemaType);
}
public void nextEvent(int kind, Event event) {
resetValues();
if (_eatContent > 0) {
switch (kind) {
case END:
_eatContent--;
break;
case BEGIN:
_eatContent++;
break;
}
} else {
assert
kind == BEGIN || kind == ATTR ||
kind == END || kind == TEXT || kind == ENDATTRS;
switch (kind) {
case BEGIN:
beginEvent(event);
break;
case ATTR:
attrEvent(event);
break;
case ENDATTRS:
endAttrsEvent(event);
break;
case TEXT:
textEvent(event);
break;
case END:
endEvent(event);
break;
}
}
}
private void beginEvent(Event event) {
_localElement = null;
_wildcardElement = null;
State state = topState();
SchemaType elementType;
SchemaField elementField;
if (state == null) {
elementType = _rootType;
elementField = _rootField;
} else {
QName name = event.getName();
assert name != null;
state._isEmpty = false;
if (state._isNil) {
emitFieldError(event, XmlErrorCodes.ELEM_LOCALLY_VALID$NIL_WITH_CONTENT,
null, state._field.getName(), state._type, null,
XmlValidationError.NIL_ELEMENT, state._type);
_eatContent = 1;
return;
}
if (state._field != null && state._field.isFixed()) {
emitFieldError(event, XmlErrorCodes.ELEM_LOCALLY_VALID$FIXED_WITH_CONTENT,
new Object[]{QNameHelper.pretty(state._field.getName())},
state._field.getName(), state._type, null,
XmlValidationError.ELEMENT_NOT_ALLOWED, state._type);
}
if (!state.visit(name)) {
findDetailedErrorBegin(event, state, name);
_eatContent = 1;
return;
}
SchemaParticle currentParticle = state.currentParticle();
_wildcardElement = currentParticle;
if (currentParticle.getParticleType() == SchemaParticle.WILDCARD) {
//_wildcardElement = currentParticle;
QNameSet elemWildcardSet = currentParticle.getWildcardSet();
if (!elemWildcardSet.contains(name)) {
// Additional processing may be needed to generate more
// descriptive messages
// KHK: cvc-complex-type.2.4? cvc-particle.1.3? cvc-wildcard-namespace ?
emitFieldError(event, XmlErrorCodes.PARTICLE_VALID$NOT_WILDCARD_VALID,
new Object[]{QNameHelper.pretty(name)},
name, null, null,
XmlValidationError.ELEMENT_NOT_ALLOWED, state._type);
_eatContent = 1;
return;
}
int wildcardProcess = currentParticle.getWildcardProcess();
if (wildcardProcess == SchemaParticle.SKIP ||
wildcardProcess == SchemaParticle.LAX && _treatLaxAsSkip) {
_eatContent = 1;
return;
}
_localElement = _globalTypes.findElement(name);
elementField = _localElement;
if (elementField == null) {
if (wildcardProcess == SchemaParticle.STRICT) {
// KHK: cvc-complex-type.2.4c? cvc-assess-elt.1.1.1.3.2?
emitFieldError(event, XmlErrorCodes.ASSESS_ELEM_SCHEMA_VALID$NOT_RESOLVED,
new Object[]{QNameHelper.pretty(name)},
name, state._type, null,
XmlValidationError.ELEMENT_NOT_ALLOWED, state._type);
}
_eatContent = 1;
return;
}
} else {
assert currentParticle.getParticleType() == SchemaParticle.ELEMENT;
// If the current element particle name does not match the name
// of the event, then the current element is a substitute for
// the current particle. Replace the field with the global
// element for the replacement
if (!currentParticle.getName().equals(name)) {
if (((SchemaLocalElement) currentParticle).blockSubstitution()) {
emitFieldError(event, XmlErrorCodes.PARTICLE_VALID$BLOCK_SUBSTITUTION,
new Object[]{QNameHelper.pretty(name)},
name, state._type, null,
XmlValidationError.ELEMENT_NOT_ALLOWED, state._type);
_eatContent = 1;
return;
}
SchemaGlobalElement newField = _globalTypes.findElement(name);
assert newField != null;
elementField = newField;
_localElement = newField;
} else {
elementField = (SchemaField) currentParticle;
}
}
elementType = elementField.getType();
}
assert elementType != null;
//
// the no-type is always invalid (even if there is an xsi:type)
//
if (elementType.isNoType()) {
emitFieldError(event, XmlErrorCodes.ELEM_LOCALLY_VALID$NO_TYPE,
null, event.getName(), null, null,
XmlValidationError.ELEMENT_TYPE_INVALID, null);
_eatContent = 1;
}
//
// See if the element has an xsi:type on it
//
SchemaType xsiType = null;
String value = event.getXsiType();
if (value != null) {
// Turn off the listener so a public error message
// does not get generated, but I can see if there was
// an error through the error state
int originalErrorState = _errorState;
_suspendErrors++;
try {
_vc._event = null;
xsiType = _globalTypes.findType(XmlQNameImpl.validateLexical(value, _vc, event));
} catch (Throwable t) {
_errorState++;
} finally {
_suspendErrors--;
}
if (originalErrorState != _errorState) {
// not sure how to extract this one
emitFieldError(event, XmlErrorCodes.ELEM_LOCALLY_VALID$XSI_TYPE_INVALID_QNAME,
new Object[]{value}, event.getName(), xsiType, null,
XmlValidationError.ELEMENT_TYPE_INVALID, (state == null ? null : state._type));
_eatContent = 1;
return;
} else if (xsiType == null) {
// NOT SURE errorAttributes._expectedSchemaType = xsiType;
emitFieldError(event, XmlErrorCodes.ELEM_LOCALLY_VALID$XSI_TYPE_NOT_FOUND,
new Object[]{value}, event.getName(), null, null,
XmlValidationError.ELEMENT_TYPE_INVALID, null);
_eatContent = 1;
return;
}
}
if (xsiType != null && !xsiType.equals(elementType)) {
if (!elementType.isAssignableFrom(xsiType)) {
emitFieldError(event, XmlErrorCodes.ELEM_LOCALLY_VALID$XSI_TYPE_NOT_DERIVED,
new Object[]{xsiType, elementType}, event.getName(), elementType, null,
XmlValidationError.ELEMENT_TYPE_INVALID, (state == null ? null : state._type));
_eatContent = 1;
return;
}
if (elementType.blockExtension()) {
for (SchemaType t = xsiType; !t.equals(elementType);
t = t.getBaseType()) {
if (t.getDerivationType() == SchemaType.DT_EXTENSION) {
emitFieldError(event, XmlErrorCodes.ELEM_LOCALLY_VALID$XSI_TYPE_BLOCK_EXTENSION,
new Object[]{xsiType, elementType}, event.getName(), elementType, null,
XmlValidationError.ELEMENT_TYPE_INVALID, (state == null ? null : state._type));
_eatContent = 1;
return;
}
}
}
if (elementType.blockRestriction()) {
for (SchemaType t = xsiType; !t.equals(elementType);
t = t.getBaseType()) {
if (t.getDerivationType() == SchemaType.DT_RESTRICTION) {
emitFieldError(event, XmlErrorCodes.ELEM_LOCALLY_VALID$XSI_TYPE_BLOCK_RESTRICTION,
new Object[]{xsiType, elementType}, event.getName(), elementType, null,
XmlValidationError.ELEMENT_TYPE_INVALID, (state == null ? null : state._type));
_eatContent = 1;
return;
}
}
}
if (elementField instanceof SchemaLocalElement) {
SchemaLocalElement sle = (SchemaLocalElement) elementField;
_localElement = sle;
if (sle.blockExtension() || sle.blockRestriction()) {
for (SchemaType t = xsiType; !t.equals(elementType);
t = t.getBaseType()) {
if ((t.getDerivationType() == SchemaType.DT_RESTRICTION && sle.blockRestriction()) ||
(t.getDerivationType() == SchemaType.DT_EXTENSION && sle.blockExtension())) {
//need to find a way to get the right type
emitFieldError(event, XmlErrorCodes.ELEM_LOCALLY_VALID$XSI_TYPE_PROHIBITED_SUBST,
new Object[]{xsiType, QNameHelper.pretty(sle.getName())},
sle.getName(), null, null, XmlValidationError.ELEMENT_TYPE_INVALID, null);
_eatContent = 1;
return;
}
}
}
}
elementType = xsiType;
}
if (elementField instanceof SchemaLocalElement) {
SchemaLocalElement sle = (SchemaLocalElement) elementField;
_localElement = sle;
if (sle.isAbstract()) {
//todo (dutta) need to find a way to get the right type
emitError(event, XmlErrorCodes.ELEM_LOCALLY_VALID$ABSTRACT,
new Object[]{QNameHelper.pretty(sle.getName())},
sle.getName(), null, XmlValidationError.ELEMENT_TYPE_INVALID, null);
_eatContent = 1;
return;
}
}
if (elementType.isAbstract()) {
emitError(event, XmlErrorCodes.ELEM_LOCALLY_VALID$ABSTRACT,
new Object[]{elementType},
event.getName(), elementType, XmlValidationError.ELEMENT_TYPE_INVALID, (state == null ? null : state._type));
_eatContent = 1;
return;
}
boolean isNil = false;
boolean hasNil = false;
String nilValue = event.getXsiNil();
if (nilValue != null) {
_vc._event = event;
isNil = JavaBooleanHolder.validateLexical(nilValue, _vc);
hasNil = true;
}
// note in schema spec 3.3.4, you're not even allowed to say xsi:nil="false" if you're not nillable!
if (hasNil && (elementField == null || !elementField.isNillable())) {
emitFieldError(event, XmlErrorCodes.ELEM_LOCALLY_VALID$NOT_NILLABLE, null,
elementField == null ? null : elementField.getName(), elementType, null,
XmlValidationError.ELEMENT_TYPE_INVALID, (state == null ? null : state._type));
_eatContent = 1;
return;
}
if (isNil && elementField != null && elementField.isFixed()) {
emitFieldError(event, XmlErrorCodes.ELEM_LOCALLY_VALID$NIL_WITH_FIXED, null,
elementField.getName(), elementType, null,
XmlValidationError.ELEMENT_TYPE_INVALID, (state == null ? null : state._type));
}
newState(elementType, elementField, isNil);
// Dispatch this element event to any identity constraints
// As well as adding any new identity constraints that exist
_constraintEngine.element(
event,
elementType,
elementField instanceof SchemaLocalElement
? ((SchemaLocalElement) elementField).getIdentityConstraints()
: null);
}
private void attrEvent(Event event) {
QName attrName = event.getName();
State state = topState();
if (state._attrs == null) {
state._attrs = new HashSet<>();
}
if (state._attrs.contains(attrName)) {
emitFieldError(event, XmlErrorCodes.XML_DUPLICATE_ATTRIBUTE,
new Object[]{QNameHelper.pretty(attrName)},
attrName, null, null, XmlValidationError.INCORRECT_ATTRIBUTE, state._type);
return;
}
state._attrs.add(attrName);
if (!state._canHaveAttrs) {
emitFieldError(event, XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NO_WILDCARD,
new Object[]{QNameHelper.pretty(attrName)}, attrName, null, null,
XmlValidationError.INCORRECT_ATTRIBUTE, state._type);
return;
}
SchemaLocalAttribute attrSchema =
state._attrModel == null
? null
: state._attrModel.getAttribute(attrName);
if (attrSchema != null) {
_localAttribute = attrSchema;
if (attrSchema.getUse() == SchemaLocalAttribute.PROHIBITED) {
emitFieldError(event, XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$PROHIBITED_ATTRIBUTE,
new Object[]{QNameHelper.pretty(attrName)},
attrName, null, null, XmlValidationError.INCORRECT_ATTRIBUTE, state._type);
return;
}
String value =
validateSimpleType(
attrSchema.getType(), attrSchema, event, false, false);
_constraintEngine.attr(event, attrName, attrSchema.getType(), value);
return;
}
int wildcardProcess = state._attrModel.getWildcardProcess();
_wildcardAttribute = state._attrModel;
if (wildcardProcess == SchemaAttributeModel.NONE) {
// todo (dutta) need additional logic to determine the expectedSchemaType
emitFieldError(event, XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NO_WILDCARD,
new Object[]{QNameHelper.pretty(attrName)},
attrName, null, null, XmlValidationError.INCORRECT_ATTRIBUTE, state._type);
return;
}
QNameSet attrWildcardSet = state._attrModel.getWildcardSet();
if (!attrWildcardSet.contains(attrName)) {
// todo (dutta) need additional logic to determine the expectedSchemaType
emitFieldError(event, XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$NOT_WILDCARD_VALID,
new Object[]{QNameHelper.pretty(attrName)},
attrName, null, null, XmlValidationError.INCORRECT_ATTRIBUTE, state._type);
return;
}
if (wildcardProcess == SchemaAttributeModel.SKIP ||
wildcardProcess == SchemaAttributeModel.LAX && _treatLaxAsSkip) {
return;
}
attrSchema = _globalTypes.findAttribute(attrName);
_localAttribute = attrSchema;
if (attrSchema == null) {
if (wildcardProcess == SchemaAttributeModel.LAX) {
return;
}
assert wildcardProcess == SchemaAttributeModel.STRICT;
// KHK: cvc-assess-attr.1.2 ?
// todo (dutta) need additional logic to determine the expectedSchemaType
emitFieldError(event, XmlErrorCodes.ASSESS_ATTR_SCHEMA_VALID$NOT_RESOLVED,
new Object[]{QNameHelper.pretty(attrName)},
attrName, null, null, XmlValidationError.INCORRECT_ATTRIBUTE, state._type);
return;
}
String value =
validateSimpleType(
attrSchema.getType(), attrSchema, event, false, false);
_constraintEngine.attr(event, attrName, attrSchema.getType(), value);
}
private void endAttrsEvent(Event event) {
State state = topState();
if (state._attrModel != null) {
SchemaLocalAttribute[] attrs = state._attrModel.getAttributes();
for (SchemaLocalAttribute sla : attrs) {
if (state._attrs == null ||
!state._attrs.contains(sla.getName())) {
if (sla.getUse() == SchemaLocalAttribute.REQUIRED) {
// KHK: cvc-complex-type.4
emitFieldError(event, XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$MISSING_REQUIRED_ATTRIBUTE,
new Object[]{QNameHelper.pretty(sla.getName())},
sla.getName(), null, null, XmlValidationError.INCORRECT_ATTRIBUTE, state._type);
} else if (sla.isDefault() || sla.isFixed()) {
_constraintEngine.attr(event, sla.getName(), sla.getType(), sla.getDefaultText());
// We don't need to validate attribute defaults because this is done at compiletime.
/*
String value = sla.getDefaultText();
SchemaType type = sla.getType();
if (XmlQName.type.isAssignableFrom(type))
{
emitFieldError(
event,
"Default QName values are unsupported for attribute: " +
QNameHelper.pretty(sla.getName()),
XmlError.SEVERITY_INFO);
}
else
{
validateSimpleType(
type, sla.getDefaultText(), event );
_constraintEngine.attr( event, type, value );
}
*/
}
}
}
}
}
private void endEvent(Event event) {
_localElement = null;
_wildcardElement = null;
State state = topState();
if (!state._isNil) {
if (!state.end()) {
findDetailedErrorEnd(event, state);
}
// This end event has no text, use this fact to pass no text to
// handleText
if (state._isEmpty) {
handleText(event, true, state._field);
}
}
popState(event);
_constraintEngine.endElement(event);
}
private void textEvent(Event event) {
State state = topState();
if (state._isNil) {
emitFieldError(event, XmlErrorCodes.ELEM_LOCALLY_VALID$NIL_WITH_CONTENT, null,
state._field.getName(), state._type, null,
XmlValidationError.NIL_ELEMENT, state._type);
} else {
handleText(event, false, state._field);
}
state._isEmpty = false;
}
private void handleText(
Event event, boolean emptyContent, SchemaField field) {
State state = topState();
if (!state._sawText) {
if (state._hasSimpleContent) {
String value =
validateSimpleType(
state._type, field, event, emptyContent, true);
_constraintEngine.text(event, state._type, value, false);
} else if (state._canHaveMixedContent) {
// handles cvc-elt.5.2.2.2.1, checking mixed content against fixed.
// if we see ac , we validate against
// the first 'a' text and we check the content of mixedType to
// be empty in beginElem(). we don't care about checking against
// the 'c' text since there will already be an error for
String value =
validateSimpleType(
XmlString.type, field, event, emptyContent, true);
_constraintEngine.text(event, XmlString.type, value, false);
} else if (emptyContent) {
_constraintEngine.text(event, state._type, null, true);
} else {
_constraintEngine.text(event, state._type, "", false);
}
}
if (!emptyContent && !state._canHaveMixedContent &&
!event.textIsWhitespace() && !state._hasSimpleContent) {
if (field instanceof SchemaLocalElement) {
SchemaLocalElement e = (SchemaLocalElement) field;
assert state._type.getContentType() == SchemaType.EMPTY_CONTENT ||
state._type.getContentType() == SchemaType.ELEMENT_CONTENT;
// KHK: cvc-complex-type.2.1 or .2.3
String errorCode = (state._type.getContentType() == SchemaType.EMPTY_CONTENT ?
XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$EMPTY_WITH_CONTENT :
XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$ELEMENT_ONLY_WITH_TEXT);
emitError(event, errorCode, new Object[]{QNameHelper.pretty(e.getName())},
e.getName(), field.getType(),
XmlValidationError.ELEMENT_TYPE_INVALID, null);
} else {
// KHK: cvc-complex-type.2.1 or .2.3
// todo (dutta) offendingQName = not sure how to get this(event.getName()??);
emitError(event, "Can't have mixed content", event.getName(),
state._type, XmlValidationError.ELEMENT_TYPE_INVALID);
}
}
if (!emptyContent) {
state._sawText = true;
}
}
private void findDetailedErrorBegin(Event event, State state, QName qName) {
ArrayList expectedNames = new ArrayList<>();
ArrayList optionalNames = new ArrayList<>();
SchemaProperty[] eltProperties = state._type.getElementProperties();
for (SchemaProperty sProp : eltProperties) {
//Get the element from the schema
// test if the element is valid
if (state.test(sProp.getName())) {
if (0 == BigInteger.ZERO.compareTo(sProp.getMinOccurs())) {
optionalNames.add(sProp.getName());
} else {
expectedNames.add(sProp.getName());
}
}
}
List names = (expectedNames.size() > 0 ? expectedNames : optionalNames);
if (names.size() > 0) {
String buf = names.stream().map(QNameHelper::pretty).collect(Collectors.joining(" "));
emitFieldError(event, XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$EXPECTED_DIFFERENT_ELEMENT,
new Object[]{names.size(), buf, QNameHelper.pretty(qName)},
qName, null, names, XmlValidationError.INCORRECT_ELEMENT, state._type);
} else {
emitFieldError(event, XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$ELEMENT_NOT_ALLOWED,
new Object[]{QNameHelper.pretty(qName)},
qName, null, null, XmlValidationError.INCORRECT_ELEMENT, state._type);
}
}
private void findDetailedErrorEnd(Event event, State state) {
SchemaProperty[] eltProperties = state._type.getElementProperties();
ArrayList expectedNames = new ArrayList<>();
ArrayList optionalNames = new ArrayList<>();
for (SchemaProperty sProp : eltProperties) {
//Get the element from the schema
// test if the element is valid
if (state.test(sProp.getName())) {
if (0 == BigInteger.ZERO.compareTo(sProp.getMinOccurs())) {
optionalNames.add(sProp.getName());
} else {
expectedNames.add(sProp.getName());
}
}
}
List names = (expectedNames.size() > 0 ? expectedNames : optionalNames);
if (names.size() > 0) {
String buf = names.stream().map(QNameHelper::pretty).collect(Collectors.joining(" "));
emitFieldError(event, XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$MISSING_ELEMENT,
new Object[]{names.size(), buf},
null, null, names, XmlValidationError.INCORRECT_ELEMENT, state._type);
} else {
emitFieldError(event, XmlErrorCodes.ELEM_COMPLEX_TYPE_LOCALLY_VALID$EXPECTED_ELEMENT,
null, null, null, null, XmlValidationError.ELEMENT_NOT_ALLOWED, state._type);
}
}
private static final class State {
boolean visit(QName name) {
return _canHaveElements && _visitor.visit(name);
}
boolean test(QName name) {
return _canHaveElements && _visitor.testValid(name);
}
boolean end() {
return !_canHaveElements || _visitor.visit(null);
}
SchemaParticle currentParticle() {
assert _visitor != null;
return _visitor.currentParticle();
}
SchemaType _type;
SchemaField _field;
boolean _canHaveAttrs;
boolean _canHaveMixedContent;
boolean _hasSimpleContent;
boolean _sawText;
boolean _isEmpty;
boolean _isNil;
SchemaTypeVisitorImpl _visitor;
boolean _canHaveElements;
SchemaAttributeModel _attrModel;
HashSet _attrs;
State _next;
}
private boolean derivedFromInteger(SchemaType type) {
int btc = type.getBuiltinTypeCode();
while (btc == SchemaType.BTC_NOT_BUILTIN) {
type = type.getBaseType();
btc = type.getBuiltinTypeCode();
}
// This depends on the ordering of the constant values, which is not ideal but is easier
return btc >= SchemaType.BTC_INTEGER && btc <= SchemaType.BTC_UNSIGNED_BYTE;
}
private void newState(SchemaType type, SchemaField field, boolean isNil) {
State state = new State();
state._type = type;
state._field = field;
state._isEmpty = true;
state._isNil = isNil;
if (type.isSimpleType()) {
state._hasSimpleContent = true;
} else {
state._canHaveAttrs = true;
state._attrModel = type.getAttributeModel();
switch (type.getContentType()) {
case SchemaType.EMPTY_CONTENT:
break;
case SchemaType.SIMPLE_CONTENT:
state._hasSimpleContent = true;
break;
case SchemaType.MIXED_CONTENT:
state._canHaveMixedContent = true;
// Fall through
case SchemaType.ELEMENT_CONTENT:
SchemaParticle particle = type.getContentModel();
state._canHaveElements = particle != null;
if (state._canHaveElements) {
state._visitor = initVisitor(particle);
}
break;
default:
throw new RuntimeException("Unexpected content type");
}
}
pushState(state);
}
private void popState(Event e) {
if (_stateStack._visitor != null) {
poolVisitor(_stateStack._visitor);
_stateStack._visitor = null;
}
_stateStack = _stateStack._next;
}
private void pushState(State state) {
state._next = _stateStack;
_stateStack = state;
}
private final LinkedList _visitorPool = new LinkedList<>();
private void poolVisitor(SchemaTypeVisitorImpl visitor) {
_visitorPool.add(visitor);
}
private SchemaTypeVisitorImpl initVisitor(SchemaParticle particle) {
if (_visitorPool.isEmpty()) {
return new SchemaTypeVisitorImpl(particle);
}
SchemaTypeVisitorImpl result =
(SchemaTypeVisitorImpl) _visitorPool.removeLast();
result.init(particle);
return result;
}
private State topState() {
return _stateStack;
}
//
// Simple Type Validation
//
// emptyContent means that you can't use the event to get text: there is
// no text, but you can use the event to do prefix resolution (in the case
// where the default is a qname)
//
private String validateSimpleType(
SchemaType type, SchemaField field, Event event,
boolean emptyContent, boolean canApplyDefault) {
if (!type.isSimpleType() &&
type.getContentType() != SchemaType.SIMPLE_CONTENT) {
assert false;
// throw new RuntimeException( "Not a simple type" );
return null; // should never happen
}
//
// the no-type is always invalid
//
if (type.isNoType()) {
emitError(event, (field.isAttribute() ? XmlErrorCodes.ATTR_LOCALLY_VALID$NO_TYPE : XmlErrorCodes.ELEM_LOCALLY_VALID$NO_TYPE),
null, field.getName(), type, XmlValidationError.ELEMENT_TYPE_INVALID, null);
return null;
}
// Get the value as a string (as normalized by the white space rule
// TODO - will want to optimize this later
String value = "";
if (!emptyContent) {
int wsr = type.getWhiteSpaceRule();
value = wsr == SchemaType.WS_PRESERVE ? event.getText() : event.getText(wsr);
}
// See if I can apply a default/fixed value
if (value.length() == 0 && canApplyDefault && field != null &&
(field.isDefault() || field.isFixed())) {
if (XmlQName.type.isAssignableFrom(type)) {
// TODO: will be fixed in XmlSchema 1.1
emitError(event, "Default QName values are unsupported for " +
QNameHelper.readable(type) + " - ignoring.", null, null,
XmlError.SEVERITY_INFO, field.getName(), null, type, null,
XmlValidationError.ELEMENT_TYPE_INVALID, null);
return null;
}
String defaultValue =
XmlWhitespace.collapse(
field.getDefaultText(), type.getWhiteSpaceRule());
// BUGBUG - should validate defaultValue at compile time
// KHK: cvc-elt.5.1.2 ?
return
validateSimpleType(type, defaultValue, event)
? defaultValue
: null;
}
// KHK: cvc-elt.5.2.1 ?
if (!validateSimpleType(type, value, event)) {
return null;
}
if (field != null && field.isFixed()) {
// TODO - fixed value should have been cooked at compile time
String fixedValue =
XmlWhitespace.collapse(
field.getDefaultText(), type.getWhiteSpaceRule());
if (!validateSimpleType(type, fixedValue, event)) {
return null;
}
XmlObject val = type.newValue(value);
XmlObject def = type.newValue(fixedValue);
if (!val.valueEquals(def)) {
// TODO (dutta) - make this more verbose
if (field.isAttribute()) {
// KHK: check for is cvc-complex-type.3.1 or cvc-au
emitError(event, XmlErrorCodes.ATTR_LOCALLY_VALID$FIXED,
new Object[]{value, fixedValue, QNameHelper.pretty(event.getName())},
null, field.getType(), XmlValidationError.ELEMENT_TYPE_INVALID, null);
} else {
String errorCode = null;
// see rule 5 of cvc-elt: Element Locally Valid (Element)
if (field.getType().getContentType() == SchemaType.MIXED_CONTENT) {
errorCode = XmlErrorCodes.ELEM_LOCALLY_VALID$FIXED_VALID_MIXED_CONTENT;
} else if (type.isSimpleType()) {
errorCode = XmlErrorCodes.ELEM_LOCALLY_VALID$FIXED_VALID_SIMPLE_TYPE;
} else {
assert false : "Element with fixed may not be EMPTY or ELEMENT_ONLY";
}
emitError(event, errorCode, new Object[]{value, fixedValue},
field.getName(), field.getType(), XmlValidationError.ELEMENT_TYPE_INVALID, null);
}
return null;
}
}
return value;
}
private boolean validateSimpleType(
SchemaType type, String value, Event event) {
if (!type.isSimpleType() &&
type.getContentType() != SchemaType.SIMPLE_CONTENT) {
assert false;
throw new RuntimeException("Not a simple type");
}
int retState = _errorState;
switch (type.getSimpleVariety()) {
case SchemaType.ATOMIC:
validateAtomicType(type, value, event);
break;
case SchemaType.UNION:
validateUnionType(type, value, event);
break;
case SchemaType.LIST:
validateListType(type, value, event);
break;
default:
throw new RuntimeException("Unexpected simple variety");
}
return retState == _errorState;
}
private void validateAtomicType(
SchemaType type, String value, Event event) {
// Now we should have only an atomic type to validate
assert type.getSimpleVariety() == SchemaType.ATOMIC;
// Record the current error state to see if any new errors are made
int errorState = _errorState;
_vc._event = event;
switch (type.getPrimitiveType().getBuiltinTypeCode()) {
case SchemaType.BTC_ANY_SIMPLE: {
// Always valid!
_stringValue = value;
break;
}
case SchemaType.BTC_STRING: {
JavaStringEnumerationHolderEx.validateLexical(value, type, _vc);
_stringValue = value;
break;
}
case SchemaType.BTC_DECIMAL: {
JavaDecimalHolderEx.validateLexical(value, type, _vc);
// An additional rule states that if the type is xs:integer or derived from it,
// then the decimal dot is not allowed.
// verify that values extending xsd:integer don't have a decimal point
if (derivedFromInteger(type) && value.lastIndexOf('.') >= 0) {
_vc.invalid(XmlErrorCodes.INTEGER, new Object[]{value});
}
if (errorState == _errorState) {
_decimalValue = new BigDecimal(value);
JavaDecimalHolderEx.validateValue(_decimalValue, type, _vc);
}
break;
}
case SchemaType.BTC_BOOLEAN: {
_booleanValue = JavaBooleanHolderEx.validateLexical(value, type, _vc);
break;
}
case SchemaType.BTC_FLOAT: {
float f =
JavaFloatHolderEx.validateLexical(value, type, _vc);
if (errorState == _errorState) {
JavaFloatHolderEx.validateValue(f, type, _vc);
}
_floatValue = f;
break;
}
case SchemaType.BTC_DOUBLE: {
double d =
JavaDoubleHolderEx.validateLexical(value, type, _vc);
if (errorState == _errorState) {
JavaDoubleHolderEx.validateValue(d, type, _vc);
}
_doubleValue = d;
break;
}
case SchemaType.BTC_QNAME: {
QName n =
JavaQNameHolderEx.validateLexical(
value, type, _vc, event);
if (errorState == _errorState) {
JavaQNameHolderEx.validateValue(n, type, _vc);
}
_qnameValue = n;
break;
}
case SchemaType.BTC_ANY_URI: {
JavaUriHolderEx.validateLexical(value, type, _vc);
// Do strict validation
if (_strict) {
try {
XsTypeConverter.lexAnyURI(value);
} catch (InvalidLexicalValueException ilve) {
_vc.invalid(XmlErrorCodes.ANYURI, new Object[]{value});
}
}
_stringValue = value;
break;
}
case SchemaType.BTC_G_MONTH: {
// In the case of gMonth, there is some strict mode validation to do
if (_strict && value.length() == 6 &&
value.charAt(4) == '-' && value.charAt(5) == '-') {
_vc.invalid(XmlErrorCodes.DATE, new Object[]{value});
}
// Fall through
}
case SchemaType.BTC_DATE_TIME:
case SchemaType.BTC_TIME:
case SchemaType.BTC_DATE:
case SchemaType.BTC_G_YEAR_MONTH:
case SchemaType.BTC_G_YEAR:
case SchemaType.BTC_G_MONTH_DAY:
case SchemaType.BTC_G_DAY: {
GDate d = XmlDateImpl.validateLexical(value, type, _vc);
if (d != null) {
XmlDateImpl.validateValue(d, type, _vc);
}
_gdateValue = d;
break;
}
case SchemaType.BTC_DURATION: {
GDuration d = XmlDurationImpl.validateLexical(value, type, _vc);
if (d != null) {
XmlDurationImpl.validateValue(d, type, _vc);
}
_gdurationValue = d;
break;
}
case SchemaType.BTC_BASE_64_BINARY: {
byte[] v =
JavaBase64HolderEx.validateLexical(value, type, _vc);
if (v != null) {
JavaBase64HolderEx.validateValue(v, type, _vc);
}
_byteArrayValue = v;
break;
}
case SchemaType.BTC_HEX_BINARY: {
byte[] v =
JavaHexBinaryHolderEx.validateLexical(value, type, _vc);
if (v != null) {
JavaHexBinaryHolderEx.validateValue(v, type, _vc);
}
_byteArrayValue = v;
break;
}
case SchemaType.BTC_NOTATION: {
QName n =
JavaNotationHolderEx.validateLexical(
value, type, _vc, event);
if (errorState == _errorState) {
JavaNotationHolderEx.validateValue(n, type, _vc);
}
_qnameValue = n;
break;
}
default:
throw new RuntimeException("Unexpected primitive type code");
}
}
private void validateListType(
SchemaType type, String value, Event event) {
int errorState = _errorState;
if (!type.matchPatternFacet(value)) {
emitError(event, XmlErrorCodes.DATATYPE_VALID$PATTERN_VALID,
new Object[]{"list", value, QNameHelper.readable(type)},
null, type, XmlValidationError.LIST_INVALID, null);
}
String[] items = XmlListImpl.split_list(value);
int i;
XmlObject o;
if ((o = type.getFacet(SchemaType.FACET_LENGTH)) != null) {
if ((i = ((SimpleValue) o).getIntValue()) != items.length) {
//offending Qname not valid
emitError(event, XmlErrorCodes.DATATYPE_LENGTH_VALID$LIST_LENGTH,
new Object[]{value, items.length, i, QNameHelper.readable(type)},
null, type, XmlValidationError.LIST_INVALID, null);
}
}
if ((o = type.getFacet(SchemaType.FACET_MIN_LENGTH)) != null) {
if ((i = ((SimpleValue) o).getIntValue()) > items.length) {
//offending Qname not valid
emitError(event, XmlErrorCodes.DATATYPE_LENGTH_VALID$LIST_LENGTH,
new Object[]{value, items.length, i, QNameHelper.readable(type)},
null, type, XmlValidationError.LIST_INVALID, null);
}
}
if ((o = type.getFacet(SchemaType.FACET_MAX_LENGTH)) != null) {
if ((i = ((SimpleValue) o).getIntValue()) < items.length) {
//offending Qname not valid
emitError(event, XmlErrorCodes.DATATYPE_LENGTH_VALID$LIST_LENGTH,
new Object[]{value, items.length, i, QNameHelper.readable(type)},
null, type, XmlValidationError.LIST_INVALID, null);
}
}
SchemaType itemType = type.getListItemType();
_listValue = new ArrayList<>();
_listTypes = new ArrayList<>();
for (i = 0; i < items.length; i++) {
validateSimpleType(
itemType, items[i], event);
addToList(itemType);
}
// If no errors up to this point, then I can create an
// XmlList from this value and campare it again enums.
if (errorState == _errorState) {
if (type.getEnumerationValues() != null) {
// Lists which contain QNames will need a resolver
NamespaceContext.push(
new NamespaceContext(event));
try {
XmlObject listValue = ((SchemaTypeImpl) type).newValidatingValue(value);
} catch (XmlValueOutOfRangeException e) {
//offending Qname not valid ??
emitError(event, XmlErrorCodes.DATATYPE_ENUM_VALID,
new Object[]{"list", value, QNameHelper.readable(type)},
null, type, XmlValidationError.LIST_INVALID, null);
} finally {
NamespaceContext.pop();
}
}
}
}
private void validateUnionType(
SchemaType type, String value, Event event) {
// TODO - if xsi:type is specified on a union, it selects
// that union member type
if (!type.matchPatternFacet(value)) {
//offending Qname not valid ??
emitError(event, XmlErrorCodes.DATATYPE_VALID$PATTERN_VALID,
new Object[]{"union", value, QNameHelper.readable(type)},
null, type, XmlValidationError.UNION_INVALID, null);
}
int currentWsr = SchemaType.WS_PRESERVE;
String currentValue = value;
SchemaType[] types = type.getUnionMemberTypes();
int originalState = _errorState;
int i;
for (i = 0; i < types.length; i++) {
int memberWsr = types[i].getWhiteSpaceRule();
if (memberWsr == SchemaType.WS_UNSPECIFIED) {
memberWsr = SchemaType.WS_PRESERVE;
}
if (memberWsr != currentWsr) {
currentWsr = memberWsr;
currentValue = XmlWhitespace.collapse(value, currentWsr);
}
int originalErrorState = _errorState;
_suspendErrors++;
try {
validateSimpleType(types[i], currentValue, event);
} finally {
_suspendErrors--;
}
if (originalErrorState == _errorState) {
_unionType = types[i];
break;
}
}
_errorState = originalState;
if (i >= types.length) {
//offending Qname not valid ??
emitError(event, XmlErrorCodes.DATATYPE_VALID$UNION,
new Object[]{value, QNameHelper.readable(type)},
null, type, XmlValidationError.UNION_INVALID, null);
} else {
XmlObject[] unionEnumvals = type.getEnumerationValues();
if (unionEnumvals != null) {
// Unions which contain QNames will need a resolver
NamespaceContext.push(new NamespaceContext(event));
try {
XmlObject unionValue = type.newValue(value);
for (i = 0; i < unionEnumvals.length; i++) {
if (unionValue.valueEquals(unionEnumvals[i])) {
break;
}
}
if (i >= unionEnumvals.length) {
//offending Qname not valid ??
emitError(event, XmlErrorCodes.DATATYPE_ENUM_VALID,
new Object[]{"union", value, QNameHelper.readable(type)},
null, type, XmlValidationError.UNION_INVALID, null);
}
} catch (XmlValueOutOfRangeException e) {
// actually, the current union code always ends up here when invalid
//offending Qname not valid ??
emitError(event, XmlErrorCodes.DATATYPE_ENUM_VALID,
new Object[]{"union", value, QNameHelper.readable(type)},
null, type, XmlValidationError.UNION_INVALID, null);
} finally {
NamespaceContext.pop();
}
}
}
}
private void addToList(SchemaType type) {
if (type.getSimpleVariety() != SchemaType.ATOMIC &&
type.getSimpleVariety() != SchemaType.UNION) {
return;
}
if (type.getUnionMemberTypes().length > 0 && getUnionType() != null) {
type = getUnionType();
_unionType = null;
}
_listTypes.add(type);
if (type.getPrimitiveType() == null) {
// instance has an error for this value so there is no primitive type.
// an error should already have been produced.
_listValue.add(null);
return;
}
switch (type.getPrimitiveType().getBuiltinTypeCode()) {
case SchemaType.BTC_ANY_SIMPLE:
case SchemaType.BTC_ANY_URI: {
_listValue.add(_stringValue);
break;
}
case SchemaType.BTC_STRING: {
_listValue.add(_stringValue);
_stringValue = null;
break;
}
case SchemaType.BTC_DECIMAL: {
_listValue.add(_decimalValue);
_decimalValue = null;
break;
}
case SchemaType.BTC_BOOLEAN: {
_listValue.add(_booleanValue ? Boolean.TRUE : Boolean.FALSE);
_booleanValue = false;
break;
}
case SchemaType.BTC_FLOAT: {
_listValue.add(_floatValue);
_floatValue = 0;
break;
}
case SchemaType.BTC_DOUBLE: {
_listValue.add(_doubleValue);
_doubleValue = 0;
break;
}
case SchemaType.BTC_QNAME:
case SchemaType.BTC_NOTATION: {
_listValue.add(_qnameValue);
_qnameValue = null;
break;
}
case SchemaType.BTC_DATE_TIME:
case SchemaType.BTC_TIME:
case SchemaType.BTC_DATE:
case SchemaType.BTC_G_YEAR_MONTH:
case SchemaType.BTC_G_YEAR:
case SchemaType.BTC_G_MONTH_DAY:
case SchemaType.BTC_G_DAY:
case SchemaType.BTC_G_MONTH: {
_listValue.add(_gdateValue);
_gdateValue = null;
break;
}
case SchemaType.BTC_DURATION: {
_listValue.add(_gdurationValue);
_gdurationValue = null;
break;
}
case SchemaType.BTC_BASE_64_BINARY:
case SchemaType.BTC_HEX_BINARY: {
_listValue.add(_byteArrayValue);
_byteArrayValue = null;
break;
}
default:
throw new RuntimeException("Unexpected primitive type code");
}
}
//
// Members of the validator class
//
private boolean _invalid;
private final SchemaType _rootType;
private final SchemaField _rootField;
private final SchemaTypeLoader _globalTypes;
private State _stateStack;
private int _errorState;
private Collection _errorListener;
private final boolean _treatLaxAsSkip;
private final boolean _strict;
private final ValidatorVC _vc;
private int _suspendErrors;
private final IdentityConstraint _constraintEngine;
private int _eatContent;
private SchemaLocalElement _localElement;
private SchemaParticle _wildcardElement;
private SchemaLocalAttribute _localAttribute;
private SchemaAttributeModel _wildcardAttribute;
private SchemaType _unionType;
// Strongly typed values
private String _stringValue;
private BigDecimal _decimalValue;
private boolean _booleanValue;
private float _floatValue;
private double _doubleValue;
private QName _qnameValue;
private GDate _gdateValue;
private GDuration _gdurationValue;
private byte[] _byteArrayValue;
private List © 2015 - 2024 Weber Informatics LLC | Privacy Policy