buffered_serialization_buffer_impl.h

Go to the documentation of this file.

/*
 * Copyright 2024 MusicScience37 (Kenta Kabashima)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#include <array>
#include <cstddef>  // IWYU pragma: keep
#include <cstring>
 
#include "msgpack_light/details/mutable_static_binary_view.h"
#include "msgpack_light/details/pack_in_big_endian.h"
#include "msgpack_light/details/static_memory_buffer_size.h"
#include "msgpack_light/details/total_size_of.h"  // IWYU pragma: keep
#include "msgpack_light/output_stream.h"
 
namespace msgpack_light::details {

class buffered_serialization_buffer_impl {
public:
    explicit buffered_serialization_buffer_impl(output_stream& stream)
        : stream_(stream) {}
 
    buffered_serialization_buffer_impl(
        const buffered_serialization_buffer_impl&) = delete;
    buffered_serialization_buffer_impl(
        buffered_serialization_buffer_impl&&) = delete;
    buffered_serialization_buffer_impl& operator=(
        const buffered_serialization_buffer_impl&) = delete;
    buffered_serialization_buffer_impl& operator=(
        buffered_serialization_buffer_impl&&) = delete;

    ~buffered_serialization_buffer_impl() noexcept { flush(); }

    void flush() {
        stream_.write(buffer_.data(), current_position_in_buffer_);
        current_position_in_buffer_ = 0U;
    }

    void write(const unsigned char* data, std::size_t size) {
        if (size == 0U) {
            return;
        }
 
        if (buffer_size - current_position_in_buffer_ < size) {
            flush();
            if (buffer_size < size) {
                stream_.write(data, size);
                return;
            }
        }
 
        std::memcpy(buffer_.data() + current_position_in_buffer_, data, size);
        current_position_in_buffer_ += size;
    }

    void put(unsigned char data) {
        if (buffer_size == current_position_in_buffer_) {
            flush();
        }
        *(buffer_.data() + current_position_in_buffer_) = data;
        ++current_position_in_buffer_;
    }

    template <typename... T>
    void write_in_big_endian(T... values) {
        details::pack_in_big_endian(
            prepare_buffer<total_size_of<T...>>(), values...);
        set_buffer_written<total_size_of<T...>>();
    }
 
private:
    template <std::size_t N>
    [[nodiscard]] details::mutable_static_binary_view<N> prepare_buffer() {
        static_assert(N <= buffer_size);
 
        if (buffer_size - current_position_in_buffer_ < N) {
            flush();
        }
 
        return details::mutable_static_binary_view<N>(
            buffer_.data() + current_position_in_buffer_);
    }

    template <std::size_t N>
    void set_buffer_written() noexcept {
        current_position_in_buffer_ += N;
    }

    output_stream& stream_;

    static constexpr std::size_t buffer_size =
        details::static_memory_buffer_size;

    std::array<unsigned char, buffer_size> buffer_{};

    std::size_t current_position_in_buffer_{0U};
};
 
}  // namespace msgpack_light::details