std_stream_wrappers.h

 
#pragma once
 
#include <iostream>
#include <vector>
#include "system/io/stream.h"
#include "system/bit_converter.h"
#include "system/details/is_template_base_of.h"
 
namespace System { namespace IO {
 
using System::Details::IsTemplateBaseOf;
 
enum class STDIOStreamWrappingMode
{
    Binary,
    Conversion,
};
 
enum class STDIOStreamPositionPreference
{
    Zero,
    ReadPosition,
    WritePosition,
};
 
template <typename T, typename = std::enable_if_t<IsTemplateBaseOf<std::basic_ios, T>::value>>
class STDIOStreamWrapperBase : public Stream
{
public:
    using ThisType = STDIOStreamWrapperBase<T>;
    using BaseType = Stream;
    using ThisTypeBaseTypesInfo = BaseTypesInfo<BaseType>;
    RTTI_INFO_TEMPLATE_CLASS(ThisType, ThisTypeBaseTypesInfo);
 
public:
    using char_type = typename T::char_type;
    using traits_type = typename T::traits_type;
 
    using int_type = typename T::int_type;
    using pos_type = typename T::pos_type;
    using off_type = typename T::off_type;
 
    STDIOStreamWrapperBase(const STDIOStreamWrapperBase&) = delete;
 
    STDIOStreamWrapperBase& operator=(const STDIOStreamWrapperBase&) = delete;
 
    virtual int64_t Seek(int64_t offset, SeekOrigin origin) override
    {
        Check();
 
        if (origin < SeekOrigin::Begin || origin > SeekOrigin::End)
            throw ArgumentException(u"Invalid SeekOrigin enum value", u"origin");
 
        if (!get_CanSeek())
            throw NotSupportedException(u"Can't seek stream.");
 
        int64_t new_pos;
        if (m_wrapping_mode == STDIOStreamWrappingMode::Conversion)
        {
            if (origin == SeekOrigin::Begin)
            {
                new_pos = offset;
            }
            else if (origin == SeekOrigin::Current)
            {
                new_pos = m_elem_pos + offset;
            }
            else
            {
                new_pos = m_length + offset;
            }
 
            if (new_pos < 0)
                throw ArgumentOutOfRangeException(u"Seeking is attempted before the beginning of the stream.");
 
            if (new_pos == m_elem_pos)
                return m_elem_pos;
 
            Pubseekpos(new_pos);
        }
        else
        { // m_wrapping_mode == STDIOStreamWrappingMode::Binary
            if (origin == SeekOrigin::Begin)
            {
                new_pos = offset;
            }
            else if (origin == SeekOrigin::Current)
            {
                new_pos = m_byte_pos + offset;
            }
            else
            {
                new_pos = m_length * m_elem_size + offset;
            }
 
            if (new_pos < 0)
                throw ArgumentOutOfRangeException(u"Seeking is attempted before the beginning of the stream.");
 
            if (new_pos == m_byte_pos)
                return m_byte_pos;
 
            bool has_new_byte_pos_shift = new_pos % m_elem_size != 0;
            int64_t new_elem_pos = Pubseekpos(new_pos / m_elem_size + int(has_new_byte_pos_shift));
            if (new_elem_pos != -1)
            {
                m_byte_pos = new_pos;
                if (has_new_byte_pos_shift)
                {
                    Pubseekpos(new_elem_pos - 1);
                }
 
                DecodeElem(m_stream.rdbuf()->sgetc());
            }
        }
 
        Sync();
        return new_pos;
    }
 
    virtual void set_Position(int64_t value) override
    {
        Check();
 
        if (!get_CanSeek())
            throw NotSupportedException(u"Can't seek stream.");
 
        if (value < 0)
            throw ArgumentOutOfRangeException(u"value must be non-negative");
 
        if (m_wrapping_mode == STDIOStreamWrappingMode::Conversion)
        {
            if (value == m_elem_pos)
                return;
 
            Pubseekpos(value);
        }
        else
        { // m_wrapping_mode == STDIOStreamWrappingMode::Binary
            if (value == m_byte_pos)
                return;
 
            int64_t new_byte_pos = value;
            bool has_new_byte_pos_shift = new_byte_pos % m_elem_size != 0;
            int64_t new_elem_pos = Pubseekpos(new_byte_pos / m_elem_size + int(has_new_byte_pos_shift));
            if (new_elem_pos != -1)
            {
                m_byte_pos = new_byte_pos;
                if (has_new_byte_pos_shift)
                {
                    Pubseekpos(new_elem_pos - 1);
                }
 
                DecodeElem(m_stream.rdbuf()->sgetc());
            }
        }
 
        Sync();
    }
 
