The validating schema instance reader. More...

#include <qxsdvalidatinginstancereader_p.h>

Inheritance diagram for QPatternist::XsdValidatingInstanceReader:

Public Types
typedef QExplicitlySharedDataPointer< XsdValidatingInstanceReader >	Ptr

Public Types inherited from QPatternist::XsdInstanceReader
typedef QExplicitlySharedDataPointer< XsdInstanceReader >	Ptr

Public Functions
void	addSchema (const XsdSchema::Ptr &schema, const QUrl &url)

bool	read ()

	XsdValidatingInstanceReader (XsdValidatedXmlNodeModel *model, const QUrl &documentUri, const XsdSchemaContext::Ptr &context)

Public Functions inherited from QPatternist::XsdInstanceReader
	XsdInstanceReader (const QAbstractXmlNodeModel *model, const XsdSchemaContext::Ptr &context)

Private Types
typedef QHash< QUrl, QStringList >	MergedSchemas

typedef QHashIterator< QUrl, QStringList >	MergedSchemasIterator

Private Functions
void	addIdIdRefBinding (const QString &id, const NamedSchemaComponent::Ptr &binding)

XsdComplexType::Ptr	anyType ()

XsdAttribute::Ptr	attributeByName (const QXmlName &name) const

void	createAndPushStateMachine (const XsdParticle::Ptr &particle)

QXmlQuery	createXQuery (const QList< QXmlName > &namespaceBindings, const QXmlItem &contextNode, const QString &query) const

XsdElement::Ptr	elementByName (const QXmlName &name) const

void	error (const QString &msg) const

bool	loadSchema (const QString &targetNamespace, const QUrl &location)

QString	qNameAttribute (const QXmlName &attributeName)

bool	selectNodeSets (const XsdElement::Ptr &element, const QXmlItem &currentItem, const XsdIdentityConstraint::Ptr &constraint, TargetNode::Set &targetNodeSet, TargetNode::Set &qualifiedNodeSet)

SchemaType::Ptr	typeByName (const QXmlName &name) const

bool	validate (bool &hasStateMachine, XsdElement::Ptr &element)

bool	validateAttribute (const XsdAttributeUse::Ptr &declaration, const QString &value)

bool	validateAttribute (const XsdAttribute::Ptr &declaration, const QString &value)

bool	validateAttributeWildcard (const QXmlName &attributeName, const XsdWildcard::Ptr &wildcard)

bool	validateElement (const XsdElement::Ptr &declaration, bool &hasStateMachine)

bool	validateElementComplexType (const XsdElement::Ptr &declaration, const SchemaType::Ptr &type, bool isNilled, bool &hasStateMachine)

bool	validateElementSimpleType (const XsdElement::Ptr &declaration, const SchemaType::Ptr &type, bool isNilled)

bool	validateElementType (const XsdElement::Ptr &declaration, const SchemaType::Ptr &type, bool isNilled, bool &hasStateMachine)

bool	validateIdentityConstraint (const XsdElement::Ptr &element, const QXmlItem &currentItem)

bool	validateKeyIdentityConstraint (const XsdElement::Ptr &element, const XsdIdentityConstraint::Ptr &constraint, const TargetNode::Set &targetNodeSet, const TargetNode::Set &qualifiedNodeSet)

bool	validateKeyRefIdentityConstraint (const XsdElement::Ptr &element, const XsdIdentityConstraint::Ptr &constraint, const TargetNode::Set &qualifiedNodeSet)

bool	validateUniqueIdentityConstraint (const XsdElement::Ptr &element, const XsdIdentityConstraint::Ptr &constraint, const TargetNode::Set &qualifiedNodeSet)

Additional Inherited Members
Protected Functions inherited from QPatternist::XsdInstanceReader
bool	atEnd () const

QString	attribute (const QXmlName &name) const

QXmlItem	attributeItem (const QXmlName &name) const

QSet< QXmlName >	attributeNames () const

QXmlName	convertToQName (const QString &name) const

bool	hasAttribute (const QXmlName &name) const

bool	hasChildElement () const

bool	hasChildText () const

bool	isEndElement () const

bool	isStartElement () const

QXmlItem	item () const

QXmlName	name () const

QVector< QXmlName >	namespaceBindings (const QXmlNodeModelIndex &index) const

void	readNext ()

QSourceLocation	sourceLocation () const

QString	text () const

Protected Variables inherited from QPatternist::XsdInstanceReader
XsdSchemaContext::Ptr	m_context

Detailed Description

The validating schema instance reader.

This class reads in a xml instance document from a QAbstractXmlNodeModel and validates it against a given xml schema.

Author: Tobias Koenig tobia.nosp@m.s.ko.nosp@m.enig@.nosp@m.noki.nosp@m.a.com

Definition at line 79 of file qxsdvalidatinginstancereader_p.h.

Typedefs

◆ MergedSchemas

typedef QHash<QUrl, QStringList> QPatternist::XsdValidatingInstanceReader::MergedSchemas

private

Definition at line 269 of file qxsdvalidatinginstancereader_p.h.

◆ MergedSchemasIterator

typedef QHashIterator<QUrl, QStringList> QPatternist::XsdValidatingInstanceReader::MergedSchemasIterator

private

Definition at line 270 of file qxsdvalidatinginstancereader_p.h.

◆ Ptr

typedef QExplicitlySharedDataPointer<XsdValidatingInstanceReader> QPatternist::XsdValidatingInstanceReader::Ptr

Definition at line 82 of file qxsdvalidatinginstancereader_p.h.

Constructors and Destructors

◆ XsdValidatingInstanceReader()

XsdValidatingInstanceReader::XsdValidatingInstanceReader	(	XsdValidatedXmlNodeModel *	model,
		const QUrl &	documentUri,
		const XsdSchemaContext::Ptr &	context
	)

Creates a new validating instance reader that reads the data from the given model.

Parameters

model	The model the data shall be read from.
documentUri	The uri of the document the model is from.
context	The context that is used to report errors etc.

Definition at line 98 of file qxsdvalidatinginstancereader.cpp.

     : XsdInstanceReader(model, context)
     , m_model(model)
     , m_namePool(m_context->namePool())
     , m_xsiNilName(m_namePool->allocateQName(CommonNamespaces::XSI, QLatin1String("nil")))
     , m_xsiTypeName(m_namePool->allocateQName(CommonNamespaces::XSI, QLatin1String("type")))
     , m_xsiSchemaLocationName(m_namePool->allocateQName(CommonNamespaces::XSI, QLatin1String("schemaLocation")))
     , m_xsiNoNamespaceSchemaLocationName(m_namePool->allocateQName(CommonNamespaces::XSI, QLatin1String("noNamespaceSchemaLocation")))
     , m_documentUri(documentUri)
 {
     m_idRefsType = m_context->schemaTypeFactory()->createSchemaType(m_namePool->allocateQName(CommonNamespaces::WXS, QLatin1String("IDREFS")));
 }

Functions

◆ addIdIdRefBinding()

void XsdValidatingInstanceReader::addIdIdRefBinding	(	const QString &	id,
		const NamedSchemaComponent::Ptr &	binding
	)

private

Adds the ID/IDREF binding to the validated model and checks for duplicates.

Definition at line 1221 of file qxsdvalidatinginstancereader.cpp.

Referenced by validateAttribute(), and validateElementSimpleType().

 {
     if (!m_model->idIdRefBindings(id).isEmpty()) {
         error(QtXmlPatterns::tr("ID value '%1' is not unique.").arg(formatKeyword(id)));
         return;
     }
 
     m_model->addIdIdRefBinding(id, binding);
 }

◆ addSchema()

void XsdValidatingInstanceReader::addSchema	(	const XsdSchema::Ptr &	schema,
		const QUrl &	url
	)

Adds a new schema to the pool of schemas that shall be used for validation. The schema is located at the given url.

Definition at line 111 of file qxsdvalidatinginstancereader.cpp.

Referenced by loadSchema(), and QXmlSchemaValidator::validate().

 {
     if (!m_mergedSchemas.contains(locationUrl)) {
         m_mergedSchemas.insert(locationUrl, QStringList() << schema->targetNamespace());
     } else {
         QStringList &targetNamespaces = m_mergedSchemas[locationUrl];
         if (targetNamespaces.contains(schema->targetNamespace()))
             return;
 
         targetNamespaces.append(schema->targetNamespace());
     }
 
     const XsdSchemaMerger merger(m_schema, schema);
     m_schema = merger.mergedSchema();
 /*
     XsdSchemaDebugger dbg(m_namePool);
     dbg.dumpSchema(m_schema);
 */
 }

◆ anyType()

XsdComplexType::Ptr XsdValidatingInstanceReader::anyType ( )

