MemoryWriter.hpp

// This file is part of libAthena.
//
// libAthena is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// libAthena is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with libAthena.  If not, see <http://www.gnu.org/licenses/>

#ifndef MEMORYWRITER_HPP
#define MEMORYWRITER_HPP

#include "Athena/IStreamWriter.hpp"
#include <string>
#include <functional>

namespace Athena
{
namespace io
{

class MemoryWriter : public IStreamWriter
{
public:
    explicit MemoryWriter(atUint8* data = nullptr, atUint64 length = 0x10);

    MemoryWriter(const std::string& filename, std::function<void(int)> progressFun = nullptr);

    virtual ~MemoryWriter();

    void setEndian(Endian endian);

    Endian endian()      const;

    bool isBigEndian()   const;

    bool isLittleEndian()const;

    bool isOpen() const;

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

    inline void seekAlign32() {seek(ROUND_UP_32(m_position), SeekOrigin::Begin);}


    bool atEnd()         const;


    atUint64 position()    const;

    atUint64 length()      const;

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


    atUint8* data() const;

    void setFilepath(const std::string& filepath);

    std::string filepath() const;

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

    void seekBit(int bit);

    void writeBit(bool val);

    void writeUByte(atUint8 val);

    void writeByte(atInt8 val);

    void writeUBytes(atUint8* data, atUint64 len);

    void writeBytes(atInt8* data, atUint64 len);

    void writeInt16(atInt16 val);

    void writeUint16(atUint16);

    void writeInt32(atInt32);

    void writeUint32(atUint32);

    void writeInt64(atInt64);

    void writeUint64(atUint64);

    void writeFloat(float);

    void writeDouble(double);

    void writeBool(bool);

    void writeUnicode(const std::string& str);

    void writeString(const std::string& str);

    void fill(atUint8 val, atUint64 length);
    void fill(atInt8 val, atUint64 length);

    void setProgressCallback(std::function<void(int)> cb);
protected:
    void loadData();
    atUint8*      m_data;
    atUint64      m_length;
    std::string m_filepath; 
    atUint64      m_position;
    atUint64      m_bitPosition;
    Endian      m_endian;
    std::function<void(int)> m_progressCallback;
private:
    void resize(atUint64 newSize);
};
}
}

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