xml_text_writer.h

 
 
#pragma once
 
#include <xml/xml_writer.h>
#include <xml/xml_space.h>
#include <xml/xml_char_type.h>
#include <xml/write_state.h>
#include <xml/formatting.h>
#include <system/array.h>
#include <cstdint>
 
 
namespace System
{
namespace Collections
{
namespace Generic
{
template <typename, typename> class Dictionary;
} // namespace Generic
} // namespace Collections
namespace IO
{
class Stream;
class TextWriter;
} // namespace IO
namespace Text
{
class Encoding;
} // namespace Text
namespace Xml
{
class XmlTextEncoder;
class XmlTextWriterBase64Encoder;
} // namespace Xml
} // namespace System
 
namespace System {
 
namespace Xml {
 
class ASPOSECPP_SHARED_CLASS XmlTextWriter : public XmlWriter
{
    typedef XmlTextWriter ThisType;
    typedef XmlWriter BaseType;
 
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    ASPOSECPP_SHARED_RTTI_INFO_DECL();
 
public:
 
    using Ptr = SharedPtr<XmlTextWriter>;
 
public:
    using XmlWriter::XmlWriter::WriteStartElement;
 
public:
    using XmlWriter::XmlWriter::WriteStartAttribute;
 
private:
 
    enum class NamespaceState
    {
        Uninitialized,
        NotDeclaredButInScope,
        DeclaredButNotWrittenOut,
        DeclaredAndWrittenOut
    };
 
    enum class SpecialAttr
    {
        None,
        XmlSpace,
        XmlLang,
        XmlNs
    };
 
    enum class State
    {
        Start,
        Prolog,
        PostDTD,
        Element,
        Attribute,
        Content,
        AttrOnly,
        Epilog,
        Error,
        Closed
    };
 
    enum class Token
    {
        PI,
        Doctype,
        Comment,
        CData,
        StartElement,
        EndElement,
        LongEndElement,
        StartAttribute,
        EndAttribute,
        Content,
        Base64,
        RawData,
        Whitespace,
        Empty
    };
 
 
private:
 
    class TagInfo : public System::Object
    {
        typedef TagInfo ThisType;
        typedef System::Object BaseType;
 
        typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
        RTTI_INFO_DECL();
 
    public:
 
        String name;
        String prefix;
        String defaultNs;
        XmlTextWriter::NamespaceState defaultNsState;
        XmlSpace xmlSpace;
        String xmlLang;
        int32_t prevNsTop;
        int32_t prefixCount;
        bool mixed;
 
        void Init(int32_t nsTop);
 
        TagInfo();
 
    protected:
 
        #ifdef ASPOSE_GET_SHARED_MEMBERS
        void GetSharedMembers(System::Object::shared_members_type& result) const override;
        #endif
 
        #ifdef __DBG_FOR_EACH_MEMBER
    public:
        ASPOSECPP_SHARED_API void DBG_for_each_member(DBG::for_each_member_visitor& visitor) const override;
        const char* DBG_class_name() const override { return "XmlTextWriter"; }
    #endif
 
 
    };
 
    class Namespace : public System::Object
    {
        typedef Namespace ThisType;
        typedef System::Object BaseType;
 
        typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
        RTTI_INFO_DECL();
 
    public:
 
        String prefix;
        String ns;
        bool declared;
        int32_t prevNsIndex;
 
        void Set(const String& prefix, const String& ns, bool declared);
 
        Namespace();
 
    };
 
 
public:
 
    ASPOSECPP_SHARED_API SharedPtr<IO::Stream> get_BaseStream();
    ASPOSECPP_SHARED_API bool get_Namespaces();
    ASPOSECPP_SHARED_API void set_Namespaces(bool value);
    ASPOSECPP_SHARED_API System::Xml::Formatting get_Formatting();
    ASPOSECPP_SHARED_API void set_Formatting(System::Xml::Formatting value);
    ASPOSECPP_SHARED_API int32_t get_Indentation();
    ASPOSECPP_SHARED_API void set_Indentation(int32_t value);
    ASPOSECPP_SHARED_API char16_t get_IndentChar();
    ASPOSECPP_SHARED_API void set_IndentChar(char16_t value);
    ASPOSECPP_SHARED_API char16_t get_QuoteChar();
    ASPOSECPP_SHARED_API void set_QuoteChar(char16_t value);
    ASPOSECPP_SHARED_API System::Xml::WriteState get_WriteState() override;
    ASPOSECPP_SHARED_API System::Xml::XmlSpace get_XmlSpace() override;
    ASPOSECPP_SHARED_API String get_XmlLang() override;
 
    ASPOSECPP_SHARED_API XmlTextWriter(const SharedPtr<IO::Stream>& w, const SharedPtr<Text::Encoding>& encoding);
    ASPOSECPP_SHARED_API XmlTextWriter(const String& filename, const SharedPtr<Text::Encoding>& encoding);
    ASPOSECPP_SHARED_API XmlTextWriter(const SharedPtr<IO::TextWriter>& w);
 
