QPatternist::XsdSchemaResolver Class Reference

Encapsulates the resolving of type/element references in a schema after parsing has finished. More...

#include <qxsdschemaresolver_p.h>

Inheritance diagram for QPatternist::XsdSchemaResolver:

Classes
class	AlternativeType
class	AlternativeTypeElement
class	AttributeType
class	ComplexBaseType
class	ComplexContentType
class	ElementType
class	KeyReference
class	RedefinedAttributeGroups
class	RedefinedGroups
class	SimpleListType
class	SimpleRestrictionBase
class	SimpleUnionType
class	SubstitutionGroupAffiliation

Public Types
typedef QExplicitlySharedDataPointer< XsdSchemaResolver >	Ptr

Public Functions
void	addAllGroupCheck (const XsdReference::Ptr &reference)
void	addAlternativeType (const XsdAlternative::Ptr &alternative, const QXmlName &typeName, const QSourceLocation &location)
void	addAlternativeType (const XsdAlternative::Ptr &alternative, const XsdElement::Ptr &element)
void	addAttributeType (const XsdAttribute::Ptr &attribute, const QXmlName &typeName, const QSourceLocation &location)
void	addComplexBaseType (const XsdComplexType::Ptr &complexType, const QXmlName &baseName, const QSourceLocation &location, const XsdFacet::Hash &facets=XsdFacet::Hash())
void	addComplexContentType (const XsdComplexType::Ptr &complexType, const XsdParticle::Ptr &content, bool mixed)
void	addComponentLocationHash (const QHash< NamedSchemaComponent::Ptr, QSourceLocation > &hash)
void	addElementType (const XsdElement::Ptr &element, const QXmlName &typeName, const QSourceLocation &location)
void	addEnumerationFacetValue (const AtomicValue::Ptr &facetValue, const NamespaceSupport &namespaceSupport)
void	addKeyReference (const XsdElement::Ptr &element, const XsdIdentityConstraint::Ptr &keyRef, const QXmlName &name, const QSourceLocation &location)
void	addRedefinedAttributeGroups (const XsdAttributeGroup::Ptr &redefinedGroup, const XsdAttributeGroup::Ptr &group)
void	addRedefinedGroups (const XsdModelGroup::Ptr &redefinedGroup, const XsdModelGroup::Ptr &group)
void	addSimpleListType (const XsdSimpleType::Ptr &simpleType, const QXmlName &typeName, const QSourceLocation &location)
void	addSimpleRestrictionBase (const XsdSimpleType::Ptr &simpleType, const QXmlName &baseName, const QSourceLocation &location)
void	addSimpleUnionTypes (const XsdSimpleType::Ptr &simpleType, const QList< QXmlName > &typeNames, const QSourceLocation &location)
void	addSubstitutionGroupAffiliation (const XsdElement::Ptr &element, const QList< QXmlName > &elementName, const QSourceLocation &location)
void	addSubstitutionGroupType (const XsdElement::Ptr &element)
QXmlName	baseTypeNameOfType (const SchemaType::Ptr &type) const
void	copyDataTo (const XsdSchemaResolver::Ptr &other) const
void	removeComplexBaseType (const XsdComplexType::Ptr &type)
void	removeSimpleRestrictionBase (const XsdSimpleType::Ptr &type)
void	resolve ()
void	setDefaultOpenContent (const XsdComplexType::OpenContent::Ptr &openContent, bool appliesToEmpty)
QXmlName	typeNameOfAttribute (const XsdAttribute::Ptr &attribute) const
	XsdSchemaResolver (const QExplicitlySharedDataPointer< XsdSchemaContext > &context, const XsdSchemaParserContext *parserContext)
	~XsdSchemaResolver ()
Public Functions inherited from QSharedData
	QSharedData ()
	Constructs a QSharedData object with a reference count of 0. More...
	QSharedData (const QSharedData &)
	Constructs a QSharedData object with reference count 0. More...

Private Functions
void	checkRedefinedAttributeGroups ()
void	checkRedefinedGroups ()
XsdFacet::Hash	complexTypeFacets (const XsdComplexType::Ptr &complexType) const
AnySimpleType::Ptr	findPrimitiveType (const AnySimpleType::Ptr &type, QSet< AnySimpleType::Ptr > &visitedTypes)
void	resolveAlternativeTypes ()
void	resolveAttributeInheritance ()
void	resolveAttributeInheritance (const XsdComplexType::Ptr &complexType, QSet< XsdComplexType::Ptr > &visitedTypes)
void	resolveAttributeTermReferences ()
XsdAttributeUse::List	resolveAttributeTermReferences (const XsdAttributeUse::List &attributeUses, XsdWildcard::Ptr &wildcard, QSet< QXmlName > visitedAttributeGroups)
void	resolveAttributeTypes ()
void	resolveComplexBaseTypes ()
void	resolveComplexContentComplexTypes ()
void	resolveComplexContentComplexTypes (const XsdComplexType::Ptr &complexType, QSet< XsdComplexType::Ptr > &visitedTypes)
void	resolveElementTypes ()
void	resolveEnumerationFacetValues ()
void	resolveKeyReferences ()
void	resolveSimpleContentComplexTypes ()
void	resolveSimpleContentComplexTypes (const XsdComplexType::Ptr &complexType, QSet< XsdComplexType::Ptr > &visitedTypes)
void	resolveSimpleListType ()
void	resolveSimpleRestrictionBaseTypes ()
void	resolveSimpleRestrictions ()
void	resolveSimpleRestrictions (const XsdSimpleType::Ptr &simpleType, QSet< XsdSimpleType::Ptr > &visitedTypes)
void	resolveSimpleUnionTypes ()
void	resolveSubstitutionGroupAffiliations ()
void	resolveSubstitutionGroups ()
void	resolveTermReference (const XsdParticle::Ptr &particle, QSet< QXmlName > visitedGroups)
void	resolveTermReferences ()
QSourceLocation	sourceLocation (const NamedSchemaComponent::Ptr component) const

Properties
QSet< XsdReference::Ptr >	m_allGroups
QVector< AlternativeTypeElement >	m_alternativeTypeElements
QVector< AlternativeType >	m_alternativeTypes
QVector< AttributeType >	m_attributeTypes
QExplicitlySharedDataPointer< XsdSchemaChecker >	m_checker
QVector< ComplexBaseType >	m_complexBaseTypes
QVector< ComplexContentType >	m_complexContentTypes
QHash< NamedSchemaComponent::Ptr, QSourceLocation >	m_componentLocationHash
QExplicitlySharedDataPointer< XsdSchemaContext >	m_context
XsdComplexType::OpenContent::Ptr	m_defaultOpenContent
bool	m_defaultOpenContentAppliesToEmpty
QVector< ElementType >	m_elementTypes
QHash< AtomicValue::Ptr, NamespaceSupport >	m_enumerationFacetValues
QVector< KeyReference >	m_keyReferences
NamePool::Ptr	m_namePool
SchemaType::List	m_predefinedSchemaTypes
QVector< RedefinedAttributeGroups >	m_redefinedAttributeGroups
QVector< RedefinedGroups >	m_redefinedGroups
XsdSchema::Ptr	m_schema
QVector< SimpleListType >	m_simpleListTypes
QVector< SimpleRestrictionBase >	m_simpleRestrictionBases
QVector< SimpleUnionType >	m_simpleUnionTypes
QVector< SubstitutionGroupAffiliation >	m_substitutionGroupAffiliations
QVector< XsdElement::Ptr >	m_substitutionGroupTypes

Additional Inherited Members
Public Variables inherited from QSharedData
QAtomicInt	ref

Detailed Description

Encapsulates the resolving of type/element references in a schema after parsing has finished.

This class collects task for resolving types or element references. After the parsing has finished, one can start the resolve process by calling resolve().

Author

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

Definition at line 89 of file qxsdschemaresolver_p.h.

Typedefs

Ptr

typedef QExplicitlySharedDataPointer<XsdSchemaResolver> QPatternist::XsdSchemaResolver::Ptr

Definition at line 92 of file qxsdschemaresolver_p.h.

Constructors and Destructors

XsdSchemaResolver()

XsdSchemaResolver::XsdSchemaResolver	(	const QExplicitlySharedDataPointer< XsdSchemaContext > &	context,
		const XsdSchemaParserContext *	parserContext
	)

Creates a new schema resolver.

Parameters

context	The schema context used for error reporting etc..
parserContext	The schema parser context where all objects to resolve belong to.

Definition at line 59 of file qxsdschemaresolver.cpp.

    : m_context(context)
    , m_checker(parserContext->checker())
    , m_namePool(parserContext->namePool())
    , m_schema(parserContext->schema())
{
    m_keyReferences.reserve(20);
    m_simpleRestrictionBases.reserve(20);
    m_simpleListTypes.reserve(20);
    m_simpleUnionTypes.reserve(20);
    m_elementTypes.reserve(20);
    m_complexBaseTypes.reserve(20);
    m_attributeTypes.reserve(20);
    m_alternativeTypes.reserve(20);
    m_alternativeTypeElements.reserve(20);
    m_substitutionGroupAffiliations.reserve(20);

    m_predefinedSchemaTypes = m_context->schemaTypeFactory()->types().values();
}

~XsdSchemaResolver()

XsdSchemaResolver::~XsdSchemaResolver

(

)

Destroys the schema resolver.

Definition at line 79 of file qxsdschemaresolver.cpp.

{
}

Functions

addAllGroupCheck()

void XsdSchemaResolver::addAllGroupCheck

(

const XsdReference::Ptr &

reference

)

Adds a check for nested all groups.

Definition at line 295 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseChoice(), QPatternist::XsdSchemaParser::parseLocalChoice(), QPatternist::XsdSchemaParser::parseLocalSequence(), and QPatternist::XsdSchemaParser::parseSequence().

{
    m_allGroups.insert(reference);
}

addAlternativeType() [1/2]

void XsdSchemaResolver::addAlternativeType	(	const XsdAlternative::Ptr &	alternative,
		const QXmlName &	typeName,
		const QSourceLocation &	location
	)

Adds a resolve task for the type of an alternative.

The resolver will set the type of the alternative to the type named by typeName.

Definition at line 233 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseAlternative(), QPatternist::XsdSchemaParser::parseGlobalElement(), and QPatternist::XsdSchemaParser::parseLocalElement().

{
    AlternativeType item;
    item.alternative = alternative;
    item.typeName = typeName;
    item.location = location;

    m_alternativeTypes.append(item);
}

addAlternativeType() [2/2]

void XsdSchemaResolver::addAlternativeType	(	const XsdAlternative::Ptr &	alternative,
		const XsdElement::Ptr &	element
	)

Adds a resolve task for the type of an alternative.

The resolver will set the type of the alternative to the type of the element after the type of the element has been resolved.

Definition at line 243 of file qxsdschemaresolver.cpp.

{
    AlternativeTypeElement item;
    item.alternative = alternative;
    item.element = element;

    m_alternativeTypeElements.append(item);
}

addAttributeType()

void XsdSchemaResolver::addAttributeType	(	const XsdAttribute::Ptr &	attribute,
		const QXmlName &	typeName,
		const QSourceLocation &	location
	)

Adds a resolve task for the type of an attribute.

The resolver will set the type of the attribute to the type named by typeName.

Definition at line 223 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseGlobalAttribute(), and QPatternist::XsdSchemaParser::parseLocalAttribute().

{
    AttributeType item;
    item.attribute = attribute;
    item.typeName = typeName;
    item.location = location;

    m_attributeTypes.append(item);
}

addComplexBaseType()

void XsdSchemaResolver::addComplexBaseType	(	const XsdComplexType::Ptr &	complexType,
		const QXmlName &	baseName,
		const QSourceLocation &	location,
		const XsdFacet::Hash &	facets = XsdFacet::Hash()
	)

Adds a resolve task for the base type of a complex type.

The resolver will set the base type of complexType to the type named by baseName.

Definition at line 193 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseComplexContentExtension(), QPatternist::XsdSchemaParser::parseComplexContentRestriction(), QPatternist::XsdSchemaParser::parseSimpleContentExtension(), and QPatternist::XsdSchemaParser::parseSimpleContentRestriction().

{
    ComplexBaseType item;
    item.complexType = complexType;
    item.baseName = baseName;
    item.location = location;
    item.facets = facets;

    m_complexBaseTypes.append(item);
}