private

Returns the xs:anyType that is used to build up the state machine. We need that as the BuiltinTypes::xsAnyType is not a XsdComplexType.

Definition at line 1242 of file qxsdvalidatinginstancereader.cpp.

Referenced by validate(), and validateElementComplexType().

 {
     if (m_anyType)
         return m_anyType;
 
     const XsdWildcard::Ptr wildcard(new XsdWildcard());
     wildcard->namespaceConstraint()->setVariety(XsdWildcard::NamespaceConstraint::Any);
     wildcard->setProcessContents(XsdWildcard::Lax);
 
     const XsdParticle::Ptr outerParticle(new XsdParticle());
     outerParticle->setMinimumOccurs(1);
     outerParticle->setMaximumOccurs(1);
 
     const XsdParticle::Ptr innerParticle(new XsdParticle());
     innerParticle->setMinimumOccurs(0);
     innerParticle->setMaximumOccursUnbounded(true);
     innerParticle->setTerm(wildcard);
 
     const XsdModelGroup::Ptr outerModelGroup(new XsdModelGroup());
     outerModelGroup->setCompositor(XsdModelGroup::SequenceCompositor);
     outerModelGroup->setParticles(XsdParticle::List() << innerParticle);
     outerParticle->setTerm(outerModelGroup);
 
     m_anyType = XsdComplexType::Ptr(new XsdComplexType());
     m_anyType->setName(BuiltinTypes::xsAnyType->name(m_namePool));
     m_anyType->setDerivationMethod(XsdComplexType::DerivationRestriction);
     m_anyType->contentType()->setVariety(XsdComplexType::ContentType::Mixed);
     m_anyType->contentType()->setParticle(outerParticle);
     m_anyType->setAttributeWildcard(wildcard);
     m_anyType->setIsAbstract(false);
 
     return m_anyType;
 }

◆ attributeByName()

XsdAttribute::Ptr XsdValidatingInstanceReader::attributeByName ( const QXmlName & name ) const

private

Returns the attribute declaration with the given name from the pool of all schemas.

Definition at line 1207 of file qxsdvalidatinginstancereader.cpp.

Referenced by validateElementComplexType().

 {
     return m_schema->attribute(name);
 }

◆ createAndPushStateMachine()

void XsdValidatingInstanceReader::createAndPushStateMachine ( const XsdParticle::Ptr & particle )

private

Helper method that creates a state machine for the given particle and pushes it on the state machine stack.

Definition at line 409 of file qxsdvalidatinginstancereader.cpp.

Referenced by validate(), and validateElementComplexType().

 {
     XsdStateMachine<XsdTerm::Ptr> stateMachine(m_namePool);
 
     XsdStateMachineBuilder builder(&stateMachine, m_namePool, XsdStateMachineBuilder::ValidatingMode);
     const XsdStateMachine<XsdTerm::Ptr>::StateId endState = builder.reset();
     const XsdStateMachine<XsdTerm::Ptr>::StateId startState = builder.buildParticle(particle, endState);
     builder.addStartState(startState);
 
 /*
     QString fileName = QString("/tmp/foo_%1.dot").arg(m_namePool->displayName(complexType->name(m_namePool)));
     QString pngFileName = QString("/tmp/foo_%1.png").arg(m_namePool->displayName(complexType->name(m_namePool)));
     QFile file(fileName);
     file.open(QIODevice::WriteOnly);
     stateMachine.outputGraph(&file, "Hello");
     file.close();
     ::system(QString("dot -Tpng %1 -o%2").arg(fileName).arg(pngFileName).toLatin1().data());
 */
 
     stateMachine = stateMachine.toDFA();
 
     m_stateMachines.push(stateMachine);
 }

◆ createXQuery()

QXmlQuery XsdValidatingInstanceReader::createXQuery	(	const QList< QXmlName > &	namespaceBindings,
		const QXmlItem &	contextNode,
		const QString &	query
	)		const

private

Creates an QXmlQuery object with the defined namespaceBindings that has the contextNode as focus and will execute query.

Definition at line 1075 of file qxsdvalidatinginstancereader.cpp.

Referenced by selectNodeSets().

 {
     // create a public name pool from our name pool
     QXmlNamePool namePool(m_namePool.data());
 
     // the QXmlQuery shall work with the same name pool as we do
     QXmlQuery query(namePool);
 
     // add additional namespace bindings
     QXmlQueryPrivate *queryPrivate = query.d;
 
     for (int i = 0; i < namespaceBindings.count(); ++i) {
         if (!namespaceBindings.at(i).prefix() == StandardPrefixes::empty)
             queryPrivate->addAdditionalNamespaceBinding(namespaceBindings.at(i));
     }
 
     // set the context node for that query and the query string
     query.setFocus(contextNode);
     query.setQuery(queryString, m_documentUri);
 
     return query;
 }

◆ elementByName()

XsdElement::Ptr XsdValidatingInstanceReader::elementByName ( const QXmlName & name ) const

private

Returns the element declaration with the given name from the pool of all schemas.

Definition at line 1202 of file qxsdvalidatinginstancereader.cpp.

Referenced by validate().

 {
     return m_schema->element(name);
 }

◆ error()

void XsdValidatingInstanceReader::error ( const QString & msg ) const

private

Reports an error via the report context.

Definition at line 184 of file qxsdvalidatinginstancereader.cpp.

Referenced by addIdIdRefBinding(), loadSchema(), qNameAttribute(), read(), selectNodeSets(), validate(), validateAttribute(), validateElement(), validateElementComplexType(), validateElementSimpleType(), validateElementType(), validateKeyIdentityConstraint(), validateKeyRefIdentityConstraint(), and validateUniqueIdentityConstraint().

 {
     m_context.data()->error(msg, XsdSchemaContext::XSDError, sourceLocation());
 }

◆ loadSchema()

bool XsdValidatingInstanceReader::loadSchema	(	const QString &	targetNamespace,
		const QUrl &	location
	)

private

Loads a schema with the given targetNamespace from the given location and adds it to the pool of schemas that are used for validation.

This method is used to load schemas defined in the xsi:schemaLocation or xsi:noNamespaceSchemaLocation attributes in the instance document.

Definition at line 189 of file qxsdvalidatinginstancereader.cpp.

Referenced by validate().

 {
     const AutoPtr<QNetworkReply> reply(AccelTreeResourceLoader::load(location, m_context->networkAccessManager(),
                                                                      m_context, AccelTreeResourceLoader::ContinueOnError));
     if (!reply)
         return true;
 
     // we have to create a separated schema context here, that however shares the type factory
     XsdSchemaContext::Ptr context(new XsdSchemaContext(m_namePool));
     context->m_schemaTypeFactory = m_context->m_schemaTypeFactory;
 
     QXmlSchemaPrivate schema(context);
     schema.load(reply.data(), location, targetNamespace);
     if (!schema.isValid()) {
         error(QtXmlPatterns::tr("Loaded schema file is invalid."));
         return false;
     }
 
     addSchema(schema.m_schemaParserContext->schema(), location);
 
     return true;
 }

◆ qNameAttribute()

QString XsdValidatingInstanceReader::qNameAttribute ( const QXmlName & attributeName )

private

Helper method that reads an attribute of type xs:QName and does syntax checking.

Definition at line 1231 of file qxsdvalidatinginstancereader.cpp.

Referenced by validate(), and validateElement().

 {
     const QString value = attribute(attributeName).simplified();
     if (!XPathHelper::isQName(value)) {
         error(QtXmlPatterns::tr("'%1' attribute contains invalid QName content: %2.").arg(m_namePool->displayName(attributeName)).arg(formatData(value)));
         return QString();
     } else {
         return value;
     }
 }

◆ read()

bool XsdValidatingInstanceReader::read ( )

Reads and validates the instance document.

Definition at line 131 of file qxsdvalidatinginstancereader.cpp.

Referenced by QXmlSchemaValidator::validate().

 {
     while (!atEnd()) {
         readNext();
 
         if (isEndElement())
             return true;
 
         if (isStartElement()) {
             const QXmlName elementName = name();
             const QXmlItem currentItem = item();
             bool hasStateMachine = false;
             XsdElement::Ptr processedElement;
 
             if (!validate(hasStateMachine, processedElement))
                 return false;
 
             read();
 
             if (processedElement) { // for wildcard with 'skip' we have no element
                 m_model->setAssignedElement(currentItem.toNodeModelIndex(), processedElement);
 
                 // check identity constraints after all child nodes have been
                 // validated, so that we know there assigned types
                 validateIdentityConstraint(processedElement, currentItem);
             }
 
             if (!m_stateMachines.isEmpty() && hasStateMachine) {
                 if (!m_stateMachines.top().inEndState()) {
                     error(QtXmlPatterns::tr("Element %1 is missing child element.").arg(formatKeyword(m_namePool->displayName(elementName))));
                     return false;
                 }
                 m_stateMachines.pop();
             }
         }
     }
 
     // final validations
 
     // check IDREF occurrences
     const QStringList ids = m_model->idIdRefBindingIds();
     QSetIterator<QString> it(m_idRefs);
     while (it.hasNext()) {
         const QString id = it.next();
         if (!ids.contains(id)) {
             error(QtXmlPatterns::tr("There is one IDREF value with no corresponding ID: %1.").arg(formatKeyword(id)));
             return false;
         }
     }
 
     return true;
 }

