chrono | Programming Place Plus　新C++編

namespace std {
    namespace chrono {
        template <typename Rep, typename Period = std::ratio<1>>
        class duration {
            // ...
        };
    }
}

namespace std {
    template <intmax_t N, intmax_t D = 1>
    class ratio {
        // ...
    };
}

#include <chrono>
#include <iostream>

int main()
{
    std::chrono::duration<int> s1 {};
    std::chrono::duration<int> s2 {15};
    std::chrono::duration<int> s3 {s2};
    
    std::cout << s1.count() << "\n"
              << s2.count() << "\n"
              << s3.count() << "\n";

    s1 = s2 + s3;   // 加算
    std::cout << s1.count() << "\n";
}

namespace std {
    namespace chrono {
        template <typename Clock, typename Duration = Clock::duration>
        class time_point {
            // ...
        };
    }
}

// 宣言
型 operator"" サフィックス名(仮引数の並び);

// 定義
型 operator"" サフィックス名(仮引数の並び)
{
}

// ring_buffer.h
#ifndef RING_BUFFER_H_INCLUDED
#define RING_BUFFER_H_INCLUDED

#include <algorithm>
#include <cassert>
#include <vector>

namespace mylib {

    // リングバッファ
    template <typename T>
    class RingBuffer {

        template <typename T>
        friend class RingBuffer;

    public:
        // イテレータ
        class Iterator {
        public:
            using value_type = T;                       // 要素型
            using reference = value_type&;              // 要素の参照型
            using const_reference = const value_type&;  // 要素の参照型
            using pointer = value_type*;                // 要素のポインタ型
            using const_pointer = const value_type*;    // 要素の constポインタ型
            using size_type = std::size_t;              // サイズ型
            using difference_type = std::ptrdiff_t;     // 距離型

        public:
            // コンストラクタ
            Iterator(RingBuffer& body, size_type pos, bool is_past_the_end);


            // ==演算子
            inline bool operator==(const Iterator& rhs) const
            {
                return m_body == rhs.m_body
                    && m_pos == rhs.m_pos
                    && m_is_past_the_end == rhs.m_is_past_the_end;
            }

            // !=演算子
            inline bool operator!=(const Iterator& rhs) const
            {
                return !(*this == rhs);
            }

            // *演算子（間接参照）
            inline reference operator*()
            {
                return *common_get_elem_ptr(this);
            }

            // *演算子（間接参照）
            inline const_reference operator*() const
            {
                return *common_get_elem_ptr(this);
            }

            // ->演算子
            inline pointer operator->()
            {
                return common_get_elem_ptr(this);
            }

            // ->演算子
            inline const_pointer operator->() const
            {
                return common_get_elem_ptr(this);
            }

            // ++演算子（前置）
            Iterator& operator++();

            // ++演算子（後置）
            Iterator operator++(int);


        private:
            template <typename T>
            inline static auto* common_get_elem_ptr(T* self)
            {
                return &self->m_body.m_data[self->m_pos];
            }

        private:
            RingBuffer&             m_body;             // 本体のリングバッファへの参照
            size_type               m_pos;              // 指し示している要素の位置
            bool                    m_is_past_the_end;  // 終端の次を指すイテレータか
        };

        // constイテレータ
        class ConstIterator {
        public:
            using value_type = T;                       // 要素型
            using const_reference = const value_type&;  // 要素の参照型
            using const_pointer = const value_type*;    // 要素の constポインタ型
            using size_type = std::size_t;              // サイズ型
            using difference_type = std::ptrdiff_t;     // 距離型

        public:
            // コンストラクタ
            ConstIterator(const RingBuffer& body, size_type pos, bool is_past_the_end);


            // ==演算子
            inline bool operator==(const ConstIterator& rhs) const
            {
                return m_body == rhs.m_body
                    && m_pos == rhs.m_pos
                    && m_is_past_the_end == rhs.m_is_past_the_end;
            }

            // !=演算子
            inline bool operator!=(const ConstIterator& rhs) const
            {
                return !(*this == rhs);
            }

            // *演算子（間接参照）
            inline const_reference operator*() const
            {
                return *common_get_elem_ptr(this);
            }

            // ->演算子
            inline const_pointer operator->() const
            {
                return common_get_elem_ptr(this);
            }

            // ++演算子（前置）
            ConstIterator& operator++();

            // ++演算子（後置）
            ConstIterator operator++(int);


        private:
            template <typename T>
            inline static auto* common_get_elem_ptr(T* self)
            {
                return &self->m_body.m_data[self->m_pos];
            }

        private:
            const RingBuffer&       m_body;             // 本体のリングバッファへの参照
            size_type               m_pos;              // 指し示している要素の位置
            bool                    m_is_past_the_end;  // 終端の次を指すイテレータか
        };

    public:
        using container_type = typename std::vector<T>;                     // 内部コンテナの型
        using value_type = typename container_type::value_type;             // 要素型
        using reference = typename container_type::reference;               // 要素の参照型
        using const_reference = typename container_type::const_reference;   // 要素の const参照型
        using pointer = typename container_type::pointer;                   // 要素のポインタ型
        using const_pointer = typename container_type::const_pointer;       // 要素の constポインタ型
        using size_type = typename container_type::size_type;               // サイズ型
        using iterator = Iterator;                                          // イテレータ型
        using const_iterator = ConstIterator;                               // constイテレータ型