addComplexContentType()

void XsdSchemaResolver::addComplexContentType	(	const XsdComplexType::Ptr &	complexType,
		const XsdParticle::Ptr &	content,
		bool	mixed
	)

Adds a resolve task for the content type of a complex type.

The resolver will set the content type properties for complexType based on the given explicit content and effective mixed value.

Definition at line 214 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::resolveComplexContentType().

{
    ComplexContentType item;
    item.complexType = complexType;
    item.explicitContent = content;
    item.effectiveMixed = mixed;
    m_complexContentTypes.append(item);
}

addComponentLocationHash()

void XsdSchemaResolver::addComponentLocationHash

(

const QHash< NamedSchemaComponent::Ptr, QSourceLocation > &

hash

)

Adds the component location hash, so the resolver is able to report meaning full error messages.

Definition at line 267 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parse().

{
    m_componentLocationHash.unite(hash);
}

addElementType()

void XsdSchemaResolver::addElementType	(	const XsdElement::Ptr &	element,
		const QXmlName &	typeName,
		const QSourceLocation &	location
	)

Adds a resolve task for the type of an element.

The resolver will set the type of the element to the type named by typeName.

Definition at line 183 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseGlobalElement(), and QPatternist::XsdSchemaParser::parseLocalElement().

{
    ElementType item;
    item.element = element;
    item.typeName = typeName;
    item.location = location;

    m_elementTypes.append(item);
}

addEnumerationFacetValue()

void XsdSchemaResolver::addEnumerationFacetValue	(	const AtomicValue::Ptr &	facetValue,
		const NamespaceSupport &	namespaceSupport
	)

Add a resolve task for enumeration facet values.

In case the enumeration is of type QName or NOTATION, we have to resolve the QName later, so we store the namespace bindings together with the facet value here and resolve it as soon as we have all type information available.

Definition at line 272 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseEnumerationFacet().

{
    m_enumerationFacetValues.insert(facetValue, namespaceSupport);
}

addKeyReference()

void XsdSchemaResolver::addKeyReference	(	const XsdElement::Ptr &	element,
		const XsdIdentityConstraint::Ptr &	keyRef,
		const QXmlName &	name,
		const QSourceLocation &	location
	)

Adds a resolve task for key references.

The resolver will try to set the referencedKey property of keyRef to the key or unique object of element that has the given name.

Definition at line 132 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseKeyRef().

{
    KeyReference item;
    item.element = element;
    item.keyRef = keyRef;
    item.reference = reference;
    item.location = location;

    m_keyReferences.append(item);
}

addRedefinedAttributeGroups()

void XsdSchemaResolver::addRedefinedAttributeGroups	(	const XsdAttributeGroup::Ptr &	redefinedGroup,
		const XsdAttributeGroup::Ptr &	group
	)

Add a check job for redefined attribute groups.

When an attribute group is redefined, we have to check whether the redefined group is a valid restriction of the group it redefines. As we need all type information for that, we keep them here for later checking.

Definition at line 286 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseRedefine().

{
    RedefinedAttributeGroups item;
    item.redefinedGroup = redefinedGroup;
    item.group = group;

    m_redefinedAttributeGroups.append(item);
}

addRedefinedGroups()

void XsdSchemaResolver::addRedefinedGroups	(	const XsdModelGroup::Ptr &	redefinedGroup,
		const XsdModelGroup::Ptr &	group
	)

Add a check job for redefined groups.

When an element group is redefined, we have to check whether the redefined group is a valid restriction of the group it redefines. As we need all type information for that, we keep them here for later checking.

Definition at line 277 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseRedefine().

{
    RedefinedGroups item;
    item.redefinedGroup = redefinedGroup;
    item.group = group;

    m_redefinedGroups.append(item);
}

addSimpleListType()

void XsdSchemaResolver::addSimpleListType	(	const XsdSimpleType::Ptr &	simpleType,
		const QXmlName &	typeName,
		const QSourceLocation &	location
	)

Adds a resolve task for the list type of a simple type.

The resolver will set the itemType property of simpleType to the type named by typeName.

Definition at line 163 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseList().

{
    SimpleListType item;
    item.simpleType = simpleType;
    item.typeName = typeName;
    item.location = location;

    m_simpleListTypes.append(item);
}

addSimpleRestrictionBase()

void XsdSchemaResolver::addSimpleRestrictionBase	(	const XsdSimpleType::Ptr &	simpleType,
		const QXmlName &	baseName,
		const QSourceLocation &	location
	)

Adds a resolve task for the base type of restriction of a simple type.

The resolver will set the base type of simpleType to the type named by baseName.

Definition at line 143 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseSimpleRestriction().

{
    SimpleRestrictionBase item;
    item.simpleType = simpleType;
    item.baseName = baseName;
    item.location = location;

    m_simpleRestrictionBases.append(item);
}

addSimpleUnionTypes()

void XsdSchemaResolver::addSimpleUnionTypes	(	const XsdSimpleType::Ptr &	simpleType,
		const QList< QXmlName > &	typeNames,
		const QSourceLocation &	location
	)

Adds a resolve task for the member types of a simple type.

The resolver will set the memberTypes property of simpleType to the types named by typeNames.

Definition at line 173 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseUnion().

{
    SimpleUnionType item;
    item.simpleType = simpleType;
    item.typeNames = typeNames;
    item.location = location;

    m_simpleUnionTypes.append(item);
}

addSubstitutionGroupAffiliation()

void XsdSchemaResolver::addSubstitutionGroupAffiliation	(	const XsdElement::Ptr &	element,
		const QList< QXmlName > &	elementName,
		const QSourceLocation &	location
	)

Adds a resolve task for the substituion group affiliations of an element.

The resolver will set the substitution group affiliations of the element to the top-level element named by elementNames.

Definition at line 252 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseGlobalElement().

{
    SubstitutionGroupAffiliation item;
    item.element = element;
    item.elementNames = elementNames;
    item.location = location;

    m_substitutionGroupAffiliations.append(item);
}

addSubstitutionGroupType()

void XsdSchemaResolver::addSubstitutionGroupType

(

const XsdElement::Ptr &

element

)

Adds a resolve task for an element that has no type specified, only a substitution group affiliation.

The resolver will set the type of the substitution group affiliation as type for the element.

Definition at line 262 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseGlobalElement().

{
    m_substitutionGroupTypes.append(element);
}

baseTypeNameOfType()

QXmlName XsdSchemaResolver::baseTypeNameOfType

(

const SchemaType::Ptr &

type

)

const

Returns the to resolve base type name for the given type.

Note

That functionality is only used by the redefine algorithm in the XsdSchemaParser.

Definition at line 316 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseRedefine().

{
    for (int i = 0; i < m_simpleRestrictionBases.count(); ++i) {
        if (m_simpleRestrictionBases.at(i).simpleType == type)
            return m_simpleRestrictionBases.at(i).baseName;
    }

    for (int i = 0; i < m_complexBaseTypes.count(); ++i) {
        if (m_complexBaseTypes.at(i).complexType == type)
            return m_complexBaseTypes.at(i).baseName;
    }

    return QXmlName();
}

checkRedefinedAttributeGroups()

void XsdSchemaResolver::checkRedefinedAttributeGroups ( )

private

Checks the redefined attribute groups.

Definition at line 1685 of file qxsdschemaresolver.cpp.

Referenced by resolve().

{
    for (int i = 0; i < m_redefinedAttributeGroups.count(); ++i) {
        const RedefinedAttributeGroups item = m_redefinedAttributeGroups.at(i);

        QString errorMsg;
        if (!XsdSchemaHelper::isValidAttributeGroupRestriction(item.redefinedGroup, item.group, m_context, errorMsg)) {
            m_context->error(QtXmlPatterns::tr("%1 element %2 is not a valid restriction of the %3 element it redefines: %4.")
                                              .arg(formatElement("attributeGroup"))
                                              .arg(formatData(item.redefinedGroup->displayName(m_namePool)))
                                              .arg(formatElement("attributeGroup"))
                                              .arg(errorMsg),
                             XsdSchemaContext::XSDError, sourceLocation(item.redefinedGroup));
            return;
        }
    }
}

checkRedefinedGroups()

void XsdSchemaResolver::checkRedefinedGroups ( )

private

Checks the redefined groups.

Definition at line 1660 of file qxsdschemaresolver.cpp.

Referenced by resolve().

{
    for (int i = 0; i < m_redefinedGroups.count(); ++i) {
        const RedefinedGroups item = m_redefinedGroups.at(i);

        // create dummy particles...
        const XsdParticle::Ptr redefinedParticle(new XsdParticle());
        redefinedParticle->setTerm(item.redefinedGroup);
        const XsdParticle::Ptr particle(new XsdParticle());
        particle->setTerm(item.group);

        // so that we can pass them to XsdParticleChecker::subsumes()
        QString errorMsg;
        if (!XsdParticleChecker::subsumes(particle, redefinedParticle, m_context, errorMsg)) {
            m_context->error(QtXmlPatterns::tr("%1 element %2 is not a valid restriction of the %3 element it redefines: %4.")
                                              .arg(formatElement("group"))
                                              .arg(formatData(item.redefinedGroup->displayName(m_namePool)))
                                              .arg(formatElement("group"))
                                              .arg(errorMsg),
                             XsdSchemaContext::XSDError, sourceLocation(item.redefinedGroup));
            return;
        }
    }
}

complexTypeFacets()

XsdFacet::Hash XsdSchemaResolver::complexTypeFacets ( const XsdComplexType::Ptr &  complexType ) const

private

Returns the facets that are marked for the given complex type with a simple type restriction.

Definition at line 1650 of file qxsdschemaresolver.cpp.

Referenced by resolveSimpleContentComplexTypes().

{
    for (int i = 0; i < m_complexBaseTypes.count(); ++i) {
        if (m_complexBaseTypes.at(i).complexType == complexType)
            return m_complexBaseTypes.at(i).facets;
    }

    return XsdFacet::Hash();
}

copyDataTo()

void XsdSchemaResolver::copyDataTo

(

const XsdSchemaResolver::Ptr &

other

)

const

Copies the data to resolve to an other resolver.

Note

That functionality is only used by the redefine algorithm in the XsdSchemaParser.

Definition at line 300 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseRedefine().

{
    other->m_keyReferences << m_keyReferences;
    other->m_simpleRestrictionBases << m_simpleRestrictionBases;
    other->m_simpleListTypes << m_simpleListTypes;
    other->m_simpleUnionTypes << m_simpleUnionTypes;
    other->m_elementTypes << m_elementTypes;
    other->m_complexBaseTypes << m_complexBaseTypes;
    other->m_complexContentTypes << m_complexContentTypes;
    other->m_attributeTypes << m_attributeTypes;
    other->m_alternativeTypes << m_alternativeTypes;
    other->m_alternativeTypeElements << m_alternativeTypeElements;
    other->m_substitutionGroupAffiliations << m_substitutionGroupAffiliations;
    other->m_substitutionGroupTypes << m_substitutionGroupTypes;
}

findPrimitiveType()

AnySimpleType::Ptr XsdSchemaResolver::findPrimitiveType ( const AnySimpleType::Ptr &  type, QSet< AnySimpleType::Ptr > &  visitedTypes  )

private

Finds the primitive type for the given simple type.

The type is found by walking up the inheritance tree, until one of the builtin primitive type definitions is reached.

Definition at line 1703 of file qxsdschemaresolver.cpp.

Referenced by resolveSimpleContentComplexTypes(), and resolveSimpleRestrictions().