◆ selectNodeSets()

bool XsdValidatingInstanceReader::selectNodeSets	(	const XsdElement::Ptr &	element,
		const QXmlItem &	currentItem,
		const XsdIdentityConstraint::Ptr &	constraint,
		TargetNode::Set &	targetNodeSet,
		TargetNode::Set &	qualifiedNodeSet
	)

private

Selects two sets of nodes that match the given identity constraint.

Parameters

element	The element the identity constraint belongs to.
currentItem	The current element that will be used as focus for the XQuery.
constraint	The constraint (selector and fields) that describe the two sets.
targetNodeSet	The target node set as defined by the schema specification.
qualifiedNodeSet	The qualified node set as defined by the schema specification.

Definition at line 1098 of file qxsdvalidatinginstancereader.cpp.

Referenced by validateIdentityConstraint().

 {
     // at first select all target nodes
     const XsdXPathExpression::Ptr selector = constraint->selector();
     const XsdXPathExpression::List fields = constraint->fields();
 
     QXmlQuery query = createXQuery(selector->namespaceBindings(), currentItem, selector->expression());
 
     QXmlResultItems resultItems;
     query.evaluateTo(&resultItems);
 
     // now we iterate over all target nodes and select the fields for each node
     QXmlItem item(resultItems.next());
     while (!item.isNull()) {
 
         TargetNode targetNode(item);
 
         for (int i = 0; i < fields.count(); ++i) {
             const XsdXPathExpression::Ptr field = fields.at(i);
             QXmlQuery fieldQuery = createXQuery(field->namespaceBindings(), item, field->expression());
 
             QXmlResultItems fieldResultItems;
             fieldQuery.evaluateTo(&fieldResultItems);
 
             // copy result into vetor for better testing...
             QVector<QXmlItem> fieldVector;
             QXmlItem fieldItem(fieldResultItems.next());
             while (!fieldItem.isNull()) {
                 fieldVector.append(fieldItem);
                 fieldItem = fieldResultItems.next();
             }
 
             if (fieldVector.count() > 1) {
                 error(QtXmlPatterns::tr("More than one value found for field %1.").arg(formatData(field->expression())));
                 return false;
             }
 
             if (fieldVector.count() == 1) {
                 fieldItem = fieldVector.first();
 
                 const QXmlNodeModelIndex index = fieldItem.toNodeModelIndex();
                 const SchemaType::Ptr type = m_model->assignedType(index);
 
                 bool typeOk = true;
                 if (type->isComplexType()) {
                     if (type->isDefinedBySchema()) {
                         if (XsdComplexType::Ptr(type)->contentType()->variety() != XsdComplexType::ContentType::Simple)
                             typeOk = false;
                     } else {
                         typeOk = false;
                     }
                 }
                 if (!typeOk) {
                     error(QtXmlPatterns::tr("Field %1 has no simple type.").arg(formatData(field->expression())));
                     return false;
                 }
 
                 SchemaType::Ptr targetType = type;
                 QString value = m_model->stringValue(fieldItem.toNodeModelIndex());
 
                 if (type->isDefinedBySchema()) {
                     if (type->isSimpleType())
                         targetType = XsdSimpleType::Ptr(type)->primitiveType();
                     else
                         targetType = XsdComplexType::Ptr(type)->contentType()->simpleType();
                 } else {
                     if (BuiltinTypes::xsAnySimpleType->name(m_namePool) == type->name(m_namePool)) {
                         targetType = BuiltinTypes::xsString;
                         value = QLatin1String("___anySimpleType_value");
                     }
                 }
 
                 // if it is xs:QName derived type, we normalize the name content
                 // and do a string comparison
                 if (BuiltinTypes::xsQName->wxsTypeMatches(type)) {
                     targetType = BuiltinTypes::xsString;
 
                     const QXmlName qName = convertToQName(value.trimmed());
                     value = QString::fromLatin1("%1:%2").arg(m_namePool->stringForNamespace(qName.namespaceURI())).arg(m_namePool->stringForLocalName(qName.localName()));
                 }
 
                 targetNode.addField(fieldItem, value, targetType);
             } else {
                 // we add an empty entry here, that makes comparison easier later on
                 targetNode.addField(QXmlItem(), QString(), SchemaType::Ptr());
             }
         }
 
         targetNodeSet.insert(targetNode);
 
         item = resultItems.next();
     }
 
     // copy all items from target node set to qualified node set, that have no empty fields
     QSetIterator<TargetNode> it(targetNodeSet);
     while (it.hasNext()) {
         const TargetNode node = it.next();
         if (node.emptyFieldsCount() == 0)
             qualifiedNodeSet.insert(node);
     }
 
     return true;
 }

◆ typeByName()

SchemaType::Ptr XsdValidatingInstanceReader::typeByName ( const QXmlName & name ) const

private

Returns the type declaration with the given name from the pool of all schemas.

Definition at line 1212 of file qxsdvalidatinginstancereader.cpp.

Referenced by validate(), and validateElement().

 {
     const SchemaType::Ptr type = m_schema->type(name);
     if (type)
         return type;
 
     return m_context->schemaTypeFactory()->createSchemaType(name);
 }

◆ validate()

bool XsdValidatingInstanceReader::validate	(	bool &	hasStateMachine,
		XsdElement::Ptr &	element
	)

private

Validates the current element tag of the instance document.

Parameters

hasStateMachine	Used to remember whether this element represents the start tag of a complex type and therefor pushes a new state machine on the stack.
element	Used to remember which element has been validated in this step.

Definition at line 212 of file qxsdvalidatinginstancereader.cpp.

