MemoryWriter.hpp

#ifndef MEMORYWRITER_HPP
#define MEMORYWRITER_HPP

#include <string>
#include <memory>
#include <functional>
#include "athena/IStreamWriter.hpp"

namespace athena
{
namespace io
{

class MemoryWriter : public IStreamWriter
{
public:

    virtual ~MemoryWriter();

    explicit MemoryWriter(atUint8* data, atUint64 length, bool takeOwnership = false);

    void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current);


    inline atUint64 position()    const
    {return m_position;}

    inline atUint64 length()      const
    {return m_length;}

    inline bool isOpen() const {return true;}

    void  setData(atUint8* data, atUint64 length, bool takeOwnership = false);


    atUint8* data() const;

    inline void setFilepath(const std::string& filepath)
    {m_filepath = filepath;}

    inline std::string filepath() const
    {return m_filepath;}


    void save(const std::string& filename = "");

    void writeUBytes(const atUint8* data, atUint64 len);

protected:
    MemoryWriter() {}
    atUint8*      m_data;
    atUint64      m_length;
    atUint64      m_position;
    bool          m_bufferOwned;
    std::string   m_filepath; 
};

class MemoryCopyWriter : public MemoryWriter
{
public:

    explicit MemoryCopyWriter(atUint8* data=nullptr, atUint64 length=0x10);

    MemoryCopyWriter(const std::string& filename);

    void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current);

    void  setData(const atUint8* data, atUint64 length);

    void writeUBytes(const atUint8* data, atUint64 len);

protected:
    std::unique_ptr<atUint8[]> m_dataCopy;
private:
    void resize(atUint64 newSize);
};

}
}

#ifndef MEMORYWRITER_BASE
#define MEMORYWRITER_BASE() \
    private: \
        typedef athena::io::MemoryWriter base
#endif // BINARYWRITER_BASE

#ifndef MEMORYCOPYWRITER_BASE
#define MEMORYCOPYWRITER_BASE() \
    private: \
        typedef athena::io::MemoryCopyWriter base
#endif // BINARYWRITER_BASE

#endif // MEMORYWRITER_HPP