{
    if (visitedTypes.contains(type)) {
        // found invalid circular reference...
        return AnySimpleType::Ptr();
    } else {
        visitedTypes.insert(type);
    }

    const QXmlName typeName = type->name(m_namePool);
    if (typeName == BuiltinTypes::xsString->name(m_namePool) ||
        typeName == BuiltinTypes::xsBoolean->name(m_namePool) ||
        typeName == BuiltinTypes::xsFloat->name(m_namePool) ||
        typeName == BuiltinTypes::xsDouble->name(m_namePool) ||
        typeName == BuiltinTypes::xsDecimal->name(m_namePool) ||
        typeName == BuiltinTypes::xsDuration->name(m_namePool) ||
        typeName == BuiltinTypes::xsDateTime->name(m_namePool) ||
        typeName == BuiltinTypes::xsTime->name(m_namePool) ||
        typeName == BuiltinTypes::xsDate->name(m_namePool) ||
        typeName == BuiltinTypes::xsGYearMonth->name(m_namePool) ||
        typeName == BuiltinTypes::xsGYear->name(m_namePool) ||
        typeName == BuiltinTypes::xsGMonthDay->name(m_namePool) ||
        typeName == BuiltinTypes::xsGDay->name(m_namePool) ||
        typeName == BuiltinTypes::xsGMonth->name(m_namePool) ||
        typeName == BuiltinTypes::xsHexBinary->name(m_namePool) ||
        typeName == BuiltinTypes::xsBase64Binary->name(m_namePool) ||
        typeName == BuiltinTypes::xsAnyURI->name(m_namePool) ||
        typeName == BuiltinTypes::xsQName->name(m_namePool) ||
        typeName == BuiltinTypes::xsNOTATION->name(m_namePool) ||
        typeName == BuiltinTypes::xsAnySimpleType->name(m_namePool))
        return type;
    else {
        if (type->wxsSuperType())
            return findPrimitiveType(type->wxsSuperType(), visitedTypes);
        else {
            return AnySimpleType::Ptr();
        }
    }
}

removeComplexBaseType()

void XsdSchemaResolver::removeComplexBaseType

(

const XsdComplexType::Ptr &

type

)

Removes the resolve task for the base type of the complex type.

Definition at line 204 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseRedefine().

{
    for (int i = 0; i < m_complexBaseTypes.count(); ++i) {
        if (m_complexBaseTypes.at(i).complexType == type) {
            m_complexBaseTypes.remove(i);
            break;
        }
    }
}

removeSimpleRestrictionBase()

void XsdSchemaResolver::removeSimpleRestrictionBase

(

const XsdSimpleType::Ptr &

type

)

Removes the resolve task for the base type of restriction of the simple type.

Definition at line 153 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parseRedefine().

{
    for (int i = 0; i < m_simpleRestrictionBases.count(); ++i) {
        if (m_simpleRestrictionBases.at(i).simpleType == type) {
            m_simpleRestrictionBases.remove(i);
            break;
        }
    }
}

resolve()

void XsdSchemaResolver::resolve

(

)

Starts the resolve process.

Definition at line 83 of file qxsdschemaresolver.cpp.

{
    m_checker->addComponentLocationHash(m_componentLocationHash);

    // resolve the base types for all types
    resolveSimpleRestrictionBaseTypes();
    resolveComplexBaseTypes();

    // do the basic checks which depend on having a base type available
    m_checker->basicCheck();

    // resolve further types that only map a type name to a type object
    resolveSimpleListType();
    resolveSimpleUnionTypes();
    resolveElementTypes();
    resolveAttributeTypes();
    resolveAlternativeTypes();

    // resolve objects that do not need information about inheritance
    resolveKeyReferences();
    resolveSubstitutionGroupAffiliations();

    // resolve objects that do need information about inheritance
    resolveSimpleRestrictions();
    resolveSimpleContentComplexTypes();

    // resolve objects which replace place holders
    resolveTermReferences();
    resolveAttributeTermReferences();

    // resolve additional objects that do need information about inheritance
    resolveAttributeInheritance();
    resolveComplexContentComplexTypes();
    resolveSubstitutionGroups();

    resolveEnumerationFacetValues();

    checkRedefinedGroups();
    checkRedefinedAttributeGroups();

    // check the constraining facets before we resolve them
    m_checker->checkConstrainingFacets();

    // add it again, as we may have added new components in the meantime
    m_checker->addComponentLocationHash(m_componentLocationHash);

    m_checker->check();
}

resolveAlternativeTypes()

void XsdSchemaResolver::resolveAlternativeTypes ( )

private

Resolves alternative types.

Definition at line 975 of file qxsdschemaresolver.cpp.

Referenced by resolve().

{
    for (int i = 0; i < m_alternativeTypes.count(); ++i) {
        const AlternativeType item = m_alternativeTypes.at(i);

        SchemaType::Ptr type = m_schema->type(item.typeName);
        if (!type) {
            // maybe it's a basic type...
            type = m_context->schemaTypeFactory()->createSchemaType(item.typeName);
            if (!type) {
                m_context->error(QtXmlPatterns::tr("Type %1 of %2 element cannot be resolved.")
                                                  .arg(formatType(m_namePool, item.typeName))
                                                  .arg(formatElement("alternative")),
                                 XsdSchemaContext::XSDError, item.location);
                return;
            }
        }

        item.alternative->setType(type);
    }

    for (int i = 0; i < m_alternativeTypeElements.count(); ++i) {
        const AlternativeTypeElement item = m_alternativeTypeElements.at(i);
        item.alternative->setType(item.element->type());
    }
}

resolveAttributeInheritance() [1/2]

void XsdSchemaResolver::resolveAttributeInheritance ( )

private

Resolves the attribute inheritance of complex types.

Note

This method must be called after all base types have been resolved.

Definition at line 1394 of file qxsdschemaresolver.cpp.

Referenced by resolve(), and resolveAttributeInheritance().

{
    // collect the global and anonymous complex types
    SchemaType::List types = m_schema->types();
    types << m_schema->anonymousTypes();

    QSet<XsdComplexType::Ptr> visitedTypes;
    for (int i = 0; i < types.count(); ++i) {
        if (!(types.at(i)->isComplexType()) || !types.at(i)->isDefinedBySchema())
            continue;

        const XsdComplexType::Ptr complexType = types.at(i);

        resolveAttributeInheritance(complexType, visitedTypes);
    }
}

resolveAttributeInheritance() [2/2]

void XsdSchemaResolver::resolveAttributeInheritance ( const XsdComplexType::Ptr &  complexType, QSet< XsdComplexType::Ptr > &  visitedTypes  )

private

Resolves the attribute inheritance of the given complex types.

Parameters

complexType	The complex type to resolve.
visitedTypes	A set of already resolved types, used for termination of recursion.

Note

This method must be called after all base types have been resolved.

Definition at line 1440 of file qxsdschemaresolver.cpp.

{
    if (visitedTypes.contains(complexType))
        return;
    else
        visitedTypes.insert(complexType);

    const SchemaType::Ptr baseType = complexType->wxsSuperType();
    Q_ASSERT(baseType);

    if (!(baseType->isComplexType()) || !baseType->isDefinedBySchema())
        return;

    const XsdComplexType::Ptr complexBaseType = baseType;

    resolveAttributeInheritance(complexBaseType, visitedTypes);

    // @see http://www.w3.org/TR/xmlschema11-1/#dcl.ctd.attuses

    // 1 and 2 (the attribute groups have been resolved here already)
    const XsdAttributeUse::List uses = complexBaseType->attributeUses();

    if (complexType->derivationMethod() == XsdComplexType::DerivationRestriction) { // 3.2
        const XsdAttributeUse::List currentUses = complexType->attributeUses();

        // 3.2.1 and 3.2.2 As we also keep the prohibited attributes as objects, the algorithm below
        // handles both the same way

        // add only these attribute uses of the base type that match one of the following criteria:
        //   1: there is no attribute use with the same name in type
        //   2: there is no attribute with the same name marked as prohibited in type
        for (int j = 0; j < uses.count(); ++j) {
            const XsdAttributeUse::Ptr use = uses.at(j);
            bool found = false;
            for (int k = 0; k < currentUses.count(); ++k) {
                if (use->attribute()->name(m_namePool) == currentUses.at(k)->attribute()->name(m_namePool)) {
                    found = true;

                    // check if prohibited usage is violated
                    if ((use->useType() == XsdAttributeUse::ProhibitedUse) && (currentUses.at(k)->useType() != XsdAttributeUse::ProhibitedUse)) {
                        m_context->error(QtXmlPatterns::tr("%1 attribute in %2 must have %3 use like in base type %4.")
                                                            .arg(formatAttribute(use->attribute()->displayName(m_namePool)))
                                                            .arg(formatType(m_namePool, complexType))
                                                            .arg(formatData("prohibited"))
                                                            .arg(formatType(m_namePool, complexBaseType)),
                                                             XsdSchemaContext::XSDError, sourceLocation(complexType));
                        return;
                    }

                    break;
                }
            }

            if (!found && uses.at(j)->useType() != XsdAttributeUse::ProhibitedUse) {
                complexType->addAttributeUse(uses.at(j));
            }
        }
    } else if (complexType->derivationMethod() == XsdComplexType::DerivationExtension) { // 3.1
        QHash<QXmlName, XsdAttributeUse::Ptr> availableUses;

        // fill hash with attribute uses of current type for faster lookup
        {
            const XsdAttributeUse::List attributeUses = complexType->attributeUses();

            for (int i = 0; i < attributeUses.count(); ++i) {
                availableUses.insert(attributeUses.at(i)->attribute()->name(m_namePool), attributeUses.at(i));
            }
        }

        // just add the attribute uses of the base type
        for (int i = 0; i < uses.count(); ++i) {
            const XsdAttributeUse::Ptr currentAttributeUse = uses.at(i);

            // if the base type defines the attribute as prohibited but we override it in current type, then don't copy the prohibited attribute use
            if ((currentAttributeUse->useType() == XsdAttributeUse::ProhibitedUse) && availableUses.contains(currentAttributeUse->attribute()->name(m_namePool)))
                continue;

            complexType->addAttributeUse(uses.at(i));
        }
    }

    // handle attribute wildcards: @see http://www.w3.org/TR/xmlschema11-1/#dcl.ctd.anyatt

    // 1
    const XsdWildcard::Ptr completeWildcard(complexType->attributeWildcard());

    if (complexType->derivationMethod() == XsdComplexType::DerivationRestriction) {
        if (complexType->wxsSuperType()->isComplexType() && complexType->wxsSuperType()->isDefinedBySchema()) {
            const XsdComplexType::Ptr complexBaseType(complexType->wxsSuperType());
            if (complexType->attributeWildcard()) {
                if (complexBaseType->attributeWildcard()) {
                    if (!isValidWildcardRestriction(complexType->attributeWildcard(), complexBaseType->attributeWildcard())) {
                        m_context->error(QtXmlPatterns::tr("Attribute wildcard of %1 is not a valid restriction of attribute wildcard of base type %2.")
                                                            .arg(formatType(m_namePool, complexType))
                                                            .arg(formatType(m_namePool, complexBaseType)),
                                                             XsdSchemaContext::XSDError, sourceLocation(complexType));
                        return;
                    }
                } else {
                    m_context->error(QtXmlPatterns::tr("%1 has attribute wildcard but its base type %2 has not.")
                                                        .arg(formatType(m_namePool, complexType))
                                                        .arg(formatType(m_namePool, complexBaseType)),
                                                         XsdSchemaContext::XSDError, sourceLocation(complexType));
                    return;
                }
            }
        }
        complexType->setAttributeWildcard(completeWildcard); // 2.1
    } else if (complexType->derivationMethod() == XsdComplexType::DerivationExtension) {
        XsdWildcard::Ptr baseWildcard; // 2.2.1
        if (complexType->wxsSuperType()->isComplexType() && complexType->wxsSuperType()->isDefinedBySchema())
            baseWildcard = XsdComplexType::Ptr(complexType->wxsSuperType())->attributeWildcard(); // 2.2.1.1
        else
            baseWildcard = XsdWildcard::Ptr(); // 2.2.1.2

        if (!baseWildcard) {
            complexType->setAttributeWildcard(completeWildcard); // 2.2.2.1
        } else if (!completeWildcard) {
            complexType->setAttributeWildcard(baseWildcard); // 2.2.2.2
        } else {
            XsdWildcard::Ptr unionWildcard = XsdSchemaHelper::wildcardUnion(completeWildcard, baseWildcard);
            if (unionWildcard) {
                unionWildcard->setProcessContents(completeWildcard->processContents());
                complexType->setAttributeWildcard(unionWildcard); // 2.2.2.3
            } else {
                m_context->error(QtXmlPatterns::tr("Union of attribute wildcard of type %1 and attribute wildcard of its base type %2 is not expressible.")
                                                    .arg(formatType(m_namePool, complexType))
                                                    .arg(formatType(m_namePool, complexBaseType)),
                                                     XsdSchemaContext::XSDError, sourceLocation(complexType));
                return;
            }
        }
    }
}

