iovector.hxx

Go to the documentation of this file.

#pragma once
 
// Linux
#include <sys/uio.h>
 
// C++
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
// Cosmos
#include <cosmos/dso_export.h>
 
namespace cosmos {
 
 
struct iovec_const {
        const void *iov_base = nullptr;
        size_t iov_len = 0;
};
 
 
template <typename IOVEC>
struct IOMemoryRegion :
                protected IOVEC {
public: // types
 
        // only allow the specialized IOVector to access the raw data fields.
        template <typename ENTRY_TYPE>
        friend class IOVector;
 
        using PtrType = decltype(IOVEC::iov_base);
 
public: // functions
        auto getBase()             { return this->iov_base; }
        auto getBase() const       { return this->iov_base; }
        void setBase(PtrType base) {        this->iov_base = base; }
 
        size_t getLength() const      { return this->iov_len; }
        void setLength(size_t length) {        this->iov_len = length; }
 
        bool finished() const { return getLength() == 0; }
 
 
        size_t update(const size_t processed_bytes) {
                auto to_reduce = std::min(processed_bytes, getLength());
 
                if constexpr (std::is_same_v<IOVEC, struct iovec_const>) {
                        auto data = reinterpret_cast<const char*>(getBase());
                        setBase(reinterpret_cast<PtrType>(data + to_reduce));
                } else {
                        auto data = reinterpret_cast<char*>(getBase());
                        setBase(reinterpret_cast<PtrType>(data + to_reduce));
                }
 
                setLength(getLength() - to_reduce);
                return to_reduce;
        }
};
 
 
struct InputMemoryRegion :
                public IOMemoryRegion<struct ::iovec> {
 
        InputMemoryRegion() : InputMemoryRegion{nullptr, 0} {}
 
        InputMemoryRegion(void *base, size_t length) {
                setBase(base);
                setLength(length);
        }
 
        explicit InputMemoryRegion(std::string &s) {
                setBase(s.data());
                setLength(s.size());
        }
 
        auto asIovec() {
                return static_cast<struct iovec*>(this);
        }
};
 
 
struct OutputMemoryRegion :
                public IOMemoryRegion<struct iovec_const> {
 
        OutputMemoryRegion() : OutputMemoryRegion{nullptr, 0} {}
 
        OutputMemoryRegion(const void *base, size_t length) {
                setBase(base);
                setLength(length);
        }
 
        explicit OutputMemoryRegion(const std::string_view sv) {
                setBase(sv.data());
                setLength(sv.size());
        }
 
        auto asIovec() {
                return reinterpret_cast<struct iovec*>(this);
        }
};
 
template <typename MEMORY_REGION>
class IOVector :
                public std::vector<MEMORY_REGION> {
        // only let these classes access the raw data
        friend class StreamIO;
        friend class SendMessageHeader;
        friend class ReceiveMessageHeader;
        template <typename MSGHDR>
        friend class MessageHeaderBase;
 
public: // functions
 
        size_t leftBytes() const {
                size_t ret = 0;
                for (const auto &entry: *this) {
                        ret += entry.getLength();
                }
 
                return ret;
        }
 
protected: // functions
 
        auto raw() { return this->data()->asIovec(); };
 
        bool update(size_t processed_bytes);
};
 
using ReadIOVector = IOVector<InputMemoryRegion>;
using WriteIOVector = IOVector<OutputMemoryRegion>;
 
extern template class COSMOS_API IOVector<InputMemoryRegion>;
extern template class COSMOS_API IOVector<OutputMemoryRegion>;
 
} // end ns