terminology.hpp

#pragma once
 
#include <algorithm>
#include <deque>
#include <iterator>
#include <optional>
#include <vector>
 
// ------------------------------------------------------------------------------------------------
// 3. Terminology
//
// https://encoding.spec.whatwg.org/#terminology
// https://triple-underscore.github.io/Encoding-ja.html#terminology
// ------------------------------------------------------------------------------------------------
 
namespace wordring::whatwg::encoding
{
    template <typename T>
    struct io_item
    {
        T m_value = T();
        bool m_eoq = false;
 
        T& operator*() { return m_value; }
    };
 
    template <typename T>
    struct io_result
    {
        using value_type = T;
 
        value_type m_value;
        bool m_wait = false;
 
        T* operator->() { return &m_value; }
        T& operator*() { return m_value; }
    };
 
    template <typename T>
    class io_queue
    {
    public:
        using value_type = io_item<T>;
        using character_type = T;
 
    public:
        io_queue() : m_q() {}
 
        io_result<value_type> read()
        {
            if (m_q.empty()) return io_result<value_type>{ value_type{}, true };
 
            value_type c = m_q.front();
            if (c.m_eoq) return io_result<value_type>{ c, false };
            m_q.pop_front();
            return io_result<value_type>{ c, false };
        }
 
        io_result<std::vector<value_type>> read(std::uint32_t n)
        {
            // 1.
            std::vector<value_type> readItems;
            // 規格に追加
            if (m_q.size() < n) return { readItems, true }; // 待機を返す
            // 2.
            for (std::uint32_t i = 0; i < n; ++i) readItems.push_back(*read());
            // 3.
            if (readItems.back().m_eoq) readItems.pop_back();
            // 4.
            return { readItems, false };
        }
 
        io_result<std::vector<value_type>> peek(std::uint32_t n)
        {
            assert(1 <= n);
 
            // 1.
            if (m_q.size() < n && !(!m_q.empty() && m_q.back().m_eoq)) return { {}, true };
            // 2.
            std::vector<value_type> prefix;
            // 3.
            for (value_type const& p : m_q)
            {
                if (p.m_eoq) break;
                prefix.push_back(p);
            }
            // 4.
            return { prefix, false };
        }
 
        void push(value_type item)
        {
            // 1.
            if (!m_q.empty() && m_q.back().m_eoq)
            {
                if (item.m_eoq);
                else m_q.insert(--m_q.end(), item);
            }
            // 2.
            else m_q.push_back(item);
        }
 
        void push(T ch)
        {
            push(value_type{ ch, false });
        }
 
        template <typename InputIterator>
        void push(InputIterator first, InputIterator last)
        {
            while (first != last)
            {
                push(*first);
                ++first;
            }
        }
 
        void prepend(value_type item)
        {
            //assert(!item.m_eoq); ISO2022_JP が EOQ を挿入する場合がある。
            m_q.push_front(item);
        }
 
        void prepend(T ch)
        {
            prepend(value_type{ ch, false });
        }
 
        template <typename InputIterator>
        void prepend(InputIterator first, InputIterator last)
        {
            auto it = m_q.begin();
            while (first != last) it = ++m_q.insert(it, value_type{ static_cast<T>(*first++), false });
        }
 
    private:
        std::deque<value_type> m_q;
    };
 
    template <typename T, typename OutputIterator>
    inline void from_io_queue_convert(io_queue<T> q, OutputIterator out)
    {
        while (true)
        {
            auto item = q.read();
            if (item.m_wait || item->m_eoq) return;
            *out++ = **item;
        }
    }
 
    template <typename InputIterator>
    inline auto to_io_queue_convert(InputIterator first, InputIterator last)
    {
        using value_type = typename std::iterator_traits<InputIterator>::value_type;
        io_queue<value_type> q;
        q.push(first, last);
        q.push({ 0, true });
        return q;
    }
}