resolveAttributeTermReferences() [1/2]

void XsdSchemaResolver::resolveAttributeTermReferences ( )

private

Resolves all XsdAttributeReferences in the schema by their corresponding XsdAttributeUse objects.

Definition at line 1254 of file qxsdschemaresolver.cpp.

Referenced by resolve(), and resolveAttributeTermReferences().

{
    // first all global attribute groups
    const XsdAttributeGroup::List attributeGroups = m_schema->attributeGroups();
    for (int i = 0; i < attributeGroups.count(); ++i) {
        XsdWildcard::Ptr wildcard = attributeGroups.at(i)->wildcard();
        const XsdAttributeUse::List uses = resolveAttributeTermReferences(attributeGroups.at(i)->attributeUses(), wildcard, QSet<QXmlName>());
        attributeGroups.at(i)->setAttributeUses(uses);
        attributeGroups.at(i)->setWildcard(wildcard);
    }

    // then the global complex types
    const SchemaType::List types = m_schema->types();
    for (int i = 0; i < types.count(); ++i) {
        if (!(types.at(i)->isComplexType()) || !types.at(i)->isDefinedBySchema())
            continue;

        const XsdComplexType::Ptr complexType = types.at(i);
        const XsdAttributeUse::List attributeUses = complexType->attributeUses();

        XsdWildcard::Ptr wildcard = complexType->attributeWildcard();
        const XsdAttributeUse::List uses = resolveAttributeTermReferences(attributeUses, wildcard, QSet<QXmlName>());
        complexType->setAttributeUses(uses);
        complexType->setAttributeWildcard(wildcard);
    }

    // and afterwards all anonymous complex types
    const SchemaType::List anonymousTypes = m_schema->anonymousTypes();
    for (int i = 0; i < anonymousTypes.count(); ++i) {
        if (!(anonymousTypes.at(i)->isComplexType()) || !anonymousTypes.at(i)->isDefinedBySchema())
            continue;

        const XsdComplexType::Ptr complexType = anonymousTypes.at(i);
        const XsdAttributeUse::List attributeUses = complexType->attributeUses();

        XsdWildcard::Ptr wildcard = complexType->attributeWildcard();
        const XsdAttributeUse::List uses = resolveAttributeTermReferences(attributeUses, wildcard, QSet<QXmlName>());
        complexType->setAttributeUses(uses);
        complexType->setAttributeWildcard(wildcard);
    }
}

resolveAttributeTermReferences() [2/2]

XsdAttributeUse::List XsdSchemaResolver::resolveAttributeTermReferences ( const XsdAttributeUse::List &  attributeUses, XsdWildcard::Ptr &  wildcard, QSet< QXmlName >  visitedAttributeGroups  )

private

Resolves all XsdAttributeReferences in the list of attributeUses by their corresponding XsdAttributeUse objects.

Definition at line 1296 of file qxsdschemaresolver.cpp.

{
    XsdAttributeUse::List resolvedAttributeUses;

    for (int i = 0; i < attributeUses.count(); ++i) {
        const XsdAttributeUse::Ptr attributeUse = attributeUses.at(i);
        if (attributeUse->isAttributeUse()) {
            // it is a real attribute use, so no need to resolve it
            resolvedAttributeUses.append(attributeUse);
        } else if (attributeUse->isReference()) {
            // it is just a reference, so resolve it to the real attribute use

            const XsdAttributeReference::Ptr reference = attributeUse;
            if (reference->type() == XsdAttributeReference::AttributeUse) {

                // lookup the real attribute
                const XsdAttribute::Ptr attribute = m_schema->attribute(reference->referenceName());
                if (!attribute) {
                    m_context->error(QtXmlPatterns::tr("Reference %1 of %2 element cannot be resolved.")
                                                      .arg(formatKeyword(m_namePool, reference->referenceName()))
                                                      .arg(formatElement("attribute")),
                                     XsdSchemaContext::XSDError, reference->sourceLocation());
                    return XsdAttributeUse::List();
                }

                // if both, reference and definition have a fixed or default value set, then they must be equal
                if (attribute->valueConstraint() && attributeUse->valueConstraint()) {
                    if (attribute->valueConstraint()->value() != attributeUse->valueConstraint()->value()) {
                        m_context->error(QtXmlPatterns::tr("%1 or %2 attribute of reference %3 does not match with the attribute declaration %4.")
                                                          .arg(formatAttribute("fixed"))
                                                          .arg(formatAttribute("default"))
                                                          .arg(formatKeyword(m_namePool, reference->referenceName()))
                                                          .arg(formatKeyword(attribute->displayName(m_namePool))),
                                         XsdSchemaContext::XSDError, reference->sourceLocation());
                        return XsdAttributeUse::List();
                    }
                }

                attributeUse->setAttribute(attribute);
                if (!attributeUse->valueConstraint() && attribute->valueConstraint())
                    attributeUse->setValueConstraint(XsdAttributeUse::ValueConstraint::fromAttributeValueConstraint(attribute->valueConstraint()));

                resolvedAttributeUses.append(attributeUse);
            } else if (reference->type() == XsdAttributeReference::AttributeGroup) {
                const XsdAttributeGroup::Ptr attributeGroup = m_schema->attributeGroup(reference->referenceName());
                if (!attributeGroup) {
                    m_context->error(QtXmlPatterns::tr("Reference %1 of %2 element cannot be resolved.")
                                                      .arg(formatKeyword(m_namePool, reference->referenceName()))
                                                      .arg(formatElement("attributeGroup")),
                                     XsdSchemaContext::XSDError, reference->sourceLocation());
                    return XsdAttributeUse::List();
                }
                if (visitedAttributeGroups.contains(attributeGroup->name(m_namePool))) {
                    m_context->error(QtXmlPatterns::tr("Attribute group %1 has circular reference.").arg(formatKeyword(m_namePool, reference->referenceName())),
                                     XsdSchemaContext::XSDError, reference->sourceLocation());
                    return XsdAttributeUse::List();
                } else {
                    visitedAttributeGroups.insert(attributeGroup->name(m_namePool));
                }

                // resolve attribute wildcards as defined in http://www.w3.org/TR/xmlschema11-1/#declare-attributeGroup-wildcard
                XsdWildcard::Ptr childWildcard;
                resolvedAttributeUses << resolveAttributeTermReferences(attributeGroup->attributeUses(), childWildcard, visitedAttributeGroups);
                if (!childWildcard) {
                    if (attributeGroup->wildcard()) {
                        if (wildcard) {
                            const XsdWildcard::ProcessContents contents = wildcard->processContents();
                            wildcard = XsdSchemaHelper::wildcardIntersection(wildcard, attributeGroup->wildcard());
                            wildcard->setProcessContents(contents);
                        } else {
                            wildcard = attributeGroup->wildcard();
                        }
                    }
                } else {
                    XsdWildcard::Ptr newWildcard;
                    if (attributeGroup->wildcard()) {
                        const XsdWildcard::ProcessContents contents = attributeGroup->wildcard()->processContents();
                        newWildcard = XsdSchemaHelper::wildcardIntersection(attributeGroup->wildcard(), childWildcard);
                        newWildcard->setProcessContents(contents);
                    } else {
                        newWildcard = childWildcard;
                    }

                    if (wildcard) {
                        const XsdWildcard::ProcessContents contents = wildcard->processContents();
                        wildcard = XsdSchemaHelper::wildcardIntersection(wildcard, newWildcard);
                        wildcard->setProcessContents(contents);
                    } else {
                        wildcard = newWildcard;
                    }
                }
            }
        }
    }

    return resolvedAttributeUses;
}

resolveAttributeTypes()

void XsdSchemaResolver::resolveAttributeTypes ( )

private

Resolves attribute types.

Definition at line 945 of file qxsdschemaresolver.cpp.

Referenced by resolve().

{
    for (int i = 0; i < m_attributeTypes.count(); ++i) {
        const AttributeType item = m_attributeTypes.at(i);

        SchemaType::Ptr type = m_schema->type(item.typeName);
        if (!type) {
            // maybe it's a basic type...
            type = m_context->schemaTypeFactory()->createSchemaType(item.typeName);
            if (!type) {
                m_context->error(QtXmlPatterns::tr("Type %1 of %2 element cannot be resolved.")
                                                  .arg(formatType(m_namePool, item.typeName))
                                                  .arg(formatElement("attribute")),
                                 XsdSchemaContext::XSDError, item.location);
                return;
            }
        }

        if (!type->isSimpleType() && type->category() != SchemaType::None) {
            m_context->error(QtXmlPatterns::tr("Type of %1 element must be a simple type, %2 is not.")
                                              .arg(formatElement("attribute"))
                                              .arg(formatType(m_namePool, item.typeName)),
                             XsdSchemaContext::XSDError, item.location);
            return;
        }

        item.attribute->setType(type);
    }
}

resolveComplexBaseTypes()

void XsdSchemaResolver::resolveComplexBaseTypes ( )

private

Resolves base type of complex types.

Definition at line 552 of file qxsdschemaresolver.cpp.

Referenced by resolve().

{
    for (int i = 0; i < m_complexBaseTypes.count(); ++i) {
        const ComplexBaseType item = m_complexBaseTypes.at(i);

        SchemaType::Ptr type = m_schema->type(item.baseName);
        if (!type) {
            // maybe it's a basic type...
            type = m_context->schemaTypeFactory()->createSchemaType(item.baseName);
            if (!type) {
                m_context->error(QtXmlPatterns::tr("Base type %1 of complex type cannot be resolved.").arg(formatType(m_namePool, item.baseName)), XsdSchemaContext::XSDError, item.location);
                return;
            }
        }

        if (item.complexType->contentType()->variety() == XsdComplexType::ContentType::Simple) {
            if (type->isComplexType() && type->isDefinedBySchema()) {
                const XsdComplexType::Ptr baseType = type;
                if (baseType->contentType()->variety() != XsdComplexType::ContentType::Simple) {
                    m_context->error(QtXmlPatterns::tr("%1 cannot have complex base type that has a %2.")
                                                      .arg(formatElement("simpleContent"))
                                                      .arg(formatElement("complexContent")),
                                     XsdSchemaContext::XSDError, item.location);
                    return;
                }
            }
        }

        item.complexType->setWxsSuperType(type);
    }
}

resolveComplexContentComplexTypes() [1/2]

void XsdSchemaResolver::resolveComplexContentComplexTypes ( )

private

Resolves the complex content model of a complex type depending on its base type.

Definition at line 688 of file qxsdschemaresolver.cpp.

Referenced by resolve(), and resolveComplexContentComplexTypes().

{
    XsdComplexType::List complexTypes;

    // first collect the global complex types
    const SchemaType::List types = m_schema->types();
    for (int i = 0; i < types.count(); ++i) {
        if (types.at(i)->isComplexType() && types.at(i)->isDefinedBySchema())
            complexTypes.append(types.at(i));
    }

    // then collect all anonymous simple types
    const SchemaType::List anonymousTypes = m_schema->anonymousTypes();
    for (int i = 0; i < anonymousTypes.count(); ++i) {
        if (anonymousTypes.at(i)->isComplexType() && anonymousTypes.at(i)->isDefinedBySchema())
            complexTypes.append(anonymousTypes.at(i));
    }

    QSet<XsdComplexType::Ptr> visitedTypes;
    for (int i = 0; i < complexTypes.count(); ++i) {
        if (XsdComplexType::Ptr(complexTypes.at(i))->contentType()->variety() != XsdComplexType::ContentType::Simple)
            resolveComplexContentComplexTypes(complexTypes.at(i), visitedTypes);
    }
}

resolveComplexContentComplexTypes() [2/2]

void XsdSchemaResolver::resolveComplexContentComplexTypes ( const XsdComplexType::Ptr &  complexType, QSet< XsdComplexType::Ptr > &  visitedTypes  )

private

Resolves the complex content model of a complex type depending on its base type.

Parameters

complexType	The complex type to resolve.
visitedTypes	A set of already resolved types, used for termination of recursion.

Definition at line 713 of file qxsdschemaresolver.cpp.