    virtual int64_t get_Position() const override
    {
        Check();
 
        if (!get_CanSeek())
            throw NotSupportedException(u"Can't seek stream.");
 
        if (m_wrapping_mode == STDIOStreamWrappingMode::Conversion)
        {
            return m_elem_pos;
        }
        else
        { // m_wrapping_mode == STDIOStreamWrappingMode::Binary
            return m_byte_pos;
        }
    }
 
    virtual int64_t get_Length() const override
    {
        Check();
 
        if (!get_CanSeek())
            throw NotSupportedException(u"Can't seek stream.");
 
        if (m_wrapping_mode == STDIOStreamWrappingMode::Conversion)
        {
            return m_length;
        }
        else
        { // m_wrapping_mode == STDIOStreamWrappingMode::Binary
            return m_length * m_elem_size;
        }
    }
 
    virtual bool get_CanRead() const override
    {
        return m_can_read && !m_stream.fail();
    }
 
    virtual bool get_CanSeek() const override
    {
        return m_can_seek && !m_stream.fail();
    }
 
    virtual bool get_CanWrite() const override
    {
        return m_can_write && !m_stream.fail();
    }
 
protected:
    STDIOStreamWrapperBase(std::basic_ios<char_type, traits_type>& str,
                           STDIOStreamWrappingMode mode = STDIOStreamWrappingMode::Binary, bool can_read = false,
                           bool can_write = false, bool can_seek = false,
                           STDIOStreamPositionPreference pref_pos = STDIOStreamPositionPreference::Zero)
        : m_stream(str), m_wrapping_mode(mode), m_can_read(can_read), m_can_write(can_write), m_can_seek(can_seek)
    {
        m_last_elem_gpos =
            can_read ? int64_t(m_stream.rdbuf()->pubseekoff(0, std::ios_base::cur, std::ios_base::in)) : int64_t(0);
        m_last_elem_ppos =
            can_write ? int64_t(m_stream.rdbuf()->pubseekoff(0, std::ios_base::cur, std::ios_base::out)) : int64_t(0);
        if (!m_can_seek)
        {
            m_elem_pos = 0;
            m_byte_pos = 0;
            m_length = 0;
        }
        else
        {
            if (m_can_read && m_can_write && m_last_elem_gpos != m_last_elem_ppos)
            {
                switch (pref_pos)
                {
                case STDIOStreamPositionPreference::Zero:
                    m_last_elem_gpos = 0;
                    m_last_elem_ppos = 0;
                    m_elem_pos = 0;
                    break;
                case STDIOStreamPositionPreference::ReadPosition:
                    m_last_elem_ppos = m_last_elem_gpos;
                    m_elem_pos = m_last_elem_gpos;
                    break;
                case STDIOStreamPositionPreference::WritePosition:
                    m_last_elem_gpos = m_last_elem_ppos;
                    m_elem_pos = m_last_elem_ppos;
                    break;
                default:
                    // nothing to do
                    break;
                }
 
                int64_t end = m_stream.rdbuf()->pubseekoff(0, std::ios_base::end, std::ios_base::in);
                int64_t beg = m_stream.rdbuf()->pubseekoff(0, std::ios_base::beg, std::ios_base::in);
                m_length = end - beg;
                m_stream.rdbuf()->pubseekpos(m_elem_pos, std::ios_base::in);
            }
            else if (m_can_read)
            {
                m_elem_pos = m_last_elem_gpos;
 
                int64_t end = m_stream.rdbuf()->pubseekoff(0, std::ios_base::end, std::ios_base::in);
                int64_t beg = m_stream.rdbuf()->pubseekoff(0, std::ios_base::beg, std::ios_base::in);
                m_length = end - beg;
                m_stream.rdbuf()->pubseekpos(m_elem_pos, std::ios_base::in);
            }
            else
            {
                m_elem_pos = m_last_elem_ppos;
 
                int64_t end = m_stream.rdbuf()->pubseekoff(0, std::ios_base::end, std::ios_base::out);
                int64_t beg = m_stream.rdbuf()->pubseekoff(0, std::ios_base::beg, std::ios_base::out);
                m_length = end - beg;
                m_stream.rdbuf()->pubseekpos(m_elem_pos, std::ios_base::out);
            }
 
            if (m_wrapping_mode == STDIOStreamWrappingMode::Binary)
            {
                m_byte_pos = m_elem_pos * m_elem_size;
            }
        }
    }
 
