MemStream.h

#pragma once


#include <libutl/Stream.h>
#include <libutl/Vector.h>


UTL_NS_BEGIN;


class BinaryData;



class MemStream : public Stream
{
    UTL_CLASS_DECL(MemStream, Stream);

public:
    MemStream(size_t size, size_t increment = size_t_max)
    {
        init(nullptr, size, true, increment);
    }

    MemStream(byte_t* array, size_t size, bool owner = true, size_t increment = size_t_max)
    {
        init(array, size, owner, increment);
    }

    virtual void
    close()
    {
        clear();
    }

    virtual size_t read(byte_t* array, size_t maxBytes, size_t minBytes = size_t_max);

    virtual void write(const byte_t* array, size_t num);

    const byte_t*
    get() const
    {
        return _array.get();
    }

    size_t
    arraySize() const
    {
        return _array.size();
    }

    void takeData(BinaryData& data);

    char* copyString() const;

    char* takeString();

    void
    seekg(size_t pos)
    {
        ASSERTD(pos <= _array.size());
        _readPos = pos;
    }

    void
    seekp(size_t pos)
    {
        _writePos = pos;
        if (_writePos > _array.size())
        {
            _array.grow(_writePos);
        }
    }

    size_t
    tellg() const
    {
        return _readPos;
    }

    size_t
    tellp() const
    {
        return _writePos;
    }

    void
    reserve(size_t size, size_t increment = size_t_max)
    {
        _array.reserve(size, increment);
    }

    void truncate(size_t size);

    void set(byte_t* array, size_t size, bool owner = true, size_t increment = size_t_max);

    void
    setOwner(bool owner)
    {
        _array.setOwner(owner);
    }

    void
    setIncrement(size_t increment)
    {
        _array.setIncrement(increment);
    }

protected:
    virtual void
    clear()
    {
        set(nullptr, 0);
    }

private:
    void init(byte_t* array = nullptr,
              size_t size = KB(4),
              bool owner = true,
              size_t increment = size_t_max);
    void
    deInit()
    {
    }

private:
    Vector<byte_t> _array;
    size_t _readPos;
    size_t _writePos;
};


UTL_NS_END;