{
    if (visitedTypes.contains(complexType))
        return;
    else
        visitedTypes.insert(complexType);

    ComplexContentType item;
    bool foundCorrespondingItem = false;
    for (int i = 0; i < m_complexContentTypes.count(); ++i) {
        if (m_complexContentTypes.at(i).complexType == complexType) {
            item = m_complexContentTypes.at(i);
            foundCorrespondingItem = true;
            break;
        }
    }

    if (!foundCorrespondingItem)
        return;

    const SchemaType::Ptr baseType = complexType->wxsSuperType();

    // at this point simple types have been resolved already, so we care about
    // complex types here only
    if (baseType->isComplexType() && baseType->isDefinedBySchema())
        resolveComplexContentComplexTypes(XsdComplexType::Ptr(baseType), visitedTypes);


    // @see http://www.w3.org/TR/xmlschema11-1/#dcl.ctd.ctcc.common

    // 3
    XsdParticle::Ptr effectiveContent;
    if (!item.explicitContent) { // 3.1
        if (item.effectiveMixed == true) { // 3.1.1
            const XsdParticle::Ptr particle(new XsdParticle());
            particle->setMinimumOccurs(1);
            particle->setMaximumOccurs(1);
            particle->setMaximumOccursUnbounded(false);

            const XsdModelGroup::Ptr sequence(new XsdModelGroup());
            sequence->setCompositor(XsdModelGroup::SequenceCompositor);
            particle->setTerm(sequence);

            effectiveContent = particle;
        } else { // 3.1.2
            effectiveContent = XsdParticle::Ptr();
        }
    } else { // 3.2
        effectiveContent = item.explicitContent;
    }

    // 4
    XsdComplexType::ContentType::Ptr explicitContentType(new XsdComplexType::ContentType());
    if (item.complexType->derivationMethod() == XsdComplexType::DerivationRestriction) { // 4.1
        if (!effectiveContent) { // 4.1.1
            explicitContentType->setVariety(XsdComplexType::ContentType::Empty);
        } else { // 4.1.2
            if (item.effectiveMixed == true)
                explicitContentType->setVariety(XsdComplexType::ContentType::Mixed);
            else
                explicitContentType->setVariety(XsdComplexType::ContentType::ElementOnly);

            explicitContentType->setParticle(effectiveContent);
        }
    } else if (item.complexType->derivationMethod() == XsdComplexType::DerivationExtension) { // 4.2
        const SchemaType::Ptr baseType = item.complexType->wxsSuperType();
        if (baseType->isSimpleType() || (baseType->isComplexType() && baseType->isDefinedBySchema() && (XsdComplexType::Ptr(baseType)->contentType()->variety() == XsdComplexType::ContentType::Empty ||
                                                                                                        XsdComplexType::Ptr(baseType)->contentType()->variety() == XsdComplexType::ContentType::Simple))) { // 4.2.1
            if (!effectiveContent) {
                explicitContentType->setVariety(XsdComplexType::ContentType::Empty);
            } else {
                if (item.effectiveMixed == true)
                    explicitContentType->setVariety(XsdComplexType::ContentType::Mixed);
                else
                    explicitContentType->setVariety(XsdComplexType::ContentType::ElementOnly);

                explicitContentType->setParticle(effectiveContent);
            }
        } else if (baseType->isComplexType() && baseType->isDefinedBySchema() && (XsdComplexType::Ptr(baseType)->contentType()->variety() == XsdComplexType::ContentType::ElementOnly ||
                                                 XsdComplexType::Ptr(baseType)->contentType()->variety() == XsdComplexType::ContentType::Mixed) && !effectiveContent) { // 4.2.2
            const XsdComplexType::Ptr complexBaseType(baseType);

            explicitContentType = complexBaseType->contentType();
        } else { // 4.2.3
            explicitContentType->setVariety(item.effectiveMixed ? XsdComplexType::ContentType::Mixed : XsdComplexType::ContentType::ElementOnly);

            XsdParticle::Ptr baseParticle;
            if (baseType == BuiltinTypes::xsAnyType) {
                // we need a workaround here, since the xsAnyType is no real (aka XsdComplexType) complex type...

                baseParticle = XsdParticle::Ptr(new XsdParticle());
                baseParticle->setMinimumOccurs(1);
                baseParticle->setMaximumOccurs(1);
                baseParticle->setMaximumOccursUnbounded(false);

                const XsdModelGroup::Ptr group(new XsdModelGroup());
                group->setCompositor(XsdModelGroup::SequenceCompositor);

                const XsdParticle::Ptr particle(new XsdParticle());
                particle->setMinimumOccurs(0);
                particle->setMaximumOccursUnbounded(true);

                const XsdWildcard::Ptr wildcard(new XsdWildcard());
                wildcard->namespaceConstraint()->setVariety(XsdWildcard::NamespaceConstraint::Any);
                wildcard->setProcessContents(XsdWildcard::Lax);

                particle->setTerm(wildcard);
                XsdParticle::List particles;
                particles.append(particle);
                group->setParticles(particles);
                baseParticle->setTerm(group);
            } else {
                const XsdComplexType::Ptr complexBaseType(baseType);
                baseParticle = complexBaseType->contentType()->particle();
            }
            if (baseParticle && baseParticle->term()->isModelGroup() && (XsdModelGroup::Ptr(baseParticle->term())->compositor() == XsdModelGroup::AllCompositor) &&
                (!item.explicitContent)) { // 4.2.3.1

                explicitContentType->setParticle(baseParticle);
            } else if (baseParticle && baseParticle->term()->isModelGroup() && (XsdModelGroup::Ptr(baseParticle->term())->compositor() == XsdModelGroup::AllCompositor) &&
                       (effectiveContent->term()->isModelGroup() && (XsdModelGroup::Ptr(effectiveContent->term())->compositor() == XsdModelGroup::AllCompositor))) { // 4.2.3.2
                const XsdParticle::Ptr particle(new XsdParticle());
                particle->setMinimumOccurs(effectiveContent->minimumOccurs());
                particle->setMaximumOccurs(1);
                particle->setMaximumOccursUnbounded(false);

                const XsdModelGroup::Ptr group(new XsdModelGroup());
                group->setCompositor(XsdModelGroup::AllCompositor);
                XsdParticle::List particles = XsdModelGroup::Ptr(baseParticle->term())->particles();
                particles << XsdModelGroup::Ptr(effectiveContent->term())->particles();
                group->setParticles(particles);
                particle->setTerm(group);

                explicitContentType->setParticle(particle);
            } else { // 4.2.3.3
                const XsdParticle::Ptr particle(new XsdParticle());
                particle->setMinimumOccurs(1);
                particle->setMaximumOccurs(1);
                particle->setMaximumOccursUnbounded(false);

                const XsdModelGroup::Ptr group(new XsdModelGroup());
                group->setCompositor(XsdModelGroup::SequenceCompositor);

                if (effectiveContent && effectiveContent->term()->isModelGroup() && XsdModelGroup::Ptr(effectiveContent->term())->compositor() == XsdModelGroup::AllCompositor) {
                    m_context->error(QtXmlPatterns::tr("Content model of complex type %1 contains %2 element, so it cannot be derived by extension from a non-empty type.")
                                                      .arg(formatType(m_namePool, complexType)).arg(formatKeyword("all")), XsdSchemaContext::XSDError, sourceLocation(complexType));
                    return;
                }

                if (baseParticle && baseParticle->term()->isModelGroup() && XsdModelGroup::Ptr(baseParticle->term())->compositor() == XsdModelGroup::AllCompositor) {
                    m_context->error(QtXmlPatterns::tr("Complex type %1 cannot be derived by extension from %2 as the latter contains %3 element in its content model.")
                                                      .arg(formatType(m_namePool, complexType))
                                                      .arg(formatType(m_namePool, baseType))
                                                      .arg(formatKeyword("all")), XsdSchemaContext::XSDError, sourceLocation(complexType));
                    return;
                }

                XsdParticle::List particles;
                if (baseParticle)
                    particles << baseParticle;
                if (effectiveContent)
                    particles << effectiveContent;
                group->setParticles(particles);
                particle->setTerm(group);

                explicitContentType->setParticle(particle);
            }

            if (baseType->isDefinedBySchema()) { // xs:anyType has no open content
                const XsdComplexType::Ptr complexBaseType(baseType);
                explicitContentType->setOpenContent(complexBaseType->contentType()->openContent());
            }
        }
    }

    // 5
    XsdComplexType::OpenContent::Ptr wildcardElement;
    if (item.complexType->contentType()->openContent()) { // 5.1
        wildcardElement = item.complexType->contentType()->openContent();
    } else {
        if (m_defaultOpenContent) { // 5.2
            if ((explicitContentType->variety() != XsdComplexType::ContentType::Empty) || // 5.2.1
                (explicitContentType->variety() == XsdComplexType::ContentType::Empty && m_defaultOpenContentAppliesToEmpty)) { // 5.2.2
                wildcardElement = m_defaultOpenContent;
            }
        }
    }

    // 6
    if (!wildcardElement) { // 6.1
        item.complexType->setContentType(explicitContentType);
    } else {
        if (wildcardElement->mode() == XsdComplexType::OpenContent::None) { // 6.2
            const XsdComplexType::ContentType::Ptr contentType(new XsdComplexType::ContentType());
            contentType->setVariety(explicitContentType->variety());
            contentType->setParticle(explicitContentType->particle());

            item.complexType->setContentType(contentType);
        } else { // 6.3
            const XsdComplexType::ContentType::Ptr contentType(new XsdComplexType::ContentType());

            if (explicitContentType->variety() == XsdComplexType::ContentType::Empty)
                contentType->setVariety(XsdComplexType::ContentType::ElementOnly);
            else
                contentType->setVariety(explicitContentType->variety());

            if (explicitContentType->variety() == XsdComplexType::ContentType::Empty) {
                const XsdParticle::Ptr particle(new XsdParticle());
                particle->setMinimumOccurs(1);
                particle->setMaximumOccurs(1);
                const XsdModelGroup::Ptr sequence(new XsdModelGroup());
                sequence->setCompositor(XsdModelGroup::SequenceCompositor);
                particle->setTerm(sequence);
                contentType->setParticle(particle);
            } else {
                contentType->setParticle(explicitContentType->particle());
            }

            const XsdComplexType::OpenContent::Ptr openContent(new XsdComplexType::OpenContent());
            if (wildcardElement)
                openContent->setMode(wildcardElement->mode());
            else
                openContent->setMode(XsdComplexType::OpenContent::Interleave);

            if (wildcardElement)
                openContent->setWildcard(wildcardElement->wildcard());

            item.complexType->setContentType(contentType);
        }
    }
}

resolveElementTypes()

void XsdSchemaResolver::resolveElementTypes ( )

private

Resolves element types.

Definition at line 530 of file qxsdschemaresolver.cpp.

Referenced by resolve().

{
    for (int i = 0; i < m_elementTypes.count(); ++i) {
        const ElementType item = m_elementTypes.at(i);

        SchemaType::Ptr type = m_schema->type(item.typeName);
        if (!type) {
            // maybe it's a basic type...
            type = m_context->schemaTypeFactory()->createSchemaType(item.typeName);
            if (!type) {
                m_context->error(QtXmlPatterns::tr("Type %1 of %2 element cannot be resolved.")
                                                  .arg(formatType(m_namePool, item.typeName))
                                                  .arg(formatElement("element")),
                                 XsdSchemaContext::XSDError, item.location);
                return;
            }
        }

        item.element->setType(type);
    }
}

resolveEnumerationFacetValues()

void XsdSchemaResolver::resolveEnumerationFacetValues ( )

private

Resolves the enumeration facet values for QName and NOTATION based facets.

Definition at line 1575 of file qxsdschemaresolver.cpp.

Referenced by resolve().

