memory_stream.h

 
#ifndef _aspose_system_io_memory_stream_h_
#define _aspose_system_io_memory_stream_h_
 
#include "system/io/stream.h"
#include "system/array.h"
#include "system/array_segment.h"
#include "system/reflection.h"
 
#include "fwd.h"
 
namespace System { namespace IO {
    class BinaryReader;
    class ASPOSECPP_SHARED_CLASS MemoryStream : public Stream
    {
        RTTI_INFO(System::IO::MemoryStream, ::System::BaseTypesInfo<System::IO::Stream>);
    public:
        friend System::IO::BinaryReader;
        typedef System::SharedPtr<System::IO::MemoryStream> Ptr;
 
        ASPOSECPP_SHARED_API MemoryStream();
        ASPOSECPP_SHARED_API MemoryStream(int capacity_);
        ASPOSECPP_SHARED_API MemoryStream(const ArrayPtr<uint8_t>& content, bool writable = true);
        ASPOSECPP_SHARED_API MemoryStream(const ArrayPtr<uint8_t>& content, int index, int count, bool writable = true, bool publiclyVisible = false);
 
        
 
        ASPOSECPP_SHARED_API void set_Capacity(int value);
        ASPOSECPP_SHARED_API int get_Capacity();
 
        virtual ASPOSECPP_SHARED_API ArrayPtr<uint8_t> ToArray();
 
        // Stream impl.
        ASPOSECPP_SHARED_API int ReadByte() override;
        ASPOSECPP_SHARED_API void WriteByte(uint8_t value) override;
        ASPOSECPP_SHARED_API int32_t Read(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count) override;
        ASPOSECPP_SHARED_API void Write(const ArrayPtr<uint8_t>& buffer, int32_t offset, int32_t count) override;
        ASPOSECPP_SHARED_API int32_t Read(const System::Details::ArrayView<uint8_t>& buffer, int32_t offset, int32_t count) override;
        ASPOSECPP_SHARED_API void Write(const System::Details::ArrayView<uint8_t>& buffer, int32_t offset, int32_t count) override;
 
        ASPOSECPP_SHARED_API int64_t Seek(int64_t offset, SeekOrigin origin) override;
 
        ASPOSECPP_SHARED_API void SetLength(int64_t value) override;
        ASPOSECPP_SHARED_API void Flush() override;
 
        virtual ASPOSECPP_SHARED_API void WriteTo(SharedPtr<Stream> stream);
        virtual ASPOSECPP_SHARED_API ArrayPtr<uint8_t> GetBuffer();
        bool TryGetBuffer(ArraySegment<uint8_t>& buffer);
        ASPOSECPP_SHARED_API void set_Position(int64_t value) override;
        ASPOSECPP_SHARED_API int64_t get_Position() const override;
        ASPOSECPP_SHARED_API int64_t get_Length() const override;
        ASPOSECPP_SHARED_API bool get_CanRead() const override;
        ASPOSECPP_SHARED_API bool get_CanSeek() const override;
        ASPOSECPP_SHARED_API bool get_CanWrite() const override;
        virtual ASPOSECPP_SHARED_API void Close() override;
 
    private:
        void CheckIfClosedThrowDisposed() const;
        void Expand (int newSize);
        int  CalculateNewCapacity (int minimum);
 
        // PERF: Internal functions for fast direct access of MemoryStream buffer (cf. BinaryReader for usage) 
        System::ArrayPtr<uint8_t> InternalGetBuffer();
        int32_t InternalGetPosition() const;
        int32_t InternalEmulateRead(int32_t count);
 
        ArrayPtr<uint8_t> internalBuffer;
        uint8_t* pCurrentPosition = nullptr;
        bool expandable;
        bool m_readable = true;
        bool m_seekable = true;
        bool m_writable;
        int capacity;
        int position;
        int length;
        int initialIndex;
        int dirty_bytes;
        bool _publiclyVisible;
        bool _exposable;
 
    protected:
#ifdef ASPOSE_GET_SHARED_MEMBERS
        virtual ASPOSECPP_SHARED_API void GetSharedMembers(System::Object::shared_members_type& result) const override;
#endif
 
#ifdef __DBG_FOR_EACH_MEMBER
    public:
        void DBG_for_each_member(DBG::for_each_member_visitor &visitor) const override
        {
            visitor.add_self(this);
        }
 
        const char* DBG_class_name() const override { return "MemoryStream"; }
#endif
    };
 
}}
 
#endif // _aspose_system_io_memory_stream_h_