Referenced by read().

 {
     // first check if a custom schema is defined
     if (hasAttribute(m_xsiSchemaLocationName)) {
         const QString schemaLocation = attribute(m_xsiSchemaLocationName);
         const QStringList parts = schemaLocation.split(QLatin1Char(' '), QString::SkipEmptyParts);
         if ((parts.count()%2) == 1) {
             error(QtXmlPatterns::tr("%1 contains invalid data.").arg(formatKeyword(m_namePool, m_xsiSchemaLocationName)));
             return false;
         }
 
         for (int i = 0; i < parts.count(); i += 2) {
             const QString identifier = QString::fromLatin1("%1 %2").arg(parts.at(i)).arg(parts.at(i + 1));
             if (m_processedSchemaLocations.contains(identifier))
                 continue;
             else
                 m_processedSchemaLocations.insert(identifier);
 
             // check constraint 4) from http://www.w3.org/TR/xmlschema-1/#schema-loc (only valid for XML Schema 1.0?)
             if (m_processedNamespaces.contains(parts.at(i))) {
                 error(QtXmlPatterns::tr("xsi:schemaLocation namespace %1 has already appeared earlier in the instance document.").arg(formatKeyword(parts.at(i))));
                 return false;
             }
 
             QUrl url(parts.at(i + 1));
             if (url.isRelative()) {
                 Q_ASSERT(m_documentUri.isValid());
 
                 url = m_documentUri.resolved(url);
             }
 
             loadSchema(parts.at(i), url);
         }
     }
 
     if (hasAttribute(m_xsiNoNamespaceSchemaLocationName)) {
         const QString schemaLocation = attribute(m_xsiNoNamespaceSchemaLocationName);
 
         if (!m_processedSchemaLocations.contains(schemaLocation)) {
             m_processedSchemaLocations.insert(schemaLocation);
 
             if (m_processedNamespaces.contains(QString())) {
                 error(QtXmlPatterns::tr("xsi:noNamespaceSchemaLocation cannot appear after the first no-namespace element or attribute."));
                 return false;
             }
 
             QUrl url(schemaLocation);
             if (url.isRelative()) {
                 Q_ASSERT(m_documentUri.isValid());
 
                 url = m_documentUri.resolved(url);
             }
 
             loadSchema(QString(), url);
         }
     }
 
     m_processedNamespaces.insert(m_namePool->stringForNamespace(name().namespaceURI()));
 
     if (!m_schema) {
         error(QtXmlPatterns::tr("No schema defined for validation."));
         return false;
     }
 
     // check if we are 'inside' a type definition
     if (m_stateMachines.isEmpty()) {
         // find out the type of the top-level element
         XsdElement::Ptr element = elementByName(name());
         if (!element) {
             if (!hasAttribute(m_xsiTypeName)) {
                 error(QtXmlPatterns::tr("No definition for element %1 available.").arg(formatKeyword(m_namePool, name())));
                 return false;
             }
 
             // This instance document has an element with no definition in the schema
             // but an explicitly given type, that is fine according to the spec.
             // We will create an element definition manually here and continue the
             // normal validation process
             element = XsdElement::Ptr(new XsdElement());
             element->setName(name());
             element->setIsAbstract(false);
             element->setIsNillable(hasAttribute(m_xsiNilName));
 
             const QString type = qNameAttribute(m_xsiTypeName);
             const QXmlName typeName = convertToQName(type);
 
             const SchemaType::Ptr elementType = typeByName(typeName);
             if (!elementType) {
                 error(QtXmlPatterns::tr("Specified type %1 is not known to the schema.").arg(formatType(m_namePool, typeName)));
                 return false;
             }
             element->setType(elementType);
         }
 
         // rememeber the element we process
         processedElement = element;
 
         if (!validateElement(element, hasStateMachine)) {
             return false;
         }
 
     } else {
         if (!m_stateMachines.top().proceed<QXmlName>(name())) {
             error(QtXmlPatterns::tr("Element %1 is not defined in this scope.").arg(formatKeyword(m_namePool, name())));
             return false;
         }
 
         const XsdTerm::Ptr term = m_stateMachines.top().lastTransition();
         if (term->isElement()) {
             const XsdElement::Ptr element(term);
 
             // rememeber the element we process
             processedElement = element;
 
             if (!validateElement(element, hasStateMachine))
                 return false;
 
         } else {
             const XsdWildcard::Ptr wildcard(term);
             if (wildcard->processContents() != XsdWildcard::Skip) {
                 XsdElement::Ptr elementDeclaration = elementByName(name());
                 if (!elementDeclaration) {
                     if (hasAttribute(m_xsiTypeName)) {
                         // This instance document has an element with no definition in the schema
                         // but an explicitly given type, that is fine according to the spec.
                         // We will create an element definition manually here and continue the
                         // normal validation process
                         elementDeclaration = XsdElement::Ptr(new XsdElement());
                         elementDeclaration->setName(name());
                         elementDeclaration->setIsAbstract(false);
                         elementDeclaration->setIsNillable(hasAttribute(m_xsiNilName));
 
                         const QString type = qNameAttribute(m_xsiTypeName);
                         const QXmlName typeName = convertToQName(type);
 
                         const SchemaType::Ptr elementType = typeByName(typeName);
                         if (!elementType) {
                             error(QtXmlPatterns::tr("Specified type %1 is not known to the schema.").arg(formatType(m_namePool, typeName)));
                             return false;
                         }
                         elementDeclaration->setType(elementType);
                     }
                 }
 
                 if (!elementDeclaration) {
                     if (wildcard->processContents() == XsdWildcard::Strict) {
                         error(QtXmlPatterns::tr("Declaration for element %1 does not exist.").arg(formatKeyword(m_namePool->displayName(name()))));
                         return false;
                     } else {
                         // in this case we put a state machine for the xs:anyType on the statemachine stack,
                         // so we accept every content of this element
 
                         createAndPushStateMachine(anyType()->contentType()->particle());
                         hasStateMachine = true;
                     }
                 } else {
                     if (!validateElement(elementDeclaration, hasStateMachine)) {
                         if (wildcard->processContents() == XsdWildcard::Strict) {
                             error(QtXmlPatterns::tr("Element %1 contains invalid content.").arg(formatKeyword(m_namePool->displayName(name()))));
                             return false;
                         }
                     }
 
                     // rememeber the type of that element node
                     m_model->setAssignedType(item().toNodeModelIndex(), elementDeclaration->type());
                 }
             } else { // wildcard process contents type is Skip
                 // in this case we put a state machine for the xs:anyType on the statemachine stack,
                 // so we accept every content of this element
 
                 const XsdWildcard::Ptr wildcard(new XsdWildcard());
                 wildcard->namespaceConstraint()->setVariety(XsdWildcard::NamespaceConstraint::Any);
                 wildcard->setProcessContents(XsdWildcard::Skip);
 
                 const XsdParticle::Ptr outerParticle(new XsdParticle());
                 outerParticle->setMinimumOccurs(1);
                 outerParticle->setMaximumOccurs(1);
 
                 const XsdParticle::Ptr innerParticle(new XsdParticle());
                 innerParticle->setMinimumOccurs(0);
                 innerParticle->setMaximumOccursUnbounded(true);
                 innerParticle->setTerm(wildcard);
 
                 const XsdModelGroup::Ptr outerModelGroup(new XsdModelGroup());
                 outerModelGroup->setCompositor(XsdModelGroup::SequenceCompositor);
                 outerModelGroup->setParticles(XsdParticle::List() << innerParticle);
                 outerParticle->setTerm(outerModelGroup);
 
                 createAndPushStateMachine(outerParticle);
                 hasStateMachine = true;
             }
         }
     }
 
     return true;
 }

◆ validateAttribute() [1/2]

bool XsdValidatingInstanceReader::validateAttribute	(	const XsdAttributeUse::Ptr &	declaration,
		const QString &	value
	)

private

Validates the given value against the attribute use declaration.

Definition at line 833 of file qxsdvalidatinginstancereader.cpp.

Referenced by validateElementComplexType().

 {
     const AnySimpleType::Ptr attributeType = declaration->attribute()->type();
     const XsdFacet::Hash facets = XsdTypeChecker::mergedFacetsForType(attributeType, m_context);
 
     const QString actualValue = XsdTypeChecker::normalizedValue(value, facets);
 
     QString errorMsg;
     AnySimpleType::Ptr boundType;
 
     const QXmlNodeModelIndex index = attributeItem(declaration->attribute()->name(m_namePool)).toNodeModelIndex();
 
     const XsdTypeChecker checker(m_context, namespaceBindings(index), sourceLocation());
     if (!checker.isValidString(actualValue, attributeType, errorMsg, &boundType)) {
         error(QtXmlPatterns::tr("Content of attribute %1 does not match its type definition: %2.").arg(formatKeyword(declaration->attribute()->displayName(m_namePool))).arg(errorMsg));
         return false;
     }
 
     // @see http://www.w3.org/TR/xmlschema11-1/#cvc-au
     if (declaration->valueConstraint() && declaration->valueConstraint()->variety() == XsdAttributeUse::ValueConstraint::Fixed) {
         const QString actualConstraintValue = XsdTypeChecker::normalizedValue(declaration->valueConstraint()->value(), facets);
         if (!checker.valuesAreEqual(actualValue, actualConstraintValue, attributeType)) {
             error(QtXmlPatterns::tr("Content of attribute %1 does not match defined value constraint.").arg(formatKeyword(declaration->attribute()->displayName(m_namePool))));
             return false;
         }
     }
 
     if (BuiltinTypes::xsID->wxsTypeMatches(declaration->attribute()->type())) {
         addIdIdRefBinding(actualValue, declaration->attribute());
     }
 
     if (m_idRefsType->wxsTypeMatches(declaration->attribute()->type())) {
         const QStringList idRefs = actualValue.split(QLatin1Char(' '), QString::SkipEmptyParts);
         for (int i = 0; i < idRefs.count(); ++i)
             m_idRefs.insert(idRefs.at(i));
     } else if (BuiltinTypes::xsIDREF->wxsTypeMatches(declaration->attribute()->type())) {
         m_idRefs.insert(actualValue);
     }
 
     m_model->setAssignedType(index, declaration->attribute()->type());
     m_model->setAssignedAttribute(index, declaration->attribute());
 
     return true;
 }

◆ validateAttribute() [2/2]

bool XsdValidatingInstanceReader::validateAttribute	(	const XsdAttribute::Ptr &	declaration,
		const QString &	value
	)

private

Validates the given value against the attribute declaration.

