packet_buffer.hpp

// Copyright Take Vos 2020-2022.
// 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
 
#include "../macros.hpp"
 
hi_export_module(hikogui.net.packet_buffer);
 
hi_export namespace hi::inline v1 {
 
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
    {
        hi_assert(!closed());
        packets.emplace_back(nrBytes);
        return {packets.back().end(), nrBytes};
    }
 
    std::span<std::byte> getpacket(ssize_t nrBytes) noexcept
    {
        hi_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
    {
        hi_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(), ssize(packets)};
            }
 
            // Check if we can merge packets.
            hi_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()) {
            hi_check(byteNr < nrBytes, "New-line not found within {} bytes", nrBytes);
 
            if (i == ssize(packets[packetNr])) {
                // Advance to next packet.
                ++packetNr;
                i = 0;
            }
 
            auto const c = packets[packetNr][i] if (c == '\n' || c == '\0')
            {
                // Found end-of-line
                auto const 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) {
            auto const packet_size = ssize(packets.front());
            if (nrBytes >= packet_size) {
                packets.pop_front();
            } else {
                packets.front().read(nrBytes);
                hi_assert(ssize(packets.front()) > 0);
            }
            nrBytes -= ssize(packets_size);
        }
    }
};
 
} // namespace hi::inline v1