buffer_chain.hpp

#ifndef NEFORCE_CORE_CONTAINER_BUFFER_CHAIN_HPP__
#define NEFORCE_CORE_CONTAINER_BUFFER_CHAIN_HPP__
#include "NeForce/core/string/string.hpp"
#ifdef NEFORCE_PLATFORM_LINUX
#    include <sys/uio.h>
#endif
#ifdef NEFORCE_PLATFORM_WINDOWS
struct iovec {
    void* iov_base;
    size_t iov_len;
};
#endif
NEFORCE_BEGIN_NAMESPACE__

class buffer_chain {
public:
    struct segment {
        const char* data{nullptr};
        size_t size{0};
    };
 
private:
    vector<segment> segments_;
    size_t total_size_{0};
 
public:
    buffer_chain() = default;

    void append(const char* data, size_t size) {
        segments_.push_back({data, size});
        total_size_ += size;
    }

    void append(const string_view sv) { append(sv.data(), sv.size()); }

    void append(const buffer_chain& other) {
        segments_.insert(segments_.end(), other.segments_.begin(), other.segments_.end());
        total_size_ += other.total_size_;
    }

    NEFORCE_NODISCARD string flatten() const {
        string result;
        result.reserve(total_size_);
        for (const auto& seg: segments_) {
            result.append(seg.data, seg.size);
        }
        return result;
    }

    NEFORCE_NODISCARD vector<::iovec> to_iovec() const {
        vector<::iovec> iov;
        iov.reserve(segments_.size());
        for (const auto& seg: segments_) {
            ::iovec v{};
            v.iov_base = const_cast<char*>(seg.data);
            v.iov_len = seg.size;
            iov.push_back(v);
        }
        return iov;
    }
 
    NEFORCE_NODISCARD size_t total_size() const noexcept { return total_size_; }
    NEFORCE_NODISCARD size_t segment_count() const noexcept { return segments_.size(); }
    NEFORCE_NODISCARD bool empty() const noexcept { return total_size_ == 0; }
 
    void clear() noexcept {
        segments_.clear();
        total_size_ = 0;
    }
 
    void reserve(size_t count) { segments_.reserve(count); }
};
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_CONTAINER_BUFFER_CHAIN_HPP__