{
    XsdSimpleType::List simpleTypes;

    // first collect the global simple types
    const SchemaType::List types = m_schema->types();
    for (int i = 0; i < types.count(); ++i) {
        if (types.at(i)->isSimpleType())
            simpleTypes.append(types.at(i));
    }

    // then collect all anonymous simple types
    const SchemaType::List anonymousTypes = m_schema->anonymousTypes();
    for (int i = 0; i < anonymousTypes.count(); ++i) {
        if (anonymousTypes.at(i)->isSimpleType())
            simpleTypes.append(anonymousTypes.at(i));
    }
    // process all simple types
    for (int i = 0; i < simpleTypes.count(); ++i) {
        const XsdSimpleType::Ptr simpleType = simpleTypes.at(i);

        // we resolve the enumeration values only for xs:QName and xs:NOTATION based types
        if (BuiltinTypes::xsQName->wxsTypeMatches(simpleType) ||
            BuiltinTypes::xsNOTATION->wxsTypeMatches(simpleType)) {
            const XsdFacet::Hash facets = simpleType->facets();
            if (facets.contains(XsdFacet::Enumeration)) {
                AtomicValue::List newValues;

                const XsdFacet::Ptr facet = facets.value(XsdFacet::Enumeration);
                const AtomicValue::List values = facet->multiValue();
                for (int j = 0; j < values.count(); ++j) {
                    const AtomicValue::Ptr value = values.at(j);

                    Q_ASSERT(m_enumerationFacetValues.contains(value));
                    const NamespaceSupport support( m_enumerationFacetValues.value(value) );

                    const QString qualifiedName = value->as<DerivedString<TypeString> >()->stringValue();
                    if (!XPathHelper::isQName(qualifiedName)) {
                        m_context->error(QtXmlPatterns::tr("Enumeration facet contains invalid content: {%1} is not a value of type %2.")
                                                          .arg(formatData(qualifiedName))
                                                          .arg(formatType(m_namePool, BuiltinTypes::xsQName)),
                                         XsdSchemaContext::XSDError, sourceLocation(simpleType));
                        return;
                    }

                    QXmlName qNameValue;
                    bool result = support.processName(qualifiedName, NamespaceSupport::ElementName, qNameValue);
                    if (!result) {
                        m_context->error(QtXmlPatterns::tr("Namespace prefix of qualified name %1 is not defined.").arg(formatData(qualifiedName)),
                                         XsdSchemaContext::XSDError, sourceLocation(simpleType));
                        return;
                    }

                    newValues.append(QNameValue::fromValue(m_namePool, qNameValue));
                }
                facet->setMultiValue(newValues);
            }
        }
    }
}

resolveKeyReferences()

void XsdSchemaResolver::resolveKeyReferences ( )

private

Resolves key references.

Definition at line 347 of file qxsdschemaresolver.cpp.

Referenced by resolve().

{
    for (int i = 0; i < m_keyReferences.count(); ++i) {
        const KeyReference ref = m_keyReferences.at(i);

        const XsdIdentityConstraint::Ptr constraint = m_schema->identityConstraint(ref.reference);
        if (!constraint) {
            m_context->error(QtXmlPatterns::tr("%1 references unknown %2 or %3 element %4.")
                                              .arg(formatKeyword(ref.keyRef->displayName(m_namePool)))
                                              .arg(formatElement("key"))
                                              .arg(formatElement("unique"))
                                              .arg(formatKeyword(m_namePool, ref.reference)),
                             XsdSchemaContext::XSDError, ref.location);
            return;
        }

        if (constraint->category() != XsdIdentityConstraint::Key && constraint->category() != XsdIdentityConstraint::Unique) { // only key and unique can be referenced
            m_context->error(QtXmlPatterns::tr("%1 references identity constraint %2 that is no %3 or %4 element.")
                                              .arg(formatKeyword(ref.keyRef->displayName(m_namePool)))
                                              .arg(formatKeyword(m_namePool, ref.reference))
                                              .arg(formatElement("key"))
                                              .arg(formatElement("unique")),
                             XsdSchemaContext::XSDError, ref.location);
            return;
        }

        if (constraint->fields().count() != ref.keyRef->fields().count()) {
            m_context->error(QtXmlPatterns::tr("%1 has a different number of fields from the identity constraint %2 that it references.")
                                              .arg(formatKeyword(ref.keyRef->displayName(m_namePool)))
                                              .arg(formatKeyword(m_namePool, ref.reference)),
                             XsdSchemaContext::XSDError, ref.location);
            return;
        }

        ref.keyRef->setReferencedKey(constraint);
    }
}

resolveSimpleContentComplexTypes() [1/2]

void XsdSchemaResolver::resolveSimpleContentComplexTypes ( )

private

Resolves the simple content model of a complex type depending on its base type.

Definition at line 584 of file qxsdschemaresolver.cpp.

Referenced by resolve(), and resolveSimpleContentComplexTypes().

{
    XsdComplexType::List complexTypes;

    // first collect the global complex types
    const SchemaType::List types = m_schema->types();
    for (int i = 0; i < types.count(); ++i) {
        if (types.at(i)->isComplexType() && types.at(i)->isDefinedBySchema())
            complexTypes.append(types.at(i));
    }

    // then collect all anonymous simple types
    const SchemaType::List anonymousTypes = m_schema->anonymousTypes();
    for (int i = 0; i < anonymousTypes.count(); ++i) {
        if (anonymousTypes.at(i)->isComplexType() && anonymousTypes.at(i)->isDefinedBySchema())
            complexTypes.append(anonymousTypes.at(i));
    }

    QSet<XsdComplexType::Ptr> visitedTypes;
    for (int i = 0; i < complexTypes.count(); ++i) {
        if (XsdComplexType::Ptr(complexTypes.at(i))->contentType()->variety() == XsdComplexType::ContentType::Simple)
            resolveSimpleContentComplexTypes(complexTypes.at(i), visitedTypes);
    }
}

resolveSimpleContentComplexTypes() [2/2]

void XsdSchemaResolver::resolveSimpleContentComplexTypes ( const XsdComplexType::Ptr &  complexType, QSet< XsdComplexType::Ptr > &  visitedTypes  )

private

Resolves the simple content model of a complex type depending on its base type.

Parameters

complexType	The complex type to resolve.
visitedTypes	A set of already resolved types, used for termination of recursion.

Definition at line 609 of file qxsdschemaresolver.cpp.

{
    if (visitedTypes.contains(complexType))
        return;
    else
        visitedTypes.insert(complexType);

    const SchemaType::Ptr baseType = complexType->wxsSuperType();

    // at this point simple types have been resolved already, so we care about
    // complex types here only

    // http://www.w3.org/TR/xmlschema11-1/#dcl.ctd.ctsc
    // 1
    if (baseType->isComplexType() && baseType->isDefinedBySchema()) {
        const XsdComplexType::Ptr complexBaseType = baseType;

        resolveSimpleContentComplexTypes(complexBaseType, visitedTypes);

        if (complexBaseType->contentType()->variety() == XsdComplexType::ContentType::Simple) {
            if (complexType->derivationMethod() == XsdComplexType::DerivationRestriction) {
                if (complexType->contentType()->simpleType()) {
                    // 1.1 contains the content of the <simpleType> already
                } else {
                    // 1.2
                    const XsdSimpleType::Ptr anonType(new XsdSimpleType());
                    XsdSimpleType::TypeCategory baseCategory = complexBaseType->contentType()->simpleType()->category();
                    anonType->setCategory(baseCategory);

                    if (baseCategory == XsdSimpleType::SimpleTypeList) {
                        const XsdSimpleType::Ptr baseSimpleType = complexBaseType->contentType()->simpleType();
                        anonType->setItemType(baseSimpleType->itemType());
                    }

                    anonType->setDerivationMethod(XsdSimpleType::DerivationRestriction);
                    anonType->setWxsSuperType(complexBaseType->contentType()->simpleType());
                    anonType->setFacets(complexTypeFacets(complexType));

                    QSet<AnySimpleType::Ptr> visitedPrimitiveTypes;
                    const AnySimpleType::Ptr primitiveType = findPrimitiveType(anonType->wxsSuperType(), visitedPrimitiveTypes);
                    anonType->setPrimitiveType(primitiveType);

                    complexType->contentType()->setSimpleType(anonType);

                    m_schema->addAnonymousType(anonType);
                    m_componentLocationHash.insert(anonType, m_componentLocationHash.value(complexType));
                }
            } else if (complexBaseType->derivationMethod() == XsdComplexType::DerivationExtension) { // 3
                complexType->contentType()->setSimpleType(complexBaseType->contentType()->simpleType());
            }
        } else if (complexBaseType->contentType()->variety() == XsdComplexType::ContentType::Mixed &&
                   complexType->derivationMethod() == XsdComplexType::DerivationRestriction &&
                   XsdSchemaHelper::isParticleEmptiable(complexBaseType->contentType()->particle())) { // 2
            // simple type was already set in parser

            const XsdSimpleType::Ptr anonType(new XsdSimpleType());
            anonType->setCategory(complexType->contentType()->simpleType()->category());
            anonType->setDerivationMethod(XsdSimpleType::DerivationRestriction);
            anonType->setWxsSuperType(complexType->contentType()->simpleType());
            anonType->setFacets(complexTypeFacets(complexType));

            QSet<AnySimpleType::Ptr> visitedPrimitiveTypes;
            const AnySimpleType::Ptr primitiveType = findPrimitiveType(anonType->wxsSuperType(), visitedPrimitiveTypes);
            anonType->setPrimitiveType(primitiveType);

            complexType->contentType()->setSimpleType(anonType);

            m_schema->addAnonymousType(anonType);
            m_componentLocationHash.insert(anonType, m_componentLocationHash.value(complexType));
        } else {
            complexType->contentType()->setSimpleType(BuiltinTypes::xsAnySimpleType);
        }
    } else if (baseType->isSimpleType()) { // 4
        complexType->contentType()->setSimpleType(baseType);
    } else { // 5
        complexType->contentType()->setSimpleType(BuiltinTypes::xsAnySimpleType);
    }
}

resolveSimpleListType()

void XsdSchemaResolver::resolveSimpleListType ( )

private

Resolves the item type property of simple types derived by list.

Definition at line 469 of file qxsdschemaresolver.cpp.

Referenced by resolve().

{
    // iterate over all simple types where the item type shall be resolved
    for (int i = 0; i < m_simpleListTypes.count(); ++i) {
        const SimpleListType item = m_simpleListTypes.at(i);

        // try to resolve the name
        SchemaType::Ptr type = m_schema->type(item.typeName);
        if (!type) {
            // maybe it's a basic type...
            type = m_context->schemaTypeFactory()->createSchemaType(item.typeName);
            if (!type) {
                m_context->error(QtXmlPatterns::tr("Item type %1 of %2 element cannot be resolved.")
                                                  .arg(formatType(m_namePool, item.typeName))
                                                  .arg(formatElement("list")),
                                 XsdSchemaContext::XSDError, item.location);
                return;
            }
        }

        item.simpleType->setItemType(type);
    }
}

resolveSimpleRestrictionBaseTypes()

void XsdSchemaResolver::resolveSimpleRestrictionBaseTypes ( )

private

Resolves the base types of simple types derived by restriction.

Definition at line 385 of file qxsdschemaresolver.cpp.

Referenced by resolve().

{
    // iterate over all simple types that are derived by restriction
    for (int i = 0; i < m_simpleRestrictionBases.count(); ++i) {
        const SimpleRestrictionBase item = m_simpleRestrictionBases.at(i);

        // find the base type
        SchemaType::Ptr type = m_schema->type(item.baseName);
        if (!type) {
            // maybe it's a basic type...
            type = m_context->schemaTypeFactory()->createSchemaType(item.baseName);
            if (!type) {
                m_context->error(QtXmlPatterns::tr("Base type %1 of %2 element cannot be resolved.")
                                                  .arg(formatType(m_namePool, item.baseName))
                                                  .arg(formatElement("restriction")),
                                 XsdSchemaContext::XSDError, item.location);
                return;
            }
        }

        item.simpleType->setWxsSuperType(type);
    }
}

resolveSimpleRestrictions() [1/2]

void XsdSchemaResolver::resolveSimpleRestrictions ( )

private

Resolves the other properties except the base type of all simple restrictions.

Definition at line 409 of file qxsdschemaresolver.cpp.

Referenced by resolve(), and resolveSimpleRestrictions().

{
    XsdSimpleType::List simpleTypes;

    // first collect the global simple types
    const SchemaType::List types = m_schema->types();
    for (int i = 0; i < types.count(); ++i) {
        if (types.at(i)->isSimpleType() && (types.at(i)->derivationMethod() == SchemaType::DerivationRestriction))
            simpleTypes.append(types.at(i));
    }

    // then collect all anonymous simple types
    const SchemaType::List anonymousTypes = m_schema->anonymousTypes();
    for (int i = 0; i < anonymousTypes.count(); ++i) {
        if (anonymousTypes.at(i)->isSimpleType() && (anonymousTypes.at(i)->derivationMethod() == SchemaType::DerivationRestriction))
            simpleTypes.append(anonymousTypes.at(i));
    }

    QSet<XsdSimpleType::Ptr> visitedTypes;
    for (int i = 0; i < simpleTypes.count(); ++i) {
        resolveSimpleRestrictions(simpleTypes.at(i), visitedTypes);
    }
}

