xml_schema.h

 
 
#pragma once
 
#include <xml/schema/xml_schema_object.h>
#include <xml/schema/xml_schema_form.h>
#include <xml/schema/xml_schema_derivation_method.h>
#include <xml/schema/validation_event_handler.h>
#include <system/enum_helpers.h>
#include <system/array.h>
#include <cstdint>
 
 
namespace System
{
namespace Collections
{
namespace Generic
{
template <typename, typename> class Dictionary;
template <typename> class IList;
template <typename> class List;
} // namespace Generic
} // namespace Collections
namespace IO
{
class Stream;
class TextReader;
class TextWriter;
} // namespace IO
class Uri;
namespace Xml
{
namespace Schema
{
class ChameleonKey;
class Compiler;
class Parser;
class Preprocessor;
class SchemaCollectionCompiler;
class SchemaCollectionPreprocessor;
class SchemaInfo;
class XmlSchemaAnnotation;
class XmlSchemaCollection;
class XmlSchemaCompilationSettings;
class XmlSchemaObjectCollection;
class XmlSchemaObjectTable;
class XmlSchemaSet;
class XmlSchemaValidator;
class XsdBuilder;
class XsdValidator;
} // namespace Schema
class XmlAttribute;
class XmlDocument;
class XmlNamespaceManager;
class XmlNameTable;
class XmlReader;
class XmlResolver;
class XmlWriter;
} // namespace Xml
} // namespace System
 
namespace System {
 
namespace Xml {
 
namespace Schema {
 
class ASPOSECPP_SHARED_CLASS XmlSchema : public XmlSchemaObject
{
    typedef XmlSchema ThisType;
    typedef XmlSchemaObject BaseType;
 
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    ASPOSECPP_SHARED_RTTI_INFO_DECL();
 
public:
 
    using Ptr = SharedPtr<XmlSchema>;
 
private:
    friend class ChameleonKey;
    friend class Parser;
    friend class Preprocessor;
    friend class SchemaCollectionCompiler;
    friend class SchemaCollectionPreprocessor;
    friend class Compiler;
    friend class XmlSchemaCollection;
    friend class XmlSchemaSet;
    friend class XmlSchemaValidator;
    friend class XsdBuilder;
    friend class XsdValidator;
 
public:
 
    static const ASPOSECPP_SHARED_API String Namespace;
    static const ASPOSECPP_SHARED_API String InstanceNamespace;
 
    ASPOSECPP_SHARED_API XmlSchemaForm get_AttributeFormDefault();
    ASPOSECPP_SHARED_API void set_AttributeFormDefault(XmlSchemaForm value);
    ASPOSECPP_SHARED_API XmlSchemaDerivationMethod get_BlockDefault();
    ASPOSECPP_SHARED_API void set_BlockDefault(XmlSchemaDerivationMethod value);
    ASPOSECPP_SHARED_API XmlSchemaDerivationMethod get_FinalDefault();
    ASPOSECPP_SHARED_API void set_FinalDefault(XmlSchemaDerivationMethod value);
    ASPOSECPP_SHARED_API XmlSchemaForm get_ElementFormDefault();
    ASPOSECPP_SHARED_API void set_ElementFormDefault(XmlSchemaForm value);
    ASPOSECPP_SHARED_API String get_TargetNamespace();
    ASPOSECPP_SHARED_API void set_TargetNamespace(const String& value);
    ASPOSECPP_SHARED_API String get_Version();
    ASPOSECPP_SHARED_API void set_Version(const String& value);
    ASPOSECPP_SHARED_API SharedPtr<XmlSchemaObjectCollection> get_Includes();
    ASPOSECPP_SHARED_API SharedPtr<XmlSchemaObjectCollection> get_Items();
    ASPOSECPP_SHARED_API bool get_IsCompiled();
    ASPOSECPP_SHARED_API SharedPtr<XmlSchemaObjectTable> get_Attributes();
    ASPOSECPP_SHARED_API SharedPtr<XmlSchemaObjectTable> get_AttributeGroups();
    ASPOSECPP_SHARED_API SharedPtr<XmlSchemaObjectTable> get_SchemaTypes();
    ASPOSECPP_SHARED_API SharedPtr<XmlSchemaObjectTable> get_Elements();
    ASPOSECPP_SHARED_API String get_Id();
    ASPOSECPP_SHARED_API void set_Id(const String& value);
    ASPOSECPP_SHARED_API ArrayPtr<SharedPtr<XmlAttribute>> get_UnhandledAttributes();
    ASPOSECPP_SHARED_API void set_UnhandledAttributes(const ArrayPtr<SharedPtr<XmlAttribute>>& value);
    ASPOSECPP_SHARED_API SharedPtr<XmlSchemaObjectTable> get_Groups();
    ASPOSECPP_SHARED_API SharedPtr<XmlSchemaObjectTable> get_Notations();
 
    ASPOSECPP_SHARED_API XmlSchema();
 