Definition at line 879 of file qxsdvalidatinginstancereader.cpp.

 {
     const AnySimpleType::Ptr attributeType = declaration->type();
     const XsdFacet::Hash facets = XsdTypeChecker::mergedFacetsForType(attributeType, m_context);
 
     const QString actualValue = XsdTypeChecker::normalizedValue(value, facets);
 
     QString errorMsg;
     AnySimpleType::Ptr boundType;
 
     const QXmlNodeModelIndex index = attributeItem(declaration->name(m_namePool)).toNodeModelIndex();
 
     const XsdTypeChecker checker(m_context, namespaceBindings(index), sourceLocation());
     if (!checker.isValidString(actualValue, attributeType, errorMsg, &boundType)) {
         error(QtXmlPatterns::tr("Content of attribute %1 does not match its type definition: %2.").arg(formatKeyword(declaration->displayName(m_namePool))).arg(errorMsg));
         return false;
     }
 
     // @see http://www.w3.org/TR/xmlschema11-1/#cvc-au
     if (declaration->valueConstraint() && declaration->valueConstraint()->variety() == XsdAttribute::ValueConstraint::Fixed) {
         const QString actualConstraintValue = XsdTypeChecker::normalizedValue(declaration->valueConstraint()->value(), facets);
         if (!checker.valuesAreEqual(actualValue, actualConstraintValue, attributeType)) {
             error(QtXmlPatterns::tr("Content of attribute %1 does not match defined value constraint.").arg(formatKeyword(declaration->displayName(m_namePool))));
             return false;
         }
     }
 
     if (BuiltinTypes::xsID->wxsTypeMatches(declaration->type())) {
         addIdIdRefBinding(actualValue, declaration);
     }
 
     if (m_idRefsType->wxsTypeMatches(declaration->type())) {
         const QStringList idRefs = actualValue.split(QLatin1Char(' '), QString::SkipEmptyParts);
         for (int i = 0; i < idRefs.count(); ++i)
             m_idRefs.insert(idRefs.at(i));
     } else if (BuiltinTypes::xsIDREF->wxsTypeMatches(declaration->type())) {
         m_idRefs.insert(actualValue);
     }
 
     m_model->setAssignedType(index, declaration->type());
     m_model->setAssignedAttribute(index, declaration);
 
     return true;
 }

◆ validateAttributeWildcard()

bool XsdValidatingInstanceReader::validateAttributeWildcard	(	const QXmlName &	attributeName,
		const XsdWildcard::Ptr &	wildcard
	)

private

Validates the given attributeName against the wildcard.

Definition at line 924 of file qxsdvalidatinginstancereader.cpp.

Referenced by validateElementComplexType().

 {
     // @see http://www.w3.org/TR/xmlschema11-1/#cvc-wildcard
 
     // wildcards using XsdWildcard::absentNamespace, so we have to fix that here
     QXmlName name(attributeName);
     if (name.namespaceURI() == StandardNamespaces::empty) {
         name.setNamespaceURI(m_namePool->allocateNamespace(XsdWildcard::absentNamespace()));
     }
 
     return XsdSchemaHelper::wildcardAllowsExpandedName(name, wildcard, m_namePool);
 }

◆ validateElement()

bool XsdValidatingInstanceReader::validateElement	(	const XsdElement::Ptr &	declaration,
		bool &	hasStateMachine
	)

private

Validates the current tag of the instance document against the given element declaration.

Parameters

declaration	The element declaration to validate against.
hasStateMachine	Used to remember whether this element represents the start tag of a complex type and therefor pushes a new state machine on the stack.

Definition at line 433 of file qxsdvalidatinginstancereader.cpp.

Referenced by validate().

 {
     // http://www.w3.org/TR/xmlschema11-1/#d0e10998
 
     bool isNilled = false;
 
     // 1 tested already, 'declaration' corresponds D
 
     // 2
     if (declaration->isAbstract()) {
         error(QtXmlPatterns::tr("Element %1 is declared as abstract.").arg(formatKeyword(declaration->displayName(m_namePool))));
         return false;
     }
 
     // 3
     if (!declaration->isNillable()) {
         if (hasAttribute(m_xsiNilName)) {
             error(QtXmlPatterns::tr("Element %1 is not nillable.").arg(formatKeyword(declaration->displayName(m_namePool))));
             return false; // 3.1
         }
     } else {
         if (hasAttribute(m_xsiNilName)) {
             const QString value = attribute(m_xsiNilName);
             const Boolean::Ptr nil = Boolean::fromLexical(value);
             if (nil->hasError()) {
                 error(QtXmlPatterns::tr("Attribute %1 contains invalid data: %2").arg(formatKeyword(QLatin1String("nil."))).arg(formatData(value)));
                 return false;
             }
 
             // 3.2.3
             if (nil->as<Boolean>()->value() == true) {
                 // 3.2.3.1
                 if (hasChildElement() || hasChildText()) {
                     error(QtXmlPatterns::tr("Element contains content although it is nillable."));
                     return false;
                 }
 
                 // 3.2.3.2
                 if (declaration->valueConstraint() && declaration->valueConstraint()->variety() == XsdElement::ValueConstraint::Fixed) {
                     error(QtXmlPatterns::tr("Fixed value constraint not allowed if element is nillable."));
                     return false;
                 }
             }
 
             isNilled = nil->as<Boolean>()->value();
         }
     }
 
     SchemaType::Ptr finalElementType = declaration->type();
 
     // 4
     if (hasAttribute(m_xsiTypeName)) {
         const QString type = qNameAttribute(m_xsiTypeName);
         const QXmlName typeName = convertToQName(type);
 
         const SchemaType::Ptr elementType = typeByName(typeName);
         // 4.1
         if (!elementType) {
             error(QtXmlPatterns::tr("Specified type %1 is not known to the schema.").arg(formatType(m_namePool, typeName)));
             return false;
         }
 
         // 4.2
         SchemaType::DerivationConstraints constraints = 0;
         if (declaration->disallowedSubstitutions() & NamedSchemaComponent::ExtensionConstraint)
             constraints |= SchemaType::ExtensionConstraint;
         if (declaration->disallowedSubstitutions() & NamedSchemaComponent::RestrictionConstraint)
             constraints |= SchemaType::RestrictionConstraint;
 
         if (!XsdSchemaHelper::isValidlySubstitutable(elementType, declaration->type(), constraints)) {
             if (declaration->type()->name(m_namePool) != BuiltinTypes::xsAnyType->name(m_namePool)) { // xs:anyType is a valid substitutable type here
                 error(QtXmlPatterns::tr("Specified type %1 is not validly substitutable with element type %2.").arg(formatType(m_namePool, elementType)).arg(formatType(m_namePool, declaration->type())));
                 return false;
             }
         }
 
         finalElementType = elementType;
     }
 
     if (!validateElementType(declaration, finalElementType, isNilled, hasStateMachine))
         return false;
 
     return true;
 }

◆ validateElementComplexType()

bool XsdValidatingInstanceReader::validateElementComplexType	(	const XsdElement::Ptr &	declaration,
		const SchemaType::Ptr &	type,
		bool	isNilled,
		bool &	hasStateMachine
	)

private

Validates the current tag of the instance document against the given complex type of the element declaration.

Parameters

declaration	The element declaration to validate against.
type	The type to validate against.
isNilled	Defines whether the element is nilled by the instance document.
hasStateMachine	Used to remember whether this element represents the start tag of a complex type and therefor pushes a new state machine on the stack.

Note: The type can differ from the element declaration type if the instance document has defined it via xsi:type attribute.

Definition at line 624 of file qxsdvalidatinginstancereader.cpp.

