packet_buffer.hpp

// Copyright Take Vos 2020.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
 
#pragma once
 
namespace tt {
 
class packet_buffer {
    std::list<packet> packets;
    ssize_t _totalNrBytes;
    bool _closed;
 
public:
    bool closed() const noexcept {
        return _closed;
    }
 
    ssize_t nrBytes() const noexcept {
        return _totalNrBytes;
    }
 
    ssize_t nrpackets() const noexcept {
        return packets.size();
    }
 
    void close() noexcept {
        _closed = true;
    }
 
    std::span<std::byte> getNewpacket(ssize_t nrBytes) noexcept {
        tt_assert(!closed());
        packets.emplace_back(nrBytes);
        return {packets.back().end(), nrBytes};
    }
   
    std::span<std::byte> getpacket(ssize_t nrBytes) noexcept {
        tt_assert(!closed());
        if (packets.empty() || (packets.back().writeSize() < nrBytes)) {
            packets.emplace_back(nrBytes);
        }
        return {packets.back().end(), nrBytes};
    }
   
    void write(ssize_t nrBytes, bool push=true) noexcept {
        tt_assert(!closed());
        packets.back().write(nrBytes);
        if (push) {
            packets.back().push();
        }
        _totalNrBytes += nrBytes;
    }
 
    std::span<std::byte const> peek(ssize_t nrBytes) {
        if (packets.empty() || size() < nrBytes) {
            return {};
        }
 
        while (true) {
            if (packets.front().readSize() >= nrBytes) {
                return {packets.front().readSize(), std::ssize(packets)};
            }
 
            // Check if we can merge packets.
            tt_assert(packets.front().size() >= nrBytes);
 
            // Merge data from next packet.
        }
    }
 
    std::string_view peekLine(ssize_t nrBytes=1024) {
        ssize_t packetNr = 0;
        ssize_t byteNr = 0;
        ssize_t i = 0;
        while (packetNr < nrpackets()) {
            tt_parse_check(byteNr < nrBytes, "New-line not found within {} bytes", nrBytes);
 
            if (i == std::ssize(packets[packetNr])) {
                // Advance to next packet.
                ++packetNr;
                i = 0;
            }
 
            ttlet c = packets[packetNr][i]
            if (c == '\n' || c == '\0') {
                // Found end-of-line
                ttlet bspan = peek(byteNr + 1);
                return {reinterpret_cast<char *>(bspan.data(), byteNr + 1};
            }
            ++i;
            ++byteNr;
        }
 
        // Not enough bytes read yet.
        return {}
    }
 
    void read(ssize_t nrBytes) noexcept {
        peekBuffer.clear();
 
        while (nrBytes) {
            ttlet packet_size = std::ssize(packets.front());
            if (nrBytes >= packet_size) {
                packets.pop_front();
            } else {
                packets.front().read(nrBytes);
                tt_axiom(std::ssize(packets.front()) > 0);
            }
            nrBytes -= std::ssize(packets_size);
        }
    }
 
 
};
 
 
}