resolveSimpleRestrictions() [2/2]

void XsdSchemaResolver::resolveSimpleRestrictions ( const XsdSimpleType::Ptr &  simpleType, QSet< XsdSimpleType::Ptr > &  visitedTypes  )

private

Resolves the other properties except the base type of the given simple restriction.

Parameters

simpleType	The restricted type to resolve.
visitedTypes	A set of already resolved types, used for termination of recursion.

Definition at line 433 of file qxsdschemaresolver.cpp.

{
    if (visitedTypes.contains(simpleType))
        return;
    else
        visitedTypes.insert(simpleType);

    if (simpleType->derivationMethod() != XsdSimpleType::DerivationRestriction)
        return;

    // as xs:NMTOKENS, xs:ENTITIES and xs:IDREFS are provided by our XsdSchemaTypesFactory, they are
    // setup correctly already and shouldn't be handled here
    if (m_predefinedSchemaTypes.contains(simpleType))
        return;

    const SchemaType::Ptr baseType = simpleType->wxsSuperType();
    Q_ASSERT(baseType);

    if (baseType->isDefinedBySchema())
        resolveSimpleRestrictions(XsdSimpleType::Ptr(baseType), visitedTypes);

    simpleType->setCategory(baseType->category());

    if (simpleType->category() == XsdSimpleType::SimpleTypeAtomic) {
        QSet<AnySimpleType::Ptr> visitedPrimitiveTypes;
        const AnySimpleType::Ptr primitiveType = findPrimitiveType(baseType, visitedPrimitiveTypes);
        simpleType->setPrimitiveType(primitiveType);
    } else if (simpleType->category() == XsdSimpleType::SimpleTypeList) {
        const XsdSimpleType::Ptr simpleBaseType = baseType;
        simpleType->setItemType(simpleBaseType->itemType());
    } else if (simpleType->category() == XsdSimpleType::SimpleTypeUnion) {
        const XsdSimpleType::Ptr simpleBaseType = baseType;
        simpleType->setMemberTypes(simpleBaseType->memberTypes());
    }
}

resolveSimpleUnionTypes()

void XsdSchemaResolver::resolveSimpleUnionTypes ( )

private

Resolves the member types property of simple types derived by union.

Definition at line 493 of file qxsdschemaresolver.cpp.

Referenced by resolve().

{
    // iterate over all simple types where the union member types shall be resolved
    for (int i = 0; i < m_simpleUnionTypes.count(); ++i) {
        const SimpleUnionType item = m_simpleUnionTypes.at(i);

        AnySimpleType::List memberTypes;

        // iterate over all union member type names
        const QList<QXmlName> typeNames = item.typeNames;
        for (int j = 0; j < typeNames.count(); ++j) {
            const QXmlName typeName = typeNames.at(j);

            // try to resolve the name
            SchemaType::Ptr type = m_schema->type(typeName);
            if (!type) {
                // maybe it's a basic type...
                type = m_context->schemaTypeFactory()->createSchemaType(typeName);
                if (!type) {
                    m_context->error(QtXmlPatterns::tr("Member type %1 of %2 element cannot be resolved.")
                                                      .arg(formatType(m_namePool, typeName))
                                                      .arg(formatElement("union")),
                                     XsdSchemaContext::XSDError, item.location);
                    return;
                }
            }

            memberTypes.append(type);
        }

        // append the types that have been defined as <simpleType> children
        memberTypes << item.simpleType->memberTypes();

        item.simpleType->setMemberTypes(memberTypes);
    }
}

resolveSubstitutionGroupAffiliations()

void XsdSchemaResolver::resolveSubstitutionGroupAffiliations ( )

private

Resolves substitution group affiliations.

Definition at line 1017 of file qxsdschemaresolver.cpp.

Referenced by resolve().

{
    for (int i = 0; i < m_substitutionGroupAffiliations.count(); ++i) {
        const SubstitutionGroupAffiliation item = m_substitutionGroupAffiliations.at(i);

        XsdElement::List affiliations;
        for (int j = 0; j < item.elementNames.count(); ++j) {
            const XsdElement::Ptr element = m_schema->element(item.elementNames.at(j));
            if (!element) {
                m_context->error(QtXmlPatterns::tr("Substitution group %1 of %2 element cannot be resolved.")
                                                  .arg(formatKeyword(m_namePool, item.elementNames.at(j)))
                                                  .arg(formatElement("element")),
                                 XsdSchemaContext::XSDError, item.location);
                return;
            }

            // @see http://www.w3.org/TR/xmlschema11-1/#e-props-correct 5)
            if (hasCircularSubstitutionGroup(element, item.element, m_namePool)) {
                m_context->error(QtXmlPatterns::tr("Substitution group %1 has circular definition.").arg(formatKeyword(m_namePool, item.elementNames.at(j))), XsdSchemaContext::XSDError, item.location);
                return;
            }

            affiliations.append(element);
        }

        item.element->setSubstitutionGroupAffiliations(affiliations);
    }

    for (int i = 0; i < m_substitutionGroupTypes.count(); ++i) {
        const XsdElement::Ptr element = m_substitutionGroupTypes.at(i);
        element->setType(element->substitutionGroupAffiliations().first()->type());
    }
}

resolveSubstitutionGroups()

void XsdSchemaResolver::resolveSubstitutionGroups ( )

private

Resolves substitution groups.

Definition at line 1065 of file qxsdschemaresolver.cpp.

Referenced by resolve().

{
    const XsdElement::List elements = m_schema->elements();
    for (int i = 0; i < elements.count(); ++i) {
        const XsdElement::Ptr element = elements.at(i);

        // the element is always itself in the substitution group
        element->addSubstitutionGroup(element);

        for (int j = 0; j < elements.count(); ++j) {
            if (i == j)
                continue;

            if (isSubstGroupHeadOf(element, elements.at(j), m_namePool))
                element->addSubstitutionGroup(elements.at(j));
        }
    }
}

resolveTermReference()

void XsdSchemaResolver::resolveTermReference ( const XsdParticle::Ptr &  particle, QSet< QXmlName >  visitedGroups  )

private

Resolves all XsdReferences in the particle recursive by their corresponding XsdElement or XsdModelGroup terms.

Definition at line 1120 of file qxsdschemaresolver.cpp.

Referenced by resolveTermReferences().

{
    if (!particle)
        return;

    const XsdTerm::Ptr term = particle->term();

    // if it is a model group, we iterate over it recursive...
    if (term->isModelGroup()) {
        const XsdModelGroup::Ptr modelGroup = term;
        const XsdParticle::List particles = modelGroup->particles();

        for (int i = 0; i < particles.count(); ++i) {
            resolveTermReference(particles.at(i), visitedGroups);
        }

        // check for unique names of elements inside all compositor
        if (modelGroup->compositor() != XsdModelGroup::ChoiceCompositor) {
            for (int i = 0; i < particles.count(); ++i) {
                const XsdParticle::Ptr particle = particles.at(i);
                const XsdTerm::Ptr term = particle->term();

                if (!(term->isElement()))
                    continue;

                for (int j = 0; j < particles.count(); ++j) {
                    const XsdParticle::Ptr otherParticle = particles.at(j);
                    const XsdTerm::Ptr otherTerm = otherParticle->term();

                    if (otherTerm->isElement() && i != j) {
                        const XsdElement::Ptr element = term;
                        const XsdElement::Ptr otherElement = otherTerm;

                        if (element->name(m_namePool) == otherElement->name(m_namePool)) {
                            if (modelGroup->compositor() == XsdModelGroup::AllCompositor) {
                                m_context->error(QtXmlPatterns::tr("Duplicated element names %1 in %2 element.")
                                                                  .arg(formatKeyword(element->displayName(m_namePool)))
                                                                  .arg(formatElement("all")),
                                                 XsdSchemaContext::XSDError, sourceLocation(modelGroup));
                                return;
                            } else if (modelGroup->compositor() == XsdModelGroup::SequenceCompositor) {
                                if (element->type() != otherElement->type()) {  // not same variety
                                    m_context->error(QtXmlPatterns::tr("Duplicated element names %1 in %2 element.")
                                                                      .arg(formatKeyword(element->displayName(m_namePool)))
                                                                      .arg(formatElement("sequence")),
                                                     XsdSchemaContext::XSDError, sourceLocation(modelGroup));
                                    return;
                                }
                            }
                        }
                    }
                }
            }
        }

        return;
    }

    // ...otherwise we have reached the end of recursion...
    if (!term->isReference())
        return;

    // ...or we have reached a reference term that must be resolved
    const XsdReference::Ptr reference = term;
    switch (reference->type()) {
        case XsdReference::Element:
                {
                    const XsdElement::Ptr element = m_schema->element(reference->referenceName());
                    if (element) {
                        particle->setTerm(element);
                    } else {
                        m_context->error(QtXmlPatterns::tr("Reference %1 of %2 element cannot be resolved.")
                                                          .arg(formatKeyword(m_namePool, reference->referenceName()))
                                                          .arg(formatElement("element")),
                                         XsdSchemaContext::XSDError, reference->sourceLocation());
                        return;
                    }
                }
            break;
        case XsdReference::ModelGroup:
                {
                    const XsdModelGroup::Ptr modelGroup = m_schema->elementGroup(reference->referenceName());
                    if (modelGroup) {
                        if (visitedGroups.contains(modelGroup->name(m_namePool))) {
                            m_context->error(QtXmlPatterns::tr("Circular group reference for %1.").arg(formatKeyword(modelGroup->displayName(m_namePool))),
                                             XsdSchemaContext::XSDError, reference->sourceLocation());
                        } else {
                            visitedGroups.insert(modelGroup->name(m_namePool));
                        }

                        particle->setTerm(modelGroup);

                        // start recursive iteration here as well to get all references resolved
                        const XsdParticle::List particles = modelGroup->particles();
                        for (int i = 0; i < particles.count(); ++i) {
                            resolveTermReference(particles.at(i), visitedGroups);
                        }

                        if (modelGroup->compositor() == XsdModelGroup::AllCompositor) {
                            if (m_allGroups.contains(reference)) {
                                m_context->error(QtXmlPatterns::tr("%1 element is not allowed in this scope").arg(formatElement("all.")),
                                                 XsdSchemaContext::XSDError, reference->sourceLocation());
                                return;
                            }
                            if (particle->maximumOccursUnbounded() || particle->maximumOccurs() != 1) {
                                m_context->error(QtXmlPatterns::tr("%1 element cannot have %2 attribute with value other than %3.")
                                                                  .arg(formatElement("all"))
                                                                  .arg(formatAttribute("maxOccurs"))
                                                                  .arg(formatData("1")),
                                                 XsdSchemaContext::XSDError, reference->sourceLocation());
                                return;
                            }
                            if (particle->minimumOccurs() != 0 && particle->minimumOccurs() != 1) {
                                m_context->error(QtXmlPatterns::tr("%1 element cannot have %2 attribute with value other than %3 or %4.")
                                                                  .arg(formatElement("all"))
                                                                  .arg(formatAttribute("minOccurs"))
                                                                  .arg(formatData("0"))
                                                                  .arg(formatData("1")),
                                                 XsdSchemaContext::XSDError, reference->sourceLocation());
                                return;
                            }
                        }
                    } else {
                        m_context->error(QtXmlPatterns::tr("Reference %1 of %2 element cannot be resolved.")
                                                          .arg(formatKeyword(m_namePool, reference->referenceName()))
                                                          .arg(formatElement("group")),
                                         XsdSchemaContext::XSDError, reference->sourceLocation());
                        return;
                    }
                }
            break;
    }
}

resolveTermReferences()

void XsdSchemaResolver::resolveTermReferences ( )

private

Resolves all XsdReferences in the schema by their corresponding XsdElement or XsdModelGroup terms.

Definition at line 1084 of file qxsdschemaresolver.cpp.

Referenced by resolve().

