xml_reader_settings.h

 
 
#pragma once
 
#include <xml/validation_type.h>
#include <xml/schema/xml_schema_validation_flags.h>
#include <xml/schema/validation_event_handler.h>
#include <xml/dtd_processing.h>
#include <xml/conformance_level.h>
#include <system/object.h>
#include <system/enum_helpers.h>
#include <cstdint>
 
 
namespace System
{
namespace IO
{
class Stream;
class TextReader;
} // namespace IO
class String;
class Uri;
namespace Xml
{
namespace Schema
{
class XmlSchemaSet;
} // namespace Schema
class XmlCharCheckingReader;
class XmlNameTable;
class XmlParserContext;
class XmlReader;
class XmlResolver;
class XmlSqlBinaryReader;
class XmlTextReaderImpl;
class XmlValidatingReaderImpl;
namespace XPath
{
class XPathNavigatorReader;
} // namespace XPath
class XsdValidatingReader;
} // namespace Xml
} // namespace System
 
namespace System {
 
namespace Xml {
 
class ASPOSECPP_SHARED_CLASS XmlReaderSettings final : public System::Object
{
    typedef XmlReaderSettings ThisType;
    typedef System::Object BaseType;
 
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    ASPOSECPP_SHARED_RTTI_INFO_DECL();
 
public:
 
    using Ptr = SharedPtr<XmlReaderSettings>;
 
private:
    friend class XmlSqlBinaryReader;
    friend class XmlReader;
    friend class XmlCharCheckingReader;
    friend class XmlTextReaderImpl;
    friend class XmlValidatingReaderImpl;
    friend class XsdValidatingReader;
    friend class Schema::XmlSchemaSet;
    friend class XPath::XPathNavigatorReader;
 
public:
 
    ASPOSECPP_SHARED_API SharedPtr<XmlNameTable> get_NameTable();
    ASPOSECPP_SHARED_API void set_NameTable(const SharedPtr<XmlNameTable>& value);
    ASPOSECPP_SHARED_API void set_XmlResolver(const SharedPtr<System::Xml::XmlResolver>& value);
    ASPOSECPP_SHARED_API int32_t get_LineNumberOffset();
    ASPOSECPP_SHARED_API void set_LineNumberOffset(int32_t value);
    ASPOSECPP_SHARED_API int32_t get_LinePositionOffset();
    ASPOSECPP_SHARED_API void set_LinePositionOffset(int32_t value);
    ASPOSECPP_SHARED_API System::Xml::ConformanceLevel get_ConformanceLevel();
    ASPOSECPP_SHARED_API void set_ConformanceLevel(System::Xml::ConformanceLevel value);
    ASPOSECPP_SHARED_API bool get_CheckCharacters();
    ASPOSECPP_SHARED_API void set_CheckCharacters(bool value);
    ASPOSECPP_SHARED_API int64_t get_MaxCharactersInDocument();
    ASPOSECPP_SHARED_API void set_MaxCharactersInDocument(int64_t value);
    ASPOSECPP_SHARED_API int64_t get_MaxCharactersFromEntities();
    ASPOSECPP_SHARED_API void set_MaxCharactersFromEntities(int64_t value);
    ASPOSECPP_SHARED_API bool get_IgnoreWhitespace();
    ASPOSECPP_SHARED_API void set_IgnoreWhitespace(bool value);
    ASPOSECPP_SHARED_API bool get_IgnoreProcessingInstructions();
    ASPOSECPP_SHARED_API void set_IgnoreProcessingInstructions(bool value);
    ASPOSECPP_SHARED_API bool get_IgnoreComments();
    ASPOSECPP_SHARED_API void set_IgnoreComments(bool value);
    ASPOSECPP_SHARED_API bool get_ProhibitDtd();
    ASPOSECPP_SHARED_API void set_ProhibitDtd(bool value);
    ASPOSECPP_SHARED_API System::Xml::DtdProcessing get_DtdProcessing();
    ASPOSECPP_SHARED_API void set_DtdProcessing(System::Xml::DtdProcessing value);
    ASPOSECPP_SHARED_API bool get_CloseInput();
    ASPOSECPP_SHARED_API void set_CloseInput(bool value);
    ASPOSECPP_SHARED_API System::Xml::ValidationType get_ValidationType();
    ASPOSECPP_SHARED_API void set_ValidationType(System::Xml::ValidationType value);
    ASPOSECPP_SHARED_API Schema::XmlSchemaValidationFlags get_ValidationFlags();
    ASPOSECPP_SHARED_API void set_ValidationFlags(Schema::XmlSchemaValidationFlags value);
    ASPOSECPP_SHARED_API SharedPtr<Schema::XmlSchemaSet> get_Schemas();
    ASPOSECPP_SHARED_API void set_Schemas(const SharedPtr<Schema::XmlSchemaSet>& value);
 