    virtual int64_t Pubseekpos(int64_t value) = 0;
 
    virtual void Check() const
    {
        if (m_wrapping_mode < STDIOStreamWrappingMode::Binary || m_wrapping_mode > STDIOStreamWrappingMode::Conversion)
            throw NotSupportedException(u"Wrapper does not support current wrapping mode.");
    };
 
    virtual void Sync() = 0;
 
    void DecodeElem(int_type meta)
    {
        DecodeElem(meta, m_decoded_elem);
    }
 
    void DecodeElem(int_type meta, ArrayPtr<uint8_t>& destination)
    {
        if (traits_type::eq_int_type(meta, traits_type::eof()))
        {
            destination.reset();
        }
        else
        {
            destination = BitConverter::GetBytes(meta);
        }
    }
 
    char_type EncodeElem()
    {
        return EncodeElem(m_decoded_elem->data_ptr());
    }
 
    char_type EncodeElem(uint8_t* source)
    {
        char_type result;
        EncodeElem(source, &result);
        return result;
    }
 
    void EncodeElem(uint8_t* source, char_type* destination)
    {
        auto dst = (uint8_t*)destination;
        if (System::BitConverter::_IsLittleEndian())
        {
            std::copy(source, source + m_elem_size, dst);
        }
        else
        {
            std::reverse_copy(source, source + m_elem_size, dst);
        }
    }
 
    std::basic_ios<char_type, traits_type>& m_stream;
    const STDIOStreamWrappingMode m_wrapping_mode;
    const bool m_can_read;
    const bool m_can_write;
    const bool m_can_seek;
    static constexpr uint8_t m_elem_size = sizeof(char_type);
    int64_t m_last_elem_gpos;
    int64_t m_last_elem_ppos;
    int64_t m_elem_pos;
    int64_t m_byte_pos;
    int64_t m_length;
 
    ArrayPtr<uint8_t> m_decoded_elem;
};
 
template <typename T, typename = std::enable_if_t<IsTemplateBaseOf<std::basic_istream, T>::value>>
class BasicSTDIStreamWrapper : public virtual STDIOStreamWrapperBase<T>
{
public:
    using ThisType = BasicSTDIStreamWrapper<T>;
    using BaseType = STDIOStreamWrapperBase<T>;
    using ThisTypeBaseTypesInfo = BaseTypesInfo<BaseType>;
    RTTI_INFO_TEMPLATE_CLASS(ThisType, ThisTypeBaseTypesInfo);
 
public:
    using char_type = typename BaseType::char_type;
    using traits_type = typename BaseType::traits_type;
 
    BasicSTDIStreamWrapper(std::basic_istream<char_type, traits_type>& str,
                           STDIOStreamWrappingMode mode = STDIOStreamWrappingMode::Binary)
        : BaseType(str, mode, true, false, (std::ios_base*)&str != &std::cin && (std::ios_base*)&str != &std::wcin)
    {}
 
    BasicSTDIStreamWrapper(const BasicSTDIStreamWrapper&) = delete;
 
    BasicSTDIStreamWrapper& operator=(const BasicSTDIStreamWrapper&) = delete;
 
    virtual int ReadByte() override
    {
        Check();
 
        if (!get_CanRead())
            throw NotSupportedException(u"Can't read from stream.");
 
        if (m_wrapping_mode == STDIOStreamWrappingMode::Conversion)
        {
            auto meta = m_stream.rdbuf()->sbumpc();
            if (traits_type::eq_int_type(meta, traits_type::eof()))
            {
                return -1;
            }
            else
            {
                Sync();
                return uint8_t(meta);
            }
        }
        else
        { // m_wrapping_mode == STDIOStreamWrappingMode::Binary
            if (m_decoded_elem == nullptr)
            {
                auto meta = m_stream.rdbuf()->sgetc();
                if (traits_type::eq_int_type(meta, traits_type::eof()))
                {
                    return -1;
                }
                else
                {
                    DecodeElem(meta);
                }
            }
 
            int64_t byte_pos_shift = m_byte_pos % m_elem_size;
            auto result = int(m_decoded_elem[byte_pos_shift]);
 
            ++m_byte_pos;
            ++byte_pos_shift %= m_elem_size;
            if (byte_pos_shift == 0)
            { // Decode element at new byte position.
                DecodeElem(m_stream.rdbuf()->snextc());
            }
 
            Sync();
            return result;
        }
    }
 
