string_writer.h

 
#ifndef string_writer_h
#define string_writer_h
 
#include "fwd.h"
 
#include "system/iformatprovider.h"
#include "system/exceptions.h"
#include "system/reflection.h"
#include "system/globalization/culture_info.h"
#include "system/io/text_writer.h"
#include "system/text/string_builder.h"
#include "system/text/unicode_encoding.h"
 
namespace System { namespace IO {
    class ASPOSECPP_SHARED_CLASS StringWriter : public TextWriter
    {
        RTTI_INFO(System::IO::StringWriter, ::System::BaseTypesInfo<System::IO::TextWriter>)
 
    public:
        StringWriter(const System::SharedPtr<Text::StringBuilder>& sb, const IFormatProviderPtr& formatProvider) : TextWriter(formatProvider)
        {
            if (sb == nullptr)
                throw ArgumentNullException(u"StringBuilder");
            _sb = sb;
        }
 
        StringWriter(const System::SharedPtr<Text::StringBuilder>& sb)
            : StringWriter(sb, Globalization::CultureInfo::get_CurrentCulture()) {}
 
        StringWriter(const IFormatProviderPtr& formatProvider)
            : StringWriter(MakeObject<Text::StringBuilder>(), formatProvider) {}
 
        StringWriter()
            : StringWriter(MakeObject<Text::StringBuilder>(), Globalization::CultureInfo::get_CurrentCulture()) {}
 
        virtual SharedPtr<Text::Encoding> get_Encoding() override
        {
            if (m_Encoding == nullptr)
                m_Encoding = MakeObject<Text::UnicodeEncoding>(false, false);
            return m_Encoding;
        };
 
        virtual SharedPtr<Text::StringBuilder> GetStringBuilder()
        {
            return _sb;
        }
 
        virtual void Write(char_t value) override {
            _sb->Append(value);
        }
 
        virtual void Write(const ArrayPtr<char_t>& buffer, int32_t index, int32_t count) override {
            if (buffer == nullptr)
                throw ArgumentNullException(u"buffer");
            if (index < 0)
                throw ArgumentOutOfRangeException(u"index");
            if (count < 0)
                throw ArgumentOutOfRangeException(u"count");
            if (buffer->get_Length() - index < count)
                throw ArgumentException(u"insufficient buffer length");
 
            _sb->Append(buffer, index, count);
        }
 
        virtual void Write(const String& value) override {
            if (!value.IsNull()) _sb->Append(value);
        }
 
        virtual String ToString() const override
        {
            return _sb->ToString();
        }
 
    private:
 
        SharedPtr<Text::StringBuilder> _sb = nullptr;
        static SharedPtr<Text::UnicodeEncoding> ASPOSECPP_SHARED_API m_Encoding;
 
    };
 
}} // namespace System{ namespace IO{
 
#endif //string_writer_h