write_buffer.hpp

 
#ifndef UFO_UTILITY_WRITE_BUFFER_HPP
#define UFO_UTILITY_WRITE_BUFFER_HPP
 
// UFO
#include <ufo/utility/io/base_buffer.hpp>
#include <ufo/utility/io/dir.hpp>
 
// STL
#include <cstddef>
#include <istream>
#include <memory>
 
namespace ufo
{
class WriteBuffer : virtual public BaseBuffer
{
 public:
    using size_type   = BaseBuffer::size_type;
    using pos_type    = BaseBuffer::pos_type;
    using offset_type = BaseBuffer::offset_type;
 
    WriteBuffer() = default;
    WriteBuffer(WriteBuffer const& other);
    WriteBuffer(WriteBuffer&&) = default;
 
    WriteBuffer& operator=(WriteBuffer const& rhs);
    WriteBuffer& operator=(WriteBuffer&&) = default;
 
    virtual ~WriteBuffer() = default;
 
    template <class T>
    WriteBuffer& write(T const& t)
    {
        return write(&t, sizeof(t));
    }
 
    WriteBuffer& write(void const* src, size_type count);
 
    WriteBuffer& write(std::istream& in, size_type count);
 
    template <class T>
    void writeAt(pos_type pos, T const& t)
    {
        writeAt(pos, &t, sizeof(t));
    }
 
    void writeAt(pos_type pos, void const* src, size_type count);
 
    void writeAt(pos_type pos, std::istream& in, size_type count);
 
    template <class T>
    void writeAt(offset_type off, IODir dir, T const& t)
    {
        writeAt(off, dir, &t, sizeof(t));
    }
 
    void writeAt(offset_type off, IODir dir, void const* src, size_type count);
 
    void writeAt(offset_type off, IODir dir, std::istream& in, size_type count);
 
    void reserve(size_type new_cap);
 
    virtual void clear();
 
    [[nodiscard]] std::byte* data();
 
    [[nodiscard]] size_type capacity() const noexcept;
 
    [[nodiscard]] pos_type writePos() const noexcept;
 
    WriteBuffer& writeSeek(pos_type pos) noexcept;
 
    WriteBuffer& writeSeek(offset_type off, IODir dir) noexcept;
 
    template <class T>
    WriteBuffer& writeSeek(T const& t, pos_type count) noexcept
    {
        return writeSeek(sizeof(t) * count);
    }
 
    template <class T>
    WriteBuffer& writeSeek(T const& t, offset_type count_signed, IODir dir) noexcept
    {
        return writeSeek(sizeof(t) * count_signed, dir);
    }
 
    [[nodiscard]] size_type writeLeft() const noexcept;
 
 protected:
    struct FreeDeleter {
        void operator()(void* p) const noexcept { std::free(p); }
    };
 
    std::unique_ptr<std::byte, FreeDeleter> data_;
    size_type                               size_{};
    size_type                               cap_{};
    pos_type                                pos_{};
};
}  // namespace ufo
#endif  // UFO_UTILITY_WRITE_BUFFER_HPP