xml_schema_set.h

 
 
#pragma once
 
#include <xml/schema/validation_event_handler.h>
#include <system/exceptions.h>
#include <system/array.h>
#include <cstdint>
 
 
namespace System
{
namespace Collections
{
namespace Generic
{
template <typename, typename> class Dictionary;
template <typename> class IList;
template <typename, typename> class KeyValuePair;
template <typename> class List;
template <typename, typename> class SortedList;
} // namespace Generic
} // namespace Collections
class Uri;
namespace Xml
{
namespace Schema
{
class ChameleonKey;
class Compiler;
class ContentValidator;
class SchemaInfo;
class SchemaNames;
class ValidationEventArgs;
class XmlSchema;
class XmlSchemaCompilationSettings;
class Details_XmlSchemaException; using XmlSchemaException = System::ExceptionWrapper<Details_XmlSchemaException>;
class XmlSchemaObject;
class XmlSchemaObjectTable;
class XmlSchemaSubstitutionGroup;
class XmlSchemaValidator;
enum class XmlSeverityType;
} // namespace Schema
class XmlNameTable;
class XmlQualifiedName;
class XmlReader;
class XmlReaderSettings;
class XmlResolver;
class XsdValidatingReader;
} // namespace Xml
} // namespace System
 
namespace System {
 
namespace Xml {
 
namespace Schema {
 
class ASPOSECPP_SHARED_CLASS XmlSchemaSet : public System::Object
{
    typedef XmlSchemaSet ThisType;
    typedef System::Object BaseType;
 
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    ASPOSECPP_SHARED_RTTI_INFO_DECL();
 
public:
 
    using Ptr = SharedPtr<XmlSchemaSet>;
 
private:
    friend class System::Xml::XsdValidatingReader;
    friend class ContentValidator;
    friend class Compiler;
    friend class XmlSchemaValidator;
 
public:
 
    ASPOSECPP_SHARED_API SharedPtr<XmlNameTable> get_NameTable();
    ASPOSECPP_SHARED_API bool get_IsCompiled();
    ASPOSECPP_SHARED_API void set_XmlResolver(const SharedPtr<System::Xml::XmlResolver>& value);
    ASPOSECPP_SHARED_API SharedPtr<XmlSchemaCompilationSettings> get_CompilationSettings();
    ASPOSECPP_SHARED_API void set_CompilationSettings(const SharedPtr<XmlSchemaCompilationSettings>& value);
    ASPOSECPP_SHARED_API int32_t get_Count();
    ASPOSECPP_SHARED_API SharedPtr<XmlSchemaObjectTable> get_GlobalElements();
    ASPOSECPP_SHARED_API SharedPtr<XmlSchemaObjectTable> get_GlobalAttributes();
    ASPOSECPP_SHARED_API SharedPtr<XmlSchemaObjectTable> get_GlobalTypes();
 
    ASPOSECPP_SHARED_API XmlSchemaSet();
    ASPOSECPP_SHARED_API XmlSchemaSet(const SharedPtr<XmlNameTable>& nameTable);
 
    template<class... Args> void ValidationEventHandler_add(Args... value)
    {
        _eventHandler.disconnect(_internalEventHandler);
        _eventHandler.connect(value...);
        if (_eventHandler == nullptr)
        {
            _eventHandler = _internalEventHandler;
        }
    }
    template<class... Args> void ValidationEventHandler_remove(Args... value)
    {
        _eventHandler.disconnect(value...);
        if (_eventHandler == nullptr)
        {
            _eventHandler = _internalEventHandler;
        }
    }
 
    ASPOSECPP_SHARED_API SharedPtr<XmlSchema> Add(String targetNamespace, const String& schemaUri);
    ASPOSECPP_SHARED_API SharedPtr<XmlSchema> Add(String targetNamespace, const SharedPtr<XmlReader>& schemaDocument);
    ASPOSECPP_SHARED_API void Add(const SharedPtr<XmlSchemaSet>& schemas);
    ASPOSECPP_SHARED_API SharedPtr<XmlSchema> Add(const SharedPtr<XmlSchema>& schema);
    ASPOSECPP_SHARED_API SharedPtr<XmlSchema> Remove(const SharedPtr<XmlSchema>& schema);
    ASPOSECPP_SHARED_API bool RemoveRecursive(const SharedPtr<XmlSchema>& schemaToRemove);
    ASPOSECPP_SHARED_API bool Contains(String targetNamespace);
    ASPOSECPP_SHARED_API bool Contains(const SharedPtr<XmlSchema>& schema);
    ASPOSECPP_SHARED_API void Compile();
    ASPOSECPP_SHARED_API SharedPtr<XmlSchema> Reprocess(SharedPtr<XmlSchema> schema);
    ASPOSECPP_SHARED_API void CopyTo(const ArrayPtr<SharedPtr<XmlSchema>>& schemas, int32_t index);
    ASPOSECPP_SHARED_API SharedPtr<Collections::Generic::IList<SharedPtr<XmlSchema>>> Schemas();
    ASPOSECPP_SHARED_API SharedPtr<Collections::Generic::List<SharedPtr<XmlSchema>>> Schemas(String targetNamespace);
 
protected:
 