    public:
        // コンストラクタ
        //
        // size: 容量
        explicit RingBuffer(size_type capacity);

        // テンプレート変換コンストラクタ
        template <typename U>
        RingBuffer(const RingBuffer<U>& other);


        // コピー代入演算子
        RingBuffer& operator=(const RingBuffer& rhs) = default;
        
        // ==演算子
        bool operator==(const RingBuffer& rhs) const;

        // !=演算子
        inline bool operator!=(const RingBuffer& rhs) const
        {
            return !(*this == rhs);
        }


        // 要素を追加
        void push_back(const value_type& value);

        // 要素を取り除く
        void pop_front();

        // 空にする
        void clear();


        // 先頭の要素の参照を返す
        inline reference front()
        {
            return common_front(this);
        }

        // 先頭の要素の参照を返す
        inline const_reference front() const
        {
            return common_front(this);
        }

        // 末尾の要素の参照を返す
        inline reference back()
        {
            return common_back(this);
        }

        // 末尾の要素の参照を返す
        inline const_reference back() const
        {
            return common_back(this);
        }



        // 先頭の要素を指す イテレータを返す
        inline iterator begin()
        {
            return iterator(*this, m_front, empty());
        }

        // 末尾の要素の次を指す イテレータを返す
        inline iterator end()
        {
            return iterator(*this, m_back, true);
        }

        // 先頭の要素を指す constイテレータを返す
        inline const_iterator begin() const
        {
            return const_iterator(*this, m_front, empty());
        }

        // 末尾の要素の次を指す constイテレータを返す
        inline const_iterator end() const
        {
            return const_iterator(*this, m_back, true);
        }


        // 容量を返す
        inline size_type capacity() const
        {
            return m_data.size();
        }

        // 要素数を返す
        inline size_type size() const
        {
            return m_size;
        }

        // 空かどうかを返す
        inline bool empty() const
        {
            return m_size == 0;
        }

        // 満杯かどうかを返す
        inline bool full() const
        {
            return m_size == capacity();
        }

    private:
        // 次の位置を返す
        inline size_type get_next_pos(size_type pos) const
        {
            return (pos + 1) % capacity();
        }

        // 手前の位置を返す
        inline size_type get_prev_pos(size_type pos) const
        {
            if (pos >= 1) {
                return pos - 1;
            }
            else {
                return m_size - 1;
            }
        }

        template <typename T>
        inline static auto& common_front(T* self)
        {
            assert(self->empty() == false);
            return self->m_data[self->m_front];
        }

        template <typename T>
        inline static auto& common_back(T* self)
        {
            assert(self->empty() == false);
            return self->m_data[self->get_prev_pos(self->m_back)];
        }

    private:
        container_type              m_data;         // 要素
        size_type                   m_size{0};      // 有効な要素の個数
        size_type                   m_back{0};      // 次に push される位置
        size_type                   m_front{0};     // 次に pop される位置
    };


    // コンストラクタ
    template <typename T>
    RingBuffer<T>::RingBuffer(size_type capacity) : m_data(capacity)
    {
    }

    // コンストラクタ（異なる要素型の RingBuffer から作成）
    template <typename T>
    template <typename U>
    RingBuffer<T>::RingBuffer(const RingBuffer<U>& other) :
        m_data(other.m_data.capacity()),
        m_size {other.m_size},
        m_back {other.m_back},
        m_front {other.m_front}
    {
        std::transform(
            std::cbegin(other.m_data),
            std::cend(other.m_data),
            std::begin(m_data),
            [](const auto& e) {
                return static_cast<T>(e);
            }
        );
    }

    // ==演算子
    template <typename T>
    bool RingBuffer<T>::operator==(const RingBuffer& rhs) const
    {
        return m_data == rhs.m_data
            && m_size == rhs.m_size
            && m_back == rhs.m_back
            && m_front == rhs.m_front;
    }

    // 要素を追加
    template <typename T>
    void RingBuffer<T>::push_back(const value_type& value)
    {
        if (full()) {
            m_front = get_next_pos(m_front);
        }
        else {
            m_size++;
        }

        m_data[m_back] = value;
        m_back = get_next_pos(m_back);
    }

    // 要素を取り除く
    template <typename T>
    void RingBuffer<T>::pop_front()
    {
        assert(empty() == false);

        m_front = get_next_pos(m_front);
        --m_size;
    }

    // 空にする
    template <typename T>
    void RingBuffer<T>::clear()
    {
        m_size = 0;
        m_back = 0;
        m_front = 0;
    }




    // ------------ Iterator ------------
    // コンストラクタ
    template <typename T>
    RingBuffer<T>::Iterator::Iterator(RingBuffer& body, size_type pos, bool is_past_the_end) :
        m_body {body},
        m_pos {pos},
        m_is_past_the_end {is_past_the_end}
    {

    }