{
    // first the global complex types
    const SchemaType::List types = m_schema->types();
    for (int i = 0; i < types.count(); ++i) {
        if (!(types.at(i)->isComplexType()) || !types.at(i)->isDefinedBySchema())
            continue;

        const XsdComplexType::Ptr complexType = types.at(i);
        if (complexType->contentType()->variety() != XsdComplexType::ContentType::ElementOnly && complexType->contentType()->variety() != XsdComplexType::ContentType::Mixed)
            continue;

        resolveTermReference(complexType->contentType()->particle(), QSet<QXmlName>());
    }

    // then all anonymous complex types
    const SchemaType::List anonymousTypes = m_schema->anonymousTypes();
    for (int i = 0; i < anonymousTypes.count(); ++i) {
        if (!(anonymousTypes.at(i)->isComplexType()) || !anonymousTypes.at(i)->isDefinedBySchema())
            continue;

        const XsdComplexType::Ptr complexType = anonymousTypes.at(i);
        if (complexType->contentType()->variety() != XsdComplexType::ContentType::ElementOnly && complexType->contentType()->variety() != XsdComplexType::ContentType::Mixed)
            continue;

        resolveTermReference(complexType->contentType()->particle(), QSet<QXmlName>());
    }

    const XsdModelGroup::List groups = m_schema->elementGroups();
    for (int i = 0; i < groups.count(); ++i) {
        const XsdParticle::Ptr particle(new XsdParticle());
        particle->setTerm(groups.at(i));
        resolveTermReference(particle, QSet<QXmlName>());
    }
}

setDefaultOpenContent()

void XsdSchemaResolver::setDefaultOpenContent	(	const XsdComplexType::OpenContent::Ptr &	openContent,
		bool	appliesToEmpty
	)

Sets the defaultOpenContent object from the schema parser.

Definition at line 341 of file qxsdschemaresolver.cpp.

Referenced by QPatternist::XsdSchemaParser::parse().

{
    m_defaultOpenContent = openContent;
    m_defaultOpenContentAppliesToEmpty = appliesToEmpty;
}

sourceLocation()

QSourceLocation XsdSchemaResolver::sourceLocation ( const NamedSchemaComponent::Ptr  component ) const

private

Returns the source location of the given schema component or a dummy source location if the component is not found in the component location hash.

Definition at line 1636 of file qxsdschemaresolver.cpp.

Referenced by checkRedefinedAttributeGroups(), checkRedefinedGroups(), resolveAttributeInheritance(), resolveComplexContentComplexTypes(), resolveEnumerationFacetValues(), and resolveTermReference().

{
    if (m_componentLocationHash.contains(component)) {
        return m_componentLocationHash.value(component);
    } else {
        QSourceLocation location;
        location.setLine(1);
        location.setColumn(1);
        location.setUri(QString::fromLatin1("dummyUri"));

        return location;
    }
}

typeNameOfAttribute()

QXmlName XsdSchemaResolver::typeNameOfAttribute

(

const XsdAttribute::Ptr &

attribute

)

const

Returns the to resolve type name for the given attribute.

Note

That functionality is only used by the redefine algorithm in the XsdSchemaParser.

Definition at line 331 of file qxsdschemaresolver.cpp.

{
    for (int i = 0; i < m_attributeTypes.count(); ++i) {
        if (m_attributeTypes.at(i).attribute == attribute)
            return m_attributeTypes.at(i).typeName;
    }

    return QXmlName();
}

Properties

m_allGroups

QSet<XsdReference::Ptr> QPatternist::XsdSchemaResolver::m_allGroups

private

Definition at line 561 of file qxsdschemaresolver_p.h.

Referenced by addAllGroupCheck(), and resolveTermReference().

m_alternativeTypeElements

QVector<AlternativeTypeElement> QPatternist::XsdSchemaResolver::m_alternativeTypeElements

private

Definition at line 555 of file qxsdschemaresolver_p.h.

Referenced by addAlternativeType(), copyDataTo(), resolveAlternativeTypes(), and XsdSchemaResolver().

m_alternativeTypes

QVector<AlternativeType> QPatternist::XsdSchemaResolver::m_alternativeTypes

private

Definition at line 554 of file qxsdschemaresolver_p.h.

Referenced by addAlternativeType(), copyDataTo(), resolveAlternativeTypes(), and XsdSchemaResolver().

m_attributeTypes

QVector<AttributeType> QPatternist::XsdSchemaResolver::m_attributeTypes

private

Definition at line 553 of file qxsdschemaresolver_p.h.

Referenced by addAttributeType(), copyDataTo(), resolveAttributeTypes(), typeNameOfAttribute(), and XsdSchemaResolver().

m_checker

QExplicitlySharedDataPointer<XsdSchemaChecker> QPatternist::XsdSchemaResolver::m_checker

private

Definition at line 564 of file qxsdschemaresolver_p.h.

Referenced by resolve().

m_complexBaseTypes

QVector<ComplexBaseType> QPatternist::XsdSchemaResolver::m_complexBaseTypes

private

Definition at line 551 of file qxsdschemaresolver_p.h.

Referenced by addComplexBaseType(), baseTypeNameOfType(), complexTypeFacets(), copyDataTo(), removeComplexBaseType(), resolveComplexBaseTypes(), and XsdSchemaResolver().

m_complexContentTypes

QVector<ComplexContentType> QPatternist::XsdSchemaResolver::m_complexContentTypes

private

Definition at line 552 of file qxsdschemaresolver_p.h.

Referenced by addComplexContentType(), copyDataTo(), and resolveComplexContentComplexTypes().

m_componentLocationHash

QHash<NamedSchemaComponent::Ptr, QSourceLocation> QPatternist::XsdSchemaResolver::m_componentLocationHash

private

Definition at line 567 of file qxsdschemaresolver_p.h.

Referenced by addComponentLocationHash(), resolve(), resolveSimpleContentComplexTypes(), and sourceLocation().

m_context

QExplicitlySharedDataPointer<XsdSchemaContext> QPatternist::XsdSchemaResolver::m_context

private

Definition at line 563 of file qxsdschemaresolver_p.h.

Referenced by checkRedefinedAttributeGroups(), checkRedefinedGroups(), resolveAlternativeTypes(), resolveAttributeInheritance(), resolveAttributeTermReferences(), resolveAttributeTypes(), resolveComplexBaseTypes(), resolveComplexContentComplexTypes(), resolveElementTypes(), resolveEnumerationFacetValues(), resolveKeyReferences(), resolveSimpleListType(), resolveSimpleRestrictionBaseTypes(), resolveSimpleUnionTypes(), resolveSubstitutionGroupAffiliations(), resolveTermReference(), and XsdSchemaResolver().

m_defaultOpenContent

XsdComplexType::OpenContent::Ptr QPatternist::XsdSchemaResolver::m_defaultOpenContent

private

Definition at line 568 of file qxsdschemaresolver_p.h.

Referenced by resolveComplexContentComplexTypes(), and setDefaultOpenContent().

m_defaultOpenContentAppliesToEmpty

bool QPatternist::XsdSchemaResolver::m_defaultOpenContentAppliesToEmpty

private

Definition at line 569 of file qxsdschemaresolver_p.h.

Referenced by resolveComplexContentComplexTypes(), and setDefaultOpenContent().

m_elementTypes

QVector<ElementType> QPatternist::XsdSchemaResolver::m_elementTypes

private

Definition at line 550 of file qxsdschemaresolver_p.h.

Referenced by addElementType(), copyDataTo(), resolveElementTypes(), and XsdSchemaResolver().

m_enumerationFacetValues

QHash<AtomicValue::Ptr, NamespaceSupport> QPatternist::XsdSchemaResolver::m_enumerationFacetValues

private

Definition at line 560 of file qxsdschemaresolver_p.h.

Referenced by addEnumerationFacetValue(), and resolveEnumerationFacetValues().

m_keyReferences

QVector<KeyReference> QPatternist::XsdSchemaResolver::m_keyReferences

private

Definition at line 546 of file qxsdschemaresolver_p.h.

Referenced by addKeyReference(), copyDataTo(), resolveKeyReferences(), and XsdSchemaResolver().

m_namePool

NamePool::Ptr QPatternist::XsdSchemaResolver::m_namePool

private

Definition at line 565 of file qxsdschemaresolver_p.h.

Referenced by checkRedefinedAttributeGroups(), checkRedefinedGroups(), findPrimitiveType(), resolveAlternativeTypes(), resolveAttributeInheritance(), resolveAttributeTermReferences(), resolveAttributeTypes(), resolveComplexBaseTypes(), resolveComplexContentComplexTypes(), resolveElementTypes(), resolveEnumerationFacetValues(), resolveKeyReferences(), resolveSimpleListType(), resolveSimpleRestrictionBaseTypes(), resolveSimpleUnionTypes(), resolveSubstitutionGroupAffiliations(), resolveSubstitutionGroups(), and resolveTermReference().

m_predefinedSchemaTypes

SchemaType::List QPatternist::XsdSchemaResolver::m_predefinedSchemaTypes

private

Definition at line 570 of file qxsdschemaresolver_p.h.

Referenced by resolveSimpleRestrictions(), and XsdSchemaResolver().

m_redefinedAttributeGroups

QVector<RedefinedAttributeGroups> QPatternist::XsdSchemaResolver::m_redefinedAttributeGroups

private

Definition at line 559 of file qxsdschemaresolver_p.h.

Referenced by addRedefinedAttributeGroups(), and checkRedefinedAttributeGroups().

m_redefinedGroups

QVector<RedefinedGroups> QPatternist::XsdSchemaResolver::m_redefinedGroups

private

Definition at line 558 of file qxsdschemaresolver_p.h.

Referenced by addRedefinedGroups(), and checkRedefinedGroups().

m_schema

XsdSchema::Ptr QPatternist::XsdSchemaResolver::m_schema

private

Definition at line 566 of file qxsdschemaresolver_p.h.

Referenced by resolveAlternativeTypes(), resolveAttributeInheritance(), resolveAttributeTermReferences(), resolveAttributeTypes(), resolveComplexBaseTypes(), resolveComplexContentComplexTypes(), resolveElementTypes(), resolveEnumerationFacetValues(), resolveKeyReferences(), resolveSimpleContentComplexTypes(), resolveSimpleListType(), resolveSimpleRestrictionBaseTypes(), resolveSimpleRestrictions(), resolveSimpleUnionTypes(), resolveSubstitutionGroupAffiliations(), resolveSubstitutionGroups(), resolveTermReference(), and resolveTermReferences().

m_simpleListTypes

QVector<SimpleListType> QPatternist::XsdSchemaResolver::m_simpleListTypes

private

Definition at line 548 of file qxsdschemaresolver_p.h.

Referenced by addSimpleListType(), copyDataTo(), resolveSimpleListType(), and XsdSchemaResolver().

m_simpleRestrictionBases

QVector<SimpleRestrictionBase> QPatternist::XsdSchemaResolver::m_simpleRestrictionBases

private

Definition at line 547 of file qxsdschemaresolver_p.h.

Referenced by addSimpleRestrictionBase(), baseTypeNameOfType(), copyDataTo(), removeSimpleRestrictionBase(), resolveSimpleRestrictionBaseTypes(), and XsdSchemaResolver().

m_simpleUnionTypes

QVector<SimpleUnionType> QPatternist::XsdSchemaResolver::m_simpleUnionTypes

private

Definition at line 549 of file qxsdschemaresolver_p.h.

Referenced by addSimpleUnionTypes(), copyDataTo(), resolveSimpleUnionTypes(), and XsdSchemaResolver().

m_substitutionGroupAffiliations

QVector<SubstitutionGroupAffiliation> QPatternist::XsdSchemaResolver::m_substitutionGroupAffiliations

private

Definition at line 556 of file qxsdschemaresolver_p.h.

Referenced by addSubstitutionGroupAffiliation(), copyDataTo(), resolveSubstitutionGroupAffiliations(), and XsdSchemaResolver().

m_substitutionGroupTypes

QVector<XsdElement::Ptr> QPatternist::XsdSchemaResolver::m_substitutionGroupTypes

private

Definition at line 557 of file qxsdschemaresolver_p.h.

Referenced by addSubstitutionGroupType(), copyDataTo(), and resolveSubstitutionGroupAffiliations().

---

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

• /src/xmlpatterns/schema/qxsdschemaresolver_p.h
• /src/xmlpatterns/schema/qxsdschemaresolver.cpp