fluxengine/lib/bytes.h

#ifndef BYTES_H
#define BYTES_H

#include <string.h>

class ByteReader;
class ByteWriter;

class Bytes
{
public:
    Bytes();
    Bytes(unsigned size);
    Bytes(const uint8_t* ptr, size_t len);
    Bytes(const char* data);
    Bytes(const std::string& data);
    Bytes(std::initializer_list<uint8_t> data);
    Bytes(std::shared_ptr<std::vector<uint8_t>> data);
    Bytes(std::shared_ptr<std::vector<uint8_t>> data, unsigned start, unsigned end);

    Bytes* operator = (const Bytes& other);

public:
	static Bytes readFromFile(const std::string& filename);

public:
    /* General purpose methods */

    unsigned size() const        { return _high - _low; }
    bool empty() const           { return _high == _low; }

    bool operator == (const Bytes& other) const
    { return std::equal(cbegin(), cend(), other.cbegin(), other.cend()); }

    bool operator != (const Bytes& other) const
    { return !(*this == other); }

    const uint8_t& operator [] (unsigned offset) const;
    const uint8_t* cbegin() const { return _data->data() + _low; }
    const uint8_t* cend() const   { return _data->data() + _high; }
    const uint8_t* begin() const  { return _data->data() + _low; }
    const uint8_t* end() const    { return _data->data() + _high; }

    uint8_t& operator [] (unsigned offset);
    uint8_t* begin()              { checkWritable(); return _data->data() + _low; }
    uint8_t* end()                { checkWritable(); return _data->data() + _high; }

	operator std::string () const { return std::string(cbegin(), cend()); }

    void boundsCheck(unsigned pos) const;
    void checkWritable();
    void adjustBounds(unsigned pos);
    Bytes& resize(unsigned size);

    Bytes& clear()
    { resize(0); return *this; }

	std::vector<Bytes> split(uint8_t separator) const;

    Bytes slice(unsigned start, unsigned len) const;
    Bytes slice(unsigned start) const;
    Bytes swab() const;
    Bytes compress() const;
    Bytes decompress() const;
	std::vector<bool> toBits() const;
	Bytes reverseBits() const;

	Bytes operator + (const Bytes& other);
	Bytes operator * (size_t count);

    ByteReader reader() const;
    ByteWriter writer();

    void writeToFile(const std::string& filename) const;
	void writeTo(std::ostream& stream) const;

private:
    std::shared_ptr<std::vector<uint8_t>> _data;
    unsigned _low;
    unsigned _high;
};

class ByteReader
{
public:
    ByteReader(const Bytes& bytes):
        _bytes(bytes)
    {}

    ByteReader(const Bytes&&) = delete;

    unsigned pos = 0;
    bool eof() const
    { return pos >= _bytes.size(); }

    ByteReader& seek(unsigned pos)
    {
        this->pos = pos;
        return *this;
    }

    ByteReader& skip(int delta)
    {
        this->pos += delta;
        return *this;
    }

    const Bytes read(unsigned len)
    {
        const Bytes bytes = _bytes.slice(pos, len);
        pos += len;
        return bytes;
    }

    uint8_t read_8()
    {
        return _bytes[pos++];
    }

    uint16_t read_be16()
    {
        uint8_t b1 = _bytes[pos++];
        uint8_t b2 = _bytes[pos++];
        return (b1<<8) | b2;
    }

    uint32_t read_be24()
    {
        uint8_t b1 = _bytes[pos++];
        uint8_t b2 = _bytes[pos++];
        uint8_t b3 = _bytes[pos++];
        return (b1<<16) | (b2<<8) | b3;
    }

    uint32_t read_be32()
    {
        uint8_t b1 = _bytes[pos++];
        uint8_t b2 = _bytes[pos++];
        uint8_t b3 = _bytes[pos++];
        uint8_t b4 = _bytes[pos++];
        return (b1<<24) | (b2<<16) | (b3<<8) | b4;
    }

    uint64_t read_be48();
    uint64_t read_be64();

    uint16_t read_le16()
    {
        uint8_t b1 = _bytes[pos++];
        uint8_t b2 = _bytes[pos++];
        return (b2<<8) | b1;
    }

    uint32_t read_le24()
    {
        uint8_t b1 = _bytes[pos++];
        uint8_t b2 = _bytes[pos++];
        uint8_t b3 = _bytes[pos++];
        return (b3<<16) | (b2<<8) | b1;
    }

    uint32_t read_le32()
    {
        uint8_t b1 = _bytes[pos++];
        uint8_t b2 = _bytes[pos++];
        uint8_t b3 = _bytes[pos++];
        uint8_t b4 = _bytes[pos++];
        return (b4<<24) | (b3<<16) | (b2<<8) | b1;
    }

private:
    const Bytes& _bytes;
};

