text: /****************************************************************************
  **
  ** 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
  