    ASPOSECPP_SHARED_API XmlReaderSettings();
 
    template<class... Args> void ValidationEventHandler_add(Args... value)
    {
        CheckReadOnly(u"ValidationEventHandler");
        _valEventHandler.connect(value...);
    }
    template<class... Args> void ValidationEventHandler_remove(Args... value)
    {
        CheckReadOnly(u"ValidationEventHandler");
        _valEventHandler.disconnect(value...);
    }
 
    ASPOSECPP_SHARED_API void Reset();
    ASPOSECPP_SHARED_API SharedPtr<XmlReaderSettings> Clone();
    // For internal purposes
    ASPOSECPP_SHARED_API void CheckReadOnly(const String& propertyName);
 
protected:
 
    bool get_IsXmlResolverSet();
    void set_IsXmlResolverSet(bool value);
    bool get_ReadOnly();
    void set_ReadOnly(bool value);
 
    SharedPtr<System::Xml::XmlResolver> GetXmlResolver();
    SharedPtr<System::Xml::XmlResolver> GetXmlResolver_CheckConfig();
    System::Xml::Schema::ValidationEventHandler& GetEventHandler();
    SharedPtr<XmlReader> CreateReader(const String& inputUri, const SharedPtr<XmlParserContext>& inputContext);
    SharedPtr<XmlReader> CreateReader(const SharedPtr<IO::Stream>& input, const SharedPtr<Uri>& baseUri, String baseUriString, const SharedPtr<XmlParserContext>& inputContext);
    SharedPtr<XmlReader> CreateReader(const SharedPtr<IO::TextReader>& input, String baseUriString, const SharedPtr<XmlParserContext>& inputContext);
    SharedPtr<XmlReader> CreateReader(const SharedPtr<XmlReader>& reader);
    SharedPtr<XmlReader> AddValidation(SharedPtr<XmlReader> reader);
    SharedPtr<XmlReader> AddConformanceWrapper(const SharedPtr<XmlReader>& baseReader);
 
    virtual ASPOSECPP_SHARED_API ~XmlReaderSettings();
 
    #ifdef ASPOSE_GET_SHARED_MEMBERS
    ASPOSECPP_SHARED_API void GetSharedMembers(System::Object::shared_members_type& result) const override;
    #endif
 
private:
 
    SharedPtr<XmlNameTable> _nameTable;
    SharedPtr<System::Xml::XmlResolver> _xmlResolver;
    int32_t _lineNumberOffset;
    int32_t _linePositionOffset;
    System::Xml::ConformanceLevel _conformanceLevel;
    bool _checkCharacters;
    int64_t _maxCharactersInDocument;
    int64_t _maxCharactersFromEntities;
    bool _ignoreWhitespace;
    bool _ignorePIs;
    bool _ignoreComments;
    System::Xml::DtdProcessing _dtdProcessing;
    System::Xml::ValidationType _validationType;
    Schema::XmlSchemaValidationFlags _validationFlags;
    SharedPtr<Schema::XmlSchemaSet> _schemas;
    System::Xml::Schema::ValidationEventHandler _valEventHandler;
    bool _closeInput;
    bool _isReadOnly;
    bool pr_IsXmlResolverSet;
 
    void Initialize();
    void Initialize(const SharedPtr<System::Xml::XmlResolver>& resolver);
    static SharedPtr<System::Xml::XmlResolver> CreateDefaultResolver();
    SharedPtr<XmlReader> AddValidationAndConformanceWrapper(SharedPtr<XmlReader> reader);
    SharedPtr<XmlValidatingReaderImpl> CreateDtdValidatingReader(const SharedPtr<XmlReader>& baseReader);
 
};
 
} // namespace Xml
} // namespace System