    virtual void WriteByte(uint8_t value) override
    {
        throw NotSupportedException(ASPOSE_CURRENT_FUNCTION);
    }
 
    virtual int32_t Read(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count) override
    {
        return Read(static_cast<System::Details::ArrayView<uint8_t>>(buffer), offset, count);
    }
 
    virtual void Write(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count) override
    {
        Write(static_cast<System::Details::ArrayView<uint8_t>>(buffer), offset, count);
    }
 
    virtual int32_t Read(const System::Details::ArrayView<uint8_t>& buffer, int32_t offset, int32_t count) override
    {
        Check();
 
        if (!get_CanRead())
            throw NotSupportedException(u"Can't read from stream.");
        if (buffer == nullptr)
            throw ArgumentNullException(u"buffer");
        if (offset < 0)
            throw ArgumentOutOfRangeException(u"offset", u"Value is less than zero");
        if (count < 0)
            throw ArgumentOutOfRangeException(u"count", u"Value is less than zero");
        if (buffer.get_Length() - offset < count)
            throw ArgumentException(u"Invalid buffer length");
 
        if (count == 0)
            return 0;
 
        if (m_elem_size == 1)
        {
            int readed_count = int(m_stream.rdbuf()->sgetn((char_type*)&buffer[offset], count));
            if (m_wrapping_mode == STDIOStreamWrappingMode::Binary)
            {
                m_byte_pos = m_stream.rdbuf()->pubseekoff(0, std::ios_base::cur, std::ios_base::in);
            }
 
            Sync();
            return readed_count;
        }
 
        if (m_wrapping_mode == STDIOStreamWrappingMode::Conversion)
        {
            std::vector<char_type> tempbuff(count, 0);
            int readed_count = int(m_stream.rdbuf()->sgetn(tempbuff.data(), count));
            auto dst = &buffer[offset];
            std::for_each(tempbuff.begin(), tempbuff.end(),
                [&dst, this](char_type& elem) { *(dst++) = uint8_t(elem); });
 
            Sync();
            return readed_count;
        }
        else
        { // m_wrapping_mode == STDIOStreamWrappingMode::Binary
            uint8_t byte_pos_shift = m_byte_pos % m_elem_size;
            int new_byte_count = byte_pos_shift + count;
            bool has_new_byte_pos_shift = new_byte_count % m_elem_size != 0;
            int elem_count = new_byte_count / m_elem_size + int(has_new_byte_pos_shift);
 
            std::vector<char_type> tempbuff(elem_count, 0);
            int readed_elem_count = int(m_stream.rdbuf()->sgetn(tempbuff.data(), elem_count));
            int readed_byte_count;
            if (readed_elem_count != elem_count)
            {
                readed_byte_count = readed_elem_count * m_elem_size - byte_pos_shift;
            }
            else
            {
                readed_byte_count = count;
                if (has_new_byte_pos_shift)
                {
                    m_stream.rdbuf()->pubseekoff(-1, std::ios_base::cur, std::ios_base::in);
                }
            }
 
            m_byte_pos += readed_byte_count;
 
            const char_type* source = &tempbuff[byte_pos_shift];
            uint8_t* destination = &buffer[offset];
            for (int i = 0; i < readed_byte_count; i += m_elem_size, ++source, destination += m_elem_size)
            {
                DecodeElem(traits_type::to_int_type(*source));
                std::strncpy((char*)destination, (const char*)m_decoded_elem->data_ptr(), m_elem_size);
            }
 
            Sync();
            return readed_byte_count;
        }
    }
 
    virtual void Write(const System::Details::ArrayView<uint8_t>& buffer, int32_t offset, int32_t count) override
    {
        throw NotSupportedException(ASPOSE_CURRENT_FUNCTION);
    }
 