    static ASPOSECPP_SHARED_API SharedPtr<XmlSchema> Read(const SharedPtr<IO::TextReader>& reader, ValidationEventHandler validationEventHandler);
    static ASPOSECPP_SHARED_API SharedPtr<XmlSchema> Read(const SharedPtr<IO::Stream>& stream, ValidationEventHandler validationEventHandler);
    static ASPOSECPP_SHARED_API SharedPtr<XmlSchema> Read(const SharedPtr<XmlReader>& reader, ValidationEventHandler validationEventHandler);
    ASPOSECPP_SHARED_API void Write(const SharedPtr<IO::Stream>& stream);
    ASPOSECPP_SHARED_API void Write(const SharedPtr<IO::Stream>& stream, const SharedPtr<XmlNamespaceManager>& namespaceManager);
    ASPOSECPP_SHARED_API void Write(const SharedPtr<IO::TextWriter>& writer);
    ASPOSECPP_SHARED_API void Write(const SharedPtr<IO::TextWriter>& writer, const SharedPtr<XmlNamespaceManager>& namespaceManager);
    ASPOSECPP_SHARED_API void Write(const SharedPtr<XmlWriter>& writer);
    ASPOSECPP_SHARED_API void Write(const SharedPtr<XmlWriter>& writer, const SharedPtr<XmlNamespaceManager>& namespaceManager);
    ASPOSECPP_SHARED_API void Compile(ValidationEventHandler validationEventHandler);
    ASPOSECPP_SHARED_API void Compile(ValidationEventHandler validationEventHandler, const SharedPtr<XmlResolver>& resolver);
 
protected:
 
    bool get_IsCompiledBySet();
    void set_IsCompiledBySet(bool value);
    bool get_IsPreprocessed();
    void set_IsPreprocessed(bool value);
    bool get_IsRedefined();
    void set_IsRedefined(bool value);
    SharedPtr<XmlSchemaObjectTable> get_IdentityConstraints();
    SharedPtr<Uri> get_BaseUri();
    void set_BaseUri(const SharedPtr<Uri>& value);
    int32_t get_SchemaId();
    bool get_IsChameleon();
    void set_IsChameleon(bool value);
    SharedPtr<Collections::Generic::Dictionary<String, SharedPtr<XmlSchemaObject>>> get_Ids();
    SharedPtr<XmlDocument> get_Document();
    int32_t get_ErrorCount();
    void set_ErrorCount(int32_t value);
    ASPOSECPP_SHARED_API String get_IdAttribute() override;
    ASPOSECPP_SHARED_API void set_IdAttribute(String value) override;
    SharedPtr<XmlNameTable> get_NameTable();
    SharedPtr<Collections::Generic::List<SharedPtr<XmlSchema>>> get_ImportedSchemas();
    SharedPtr<Collections::Generic::List<String>> get_ImportedNamespaces();
 
    bool CompileSchema(const SharedPtr<XmlSchemaCollection>& xsc, const SharedPtr<XmlResolver>& resolver, const SharedPtr<SchemaInfo>& schemaInfo, const String& ns, ValidationEventHandler validationEventHandler, const SharedPtr<XmlNameTable>& nameTable, bool CompileContentModel);
    void CompileSchemaInSet(const SharedPtr<XmlNameTable>& nameTable, ValidationEventHandler eventHandler, const SharedPtr<XmlSchemaCompilationSettings>& compilationSettings);
    ASPOSECPP_SHARED_API SharedPtr<XmlSchemaObject> Clone() override;
    SharedPtr<XmlSchema> DeepClone();
    void SetIsCompiled(bool isCompiled);
    ASPOSECPP_SHARED_API void SetUnhandledAttributes(ArrayPtr<SharedPtr<XmlAttribute>> moreAttributes) override;
    ASPOSECPP_SHARED_API void AddAnnotation(SharedPtr<XmlSchemaAnnotation> annotation) override;
    void GetExternalSchemasList(const SharedPtr<Collections::Generic::IList<SharedPtr<XmlSchema>>>& extList, const SharedPtr<XmlSchema>& schema);
 
    virtual ASPOSECPP_SHARED_API ~XmlSchema();
 
    #ifdef ASPOSE_GET_SHARED_MEMBERS
    ASPOSECPP_SHARED_API void GetSharedMembers(System::Object::shared_members_type& result) const override;
    #endif
 
private:
 
    XmlSchemaForm _attributeFormDefault;
    XmlSchemaForm _elementFormDefault;
    XmlSchemaDerivationMethod _blockDefault;
    XmlSchemaDerivationMethod _finalDefault;
    String _targetNs;
    String _version;
    SharedPtr<XmlSchemaObjectCollection> _includes;
    SharedPtr<XmlSchemaObjectCollection> _items;
    String _id;
    ArrayPtr<SharedPtr<XmlAttribute>> _moreAttributes;
    bool _isCompiled;
    bool _isCompiledBySet;
    bool _isPreprocessed;
    bool _isRedefined;
    int32_t _errorCount;
    SharedPtr<XmlSchemaObjectTable> _attributes;
    SharedPtr<XmlSchemaObjectTable> _attributeGroups;
    SharedPtr<XmlSchemaObjectTable> _elements;
    SharedPtr<XmlSchemaObjectTable> _types;
    SharedPtr<XmlSchemaObjectTable> _groups;
    SharedPtr<XmlSchemaObjectTable> _notations;
    SharedPtr<XmlSchemaObjectTable> _identityConstraints;
    static int32_t s_globalIdCounter;
    SharedPtr<Collections::Generic::List<SharedPtr<XmlSchema>>> _importedSchemas;
    SharedPtr<Collections::Generic::List<String>> _importedNamespaces;
    int32_t _schemaId;
    SharedPtr<Uri> _baseUri;
    bool _isChameleon;
    System::DynamicWeakPtr<Collections::Generic::Dictionary<String, SharedPtr<XmlSchemaObject>>, System::SmartPtrMode::Shared, 1> _ids;
    SharedPtr<XmlDocument> _document;
    SharedPtr<XmlNameTable> _nameTable;
 
    ThisType* CppMemberwiseClone() const override { return new ThisType(*this); } 
 
};
 
} // namespace Schema
} // namespace Xml
} // namespace System