BitOStream.hpp

Go to the documentation of this file.

#pragma once

#include <climits>
#include <cstdint>
#include <iostream>
#include <tudocomp/util.hpp>
#include <tudocomp/io/Output.hpp>

namespace tdc {
namespace io {

class BitOStream {
    OutputStream m_stream;

    bool m_dirty;
    uint8_t m_next;
    int m_cursor;

    inline void reset() {
        const int MSB = 7;

        m_next = 0;
        m_cursor = MSB;
        m_dirty = false;
    }

    inline void write_next() {
        if (m_dirty) {
            m_stream.put(char(m_next));
            reset();
        }
    }

public:
    inline BitOStream(OutputStream&& output) : m_stream(std::move(output)) {
        reset();
    }

    inline BitOStream(Output& output) : BitOStream(output.as_stream()) {
    }

    ~BitOStream() {
        char set = 7 - m_cursor;
        if(m_cursor >= 2) {
            m_next |= set;
        } else {
            write_next();
            m_next = set;
        }

        m_dirty = true;
        write_next();
    }

    inline auto tellp() -> decltype(m_stream.tellp()) {
        return m_stream.tellp();
    }

    inline void write_bit(bool set) {
        if (set) {
            m_next |= (1 << m_cursor);
        }

        m_dirty = true;
        if (--m_cursor < 0) {
            write_next();
        }
    }

    template<class T>
    inline void write_int(T value, size_t bits = sizeof(T) * CHAR_BIT) {
        for (int i = bits - 1; i >= 0; i--) {
            write_bit((value & T(T(1) << i)) != T(0));
        }
    }

    template<typename value_t>
    inline void write_unary(value_t v) {
        while(v--) {
            write_bit(0);
        }

        write_bit(1);
    }

    template<typename value_t>
    inline void write_ternary(value_t v) {
        if(v) {
            --v;
            do {
                write_int(v % 3, 2); // 0 -> 00, 1 -> 01, 2 -> 10
                v /= 3;
            } while(v);
        }
        write_int(3, 2); // terminator -> 11
    }

    template<typename value_t>
    inline void write_elias_gamma(value_t v) {
        write_unary(bits_for(v));
        write_int(v, bits_for(v));
    }

    template<typename value_t>
    inline void write_elias_delta(value_t v) {
        write_elias_gamma(bits_for(v));
        write_int(v, bits_for(v));
    }

    template<typename T>
    inline void write_compressed_int(T v, size_t b = 7) {
        DCHECK(b > 0);

        uint64_t u = uint64_t(v);
        uint64_t mask = (u << b) - 1;
        do {
            uint64_t current = v & mask;
            v >>= b;

            write_bit(v > 0);
            write_int(current, b);
        } while(v > 0);
    }
};

}}