chunk_memory_output_stream.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <functional>
#include <numeric>
#include <ranges>
#include <vector>
 
namespace sparrow_ipc
{
    template <typename R>
        requires std::ranges::random_access_range<R>
                 && std::ranges::random_access_range<std::ranges::range_value_t<R>>
                 && std::same_as<typename std::ranges::range_value_t<R>::value_type, uint8_t>
    class chunked_memory_output_stream
    {
    public:

        explicit chunked_memory_output_stream(R& chunks)
            : m_chunks(&chunks) {};

        chunked_memory_output_stream<R>& write(const char* s, std::streamsize count);

        chunked_memory_output_stream<R>& write(std::span<const std::uint8_t> span);

        chunked_memory_output_stream<R>& write(std::vector<uint8_t>&& buffer);

        chunked_memory_output_stream<R>& write(uint8_t value, std::size_t count);

        chunked_memory_output_stream<R>& put(char value);

        void reserve(std::size_t size);

        void reserve(const std::function<std::size_t()>& calculate_reserve_size);

        [[nodiscard]] size_t size() const;
 
    private:
 
        R* m_chunks;
    };
 
    // Implementation
 
    template <typename R>
        requires std::ranges::random_access_range<R>
                 && std::ranges::random_access_range<std::ranges::range_value_t<R>>
                 && std::same_as<typename std::ranges::range_value_t<R>::value_type, uint8_t>
    chunked_memory_output_stream<R>& chunked_memory_output_stream<R>::write(const char* s, std::streamsize count)
    {
        m_chunks->emplace_back(s, s + count);
        return *this;
    }
 
    template <typename R>
        requires std::ranges::random_access_range<R>
                 && std::ranges::random_access_range<std::ranges::range_value_t<R>>
                 && std::same_as<typename std::ranges::range_value_t<R>::value_type, uint8_t>
    chunked_memory_output_stream<R>& chunked_memory_output_stream<R>::write(std::span<const std::uint8_t> span)
    {
        m_chunks->emplace_back(span.begin(), span.end());
        return *this;
    }
 
    template <typename R>
        requires std::ranges::random_access_range<R>
                 && std::ranges::random_access_range<std::ranges::range_value_t<R>>
                 && std::same_as<typename std::ranges::range_value_t<R>::value_type, uint8_t>
    chunked_memory_output_stream<R>& chunked_memory_output_stream<R>::write(std::vector<uint8_t>&& buffer)
    {
        m_chunks->emplace_back(std::move(buffer));
        return *this;
    }
 
    template <typename R>
        requires std::ranges::random_access_range<R>
                 && std::ranges::random_access_range<std::ranges::range_value_t<R>>
                 && std::same_as<typename std::ranges::range_value_t<R>::value_type, uint8_t>
    chunked_memory_output_stream<R>& chunked_memory_output_stream<R>::write(uint8_t value, std::size_t count)
    {
        m_chunks->emplace_back(count, value);
        return *this;
    }
 
    template <typename R>
        requires std::ranges::random_access_range<R>
                 && std::ranges::random_access_range<std::ranges::range_value_t<R>>
                 && std::same_as<typename std::ranges::range_value_t<R>::value_type, uint8_t>
    chunked_memory_output_stream<R>& chunked_memory_output_stream<R>::put(char value)
    {
        m_chunks->emplace_back(std::vector<uint8_t>{static_cast<uint8_t>(value)});
        return *this;
    }
 
    template <typename R>
        requires std::ranges::random_access_range<R>
                 && std::ranges::random_access_range<std::ranges::range_value_t<R>>
                 && std::same_as<typename std::ranges::range_value_t<R>::value_type, uint8_t>
    void chunked_memory_output_stream<R>::reserve(std::size_t size)
    {
        m_chunks->reserve(size);
    }
 
    template <typename R>
        requires std::ranges::random_access_range<R>
                 && std::ranges::random_access_range<std::ranges::range_value_t<R>>
                 && std::same_as<typename std::ranges::range_value_t<R>::value_type, uint8_t>
    void chunked_memory_output_stream<R>::reserve(const std::function<std::size_t()>& calculate_reserve_size)
    {
        m_chunks->reserve(calculate_reserve_size());
    }
 
    template <typename R>
        requires std::ranges::random_access_range<R>
                 && std::ranges::random_access_range<std::ranges::range_value_t<R>>
                 && std::same_as<typename std::ranges::range_value_t<R>::value_type, uint8_t>
    size_t chunked_memory_output_stream<R>::size() const
    {
        return std::accumulate(
            m_chunks->begin(),
            m_chunks->end(),
            0,
            [](size_t acc, const auto& chunk)
            {
                return acc + chunk.size();
            }
        );
    }
}