stream_writer.h

 
#ifndef __StreamWriter_h__
#define __StreamWriter_h__
 
#include "system/io/text_writer.h"
#include "system/text/encoding.h"
 
#include "fwd.h"
 
namespace System { namespace IO {
 
    class Stream;
    class ASPOSECPP_SHARED_CLASS StreamWriter : public TextWriter
    {
    public:
        using TextWriter::Write;
        using TextWriter::WriteLine;
 
        ASPOSECPP_SHARED_API StreamWriter(const SharedPtr<Stream>& stream);
        ASPOSECPP_SHARED_API StreamWriter(const SharedPtr<Stream>& stream, const EncodingPtr& encoding);
        ASPOSECPP_SHARED_API StreamWriter(const SharedPtr<Stream>& stream, const EncodingPtr& encoding, int buffer_size, bool leave_open = false);
 
        ASPOSECPP_SHARED_API StreamWriter(const String& path);
        ASPOSECPP_SHARED_API StreamWriter(const String& path, bool append, const EncodingPtr& encoding = System::Text::Encoding::get_UTF8Unmarked());
        ASPOSECPP_SHARED_API StreamWriter(const String& path, bool append, const EncodingPtr& encoding, int buffer_size);
 
        ASPOSECPP_SHARED_API ~StreamWriter();
 
        ASPOSECPP_SHARED_API bool get_AutoFlush() const;
        ASPOSECPP_SHARED_API void set_AutoFlush(bool value);
        ASPOSECPP_SHARED_API SharedPtr<Stream> get_BaseStream() const;
        ASPOSECPP_SHARED_API EncodingPtr get_Encoding() override;
 
        ASPOSECPP_SHARED_API void Write(char_t value) override;
        ASPOSECPP_SHARED_API void Write(const String &value) override;
        ASPOSECPP_SHARED_API void Write(const SharedPtr<Object>& obj) override;
 
        ASPOSECPP_SHARED_API void Write(const ArrayPtr<char_t>& buffer) override;
        ASPOSECPP_SHARED_API void Write(const ArrayPtr<char_t>& buffer, int32_t index, int32_t count) override;
        ASPOSECPP_SHARED_API void Write(const char_t* buffer) override;
 
        ASPOSECPP_SHARED_API void WriteLine() override;
        ASPOSECPP_SHARED_API void WriteLine(const String &value) override;
        ASPOSECPP_SHARED_API void WriteLine(const SharedPtr<Object>& obj) override;
        ASPOSECPP_SHARED_API void WriteLine(const ArrayPtr<char_t>& buffer) override;
        ASPOSECPP_SHARED_API void WriteLine(const ArrayPtr<char_t>& buffer, int32_t index, int32_t count) override;
        ASPOSECPP_SHARED_API void WriteLine(const char_t* buffer) override { Write(buffer); WriteLine(); }
 
        template <typename T>
        void Write(const System::SharedPtr<T>& obj)
        {
            Write(obj->ToString());
        }
 
        template <typename T>
        void WriteLine(const System::SharedPtr<T>& obj)
        {
            WriteLine(obj->ToString());
        }
 
        using TextWriter::Dispose;
 
        ASPOSECPP_SHARED_API void Close() override;
        ASPOSECPP_SHARED_API void Flush() override;
 
    protected:
        ASPOSECPP_SHARED_API void Dispose(bool disposing) override;
 
    private:
        void FlushCore();
        void FlushBytes();
        void Decode();
        void CheckState() const;
 
        void LowLevelWrite (const char_t* first, const char_t* last);
        void LowLevelWrite (std::vector<char_t>::const_iterator first, std::vector<char_t>::const_iterator last);
 
        void Initialize(const EncodingPtr& encoding, int buffer_size);
 
        bool m_flush{};
        bool m_preamble_done{};
        ArrayPtr<uint8_t> m_byte_buf;
        ArrayPtr<char_t> m_decode_buf;
        int m_byte_pos{};
        int m_decode_pos{};
        bool m_leave_open{};
 
        SharedPtr<Stream> m_internal_stream;
        EncodingPtr m_internal_encoding;
 
    protected:
#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 "StreamWriter"; }
#endif
    };
 
}}
 
#endif