types.hpp

#pragma once
 
#include <cstdint>
#include <queue>
#include <vector>
 
namespace fly::coders {
 
using symbol_type = std::uint8_t;
using frequency_type = std::uint64_t;
 
using code_type = std::uint16_t;
using length_type = std::uint8_t;
 
struct HuffmanNode;
struct HuffmanNodeComparator;
 
using HuffmanNodeQueue =
    std::priority_queue<HuffmanNode *, std::vector<HuffmanNode *>, HuffmanNodeComparator>;
 
struct HuffmanNode
{
    HuffmanNode() noexcept;
 
    HuffmanNode &operator=(HuffmanNode &&node) noexcept;
 
    void become_symbol(symbol_type symbol, frequency_type frequency);
 
    void become_intermediate(HuffmanNode *left, HuffmanNode *right);
 
    symbol_type m_symbol;
    frequency_type m_frequency;
 
    HuffmanNode *m_left;
    HuffmanNode *m_right;
 
private:
    HuffmanNode(const HuffmanNode &) = delete;
    HuffmanNode &operator=(const HuffmanNode &) = delete;
};
 
struct HuffmanNodeComparator
{
    bool operator()(const HuffmanNode *left, const HuffmanNode *right);
};
 
struct HuffmanCode
{
    HuffmanCode() noexcept;
 
    HuffmanCode(symbol_type symbol, code_type code, length_type length) noexcept;
 
    HuffmanCode(HuffmanCode &&code) noexcept;
 
    HuffmanCode &operator=(HuffmanCode &&code) noexcept;
 
    friend bool operator<(const HuffmanCode &left, const HuffmanCode &right);
 
    symbol_type m_symbol;
    code_type m_code;
    length_type m_length;
 
private:
    HuffmanCode(const HuffmanCode &) = delete;
    HuffmanCode &operator=(const HuffmanCode &) = delete;
};
 
} // namespace fly::coders