Coder.hpp

Go to the documentation of this file.

#pragma once

#include <tudocomp/io.hpp>
#include <tudocomp/Algorithm.hpp>
#include <tudocomp/Env.hpp>
#include <tudocomp/Literal.hpp>
#include <tudocomp/Range.hpp>

namespace tdc {

class Encoder : public Algorithm {

protected:
    std::shared_ptr<BitOStream> m_out;

public:
    template<typename literals_t>
    inline Encoder(
        Env&& env,
        std::shared_ptr<BitOStream> out,
        literals_t&& literals)
        : Algorithm(std::move(env)), m_out(out) {
    }

    template<typename literals_t>
    inline Encoder(Env&& env, Output& out, literals_t&& literals)
        : Encoder(
            std::move(env),
            std::make_shared<BitOStream>(out),
            literals) {
    }

    template<typename value_t>
    inline void encode(value_t v, const Range& r) {
        m_out->write_int(v - r.min(), bits_for(r.max() - r.min()));
    }

    template<typename value_t>
    inline void encode(value_t v, const BitRange& r) {
        m_out->write_bit(v);
    }

    inline const std::shared_ptr<BitOStream>& stream() {
        return m_out;
    }
};

class Decoder : public Algorithm {

protected:
    std::shared_ptr<BitIStream> m_in;

public:
    inline Decoder(Env&& env, std::shared_ptr<BitIStream> in)
        : Algorithm(std::move(env)), m_in(in) {
    }

    inline Decoder(Env&& env, Input& in)
        : Decoder(std::move(env), std::make_shared<BitIStream>(in)) {
    }

    inline bool eof() const {
        return m_in->eof();
    }

    template<typename value_t>
    inline value_t decode(const Range& r) {
        return value_t(r.min()) +
               m_in->read_int<value_t>(bits_for(r.max() - r.min()));
    }

    template<typename value_t>
    inline value_t decode(const BitRange& r) {
        return value_t(m_in->read_bit());
    }

    inline const std::shared_ptr<BitIStream>& stream() {
        return m_in;
    }
};

#define DECODER_CTOR(env, in)                                \
        inline Decoder(Env&& env, Input& in)                 \
             : Decoder(std::move(env),                       \
                       std::make_shared<BitIStream>(in)) {}  \
        inline Decoder(Env&& env, std::shared_ptr<BitIStream> in) \
            : tdc::Decoder(std::move(env), in)

}