    virtual void SetLength(int64_t value) override
    {
        throw NotSupportedException(ASPOSE_CURRENT_FUNCTION);
    }
 
    virtual void Flush() override
    {
        throw NotSupportedException(ASPOSE_CURRENT_FUNCTION);
    }
 
protected:
    virtual int64_t Pubseekpos(int64_t value) override
    {
        return m_stream.rdbuf()->pubseekpos(value, std::ios_base::in);
    }
 
    virtual void Check() const override
    {
        BaseType::Check();
        auto elem_gpos = m_stream.rdbuf()->pubseekoff(0, std::ios_base::cur, std::ios_base::in);
        if (m_stream.fail() || m_last_elem_gpos != elem_gpos)
        {
            if (!m_stream.fail())
            {
                m_stream.setstate(std::ios_base::failbit);
            }
 
            throw IOException(u"The stream has been modified outside the wrapper.");
        }
    }
 
    virtual void Sync() override
    {
        auto elem_gpos = m_stream.rdbuf()->pubseekoff(0, std::ios_base::cur, std::ios_base::in);
        if (m_last_elem_gpos != elem_gpos)
        {
            m_last_elem_gpos = elem_gpos;
            m_elem_pos = elem_gpos;
        }
    }
 
    using BaseType::DecodeElem;
    using BaseType::get_CanRead;
 
    using BaseType::m_byte_pos;
    using BaseType::m_decoded_elem;
    using BaseType::m_elem_pos;
    using BaseType::m_elem_size;
    using BaseType::m_last_elem_gpos;
    using BaseType::m_stream;
    using BaseType::m_wrapping_mode;
};
 
template <typename T, typename = std::enable_if_t<IsTemplateBaseOf<std::basic_ostream, T>::value>>
class BasicSTDOStreamWrapper : public virtual STDIOStreamWrapperBase<T>
{
public:
    using ThisType = BasicSTDOStreamWrapper<T>;
    using BaseType = STDIOStreamWrapperBase<T>;
    using ThisTypeBaseTypesInfo = BaseTypesInfo<BaseType>;
    RTTI_INFO_TEMPLATE_CLASS(ThisType, ThisTypeBaseTypesInfo);
 
public:
    using char_type = typename BaseType::char_type;
    using traits_type = typename BaseType::traits_type;
 
    BasicSTDOStreamWrapper(std::basic_ostream<char_type, traits_type>& str,
                           STDIOStreamWrappingMode mode = STDIOStreamWrappingMode::Binary)
        : BaseType(str, mode, false, true, (std::ios_base*)&str != &std::cout && (std::ios_base*)&str != &std::wcout)
    {}
 
    BasicSTDOStreamWrapper(const BasicSTDOStreamWrapper&) = delete;
 
    BasicSTDOStreamWrapper& operator=(const BasicSTDOStreamWrapper&) = delete;
 
    virtual int ReadByte() override
    {
        throw NotSupportedException(ASPOSE_CURRENT_FUNCTION);
    }
 
    virtual void WriteByte(uint8_t value) override
    {
        Check();
 
        if (!get_CanWrite())
            throw NotSupportedException(u"Can't write to stream.");
 
        if (m_wrapping_mode == STDIOStreamWrappingMode::Conversion)
        {
            m_stream.rdbuf()->sputc(char_type(value));
        }
        else
        { // m_wrapping_mode == STDIOStreamWrappingMode::Binary
            if (m_decoded_elem == nullptr)
            {
                m_decoded_elem = MakeArray<uint8_t>(m_elem_size, 0);
            }
 
            int64_t byte_pos_shift = m_byte_pos % m_elem_size;
            m_decoded_elem[byte_pos_shift] = value;
            ++m_byte_pos;
            ++byte_pos_shift %= m_elem_size;
 
            m_stream.rdbuf()->sputc(EncodeElem());
            if (byte_pos_shift != 0)
            { // New byte position is previous element position.
                m_stream.rdbuf()->pubseekoff(-1, std::ios_base::cur, std::ios_base::in);
            }
            else
            { // Decode element at new byte position.
                DecodeElem(m_stream.rdbuf()->sgetc());
            }
        }
 
        Sync();
    }
 
    virtual int32_t Read(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count) override
    {
        return Read(static_cast<System::Details::ArrayView<uint8_t>>(buffer), offset, count);
    }
 