Referenced by validateElementType().

 {
     // @see http://www.w3.org/TR/xmlschema11-1/#cvc-complex-type
 
     // 1
     if (!isNilled) {
         XsdComplexType::Ptr complexType;
 
         if (type->isDefinedBySchema()) {
             complexType = XsdComplexType::Ptr(type);
         } else {
             if (type->name(m_namePool) == BuiltinTypes::xsAnyType->name(m_namePool))
                 complexType = anyType();
         }
 
         if (complexType) {
             // 1.1
             if (complexType->contentType()->variety() == XsdComplexType::ContentType::Empty) {
                 if (hasChildText() || hasChildElement()) {
                     error(QtXmlPatterns::tr("Element %1 contains not allowed child content.").arg(formatKeyword(declaration->displayName(m_namePool))));
                     return false;
                 }
             }
 
             // 1.2
             if (complexType->contentType()->variety() == XsdComplexType::ContentType::Simple) {
                 if (hasChildElement()) {
                     error(QtXmlPatterns::tr("Element %1 contains not allowed child element.").arg(formatKeyword(declaration->displayName(m_namePool))));
                     return false;
                 }
 
                 const XsdFacet::Hash facets = XsdTypeChecker::mergedFacetsForType(complexType->contentType()->simpleType(), m_context);
                 QString actualValue;
                 if (hasChildText()) {
                     actualValue = XsdTypeChecker::normalizedValue(text(), facets);
                 } else {
                     if (declaration->valueConstraint())
                         actualValue = XsdTypeChecker::normalizedValue(declaration->valueConstraint()->value(), facets);
                 }
 
                 QString errorMsg;
                 AnySimpleType::Ptr boundType;
                 const XsdTypeChecker checker(m_context, namespaceBindings(item().toNodeModelIndex()), sourceLocation());
                 if (!checker.isValidString(actualValue, complexType->contentType()->simpleType(), errorMsg, &boundType)) {
                     error(QtXmlPatterns::tr("Content of element %1 does not match its type definition: %2.").arg(formatKeyword(declaration->displayName(m_namePool))).arg(errorMsg));
                     return false;
                 }
 
                 // additional check
                 if (declaration->valueConstraint() && declaration->valueConstraint()->variety() == XsdElement::ValueConstraint::Fixed) {
                     if (!checker.valuesAreEqual(actualValue, declaration->valueConstraint()->value(), boundType)) {
                         error(QtXmlPatterns::tr("Content of element %1 does not match defined value constraint.").arg(formatKeyword(declaration->displayName(m_namePool))));
                         return false;
                     }
                 }
             }
 
             // 1.3
             if (complexType->contentType()->variety() == XsdComplexType::ContentType::ElementOnly) {
                 if (!text().simplified().isEmpty()) {
                     error(QtXmlPatterns::tr("Element %1 contains not allowed text content.").arg(formatKeyword(declaration->displayName(m_namePool))));
                     return false;
                 }
             }
 
             // 1.4
             if (complexType->contentType()->variety() == XsdComplexType::ContentType::ElementOnly ||
                 complexType->contentType()->variety() == XsdComplexType::ContentType::Mixed) {
 
                 if (complexType->contentType()->particle()) {
                     createAndPushStateMachine(complexType->contentType()->particle());
                     hasStateMachine = true;
                 }
 
                 // additional check
                 if (complexType->contentType()->variety() == XsdComplexType::ContentType::Mixed) {
                     if (declaration->valueConstraint() && declaration->valueConstraint()->variety() == XsdElement::ValueConstraint::Fixed) {
                         if (hasChildElement()) {
                             error(QtXmlPatterns::tr("Element %1 cannot contain other elements, as it has fixed content.").arg(formatKeyword(declaration->displayName(m_namePool))));
                             return false;
                         }
 
                         const XsdFacet::Hash facets = XsdTypeChecker::mergedFacetsForType(complexType->contentType()->simpleType(), m_context);
                         QString actualValue;
                         if (hasChildText()) {
                             actualValue = XsdTypeChecker::normalizedValue(text(), facets);
                         } else {
                             if (declaration->valueConstraint())
                                 actualValue = XsdTypeChecker::normalizedValue(declaration->valueConstraint()->value(), facets);
                         }
 
                         if (actualValue != declaration->valueConstraint()->value()) {
                             error(QtXmlPatterns::tr("Content of element %1 does not match defined value constraint.").arg(formatKeyword(declaration->displayName(m_namePool))));
                             return false;
                         }
                     }
                 }
             }
         }
     }
 
     if (type->isDefinedBySchema()) {
         const XsdComplexType::Ptr complexType(type);
 
         // create a lookup hash for faster access
         QHash<QXmlName, XsdAttributeUse::Ptr> attributeUseHash;
         {
             const XsdAttributeUse::List attributeUses = complexType->attributeUses();
             for (int i = 0; i < attributeUses.count(); ++i)
                 attributeUseHash.insert(attributeUses.at(i)->attribute()->name(m_namePool), attributeUses.at(i));
         }
 
         const QSet<QXmlName> attributes(attributeNames());
 
         // 3
         QHashIterator<QXmlName, XsdAttributeUse::Ptr> usesIt(attributeUseHash);
         while (usesIt.hasNext()) {
             usesIt.next();
 
             if (usesIt.value()->isRequired()) {
                 if (!attributes.contains(usesIt.key())) {
                     error(QtXmlPatterns::tr("Element %1 is missing required attribute %2.").arg(formatKeyword(declaration->displayName(m_namePool)))
                                                                                           .arg(formatKeyword(m_namePool->displayName(usesIt.key()))));
                     return false;
                 }
             }
         }
 
         bool hasIDAttribute = hasIDAttributeUse(complexType->attributeUses());
 
         // 2
         QSetIterator<QXmlName> it(attributes);
         while (it.hasNext()) {
             const QXmlName attributeName = it.next();
 
             // skip builtin attributes
             if (attributeName == m_xsiNilName ||
                 attributeName == m_xsiTypeName ||
                 attributeName == m_xsiSchemaLocationName ||
                 attributeName == m_xsiNoNamespaceSchemaLocationName)
                 continue;
 
             // 2.1
             if (attributeUseHash.contains(attributeName) && (attributeUseHash.value(attributeName)->useType() != XsdAttributeUse::ProhibitedUse)) {
                 if (!validateAttribute(attributeUseHash.value(attributeName), attribute(attributeName)))
                     return false;
             } else { // 2.2
                 if (complexType->attributeWildcard()) {
                     const XsdWildcard::Ptr wildcard(complexType->attributeWildcard());
                     if (!validateAttributeWildcard(attributeName, wildcard)) {
                         error(QtXmlPatterns::tr("Attribute %1 does not match the attribute wildcard.").arg(formatKeyword(m_namePool->displayName(attributeName))));
                         return false;
                     }
 
                     if (wildcard->processContents() != XsdWildcard::Skip) {
                         const XsdAttribute::Ptr attributeDeclaration = attributeByName(attributeName);
 
                         if (!attributeDeclaration) {
                             if (wildcard->processContents() == XsdWildcard::Strict) {
                                 error(QtXmlPatterns::tr("Declaration for attribute %1 does not exist.").arg(formatKeyword(m_namePool->displayName(attributeName))));
                                 return false;
                             }
                         } else {
                             if (BuiltinTypes::xsID->wxsTypeMatches(attributeDeclaration->type())) {
                                 if (hasIDAttribute) {
                                     error(QtXmlPatterns::tr("Element %1 contains two attributes of type %2.")
                                                            .arg(formatKeyword(declaration->displayName(m_namePool)))
                                                            .arg(formatKeyword("ID")));
                                     return false;
                                 }
 
                                 hasIDAttribute = true;
                             }
 
                             if (!validateAttribute(attributeDeclaration, attribute(attributeName))) {
                                 if (wildcard->processContents() == XsdWildcard::Strict) {
                                     error(QtXmlPatterns::tr("Attribute %1 contains invalid content.").arg(formatKeyword(m_namePool->displayName(attributeName))));
                                     return false;
                                 }
                             }
                         }
                     }
                 } else {
                     error(QtXmlPatterns::tr("Element %1 contains unknown attribute %2.").arg(formatKeyword(declaration->displayName(m_namePool)))
                                                                                        .arg(formatKeyword(m_namePool->displayName(attributeName))));
                     return false;
                 }
             }
         }
     }
 
     // 4
     // so what?...
 
     // 5
     // hmm...
 
     // 6
     // TODO: check assertions
 
     // 7
     // TODO: check type table restrictions
 
     // rememeber the type of that element node
     m_model->setAssignedType(item().toNodeModelIndex(), type);
 
     return true;
 }

◆ validateElementSimpleType()

bool XsdValidatingInstanceReader::validateElementSimpleType	(	const XsdElement::Ptr &	declaration,
		const SchemaType::Ptr &	type,
		bool	isNilled
	)

private

Validates the current tag of the instance document against the given simple type of the element declaration.

Parameters

declaration	The element declaration to validate against.
type	The type to validate against.
isNilled	Defines whether the element is nilled by the instance document.

Note: The type can differ from the element declaration type if the instance document has defined it via xsi:type attribute.

Definition at line 539 of file qxsdvalidatinginstancereader.cpp.

