buffer.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_BUFFER_HPP__
#define NEFORCE_CORE_ASYNC_BUFFER_HPP__

 
#include "NeForce/core/container/vector.hpp"
NEFORCE_BEGIN_NAMESPACE__


using mutable_buffer = memory_view<char>;

using const_buffer = memory_view<const char>;

class mutable_buffers {
public:
    using value_type = mutable_buffer;                             
    using iterator = vector<mutable_buffer>::iterator;             
    using const_iterator = vector<mutable_buffer>::const_iterator; 
 
private:
    vector<mutable_buffer> buffers_; 
 
public:
    mutable_buffers() = default;

    explicit mutable_buffers(mutable_buffer b) { buffers_.push_back(b); }

    void push_back(mutable_buffer b) { buffers_.push_back(b); }

    NEFORCE_NODISCARD size_t size() const noexcept { return buffers_.size(); }

    NEFORCE_NODISCARD bool empty() const noexcept { return buffers_.empty(); }

    NEFORCE_NODISCARD const mutable_buffer& operator[](size_t i) const { return buffers_[i]; }

    NEFORCE_NODISCARD mutable_buffer& operator[](size_t i) { return buffers_[i]; }

    NEFORCE_NODISCARD iterator begin() noexcept { return buffers_.begin(); }

    NEFORCE_NODISCARD iterator end() noexcept { return buffers_.end(); }

    NEFORCE_NODISCARD const_iterator begin() const noexcept { return buffers_.begin(); }

    NEFORCE_NODISCARD const_iterator end() const noexcept { return buffers_.end(); }
};

class const_buffers {
public:
    using value_type = const_buffer;                             
    using iterator = vector<const_buffer>::iterator;             
    using const_iterator = vector<const_buffer>::const_iterator; 
 
private:
    vector<const_buffer> buffers_; 
 
public:
    const_buffers() = default;

    explicit const_buffers(const_buffer b) { buffers_.push_back(b); }

    void push_back(const_buffer b) { buffers_.push_back(b); }

    NEFORCE_NODISCARD size_t size() const noexcept { return buffers_.size(); }

    NEFORCE_NODISCARD bool empty() const noexcept { return buffers_.empty(); }

    NEFORCE_NODISCARD const const_buffer& operator[](size_t i) const { return buffers_[i]; }

    NEFORCE_NODISCARD const_buffer& operator[](size_t i) { return buffers_[i]; }

    NEFORCE_NODISCARD iterator begin() noexcept { return buffers_.begin(); }

    NEFORCE_NODISCARD iterator end() noexcept { return buffers_.end(); }

    NEFORCE_NODISCARD const_iterator begin() const noexcept { return buffers_.begin(); }

    NEFORCE_NODISCARD const_iterator end() const noexcept { return buffers_.end(); }
};

class dynamic_buffer {
private:
    vector<char> data_;   
    size_t write_pos_{0}; 
 
public:
    mutable_buffers prepare(size_t n) {
        if (data_.size() - write_pos_ < n) {
            data_.resize(write_pos_ + n);
        }
        return mutable_buffers(mutable_buffer(data_.data() + write_pos_, data_.size() - write_pos_));
    }

    void commit(size_t n) { write_pos_ += n; }

    void consume(size_t n) {
        if (n >= write_pos_) {
            write_pos_ = 0;
            return;
        }
        const size_t remaining = write_pos_ - n;
        memory_move(data_.data(), data_.data() + n, remaining);
        write_pos_ = remaining;
    }

    NEFORCE_NODISCARD size_t size() const noexcept { return write_pos_; }

    NEFORCE_NODISCARD const char* data() const noexcept { return data_.data(); }

    NEFORCE_NODISCARD char* data() noexcept { return data_.data(); }

    NEFORCE_NODISCARD size_t capacity() const noexcept { return data_.size(); }

    NEFORCE_NODISCARD size_t max_size() const noexcept { return numeric_traits<size_t>::max(); }
};
 // AsyncBuffers
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ASYNC_BUFFER_HPP__