write_buffer.cpp

 
// UFO
#include <ufo/utility/io/write_buffer.hpp>
 
// STL
#include <cstring>
 
namespace ufo
{
 
WriteBuffer::WriteBuffer(WriteBuffer const& other)
{
    if (other.data_) {
        write(other.data_.get(), other.size_);
    }
}
 
WriteBuffer& WriteBuffer::operator=(WriteBuffer const& rhs)
{
    size_ = {};
    pos_  = {};
    if (rhs.data_) {
        write(rhs.data_.get(), rhs.size_);
    }
    return *this;
}
 
WriteBuffer& WriteBuffer::write(void const* src, size_type count)
{
    writeAt(pos_, src, count);
    pos_ += count;
    return *this;
}
 
WriteBuffer& WriteBuffer::write(std::istream& in, size_type count)
{
    writeAt(pos_, in, count);
    pos_ += count;
    return *this;
}
 
void WriteBuffer::writeAt(pos_type pos, void const* src, size_type count)
{
    reserve(pos + count);
 
    std::memmove(data_.get() + pos, src, count);
 
    size_ = std::max(size_, pos + count);
}
 
void WriteBuffer::writeAt(pos_type pos, std::istream& in, size_type count)
{
    reserve(pos + count);
 
    in.read(reinterpret_cast<char*>(data_.get() + pos),
            static_cast<std::streamsize>(count));
 
    size_ = std::max(size_, pos + count);
}
 
void WriteBuffer::writeAt(offset_type off, IODir dir, void const* src, size_type count)
{
    return writeAt(pos(pos_, off, dir), src, count);
}
 
void WriteBuffer::writeAt(offset_type off, IODir dir, std::istream& in, size_type count)
{
    return writeAt(pos(pos_, off, dir), in, count);
}
 
void WriteBuffer::reserve(size_type new_cap)
{
    if (cap_ >= new_cap) [[likely]] {
        return;
    }
 
    std::byte* prev = data_.get();
    void*      next = realloc(prev, new_cap * sizeof(std::byte));
 
    if (nullptr != next) [[likely]] {
        [[maybe_unused]] auto prev = data_.release();
        data_.reset(static_cast<std::byte*>(next));
        BaseBuffer::data_ = static_cast<std::byte const*>(next);
        cap_              = new_cap;
    } else [[unlikely]] {
        free(prev);
        BaseBuffer::data_ = nullptr;
        size_             = {};
        cap_              = {};
        pos_              = {};
        // TODO: Add message
        throw std::bad_alloc();
    }
}
 
void WriteBuffer::clear()
{
    size_ = 0;
    pos_  = 0;
}
 
std::byte* WriteBuffer::data() { return data_.get(); }
 
WriteBuffer::size_type WriteBuffer::capacity() const noexcept { return cap_; }
 
WriteBuffer::pos_type WriteBuffer::writePos() const noexcept { return pos_; }
 
WriteBuffer& WriteBuffer::writeSeek(pos_type pos) noexcept
{
    pos_ = pos;
    return *this;
}
 
WriteBuffer& WriteBuffer::writeSeek(offset_type off, IODir dir) noexcept
{
    return writeSeek(pos(pos_, off, dir));
}
 
WriteBuffer::size_type WriteBuffer::writeLeft() const noexcept
{
    return size_ < pos_ ? 0 : pos_ - size_;
}
}  // namespace ufo