Referenced by validateElementType().

 {
     // @see http://www.w3.org/TR/xmlschema11-1/#d0e11749
 
     // 3.1.1
     const QSet<QXmlName> allowedAttributes(QSet<QXmlName>() << m_xsiNilName << m_xsiTypeName << m_xsiSchemaLocationName << m_xsiNoNamespaceSchemaLocationName);
     QSet<QXmlName> elementAttributes = attributeNames();
     elementAttributes.subtract(allowedAttributes);
     if (!elementAttributes.isEmpty()) {
         error(QtXmlPatterns::tr("Element %1 contains not allowed attributes.").arg(formatKeyword(declaration->displayName(m_namePool))));
         return false;
     }
 
     // 3.1.2
     if (hasChildElement()) {
         error(QtXmlPatterns::tr("Element %1 contains not allowed child element.").arg(formatKeyword(declaration->displayName(m_namePool))));
         return false;
     }
 
     // 3.1.3
     if (!isNilled) {
         const XsdFacet::Hash facets = XsdTypeChecker::mergedFacetsForType(type, m_context);
 
         QString actualValue;
         if (hasChildText()) {
             actualValue = XsdTypeChecker::normalizedValue(text(), facets);
         } else {
             if (declaration->valueConstraint())
                 actualValue = XsdTypeChecker::normalizedValue(declaration->valueConstraint()->value(), facets);
         }
 
         QString errorMsg;
         AnySimpleType::Ptr boundType;
 
         const XsdTypeChecker checker(m_context, namespaceBindings(item().toNodeModelIndex()), sourceLocation());
         if (!checker.isValidString(actualValue, type, errorMsg, &boundType)) {
             error(QtXmlPatterns::tr("Content of element %1 does not match its type definition: %2.").arg(formatKeyword(declaration->displayName(m_namePool))).arg(errorMsg));
             return false;
         }
 
         // additional check
         if (declaration->valueConstraint() && declaration->valueConstraint()->variety() == XsdElement::ValueConstraint::Fixed) {
             const QString actualConstraintValue = XsdTypeChecker::normalizedValue(declaration->valueConstraint()->value(), facets);
             if (!text().isEmpty() && !checker.valuesAreEqual(actualValue, actualConstraintValue, type)) {
                 error(QtXmlPatterns::tr("Content of element %1 does not match defined value constraint.").arg(formatKeyword(declaration->displayName(m_namePool))));
                 return false;
             }
         }
     }
 
     // 4  checked in validateElement already
 
     // rememeber the type of that element node
     m_model->setAssignedType(item().toNodeModelIndex(), type);
 
     const XsdFacet::Hash facets = XsdTypeChecker::mergedFacetsForType(type, m_context);
     const QString actualValue = XsdTypeChecker::normalizedValue(text(), facets);
 
     if (BuiltinTypes::xsID->wxsTypeMatches(type)) {
         addIdIdRefBinding(actualValue, declaration);
     }
 
     if (m_idRefsType->wxsTypeMatches(type)) {
         const QStringList idRefs = actualValue.split(QLatin1Char(' '), QString::SkipEmptyParts);
         for (int i = 0; i < idRefs.count(); ++i) {
             m_idRefs.insert(idRefs.at(i));
         }
     } else if (BuiltinTypes::xsIDREF->wxsTypeMatches(type)) {
         m_idRefs.insert(actualValue);
     }
 
     return true;
 }

◆ validateElementType()

bool XsdValidatingInstanceReader::validateElementType	(	const XsdElement::Ptr &	declaration,
		const SchemaType::Ptr &	type,
		bool	isNilled,
		bool &	hasStateMachine
	)

private

Validates the current tag of the instance document against the given type of the element declaration.

Parameters

declaration	The element declaration to validate against.
type	The type to validate against.
isNilled	Defines whether the element is nilled by the instance document.
hasStateMachine	Used to remember whether this element represents the start tag of a complex type and therefor pushes a new state machine on the stack.

Note: The type can differ from the element declaration type if the instance document has defined it via xsi:type attribute.

Definition at line 518 of file qxsdvalidatinginstancereader.cpp.

Referenced by validateElement().

 {
     // @see http://www.w3.org/TR/xmlschema11-1/#d0e11749
 
     // 1 checked already
 
     // 2
     if (type->isComplexType() && type->isDefinedBySchema()) {
         if (XsdComplexType::Ptr(type)->isAbstract()) {
             error(QtXmlPatterns::tr("Complex type %1 is not allowed to be abstract.").arg(formatType(m_namePool, type)));
             return false;
         }
     }
 
     // 3
     if (type->isSimpleType())
         return validateElementSimpleType(declaration, type, isNilled); // 3.1
     else
         return validateElementComplexType(declaration, type, isNilled, hasStateMachine); // 3.2
 }

◆ validateIdentityConstraint()

bool XsdValidatingInstanceReader::validateIdentityConstraint	(	const XsdElement::Ptr &	element,
		const QXmlItem &	currentItem
	)

private

Validates the identity constraints of an element.

Definition at line 937 of file qxsdvalidatinginstancereader.cpp.

Referenced by read().

 {
     const XsdIdentityConstraint::List constraints = element->identityConstraints();
 
     for (int i = 0; i < constraints.count(); ++i) {
         const XsdIdentityConstraint::Ptr constraint = constraints.at(i);
 
         TargetNode::Set targetNodeSet, qualifiedNodeSet;
         selectNodeSets(element, currentItem, constraint, targetNodeSet, qualifiedNodeSet);
 
         if (constraint->category() == XsdIdentityConstraint::Unique) {
             if (!validateUniqueIdentityConstraint(element, constraint, qualifiedNodeSet))
                 return false;
         } else if (constraint->category() == XsdIdentityConstraint::Key) {
             if (!validateKeyIdentityConstraint(element, constraint, targetNodeSet, qualifiedNodeSet))
                 return false;
         }
     }
 
     // we do the keyref check in a separated run to make sure that all keys are available
     for (int i = 0; i < constraints.count(); ++i) {
         const XsdIdentityConstraint::Ptr constraint = constraints.at(i);
         if (constraint->category() == XsdIdentityConstraint::KeyReference) {
             TargetNode::Set targetNodeSet, qualifiedNodeSet;
             selectNodeSets(element, currentItem, constraint, targetNodeSet, qualifiedNodeSet);
 
             if (!validateKeyRefIdentityConstraint(element, constraint, qualifiedNodeSet))
                 return false;
         }
     }
 
     return true;
 }

◆ validateKeyIdentityConstraint()

bool XsdValidatingInstanceReader::validateKeyIdentityConstraint	(	const XsdElement::Ptr &	element,
		const XsdIdentityConstraint::Ptr &	constraint,
		const TargetNode::Set &	targetNodeSet,
		const TargetNode::Set &	qualifiedNodeSet
	)

private

Validates the key identity constraint of the element.

Definition at line 1000 of file qxsdvalidatinginstancereader.cpp.

Referenced by validateIdentityConstraint().

 {
     // @see http://www.w3.org/TR/xmlschema11-1/#d0e32243
 
     // 4.2
     const XsdSchemaSourceLocationReflection reflection(sourceLocation());
 
     // 4.2.1
     if (targetNodeSet.count() != qualifiedNodeSet.count()) {
         error(QtXmlPatterns::tr("Key constraint %1 contains absent fields.").arg(formatKeyword(constraint->displayName(m_namePool))));
         return false;
     }
 
     // 4.2.2
     if (!validateUniqueIdentityConstraint(element, constraint, qualifiedNodeSet))
         return false;
 
     // 4.2.3
     QSetIterator<TargetNode> it(qualifiedNodeSet);
     while (it.hasNext()) {
         const TargetNode node = it.next();
         const QVector<QXmlItem> fieldItems = node.fieldItems();
         for (int i = 0; i < fieldItems.count(); ++i) {
             const QXmlNodeModelIndex index = fieldItems.at(i).toNodeModelIndex();
             if (m_model->kind(index) == QXmlNodeModelIndex::Element) {
                 const XsdElement::Ptr declaration = m_model->assignedElement(index);
                 if (declaration && declaration->isNillable()) {
                     error(QtXmlPatterns::tr("Key constraint %1 contains references nillable element %2.")
                                            .arg(formatKeyword(constraint->displayName(m_namePool)))
                                            .arg(formatKeyword(declaration->displayName(m_namePool))));
                     return false;
                 }
             }
         }
     }
 
     m_idcKeys.insert(constraint->name(m_namePool), qualifiedNodeSet);
 
     return true;
 }

◆ validateKeyRefIdentityConstraint()

bool XsdValidatingInstanceReader::validateKeyRefIdentityConstraint	(	const XsdElement::Ptr &	element,
		const XsdIdentityConstraint::Ptr &	constraint,
		const TargetNode::Set &	qualifiedNodeSet
	)

private

Validates the keyref identity constraint of the element.

Definition at line 1041 of file qxsdvalidatinginstancereader.cpp.

Referenced by validateIdentityConstraint().

 {
     // @see http://www.w3.org/TR/xmlschema11-1/#d0e32243
 
     // 4.3
     const XsdSchemaSourceLocationReflection reflection(sourceLocation());
 
     const TargetNode::Set keySet = m_idcKeys.value(constraint->referencedKey()->name(m_namePool));
 
     QSetIterator<TargetNode> it(qualifiedNodeSet);
     while (it.hasNext()) {
         const TargetNode node = it.next();
 
         bool foundMatching = false;
 
         QSetIterator<TargetNode> keyIt(keySet);
         while (keyIt.hasNext()) {
             const TargetNode keyNode = keyIt.next();
 
             if (node.fieldsAreEqual(keyNode, m_namePool, m_context, &reflection)) {
                 foundMatching = true;
                 break;
             }
         }
 
         if (!foundMatching) {
             error(QtXmlPatterns::tr("No referenced value found for key reference %1.").arg(formatKeyword(constraint->displayName(m_namePool))));
             return false;
         }
     }
 
     return true;
 }

