binary_reader.h

 
#pragma once
 
#include "system/array.h"
#include "system/string.h"
#include "system/idisposable.h"
#include "system/decimal.h"
#include "fwd.h"
 
namespace System {
    namespace IO {
        class Stream;
    }
    namespace Text {
        class Encoding;
        class Decoder;
    }
}
 
namespace System { namespace IO {
    class ASPOSECPP_SHARED_CLASS BinaryReader: public IDisposable
    {
        RTTI_INFO(System::IO::BinaryReader, ::System::BaseTypesInfo<System::IDisposable>)
    private:
        SharedPtr<Stream> m_stream;
        ArrayPtr<uint8_t> m_buffer;
        SharedPtr<Text::Decoder> decoder;
        ArrayPtr<char_t> charBuffer;
        ArrayPtr<uint8_t> charByteBuffer;
 
        //
        // 128 chars should cover most strings in one grab.
        enum {
            MaxBufferSize = 128
        };
 
        bool m_disposed;
        const bool leave_open;
        void * m_native_converter;
        bool m_isMemoryStream;
 
    public:
        ASPOSECPP_SHARED_API BinaryReader(const SharedPtr<Stream>& input);
        ASPOSECPP_SHARED_API BinaryReader(const SharedPtr<Stream>& input, const SharedPtr<Text::Encoding>& encoding);
        ASPOSECPP_SHARED_API BinaryReader(const SharedPtr<Stream>& input, const SharedPtr<Text::Encoding>& encoding, bool leaveOpen);
 
        virtual ASPOSECPP_SHARED_API SharedPtr<Stream> get_BaseStream();
 
        virtual ASPOSECPP_SHARED_API void Close();
 
        virtual ASPOSECPP_SHARED_API ~BinaryReader();
 
        virtual ASPOSECPP_SHARED_API int PeekChar();
 
        virtual ASPOSECPP_SHARED_API int Read();
        
        virtual ASPOSECPP_SHARED_API int Read(ArrayPtr<uint8_t> buffer, int index, int count);
 
        virtual ASPOSECPP_SHARED_API int Read(ArrayPtr<char_t> buffer, int index, int count);
 
    private:
        void Dispose(bool disposing);
        void FillBuffer(int numBytes);
        ASPOSECPP_SHARED_API int ReadCharBytes(const ArrayPtr<char_t>& buffer, int index, int count, int &bytes_read);
 
    protected:
        ASPOSECPP_SHARED_API int Read7BitEncodedInt();
 
    public:
        virtual ASPOSECPP_SHARED_API bool ReadBoolean();
 
        virtual ASPOSECPP_SHARED_API uint8_t ReadByte();
 
        virtual ASPOSECPP_SHARED_API ArrayPtr<uint8_t> ReadBytes(int count);
 
        virtual ASPOSECPP_SHARED_API char_t ReadChar();
 
        virtual ASPOSECPP_SHARED_API ArrayPtr<char_t> ReadChars(int count);
 
        //virtual decimal ReadDecimal();
        virtual ASPOSECPP_SHARED_API double ReadDouble();
 
        virtual ASPOSECPP_SHARED_API int16_t ReadInt16();
 
        virtual ASPOSECPP_SHARED_API int ReadInt32();
 
        virtual ASPOSECPP_SHARED_API int64_t ReadInt64();
 
    //C# TO C++ CONVERTER NOTE: The following .NET attribute has no direct equivalent in native C++:
    //ORIGINAL LINE: [CLSCompliant(false)] public virtual sbyte ReadSByte()
        virtual ASPOSECPP_SHARED_API int8_t ReadSByte();
        virtual ASPOSECPP_SHARED_API String ReadString();
        virtual ASPOSECPP_SHARED_API float ReadSingle();
        virtual ASPOSECPP_SHARED_API uint16_t ReadUInt16();
        virtual ASPOSECPP_SHARED_API uint32_t ReadUInt32();
        virtual ASPOSECPP_SHARED_API uint64_t ReadUInt64();
        virtual ASPOSECPP_SHARED_API Decimal ReadDecimal();
        virtual ASPOSECPP_SHARED_API void Dispose() override;
 
    private:
        void InitializeInstanceFields();
    };
 
}}