    virtual void Write(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count) override
    {
        Write(static_cast<System::Details::ArrayView<uint8_t>>(buffer), offset, count);
    }
 
    virtual int32_t Read(const System::Details::ArrayView<uint8_t>& buffer, int32_t offset, int32_t count) override
    {
        throw NotSupportedException(ASPOSE_CURRENT_FUNCTION);
    }
 
    virtual void Write(const System::Details::ArrayView<uint8_t>& buffer, int32_t offset, int32_t count) override
    {
        Check();
 
        if (!get_CanWrite())
            throw NotSupportedException(u"Can't write to stream.");
        if (buffer == nullptr)
            throw ArgumentNullException(u"buffer");
        if (offset < 0)
            throw ArgumentOutOfRangeException(u"offset", u"Value is less than zero");
        if (count < 0)
            throw ArgumentOutOfRangeException(u"count", u"Value is less than zero");
        if (buffer.get_Length() - offset < count)
            throw ArgumentException(u"Invalid buffer length");
 
        if (count == 0)
            return;
 
        if (sizeof(char_type) == 1)
        {
            m_stream.rdbuf()->sputn((const char_type*)&buffer[offset], count);
            if (m_wrapping_mode == STDIOStreamWrappingMode::Binary)
            {
                m_byte_pos = m_stream.rdbuf()->pubseekoff(0, std::ios_base::cur, std::ios_base::out);
            }
 
            Sync();
            return;
        }
 
        if (m_wrapping_mode == STDIOStreamWrappingMode::Conversion)
        {
            std::vector<char_type> tempbuff(count, 0);
            auto dst = tempbuff.data();
            std::for_each(buffer.begin() + offset, buffer.begin() + offset + count,
                [&dst, this](uint8_t& byte) { *(dst++) = char_type(byte); });
            m_stream.rdbuf()->sputn(tempbuff.data(), count);
 
            Sync();
        }
        else
        { // m_wrapping_mode == STDIOStreamWrappingMode::Binary
            if (m_decoded_elem == nullptr)
            {
                m_decoded_elem = MakeArray<uint8_t>(m_elem_size, 0);
            }
 
            uint8_t* source = &buffer[offset];
            uint8_t byte_pos_shift = m_byte_pos % m_elem_size;
            m_byte_pos += count;
 
            if (byte_pos_shift != 0)
            {
                for (; count > 0 && byte_pos_shift != 0; ++source, --count, ++byte_pos_shift %= m_elem_size)
                { // Append to the remaining memory cells of the decoded_elem.
                    m_decoded_elem[byte_pos_shift] = *source;
                }
 
                m_stream.rdbuf()->sputc(EncodeElem());
 
                if (byte_pos_shift != 0)
                { // New byte position is previous element position.
                    m_stream.rdbuf()->pubseekoff(-1, std::ios_base::cur, std::ios_base::out);
 
                    Sync();
                    return;
                }
            }
 
            int elem_count = count / m_elem_size;
            if (elem_count != 0)
            { // Encode and put elem_count elements into stream.
                std::vector<char_type> tempbuff(elem_count, 0);
                char_type* destination = tempbuff.data();
                for (; count >= m_elem_size; source += m_elem_size, ++destination, count -= m_elem_size)
                {
                    EncodeElem(source, destination);
                }
 
                m_stream.rdbuf()->sputn(tempbuff.data(), elem_count);
            }
 
            DecodeElem(m_stream.rdbuf()->sgetc());
 
            if (count != 0)
            { // There are unwritten bytes. Write bytes in decoded_elem, encode it and put result in the stream.
                if (m_decoded_elem == nullptr)
                {
                    m_decoded_elem = MakeArray<uint8_t>(m_elem_size, 0);
                }
 
                for (; count > 0; ++source, --count, ++byte_pos_shift %= m_elem_size)
                {
                    m_decoded_elem[byte_pos_shift] = *source;
                }
 
                m_stream.rdbuf()->sputc(EncodeElem());
                m_stream.rdbuf()->pubseekoff(-1, std::ios_base::cur, std::ios_base::out);
            }
 
            Sync();
        }
    }
 
    virtual void SetLength(int64_t value) override
    {
        throw NotSupportedException(ASPOSE_CURRENT_FUNCTION);
    }
 
