memory_output_stream.hpp

Go to the documentation of this file.

 
#include <cstdint>
#include <functional>
#include <ranges>
#include <span>
 
namespace sparrow_ipc
{
    template <typename R>
        requires std::ranges::random_access_range<R> && std::same_as<typename R::value_type, uint8_t>
    class memory_output_stream
    {
    public:

        memory_output_stream(R& buffer)
            : m_buffer(&buffer) {};

        memory_output_stream& write(const char* s, std::streamsize count);

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

        memory_output_stream& write(uint8_t value, std::size_t count);

        memory_output_stream& 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_buffer;
    };
 
    // Implementation
 
    template <typename R>
        requires std::ranges::random_access_range<R> && std::same_as<typename R::value_type, uint8_t>
    memory_output_stream<R>& memory_output_stream<R>::write(const char* s, std::streamsize count)
    {
        m_buffer->insert(m_buffer->end(), s, s + count);
        return *this;
    }
 
    template <typename R>
        requires std::ranges::random_access_range<R> && std::same_as<typename R::value_type, uint8_t>
    memory_output_stream<R>& memory_output_stream<R>::write(std::span<const std::uint8_t> span)
    {
        m_buffer->insert(m_buffer->end(), span.begin(), span.end());
        return *this;
    }
 
    template <typename R>
        requires std::ranges::random_access_range<R> && std::same_as<typename R::value_type, uint8_t>
    memory_output_stream<R>& memory_output_stream<R>::write(uint8_t value, std::size_t count)
    {
        m_buffer->insert(m_buffer->end(), count, value);
        return *this;
    }
 
    template <typename R>
        requires std::ranges::random_access_range<R> && std::same_as<typename R::value_type, uint8_t>
    memory_output_stream<R>& memory_output_stream<R>::put(char value)
    {
        m_buffer->push_back(static_cast<uint8_t>(value));
        return *this;
    }
 
    template <typename R>
        requires std::ranges::random_access_range<R> && std::same_as<typename R::value_type, uint8_t>
    void memory_output_stream<R>::reserve(std::size_t size)
    {
        m_buffer->reserve(size);
    }
 
    template <typename R>
        requires std::ranges::random_access_range<R> && std::same_as<typename R::value_type, uint8_t>
    void memory_output_stream<R>::reserve(const std::function<std::size_t()>& calculate_reserve_size)
    {
        m_buffer->reserve(calculate_reserve_size());
    }
 
    template <typename R>
        requires std::ranges::random_access_range<R> && std::same_as<typename R::value_type, uint8_t>
    size_t memory_output_stream<R>::size() const
    {
        return m_buffer->size();
    }
}