MemoryStream.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Commons/Io/Stream.hpp"
#include "Arp/System/Commons/Exceptions/Exceptions.h"
#include <vector>
 
namespace Arp { namespace System { namespace Commons { namespace Io
{
 
class MemoryStream : public Stream
{
public: // typedefs
 
public: // construction/destruction
    MemoryStream(void);
    MemoryStream(size_t capacity);
    MemoryStream(byte* buffer, size_t bufferSize);
    MemoryStream(byte* buffer, size_t bufferSize, boolean writable);
    MemoryStream(byte* buffer, size_t bufferSize, size_t index, size_t count);
    MemoryStream(byte* buffer, size_t bufferSize, size_t index, size_t count, boolean writable);
    MemoryStream(byte* buffer, size_t bufferSize, size_t index, size_t count, boolean writable, boolean publiclyVisible);
    MemoryStream(const MemoryStream& arg) = delete;
    MemoryStream& operator=(const MemoryStream& arg) = delete;
    virtual ~MemoryStream(void);
 
public: // operators
 
public: // static operations
 
public: // setter/getter operations
    boolean CanRead(void) override;
    boolean CanWrite(void) override;
    boolean CanSeek(void) override;
    size_t GetLength(void) override;
    void SetLength(size_t argLength) override;
    size_t GetPosition(void) override;
    void SetPosition(size_t argPostion) override;
 
    virtual size_t GetCapacity(void);
    virtual void SetCapacity(size_t argCapacity);
 
public: // operations
    void Flush(void) override;
    size_t Seek(size_t offset, SeekOrigin origin) override;
    size_t Read(byte* pBuffer, size_t bufferSize, size_t offset, size_t count) override;
    std::vector<byte> ToArray(void);
    void Write(const byte* pBuffer, size_t bufferSize, size_t offset, size_t count) override;
 
    virtual void WriteTo(Stream& stream);
 
protected: // operations
    void InternalDispose(void) override;
 
private: // static methods
 
private: // methods
    void InternalConstructor(byte* buffer, size_t bufferSize, size_t index, size_t count, boolean writable, boolean publicallyVisible);
    void EnsureSize(size_t newSize);
 
private: // fields
    // The underlying buffer of this stream.
    byte* streamBuffer;
    size_t streamBufferSize;
    // True if the stream is writeable
    boolean writeable;
    // The actual position of this stream
    size_t position;
    // The actual length of the stream.
    size_t length;
    // Is true, if the stream is expandable
    boolean expandable;
    // The capacity of the stream
    size_t capacity;
    // The initial start index in the buffer
    size_t bufferOffset;
    // Is true if it is allowed to get the underlying buffer
    boolean allowGetBuffer;
    // Is true, the buffer created by the memory stream self
    boolean selfCreated;
 
private: // static fields
    static size_t minCapacity;
};
 
// inline methods of class MemoryStream
inline MemoryStream::MemoryStream(void)
    : MemoryStream(0)
{
}
 
inline MemoryStream::MemoryStream(size_t capacity)
    : streamBuffer(nullptr), writeable(true), position(0), length(0), expandable(false), capacity(capacity), bufferOffset(0), allowGetBuffer(true), selfCreated(true)
{
    if (capacity < 0)
    {
        throw ArgumentException("{0}: capacity must not be less than 0", __FUNCTION__);
    }
 
    this->streamBuffer = new byte[capacity];
    this->streamBufferSize = capacity;
    memset(this->streamBuffer, 0, capacity);
}
 
inline MemoryStream::MemoryStream(byte* buffer, size_t bufferSize)
    : streamBuffer(nullptr), writeable(true), position(0), length(0), expandable(false), capacity(0), bufferOffset(0), allowGetBuffer(true), selfCreated(false)
{
    if (buffer == nullptr)
    {
        throw ArgumentNullException("{0}: buffer", __FUNCTION__);
    }
 
    this->InternalConstructor(buffer, bufferSize, 0, bufferSize, true, false);
}
 
inline MemoryStream::MemoryStream(byte* buffer, size_t bufferSize, boolean writable)
    : streamBuffer(nullptr), writeable(true), position(0), length(0), expandable(false), capacity(0), bufferOffset(0), allowGetBuffer(true), selfCreated(false)
{
    if (buffer == nullptr)
    {
        throw ArgumentNullException("{0}: buffer", __FUNCTION__);
    }
 
    this->InternalConstructor(buffer, bufferSize, 0, sizeof(buffer), writable, false);
}
 
inline MemoryStream::MemoryStream(byte* buffer, size_t bufferSize, size_t index, size_t count)
    : streamBuffer(nullptr), writeable(true), position(0), length(0), expandable(false), capacity(0), bufferOffset(0), allowGetBuffer(true), selfCreated(false)
{
    if (buffer == nullptr)
    {
        throw ArgumentNullException("{0}: buffer", __FUNCTION__);
    }
 
    this->InternalConstructor(buffer, bufferSize, index, count, true, false);
}
 
inline MemoryStream::MemoryStream(byte* buffer, size_t bufferSize, size_t index, size_t count, boolean writable)
    : streamBuffer(nullptr), writeable(true), position(0), length(0), expandable(false), capacity(0), bufferOffset(0), allowGetBuffer(true), selfCreated(false)
{
    this->InternalConstructor(buffer, bufferSize, index, count, writable, false);
}
 
inline MemoryStream::MemoryStream(byte* buffer, size_t bufferSize, size_t index, size_t count, boolean writable, boolean publiclyVisible)
    : streamBuffer(nullptr), writeable(true), position(0), length(0), expandable(false), capacity(0), bufferOffset(0), allowGetBuffer(true), selfCreated(false)
{
    if (buffer == nullptr)
    {
        throw ArgumentNullException("{0}: buffer", __FUNCTION__);
    }
 
    this->InternalConstructor(buffer, bufferSize, index, count, writable, publiclyVisible);
}
 
inline MemoryStream::~MemoryStream(void)
{
    this->Dispose();
}
 
}}}} // end of namespace Arp::System::Commons::Io