◆ validateUniqueIdentityConstraint()

bool XsdValidatingInstanceReader::validateUniqueIdentityConstraint	(	const XsdElement::Ptr &	element,
		const XsdIdentityConstraint::Ptr &	constraint,
		const TargetNode::Set &	qualifiedNodeSet
	)

private

Validates the unique identity constraint of the element.

Definition at line 971 of file qxsdvalidatinginstancereader.cpp.

Referenced by validateIdentityConstraint(), and validateKeyIdentityConstraint().

 {
     // @see http://www.w3.org/TR/xmlschema11-1/#d0e32243
 
     // 4.1
     const XsdSchemaSourceLocationReflection reflection(sourceLocation());
 
     QSetIterator<TargetNode> it(qualifiedNodeSet);
     while (it.hasNext()) {
         const TargetNode node = it.next();
         QSetIterator<TargetNode> innerIt(qualifiedNodeSet);
         while (innerIt.hasNext()) {
             const TargetNode innerNode = innerIt.next();
 
             if (node == innerNode) // do not compare with ourself
                 continue;
 
             if (node.fieldsAreEqual(innerNode, m_namePool, m_context, &reflection)) {
                 error(QtXmlPatterns::tr("Non-unique value found for constraint %1.").arg(formatKeyword(constraint->displayName(m_namePool))));
                 return false;
             }
         }
     }
 
     m_idcKeys.insert(constraint->name(m_namePool), qualifiedNodeSet);
 
     return true;
 }

Properties

◆ m_anyType

XsdComplexType::Ptr QPatternist::XsdValidatingInstanceReader::m_anyType

private

Definition at line 283 of file qxsdvalidatinginstancereader_p.h.

Referenced by anyType().

◆ m_documentUri

QUrl QPatternist::XsdValidatingInstanceReader::m_documentUri

private

Definition at line 282 of file qxsdvalidatinginstancereader_p.h.

Referenced by createXQuery(), and validate().

◆ m_idcKeys

QHash<QXmlName, TargetNode::Set> QPatternist::XsdValidatingInstanceReader::m_idcKeys

private

Definition at line 287 of file qxsdvalidatinginstancereader_p.h.

Referenced by validateKeyIdentityConstraint(), validateKeyRefIdentityConstraint(), and validateUniqueIdentityConstraint().

◆ m_idRefs

QSet<QString> QPatternist::XsdValidatingInstanceReader::m_idRefs

private

Definition at line 286 of file qxsdvalidatinginstancereader_p.h.

Referenced by read(), validateAttribute(), and validateElementSimpleType().

◆ m_idRefsType

SchemaType::Ptr QPatternist::XsdValidatingInstanceReader::m_idRefsType

private

Definition at line 288 of file qxsdvalidatinginstancereader_p.h.

Referenced by validateAttribute(), validateElementSimpleType(), and XsdValidatingInstanceReader().

◆ m_mergedSchemas

MergedSchemas QPatternist::XsdValidatingInstanceReader::m_mergedSchemas

private

Definition at line 273 of file qxsdvalidatinginstancereader_p.h.

Referenced by addSchema().

◆ m_model

XsdValidatedXmlNodeModel::Ptr QPatternist::XsdValidatingInstanceReader::m_model

private

Definition at line 272 of file qxsdvalidatinginstancereader_p.h.

Referenced by addIdIdRefBinding(), read(), selectNodeSets(), validate(), validateAttribute(), validateElementComplexType(), validateElementSimpleType(), and validateKeyIdentityConstraint().

◆ m_namePool

const NamePool::Ptr QPatternist::XsdValidatingInstanceReader::m_namePool

private

◆ m_processedNamespaces

QSet<QString> QPatternist::XsdValidatingInstanceReader::m_processedNamespaces

private

Definition at line 284 of file qxsdvalidatinginstancereader_p.h.

Referenced by validate().

◆ m_processedSchemaLocations

QSet<QString> QPatternist::XsdValidatingInstanceReader::m_processedSchemaLocations

private

Definition at line 285 of file qxsdvalidatinginstancereader_p.h.

Referenced by validate().

◆ m_schema

XsdSchema::Ptr QPatternist::XsdValidatingInstanceReader::m_schema

private

Definition at line 274 of file qxsdvalidatinginstancereader_p.h.

Referenced by addSchema(), attributeByName(), elementByName(), typeByName(), and validate().

◆ m_stateMachines

QStack<XsdStateMachine<XsdTerm::Ptr> > QPatternist::XsdValidatingInstanceReader::m_stateMachines

private

Definition at line 281 of file qxsdvalidatinginstancereader_p.h.

Referenced by createAndPushStateMachine(), read(), and validate().

◆ m_xsiNilName

const QXmlName QPatternist::XsdValidatingInstanceReader::m_xsiNilName

private

Definition at line 276 of file qxsdvalidatinginstancereader_p.h.

Referenced by validate(), validateElement(), validateElementComplexType(), and validateElementSimpleType().

◆ m_xsiNoNamespaceSchemaLocationName

const QXmlName QPatternist::XsdValidatingInstanceReader::m_xsiNoNamespaceSchemaLocationName

private

Definition at line 279 of file qxsdvalidatinginstancereader_p.h.

Referenced by validate(), validateElementComplexType(), and validateElementSimpleType().

◆ m_xsiSchemaLocationName

const QXmlName QPatternist::XsdValidatingInstanceReader::m_xsiSchemaLocationName

private

Definition at line 278 of file qxsdvalidatinginstancereader_p.h.

Referenced by validate(), validateElementComplexType(), and validateElementSimpleType().

◆ m_xsiTypeName

const QXmlName QPatternist::XsdValidatingInstanceReader::m_xsiTypeName

private

Definition at line 277 of file qxsdvalidatinginstancereader_p.h.

Referenced by validate(), validateElement(), validateElementComplexType(), and validateElementSimpleType().

The documentation for this class was generated from the following files:

/src/xmlpatterns/schema/qxsdvalidatinginstancereader_p.h
/src/xmlpatterns/schema/qxsdvalidatinginstancereader.cpp

Properties
XsdComplexType::Ptr	m_anyType

QUrl	m_documentUri

QHash< QXmlName, TargetNode::Set >	m_idcKeys

QSet< QString >	m_idRefs

SchemaType::Ptr	m_idRefsType

MergedSchemas	m_mergedSchemas

XsdValidatedXmlNodeModel::Ptr	m_model

const NamePool::Ptr	m_namePool

QSet< QString >	m_processedNamespaces

QSet< QString >	m_processedSchemaLocations

XsdSchema::Ptr	m_schema

QStack< XsdStateMachine< XsdTerm::Ptr > >	m_stateMachines

const QXmlName	m_xsiNilName

const QXmlName	m_xsiNoNamespaceSchemaLocationName

const QXmlName	m_xsiSchemaLocationName

const QXmlName	m_xsiTypeName

Public Types

Public Functions

Private Types

Private Functions

Properties

Additional Inherited Members

Detailed Description

Typedefs

◆ MergedSchemas

◆ MergedSchemasIterator

◆ Ptr

Constructors and Destructors

◆ XsdValidatingInstanceReader()

Functions

◆ addIdIdRefBinding()

◆ addSchema()

◆ anyType()

◆ attributeByName()

◆ createAndPushStateMachine()

◆ createXQuery()

◆ elementByName()

◆ error()

◆ loadSchema()

◆ qNameAttribute()

◆ read()

◆ selectNodeSets()

◆ typeByName()

◆ validate()

◆ validateAttribute() [1/2]

◆ validateAttribute() [2/2]

◆ validateAttributeWildcard()

◆ validateElement()

◆ validateElementComplexType()

◆ validateElementSimpleType()

◆ validateElementType()

◆ validateIdentityConstraint()

◆ validateKeyIdentityConstraint()

◆ validateKeyRefIdentityConstraint()

◆ validateUniqueIdentityConstraint()

Properties

◆ m_anyType

◆ m_documentUri

◆ m_idcKeys

◆ m_idRefs

◆ m_idRefsType

◆ m_mergedSchemas

◆ m_model

◆ m_namePool

◆ m_processedNamespaces

◆ m_processedSchemaLocations

◆ m_schema

◆ m_stateMachines

◆ m_xsiNilName

◆ m_xsiNoNamespaceSchemaLocationName

◆ m_xsiSchemaLocationName

◆ m_xsiTypeName