    SharedPtr<XmlSchemaObjectTable> elements;
    SharedPtr<XmlSchemaObjectTable> attributes;
    SharedPtr<XmlSchemaObjectTable> schemaTypes;
    SharedPtr<XmlSchemaObjectTable> substitutionGroups;
 
    SharedPtr<Object> get_InternalSyncObject();
    SharedPtr<XmlSchemaObjectTable> get_SubstitutionGroups();
    SharedPtr<Collections::Generic::Dictionary<SharedPtr<Uri>, SharedPtr<XmlSchema>>> get_SchemaLocations();
    SharedPtr<XmlSchemaObjectTable> get_TypeExtensions();
    SharedPtr<SchemaInfo> get_CompiledInfo();
    SharedPtr<XmlReaderSettings> get_ReaderSettings();
    SharedPtr<Collections::Generic::SortedList<int32_t, SharedPtr<XmlSchema>>> get_SortedSchemas();
 
    void Add(String targetNamespace, const SharedPtr<XmlReader>& reader, const SharedPtr<Collections::Generic::Dictionary<String, String>>& validatedNamespaces);
    SharedPtr<XmlSchema> FindSchemaByNSAndUrl(const SharedPtr<Uri>& schemaUri, const String& ns, const ArrayPtr<Collections::Generic::KeyValuePair<SharedPtr<Uri>, SharedPtr<XmlSchema>>>& locationsTable);
    SharedPtr<XmlSchema> Remove(const SharedPtr<XmlSchema>& schema, bool forceCompile);
    bool PreprocessSchema(SharedPtr<XmlSchema>& schema, const String& targetNamespace);
    SharedPtr<XmlSchema> ParseSchema(const String& targetNamespace, const SharedPtr<XmlReader>& reader);
    void CopyFromCompiledSet(const SharedPtr<XmlSchemaSet>& otherSet);
    SharedPtr<System::Xml::XmlResolver> GetResolver();
    System::Xml::Schema::ValidationEventHandler& GetEventHandler();
    SharedPtr<SchemaNames> GetSchemaNames(const SharedPtr<XmlNameTable>& nt);
    bool IsSchemaLoaded(const SharedPtr<Uri>& schemaUri, String targetNamespace, SharedPtr<XmlSchema>& schema);
    bool GetSchemaByUri(const SharedPtr<Uri>& schemaUri, SharedPtr<XmlSchema>& schema);
    String GetTargetNamespace(const SharedPtr<XmlSchema>& schema);
 
    virtual ASPOSECPP_SHARED_API ~XmlSchemaSet();
 
    #ifdef ASPOSE_GET_SHARED_MEMBERS
    ASPOSECPP_SHARED_API void GetSharedMembers(System::Object::shared_members_type& result) const override;
    #endif
 
private:
 
    SharedPtr<XmlNameTable> _nameTable;
    SharedPtr<SchemaNames> _schemaNames;
    SharedPtr<Collections::Generic::SortedList<int32_t, SharedPtr<XmlSchema>>> _schemas;
    System::Xml::Schema::ValidationEventHandler _internalEventHandler;
    System::Xml::Schema::ValidationEventHandler _eventHandler;
    bool _isCompiled;
    SharedPtr<Collections::Generic::Dictionary<SharedPtr<Uri>, SharedPtr<XmlSchema>>> _schemaLocations;
    SharedPtr<Collections::Generic::Dictionary<SharedPtr<ChameleonKey>, SharedPtr<XmlSchema>>> _chameleonSchemas;
    SharedPtr<Collections::Generic::Dictionary<String, String>> _targetNamespaces;
    bool _compileAll;
    SharedPtr<SchemaInfo> _cachedCompiledInfo;
    SharedPtr<XmlReaderSettings> _readerSettings;
    SharedPtr<XmlSchema> _schemaForSchema;
    SharedPtr<XmlSchemaCompilationSettings> _compilationSettings;
    SharedPtr<XmlSchemaObjectTable> _typeExtensions;
    SharedPtr<Object> _internalSyncObject;
 
    SharedPtr<XmlSchema> Add(const String& targetNamespace, SharedPtr<XmlSchema> schema);
    void SetDtdProcessing(const SharedPtr<XmlReader>& reader);
    void AddSchemaToSet(const SharedPtr<XmlSchema>& schema);
    void ProcessNewSubstitutionGroups(const SharedPtr<XmlSchemaObjectTable>& substitutionGroupsTable, bool resolve);
    void ResolveSubstitutionGroup(const SharedPtr<XmlSchemaSubstitutionGroup>& substitutionGroup, const SharedPtr<XmlSchemaObjectTable>& substTable);
    void ClearTables();
    void RemoveSchemaFromCaches(const SharedPtr<XmlSchema>& schema);
    void RemoveSchemaFromGlobalTables(const SharedPtr<XmlSchema>& schema);
    bool AddToTable(const SharedPtr<XmlSchemaObjectTable>& table, const SharedPtr<XmlQualifiedName>& qname, const SharedPtr<XmlSchemaObject>& item);
    void VerifyTables();
    void InternalValidationCallback(const SharedPtr<Object>& sender, const SharedPtr<ValidationEventArgs>& e);
    void SendValidationEvent(XmlSchemaException e, XmlSeverityType severity);
 
};
 
} // namespace Schema
} // namespace Xml
} // namespace System