    virtual void Flush() override
    {
        Check();
 
        if (!get_CanWrite())
            throw NotSupportedException(u"Can't write to stream.");
 
        m_stream.rdbuf()->pubsync();
    }
 
protected:
    virtual int64_t Pubseekpos(int64_t value) override
    {
        return m_stream.rdbuf()->pubseekpos(value, std::ios_base::out);
    }
 
    virtual void Check() const override
    {
        BaseType::Check();
        auto elem_ppos = m_stream.rdbuf()->pubseekoff(0, std::ios_base::cur, std::ios_base::out);
        if (m_stream.fail() || m_last_elem_ppos != elem_ppos)
        {
            if (!m_stream.fail())
            {
                m_stream.setstate(std::ios_base::failbit);
            }
 
            throw IOException(u"The stream has been modified outside the wrapper.");
        }
    }
 
    virtual void Sync() override
    {
        auto elem_ppos = m_stream.rdbuf()->pubseekoff(0, std::ios_base::cur, std::ios_base::out);
        if (m_last_elem_ppos != elem_ppos)
        {
            m_elem_pos = elem_ppos;
            m_last_elem_ppos = m_elem_pos;
            if (m_elem_pos > m_length)
            {
                m_length = m_elem_pos;
            }
        }
    }
 
    using BaseType::DecodeElem;
    using BaseType::EncodeElem;
    using BaseType::get_CanWrite;
 
    using BaseType::m_byte_pos;
    using BaseType::m_decoded_elem;
    using BaseType::m_elem_pos;
    using BaseType::m_elem_size;
    using BaseType::m_last_elem_ppos;
    using BaseType::m_length;
    using BaseType::m_stream;
    using BaseType::m_wrapping_mode;
};
 
template <typename T, typename = std::enable_if_t<IsTemplateBaseOf<std::basic_iostream, T>::value>>
class BasicSTDIOStreamWrapper : public BasicSTDIStreamWrapper<T>, public BasicSTDOStreamWrapper<T>
{
public:
    using ThisType = BasicSTDIOStreamWrapper<T>;
    using BaseType = STDIOStreamWrapperBase<T>;
    using BaseIType = BasicSTDIStreamWrapper<T>;
    using BaseOType = BasicSTDOStreamWrapper<T>;
    using ThisTypeBaseTypesInfo = BaseTypesInfo<BaseIType, BaseOType>;
    RTTI_INFO_TEMPLATE_CLASS(ThisType, ThisTypeBaseTypesInfo);
 
public:
    using char_type = typename BaseType::char_type;
    using traits_type = typename BaseType::traits_type;
 
    BasicSTDIOStreamWrapper(std::basic_iostream<char_type, traits_type>& str,
                            STDIOStreamWrappingMode mode = STDIOStreamWrappingMode::Binary,
                            STDIOStreamPositionPreference pref_pos = STDIOStreamPositionPreference::Zero)
        : BaseType(str, mode, true, true, true, pref_pos), BaseIType(str, mode), BaseOType(str, mode)
    {}
 
    BasicSTDIOStreamWrapper(const BasicSTDIOStreamWrapper&) = delete;
 
    BasicSTDIOStreamWrapper& operator=(const BasicSTDIOStreamWrapper&) = delete;
 
    virtual int ReadByte() override
    {
        return BaseIType::ReadByte();
    }
 
    virtual void WriteByte(uint8_t value) override
    {
        BaseOType::WriteByte(value);
    }
 
    virtual int32_t Read(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count) override
    {
        return Read(static_cast<System::Details::ArrayView<uint8_t>>(buffer), offset, count);
    }
 
    virtual void Write(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count) override
    {
        Write(static_cast<System::Details::ArrayView<uint8_t>>(buffer), offset, count);
    }
 
    virtual int32_t Read(const System::Details::ArrayView<uint8_t>& buffer, int32_t offset, int32_t count) override
    {
        return BaseIType::Read(buffer, offset, count);
    }
 
    virtual void Write(const System::Details::ArrayView<uint8_t>& buffer, int32_t offset, int32_t count) override
    {
        BaseOType::Write(buffer, offset, count);
    }
 
    virtual void SetLength(int64_t value) override
    {
        BaseOType::SetLength(value);
    }
 