    ASPOSECPP_SHARED_API void WriteStartDocument() override;
    ASPOSECPP_SHARED_API void WriteStartDocument(bool standalone) override;
    ASPOSECPP_SHARED_API void WriteEndDocument() override;
    ASPOSECPP_SHARED_API void WriteDocType(const String& name, const String& pubid, const String& sysid, const String& subset) override;
    ASPOSECPP_SHARED_API void WriteStartElement(const String& prefix, const String& localName, const String& ns) override;
    ASPOSECPP_SHARED_API void WriteEndElement() override;
    ASPOSECPP_SHARED_API void WriteFullEndElement() override;
    ASPOSECPP_SHARED_API void WriteStartAttribute(const String& prefix, const String& localName, const String& ns) override;
    ASPOSECPP_SHARED_API void WriteEndAttribute() override;
    ASPOSECPP_SHARED_API void WriteCData(String text) override;
    ASPOSECPP_SHARED_API void WriteComment(String text) override;
    ASPOSECPP_SHARED_API void WriteProcessingInstruction(String name, String text) override;
    ASPOSECPP_SHARED_API void WriteEntityRef(const String& name) override;
    ASPOSECPP_SHARED_API void WriteCharEntity(char16_t ch) override;
    ASPOSECPP_SHARED_API void WriteWhitespace(String ws) override;
    ASPOSECPP_SHARED_API void WriteString(const String& text) override;
    ASPOSECPP_SHARED_API void WriteSurrogateCharEntity(char16_t lowChar, char16_t highChar) override;
    ASPOSECPP_SHARED_API void WriteChars(ArrayPtr<char16_t> buffer, int32_t index, int32_t count) override;
    ASPOSECPP_SHARED_API void WriteRaw(ArrayPtr<char16_t> buffer, int32_t index, int32_t count) override;
    ASPOSECPP_SHARED_API void WriteRaw(const String& data) override;
    ASPOSECPP_SHARED_API void WriteBase64(ArrayPtr<uint8_t> buffer, int32_t index, int32_t count) override;
    ASPOSECPP_SHARED_API void WriteBinHex(ArrayPtr<uint8_t> buffer, int32_t index, int32_t count) override;
    ASPOSECPP_SHARED_API void Close() override;
    ASPOSECPP_SHARED_API void Flush() override;
    ASPOSECPP_SHARED_API void WriteName(const String& name) override;
    ASPOSECPP_SHARED_API void WriteQualifiedName(const String& localName, const String& ns) override;
    ASPOSECPP_SHARED_API String LookupPrefix(String ns) override;
    ASPOSECPP_SHARED_API void WriteNmToken(const String& name) override;
 
protected:
 
    XmlTextWriter();
    MEMBER_FUNCTION_MAKE_OBJECT_DECLARATION(XmlTextWriter, CODEPORTING_ARGS());
 
    virtual ASPOSECPP_SHARED_API ~XmlTextWriter();
 
    #ifdef ASPOSE_GET_SHARED_MEMBERS
    ASPOSECPP_SHARED_API void GetSharedMembers(System::Object::shared_members_type& result) const override;
    #endif
 
    #ifdef __DBG_FOR_EACH_MEMBER
public:
    ASPOSECPP_SHARED_API void DBG_for_each_member(DBG::for_each_member_visitor& visitor) const override;
    const char* DBG_class_name() const override { return "XmlTextWriter"; }
    #endif
 
private:
 
    SharedPtr<IO::TextWriter> _textWriter;
    SharedPtr<XmlTextEncoder> _xmlEncoder;
    SharedPtr<Text::Encoding> _encoding;
    System::Xml::Formatting _formatting;
    bool _indented;
    int32_t _indentation;
    char16_t _indentChar;
    ArrayPtr<XmlTextWriter::TagInfo> _stack;
    int32_t _top;
    ArrayPtr<XmlTextWriter::State> _stateTable;
    XmlTextWriter::State _currentState;
    XmlTextWriter::Token _lastToken;
    SharedPtr<XmlTextWriterBase64Encoder> _base64Encoder;
    char16_t _quoteChar;
    char16_t _curQuoteChar;
    bool _namespaces;
    XmlTextWriter::SpecialAttr _specialAttr;
    String _prefixForXmlNs;
    bool _flush;
    ArrayPtr<XmlTextWriter::Namespace> _nsStack;
    int32_t _nsTop;
    SharedPtr<Collections::Generic::Dictionary<String, int32_t>> _nsHashtable;
    bool _useNsHashtable;
    XmlCharType _xmlCharType;
    static const int32_t NamespaceStackInitialSize;
    static const int32_t MaxNamespacesWalkCount;
    static ArrayPtr<String> s_stateName;
    static ArrayPtr<String> s_tokenName;
    static ArrayPtr<XmlTextWriter::State> s_stateTableDefault;
    static ArrayPtr<XmlTextWriter::State> s_stateTableDocument;
 
    String PrepareElementPrefix(const String& prefix, const String& ns);
    String PrepareAttributePrefix(const String& prefix, const String*& localName, const String& ns);
    void StartDocument(int32_t standalone);
    void AutoComplete(XmlTextWriter::Token token);
    void AutoCompleteAll();
    void InternalWriteEndElement(bool longFormat);
    void WriteEndStartTag(bool empty);
    void WriteEndAttributeQuote();
    void Indent(bool beforeEndElement);
    void PushNamespace(const String& prefix, const String& ns, bool declared);
    void AddNamespace(const String& prefix, const String& ns, bool declared);
    void AddToNamespaceHashtable(int32_t namespaceIndex);
    void PopNamespaces(int32_t indexFrom, int32_t indexTo);
    String GeneratePrefix();
    void InternalWriteProcessingInstruction(const String& name, const String& text);
    int32_t LookupNamespace(const String& prefix);
    int32_t LookupNamespaceInCurrentScope(const String& prefix);
    String FindPrefix(const String& ns);
    void InternalWriteName(const String& name, bool isNCName);
    void ValidateName(const String& name, bool isNCName);
    void HandleSpecialAttribute();
    void VerifyPrefixXml(const String& prefix, const String& ns);
    void PushStack();
    void FlushEncoders();
 
    static struct __StaticConstructor__ { __StaticConstructor__(); } s_constructor__;
 
};
 
} // namespace Xml
} // namespace System