| /**************************************************************************** | |
| ** | |
| ** Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies). | |
| ** All rights reserved. | |
| ** Contact: Nokia Corporation (qt-info@nokia.com) | |
| ** | |
| ** This file is part of the QtXmlPatterns module of the Qt Toolkit. | |
| ** | |
| ** $QT_BEGIN_LICENSE:LGPL$ | |
| ** GNU Lesser General Public License Usage | |
| ** This file may be used under the terms of the GNU Lesser General Public | |
| ** License version 2.1 as published by the Free Software Foundation and | |
| ** appearing in the file LICENSE.LGPL included in the packaging of this | |
| ** file. Please review the following information to ensure the GNU Lesser | |
| ** General Public License version 2.1 requirements will be met: | |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. | |
| ** | |
| ** In addition, as a special exception, Nokia gives you certain additional | |
| ** rights. These rights are described in the Nokia Qt LGPL Exception | |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. | |
| ** | |
| ** GNU General Public License Usage | |
| ** Alternatively, this file may be used under the terms of the GNU General | |
| ** Public License version 3.0 as published by the Free Software Foundation | |
| ** and appearing in the file LICENSE.GPL included in the packaging of this | |
| ** file. Please review the following information to ensure the GNU General | |
| ** Public License version 3.0 requirements will be met: | |
| ** http://www.gnu.org/copyleft/gpl.html. | |
| ** | |
| ** Other Usage | |
| ** Alternatively, this file may be used in accordance with the terms and | |
| ** conditions contained in a signed written agreement between you and Nokia. | |
| ** | |
| ** | |
| ** | |
| ** | |
| ** | |
| ** $QT_END_LICENSE$ | |
| ** | |
| ****************************************************************************/ | |
| // | |
| // W A R N I N G | |
| // ------------- | |
| // | |
| // This file is not part of the Qt API. It exists purely as an | |
| // implementation detail. This header file may change from version to | |
| // version without notice, or even be removed. | |
| // | |
| // We mean it. | |
| #ifndef Patternist_XsdSchemaResolver_H | |
| #define Patternist_XsdSchemaResolver_H | |
| #include "qnamespacesupport_p.h" | |
| #include "qschematype_p.h" | |
| #include "qschematypefactory_p.h" | |
| #include "qxsdalternative_p.h" | |
| #include "qxsdattribute_p.h" | |
| #include "qxsdattributegroup_p.h" | |
| #include "qxsdelement_p.h" | |
| #include "qxsdmodelgroup_p.h" | |
| #include "qxsdnotation_p.h" | |
| #include "qxsdreference_p.h" | |
| #include "qxsdschema_p.h" | |
| #include "qxsdschemachecker_p.h" | |
| #include "qxsdsimpletype_p.h" | |
| #include <QtCore/QExplicitlySharedDataPointer> | |
| QT_BEGIN_HEADER | |
| QT_BEGIN_NAMESPACE | |
| namespace QPatternist | |
| { | |
| class XsdSchemaContext; | |
| class XsdSchemaParserContext; | |
| /** | |
| * @short 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(). | |
| * | |
| * @ingroup Patternist_schema | |
| * @author Tobias Koenig <tobias.koenig@nokia.com> | |
| */ | |
| class XsdSchemaResolver : public QSharedData | |
| { | |
| public: | |
| typedef QExplicitlySharedDataPointer<XsdSchemaResolver> Ptr; | |
| /** | |
| * Creates a new schema resolver. | |
| * | |
| * @param context The schema context used for error reporting etc.. | |
| * @param parserContext The schema parser context where all objects to resolve belong to. | |
| */ | |
| XsdSchemaResolver(const QExplicitlySharedDataPointer<XsdSchemaContext> &context, const XsdSchemaParserContext *parserContext); | |
| /** | |
| * Destroys the schema resolver. | |
| */ | |
| ~XsdSchemaResolver(); | |
| /** | |
| * Starts the resolve process. | |
| */ | |
| void resolve(); | |
| /** | |
| * Adds a resolve task for key references. | |
| * | |
| * The resolver will try to set the referencedKey property of @p keyRef to the <em>key</em> or <em>unique</em> object | |
| * of @p element that has the given @p name. | |
| */ | |
| void addKeyReference(const XsdElement::Ptr &element, const XsdIdentityConstraint::Ptr &keyRef, const QXmlName &name, 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 @p simpleType to the type named by @p baseName. | |
| */ | |
| void addSimpleRestrictionBase(const XsdSimpleType::Ptr &simpleType, const QXmlName &baseName, const QSourceLocation &location); | |
| /** | |
| * Removes the resolve task for the base type of restriction of the simple @p type. | |
| */ | |
| void removeSimpleRestrictionBase(const XsdSimpleType::Ptr &type); | |
| /** | |
| * Adds a resolve task for the list type of a simple type. | |
| * | |
| * The resolver will set the itemType property of @p simpleType to the type named by @p typeName. | |
| */ | |
| void addSimpleListType(const XsdSimpleType::Ptr &simpleType, const QXmlName &typeName, const QSourceLocation &location); | |
| /** | |
| * Adds a resolve task for the member types of a simple type. | |
| * | |
| * The resolver will set the memberTypes property of @p simpleType to the types named by @p typeNames. | |
| */ | |
| void addSimpleUnionTypes(const XsdSimpleType::Ptr &simpleType, const QList<QXmlName> &typeNames, const QSourceLocation &location); | |
| /** | |
| * Adds a resolve task for the type of an element. | |
| * | |
| * The resolver will set the type of the @p element to the type named by @p typeName. | |
| */ | |
| void addElementType(const XsdElement::Ptr &element, const QXmlName &typeName, const QSourceLocation &location); | |
| /** | |
| * Adds a resolve task for the base type of a complex type. | |
| * | |
| * The resolver will set the base type of @p complexType to the type named by @p baseName. | |
| */ | |
| void addComplexBaseType(const XsdComplexType::Ptr &complexType, const QXmlName &baseName, const QSourceLocation &location, const XsdFacet::Hash &facets = XsdFacet::Hash()); | |
| /** | |
| * Removes the resolve task for the base type of the complex @p type. | |
| */ | |
| void removeComplexBaseType(const XsdComplexType::Ptr &type); | |
| /** | |
| * Adds a resolve task for the content type of a complex type. | |
| * | |
| * The resolver will set the content type properties for @p complexType based on the | |
| * given explicit @p content and effective @p mixed value. | |
| */ | |
| void addComplexContentType(const XsdComplexType::Ptr &complexType, const XsdParticle::Ptr &content, bool mixed); | |
| /** | |
| * Adds a resolve task for the type of an attribute. | |
| * | |
| * The resolver will set the type of the @p attribute to the type named by @p typeName. | |
| */ | |
| void addAttributeType(const XsdAttribute::Ptr &attribute, const QXmlName &typeName, const QSourceLocation &location); | |
| /** | |
| * Adds a resolve task for the type of an alternative. | |
| * | |
| * The resolver will set the type of the @p alternative to the type named by @p typeName. | |
| */ | |
| void 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 @p alternative to the type of the @p element after | |
| * the type of the @p element has been resolved. | |
| */ | |
| void addAlternativeType(const XsdAlternative::Ptr &alternative, const XsdElement::Ptr &element); | |
| /** | |
| * Adds a resolve task for the substituion group affiliations of an element. | |
| * | |
| * The resolver will set the substitution group affiliations of the @p element to the | |
| * top-level element named by @p elementNames. | |
| */ | |
| void addSubstitutionGroupAffiliation(const XsdElement::Ptr &element, const QList<QXmlName> &elementName, const QSourceLocation &location); | |
| /** | |
| * 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. | |
| */ | |
| void addSubstitutionGroupType(const XsdElement::Ptr &element); | |
| /** | |
| * Adds the component location hash, so the resolver is able to report meaning full | |
| * error messages. | |
| */ | |
| void addComponentLocationHash(const QHash<NamedSchemaComponent::Ptr, QSourceLocation> &hash); | |
| /** | |
| * 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. | |
| */ | |
| void addEnumerationFacetValue(const AtomicValue::Ptr &facetValue, const NamespaceSupport &namespaceSupport); | |
| /** | |
| * 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. | |
| */ | |
| void addRedefinedGroups(const XsdModelGroup::Ptr &redefinedGroup, const XsdModelGroup::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. | |
| */ | |
| void addRedefinedAttributeGroups(const XsdAttributeGroup::Ptr &redefinedGroup, const XsdAttributeGroup::Ptr &group); | |
| /** | |
| * Adds a check for nested <em>all</em> groups. | |
| */ | |
| void addAllGroupCheck(const XsdReference::Ptr &reference); | |
| /** | |
| * Copies the data to resolve to an @p other resolver. | |
| * | |
| * @note That functionality is only used by the redefine algorithm in the XsdSchemaParser. | |
| */ | |
| void copyDataTo(const XsdSchemaResolver::Ptr &other) const; | |
| /** | |
| * Returns the to resolve base type name for the given @p type. | |
| * | |
| * @note That functionality is only used by the redefine algorithm in the XsdSchemaParser. | |
| */ | |
| QXmlName baseTypeNameOfType(const SchemaType::Ptr &type) const; | |
| /** | |
| * Returns the to resolve type name for the given @p attribute. | |
| * | |
| * @note That functionality is only used by the redefine algorithm in the XsdSchemaParser. | |
| */ | |
| QXmlName typeNameOfAttribute(const XsdAttribute::Ptr &attribute) const; | |
| /** | |
| * Sets the defaultOpenContent object from the schema parser. | |
| */ | |
| void setDefaultOpenContent(const XsdComplexType::OpenContent::Ptr &openContent, bool appliesToEmpty); | |
| private: | |
| /** | |
| * Resolves key references. | |
| */ | |
| void resolveKeyReferences(); | |
| /** | |
| * Resolves the base types of simple types derived by restriction. | |
| */ | |
| void resolveSimpleRestrictionBaseTypes(); | |
| /** | |
| * Resolves the other properties except the base type | |
| * of all simple restrictions. | |
| */ | |
| void resolveSimpleRestrictions(); | |
| /** | |
| * Resolves the other properties except the base type | |
| * of the given simple restriction. | |
| * | |
| * @param simpleType The restricted type to resolve. | |
| * @param visitedTypes A set of already resolved types, used for termination of recursion. | |
| */ | |
| void resolveSimpleRestrictions(const XsdSimpleType::Ptr &simpleType, QSet<XsdSimpleType::Ptr> &visitedTypes); | |
| /** | |
| * Resolves the item type property of simple types derived by list. | |
| */ | |
| void resolveSimpleListType(); | |
| /** | |
| * Resolves the member types property of simple types derived by union. | |
| */ | |
| void resolveSimpleUnionTypes(); | |
| /** | |
| * Resolves element types. | |
| */ | |
| void resolveElementTypes(); | |
| /** | |
| * Resolves base type of complex types. | |
| */ | |
| void resolveComplexBaseTypes(); | |
| /** | |
| * Resolves the simple content model of a complex type | |
| * depending on its base type. | |
| */ | |
| void resolveSimpleContentComplexTypes(); | |
| /** | |
| * Resolves the complex content model of a complex type | |
| * depending on its base type. | |
| */ | |
| void resolveComplexContentComplexTypes(); | |
| /** | |
| * Resolves the simple content model of a complex type | |
| * depending on its base type. | |
| * | |
| * @param complexType The complex type to resolve. | |
| * @param visitedTypes A set of already resolved types, used for termination of recursion. | |
| */ | |
| void resolveSimpleContentComplexTypes(const XsdComplexType::Ptr &complexType, QSet<XsdComplexType::Ptr> &visitedTypes); | |
| /** | |
| * Resolves the complex content model of a complex type | |
| * depending on its base type. | |
| * | |
| * @param complexType The complex type to resolve. | |
| * @param visitedTypes A set of already resolved types, used for termination of recursion. | |
| */ | |
| void resolveComplexContentComplexTypes(const XsdComplexType::Ptr &complexType, QSet<XsdComplexType::Ptr> &visitedTypes); | |
| /** | |
| * Resolves attribute types. | |
| */ | |
| void resolveAttributeTypes(); | |
| /** | |
| * Resolves alternative types. | |
| */ | |
| void resolveAlternativeTypes(); | |
| /** | |
| * Resolves substitution group affiliations. | |
| */ | |
| void resolveSubstitutionGroupAffiliations(); | |
| /** | |
| * Resolves substitution groups. | |
| */ | |
| void resolveSubstitutionGroups(); | |
| /** | |
| * Resolves all XsdReferences in the schema by their corresponding XsdElement or XsdModelGroup terms. | |
| */ | |
| void resolveTermReferences(); | |
| /** | |
| * Resolves all XsdReferences in the @p particle recursive by their corresponding XsdElement or XsdModelGroup terms. | |
| */ | |
| void resolveTermReference(const XsdParticle::Ptr &particle, QSet<QXmlName> visitedGroups); | |
| /** | |
| * Resolves all XsdAttributeReferences in the schema by their corresponding XsdAttributeUse objects. | |
| */ | |
| void resolveAttributeTermReferences(); | |
| /** | |
| * Resolves all XsdAttributeReferences in the list of @p attributeUses by their corresponding XsdAttributeUse objects. | |
| */ | |
| XsdAttributeUse::List resolveAttributeTermReferences(const XsdAttributeUse::List &attributeUses, XsdWildcard::Ptr &wildcard, QSet<QXmlName> visitedAttributeGroups); | |
| /** | |
| * Resolves the attribute inheritance of complex types. | |
| * | |
| * @note This method must be called after all base types have been resolved. | |
| */ | |
| void resolveAttributeInheritance(); | |
| /** | |
| * Resolves the attribute inheritance of the given complex types. | |
| * | |
| * @param complexType The complex type to resolve. | |
| * @param 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. | |
| */ | |
| void resolveAttributeInheritance(const XsdComplexType::Ptr &complexType, QSet<XsdComplexType::Ptr> &visitedTypes); | |
| /** | |
| * Resolves the enumeration facet values for QName and NOTATION based facets. | |
| */ | |
| void resolveEnumerationFacetValues(); | |
| /** | |
| * Returns the source location of the given schema @p component or a dummy | |
| * source location if the component is not found in the component location hash. | |
| */ | |
| QSourceLocation sourceLocation(const NamedSchemaComponent::Ptr component) const; | |
| /** | |
| * Returns the facets that are marked for the given complex @p type with a simple | |
| * type restriction. | |
| */ | |
| XsdFacet::Hash complexTypeFacets(const XsdComplexType::Ptr &complexType) const; | |
| /** | |
| * Finds the primitive type for the given simple @p type. | |
| * | |
| * The type is found by walking up the inheritance tree, until one of the builtin | |
| * primitive type definitions is reached. | |
| */ | |
| AnySimpleType::Ptr findPrimitiveType(const AnySimpleType::Ptr &type, QSet<AnySimpleType::Ptr> &visitedTypes); | |
| /** | |
| * Checks the redefined groups. | |
| */ | |
| void checkRedefinedGroups(); | |
| /** | |
| * Checks the redefined attribute groups. | |
| */ | |
| void checkRedefinedAttributeGroups(); | |
| class KeyReference | |
| { | |
| public: | |
| XsdElement::Ptr element; | |
| XsdIdentityConstraint::Ptr keyRef; | |
| QXmlName reference; | |
| QSourceLocation location; | |
| }; | |
| class SimpleRestrictionBase | |
| { | |
| public: | |
| XsdSimpleType::Ptr simpleType; | |
| QXmlName baseName; | |
| QSourceLocation location; | |
| }; | |
| class SimpleListType | |
| { | |
| public: | |
| XsdSimpleType::Ptr simpleType; | |
| QXmlName typeName; | |
| QSourceLocation location; | |
| }; | |
| class SimpleUnionType | |
| { | |
| public: | |
| XsdSimpleType::Ptr simpleType; | |
| QList<QXmlName> typeNames; | |
| QSourceLocation location; | |
| }; | |
| class ElementType | |
| { | |
| public: | |
| XsdElement::Ptr element; | |
| QXmlName typeName; | |
| QSourceLocation location; | |
| }; | |
| class ComplexBaseType | |
| { | |
| public: | |
| XsdComplexType::Ptr complexType; | |
| QXmlName baseName; | |
| QSourceLocation location; | |
| XsdFacet::Hash facets; | |
| }; | |
| class ComplexContentType | |
| { | |
| public: | |
| XsdComplexType::Ptr complexType; | |
| XsdParticle::Ptr explicitContent; | |
| bool effectiveMixed; | |
| }; | |
| class AttributeType | |
| { | |
| public: | |
| XsdAttribute::Ptr attribute; | |
| QXmlName typeName; | |
| QSourceLocation location; | |
| }; | |
| class AlternativeType | |
| { | |
| public: | |
| XsdAlternative::Ptr alternative; | |
| QXmlName typeName; | |
| QSourceLocation location; | |
| }; | |
| class AlternativeTypeElement | |
| { | |
| public: | |
| XsdAlternative::Ptr alternative; | |
| XsdElement::Ptr element; | |
| }; | |
| class SubstitutionGroupAffiliation | |
| { | |
| public: | |
| XsdElement::Ptr element; | |
| QList<QXmlName> elementNames; | |
| QSourceLocation location; | |
| }; | |
| class RedefinedGroups | |
| { | |
| public: | |
| XsdModelGroup::Ptr redefinedGroup; | |
| XsdModelGroup::Ptr group; | |
| }; | |
| class RedefinedAttributeGroups | |
| { | |
| public: | |
| XsdAttributeGroup::Ptr redefinedGroup; | |
| XsdAttributeGroup::Ptr group; | |
| }; | |
| QVector<KeyReference> m_keyReferences; | |
| QVector<SimpleRestrictionBase> m_simpleRestrictionBases; | |
| QVector<SimpleListType> m_simpleListTypes; | |
| QVector<SimpleUnionType> m_simpleUnionTypes; | |
| QVector<ElementType> m_elementTypes; | |
| QVector<ComplexBaseType> m_complexBaseTypes; | |
| QVector<ComplexContentType> m_complexContentTypes; | |
| QVector<AttributeType> m_attributeTypes; | |
| QVector<AlternativeType> m_alternativeTypes; | |
| QVector<AlternativeTypeElement> m_alternativeTypeElements; | |
| QVector<SubstitutionGroupAffiliation> m_substitutionGroupAffiliations; | |
| QVector<XsdElement::Ptr> m_substitutionGroupTypes; | |
| QVector<RedefinedGroups> m_redefinedGroups; | |
| QVector<RedefinedAttributeGroups> m_redefinedAttributeGroups; | |
| QHash<AtomicValue::Ptr, NamespaceSupport> m_enumerationFacetValues; | |
| QSet<XsdReference::Ptr> m_allGroups; | |
| QExplicitlySharedDataPointer<XsdSchemaContext> m_context; | |
| QExplicitlySharedDataPointer<XsdSchemaChecker> m_checker; | |
| NamePool::Ptr m_namePool; | |
| XsdSchema::Ptr m_schema; | |
| QHash<NamedSchemaComponent::Ptr, QSourceLocation> m_componentLocationHash; | |
| XsdComplexType::OpenContent::Ptr m_defaultOpenContent; | |
| bool m_defaultOpenContentAppliesToEmpty; | |
| SchemaType::List m_predefinedSchemaTypes; | |
| }; | |
| } | |
| QT_END_NAMESPACE | |
| QT_END_HEADER | |
| #endif |