    // ++演算子（前置）
    template <typename T>
    typename RingBuffer<T>::Iterator& RingBuffer<T>::Iterator::operator++()
    {
        assert(!m_is_past_the_end);

        m_pos = m_body.get_next_pos(m_pos);

        // 終端要素の位置を越えた？
        if (m_body.get_next_pos(m_pos) == m_body.get_next_pos(m_body.end().m_pos)) {
            m_is_past_the_end = true;
        }

        return *this;
    }

    // ++演算子（後置）
    template <typename T>
    typename RingBuffer<T>::Iterator RingBuffer<T>::Iterator::operator++(int)
    {
        Iterator tmp {*this};
        ++(*this);
        return tmp;
    }


    // ------------ ConstIterator ------------
    // コンストラクタ
    template <typename T>
    RingBuffer<T>::ConstIterator::ConstIterator(const RingBuffer& body, size_type pos, bool is_past_the_end) :
        m_body {body},
        m_pos {pos},
        m_is_past_the_end {is_past_the_end}
    {

    }

    // ++演算子（前置）
    template <typename T>
    typename RingBuffer<T>::ConstIterator& RingBuffer<T>::ConstIterator::operator++()
    {
        assert(!m_is_past_the_end);

        m_pos = m_body.get_next_pos(m_pos);

        // 終端要素の位置を越えた？
        if (m_body.get_next_pos(m_pos) == m_body.get_next_pos(m_body.end().m_pos)) {
            m_is_past_the_end = true;
        }

        return *this;
    }

    // ++演算子（後置）
    template <typename T>
    typename RingBuffer<T>::ConstIterator RingBuffer<T>::ConstIterator::operator++(int)
    {
        Iterator tmp {*this};
        ++(*this);
        return tmp;
    }
}

#endif

//main.cpp
#include <chrono>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <random>
#include <string>
#include "ring_buffer.h"

#define READ_LOG_ENABLED    1   // 読み取り時のログを出力する

namespace {


#if READ_LOG_ENABLED == 1
    void print_readlog(const char* s)
    {
        std::cout << s;
    }
#else
    void print_readlog(const char* s)
    {
    }
#endif


    constexpr auto read_interval = std::chrono::seconds{1};     // ファイルからの読み込みを行う時間間隔 
    constexpr auto write_interval = std::chrono::seconds{3};    // 標準出力への書き出しを行う時間間隔 
    constexpr unsigned int read_line_num_min {1};   // １回に読み込む最小行数
    constexpr unsigned int read_line_num_max {3};   // １回に読み込む最大行数
    constexpr unsigned int write_line_num {6};      // １回に書き出す行数
    constexpr std::size_t ring_buffer_size {64};    // リングバッファの要素数

}

int main()
{
    std::random_device rand_dev {};
    std::mt19937 rand_engine(rand_dev());

    constexpr auto path = "input_data.txt";
    std::ifstream ifs(path);
    if (!ifs) {
        std::cerr << "File open error: " << path << "\n";
        return EXIT_FAILURE;
    }

    mylib::RingBuffer<std::string> ring_buf {ring_buffer_size};

    auto next_read_time = std::chrono::steady_clock::now() + read_interval;
    auto next_write_time = std::chrono::steady_clock::now() + write_interval;

    while (true) {
        
        const auto now = std::chrono::steady_clock::now();

        // データ読み込み
        if (next_read_time <= now) {

            print_readlog("\n");
            print_readlog("Read data...\n");

            // ランダムな行数だけ読み込む
            int read_line_count = rand_engine() % (read_line_num_max - read_line_num_min + 1) + read_line_num_min;
            while (read_line_count > 0) {

                // リングバッファが満杯だったら終了する
                if (ring_buf.full()) {
                    print_readlog("RingBuffer is full.\n");
                    break;
                }

                // 末尾に到達していたら、先頭に戻す
                if (ifs.eof()) {
                    ifs.seekg(0, std::ios_base::beg);
                }

                // １行読み込んで、リングバッファに格納
                std::string s {};
                std::getline(ifs, s);
                ring_buf.push_back(s);
                print_readlog((s + "\n").c_str());

                --read_line_count;
            }

            next_read_time += read_interval;
        }
        
        // データ書き出し
        if (next_write_time <= now) {

            std::cout << "\n";
            std::cout << "Write data...\n";

            // リングバッファから一定行数取り出して、標準出力に書き出す
            for (int i = 0; i < write_line_num; ++i) {
                if (ring_buf.empty()) {
                    std::cout << "empty.\n";
                }
                else {
                    auto s = ring_buf.front();
                    ring_buf.pop_front();
                    std::cout << s << "\n";
                }
            }

            next_write_time += write_interval;
        }

    }
}

aaaaa
bbbbb
ccccc
ddddd
eeeee
fffff
ggggg
hhhhh
iiiii
jjjjj
kkkkk
lllll
mmmmm
nnnnn
ooooo
ppppp
qqqqq
rrrrr
sssss
ttttt
uuuuu
vvvvv
wwwww
xxxxx
yyyyy
zzzzz