    virtual void Flush() override
    {
        BaseOType::Flush();
    }
 
protected:
    virtual int64_t Pubseekpos(int64_t value)
    {
        m_stream.rdbuf()->pubseekpos(value, std::ios_base::in);
        return m_stream.rdbuf()->pubseekpos(value, std::ios_base::out);
    }
 
    virtual void Check() const
    {
        BaseType::Check();
        auto elem_gpos = m_stream.rdbuf()->pubseekoff(0, std::ios_base::cur, std::ios_base::in);
        auto elem_ppos = m_stream.rdbuf()->pubseekoff(0, std::ios_base::cur, std::ios_base::out);
        if (m_stream.fail() || m_last_elem_gpos != elem_gpos || m_last_elem_ppos != elem_ppos || elem_gpos != elem_ppos)
        {
            if (!m_stream.fail())
            {
                m_stream.setstate(std::ios_base::failbit);
            }
 
            throw IOException(u"The stream has been modified outside the wrapper.");
        }
    }
 
    virtual void Sync()
    {
        auto elem_gpos = m_stream.rdbuf()->pubseekoff(0, std::ios_base::cur, std::ios_base::in);
        auto elem_ppos = m_stream.rdbuf()->pubseekoff(0, std::ios_base::cur, std::ios_base::out);
        if (m_last_elem_gpos != elem_gpos || m_last_elem_ppos != elem_ppos)
        {
            if (m_last_elem_gpos != elem_gpos)
            {
                m_last_elem_gpos = elem_gpos;
                if (elem_ppos != elem_gpos)
                {
                    m_last_elem_ppos = m_stream.rdbuf()->pubseekpos(elem_gpos, std::ios_base::out);
                }
                else
                {
                    m_last_elem_ppos = elem_gpos;
                }
 
                m_elem_pos = elem_gpos;
            }
            else
            {
                m_last_elem_ppos = elem_ppos;
                if (elem_gpos != elem_ppos)
                {
                    m_last_elem_gpos = m_stream.rdbuf()->pubseekpos(elem_ppos, std::ios_base::in);
                }
                else
                {
                    m_last_elem_gpos = elem_ppos;
                }
 
                m_elem_pos = elem_ppos;
            }
 
            if (m_elem_pos > m_length)
            {
                m_length = m_elem_pos;
            }
        }
    }
 
    using BaseType::m_elem_pos;
    using BaseType::m_last_elem_gpos;
    using BaseType::m_last_elem_ppos;
    using BaseType::m_length;
    using BaseType::m_stream;
};
 
template <typename char_type, typename traits_type>
SharedPtr<Stream> WrapSTDIOStream(std::basic_istream<char_type, traits_type>& stream,
                                  STDIOStreamWrappingMode mode = STDIOStreamWrappingMode::Binary)
{
    return MakeObject<BasicSTDIStreamWrapper<std::basic_istream<char_type, traits_type>>>(stream, mode);
}
 
template <typename char_type, typename traits_type>
SharedPtr<Stream> WrapSTDIOStream(std::basic_ostream<char_type, traits_type>& stream,
                                  STDIOStreamWrappingMode mode = STDIOStreamWrappingMode::Binary)
{
    return MakeObject<BasicSTDOStreamWrapper<std::basic_ostream<char_type, traits_type>>>(stream, mode);
}
 
template <typename char_type, typename traits_type>
SharedPtr<Stream> WrapSTDIOStream(std::basic_iostream<char_type, traits_type>& stream,
                                  STDIOStreamWrappingMode mode = STDIOStreamWrappingMode::Binary,
                                  STDIOStreamPositionPreference pref_pos = STDIOStreamPositionPreference::Zero)
{
    return MakeObject<BasicSTDIOStreamWrapper<std::basic_iostream<char_type, traits_type>>>(stream, mode);
}
 
using STDIStreamWrapper = BasicSTDIStreamWrapper<std::istream>;
using STDWIStreamWrapper = BasicSTDIStreamWrapper<std::wistream>;
using STDOStreamWrapper = BasicSTDOStreamWrapper<std::ostream>;
using STDWOStreamWrapper = BasicSTDOStreamWrapper<std::wostream>;
using STDIOStreamWrapper = BasicSTDIOStreamWrapper<std::iostream>;
using STDWIOStreamWrapper = BasicSTDIOStreamWrapper<std::wiostream>;
 
}} // namespace System::IO