class ByteWriter
{
public:
    ByteWriter(Bytes& bytes):
        _bytes(bytes)
    {}

    ByteWriter(const Bytes&&) = delete;

    unsigned pos = 0;

    ByteWriter& seek(unsigned pos)
    {
        this->pos = pos;
        return *this;
    }

    ByteWriter& seekToEnd()
    {
        pos = _bytes.size();
        return *this;
    }

    ByteWriter& write_8(uint8_t value)
    {
        _bytes.adjustBounds(pos);
        uint8_t* p = _bytes.begin();
        p[pos++] = value;
        return *this;
    }

    ByteWriter& write_be16(uint16_t value)
    {
        _bytes.adjustBounds(pos+1);
        uint8_t* p = _bytes.begin();
        p[pos++] = value >> 8;
        p[pos++] = value;
        return *this;
    }

    ByteWriter& write_be24(uint32_t value)
    {
        _bytes.adjustBounds(pos+2);
        uint8_t* p = _bytes.begin();
        p[pos++] = value >> 16;
        p[pos++] = value >> 8;
        p[pos++] = value;
        return *this;
    }

    ByteWriter& write_be32(uint32_t value)
    {
        _bytes.adjustBounds(pos+3);
        uint8_t* p = _bytes.begin();
        p[pos++] = value >> 24;
        p[pos++] = value >> 16;
        p[pos++] = value >> 8;
        p[pos++] = value;
        return *this;
    }

    ByteWriter& write_le16(uint16_t value)
    {
        _bytes.adjustBounds(pos+1);
        uint8_t* p = _bytes.begin();
        p[pos++] = value;
        p[pos++] = value >> 8;
        return *this;
    }

    ByteWriter& write_le24(uint32_t value)
    {
        _bytes.adjustBounds(pos+2);
        uint8_t* p = _bytes.begin();
        p[pos++] = value;
        p[pos++] = value >> 8;
        p[pos++] = value >> 16;
        return *this;
    }

    ByteWriter& write_le32(uint32_t value)
    {
        _bytes.adjustBounds(pos+3);
        uint8_t* p = _bytes.begin();
        p[pos++] = value;
        p[pos++] = value >> 8;
        p[pos++] = value >> 16;
        p[pos++] = value >> 24;
        return *this;
    }

    ByteWriter& operator += (std::initializer_list<uint8_t> data)
    {
        _bytes.adjustBounds(pos + data.size() - 1);
        std::copy(data.begin(), data.end(), _bytes.begin() + pos);
        pos += data.size();
        return *this;
    }

    ByteWriter& operator += (const std::vector<uint8_t>& data)
    {
        _bytes.adjustBounds(pos + data.size() - 1);
        std::copy(data.begin(), data.end(), _bytes.begin() + pos);
        pos += data.size();
        return *this;
    }

    ByteWriter& operator += (const Bytes data)
    {
        _bytes.adjustBounds(pos + data.size() - 1);
        std::copy(data.begin(), data.end(), _bytes.begin() + pos);
        pos += data.size();
        return *this;
    }

    ByteWriter& operator += (std::istream& stream);

	ByteWriter& append(const char* data)
	{
		return *this += Bytes((const uint8_t*)data, strlen(data));
	}

	ByteWriter& append(const std::string& data)
	{
		return *this += Bytes(data);
	}

    ByteWriter& append(const Bytes data)
    {
        return *this += data;
    }

    ByteWriter& append(std::istream& stream)
    {
        return *this += stream;
    }

private:
    Bytes& _bytes;
};

class BitWriter
{
public:
    BitWriter(ByteWriter& bw):
        _bw(bw)
    {}

    BitWriter(ByteWriter&&) = delete;

    void push(uint32_t bits, size_t size);
	void push(bool bit) { push(bit, 1); }
    void flush();

private:
    uint8_t _fifo = 0;
    size_t _bitcount = 0;
    ByteWriter& _bw;
};

class BitReader
{
public:
	BitReader(ByteReader& br):
		_br(br)
	{}

	BitReader(ByteReader&&) = delete;

	bool get();
	bool eof();

private:
	uint8_t _fifo = 0;
	size_t _bitcount = 0;
	ByteReader& _br;
};

static inline uint8_t reverse_bits(uint8_t b)
{
    b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;
    b = (b & 0xCC) >> 2 | (b & 0x33) << 2;
    b = (b & 0xAA) >> 1 | (b & 0x55) << 1;
    return b;
}

extern uint8_t toByte(
    std::vector<bool>::const_iterator start,
    std::vector<bool>::const_iterator end);

extern Bytes toBytes(
    std::vector<bool>::const_iterator start,
    std::vector<bool>::const_iterator end);

inline Bytes toBytes(const std::vector<bool>& bits)
{ return toBytes(bits.begin(), bits.end()); }

extern std::vector<bool> reverseBits(const std::vector<bool>& bits);

#endif