| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the QtXmlPatterns module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or (at your option) the GNU General |
| ** Public license version 3 or any later version approved by the KDE Free |
| ** Qt Foundation. The licenses are as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
| ** https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $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 <private/qnamespacesupport_p.h> |
| #include <private/qschematype_p.h> |
| #include <private/qschematypefactory_p.h> |
| #include <private/qxsdalternative_p.h> |
| #include <private/qxsdattribute_p.h> |
| #include <private/qxsdattributegroup_p.h> |
| #include <private/qxsdelement_p.h> |
| #include <private/qxsdmodelgroup_p.h> |
| #include <private/qxsdnotation_p.h> |
| #include <private/qxsdreference_p.h> |
| #include <private/qxsdschema_p.h> |
| #include <private/qxsdschemachecker_p.h> |
| #include <private/qxsdsimpletype_p.h> |
| |
| #include <QtCore/QExplicitlySharedDataPointer> |
| |
| 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 |
| |
| #endif |