buffer.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include "sdkconfig.h"
 
#include <idfxx/net/endpoint>
#include <idfxx/net/error>
 
#include <cstddef>
#include <iterator>
#include <optional>
#include <ranges>
#include <span>
 
// Forward declaration from lwIP.
struct netbuf;
 
namespace idfxx::net::netconn {
 
class stream_channel;
class datagram_channel;
class raw_channel;
namespace detail {
class connectionless_channel;
}
 
class [[nodiscard]] buffer {
public:
    [[nodiscard]] static result<buffer> make();
 
    buffer() noexcept = default;
 
    ~buffer();
 
    buffer(const buffer&) = delete;
    buffer& operator=(const buffer&) = delete;
 
    buffer(buffer&& other) noexcept;
 
    buffer& operator=(buffer&& other) noexcept;
 
    [[nodiscard]] ::netbuf* idf_handle() const noexcept { return _buf; }
 
    [[nodiscard]] bool is_open() const noexcept { return _buf != nullptr; }
 
    [[nodiscard]] size_t len() const noexcept;
 
    [[nodiscard]] std::optional<endpoint> from_endpoint() const noexcept;
 
    class segment_view {
    public:
        class iterator {
        public:
            using value_type = std::span<const std::byte>;
            using difference_type = std::ptrdiff_t;
            using iterator_concept = std::forward_iterator_tag;
            // operator* yields a prvalue span, so the C++17 category tops out at
            // input; iterator_concept above is what makes it a forward_iterator.
            using iterator_category = std::input_iterator_tag;
 
            iterator() noexcept = default;
 
            [[nodiscard]] value_type operator*() const noexcept;
 
            iterator& operator++() noexcept;
 
            iterator operator++(int) noexcept {
                auto tmp = *this;
                ++*this;
                return tmp;
            }
 
            [[nodiscard]] bool operator==(const iterator& other) const noexcept { return _seg == other._seg; }
 
        private:
            friend class segment_view;
            explicit iterator(const void* seg) noexcept
                : _seg(seg) {}
 
            const void* _seg = nullptr;
        };
 
        [[nodiscard]] iterator begin() const noexcept;
 
        [[nodiscard]] iterator end() const noexcept { return iterator{}; }
 
    private:
        friend class buffer;
        explicit segment_view(const ::netbuf* buf) noexcept
            : _buf(buf) {}
 
        const ::netbuf* _buf = nullptr;
    };
 
    [[nodiscard]] segment_view segments() const noexcept { return segment_view{_buf}; }
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void attach(std::span<const std::byte> data) { idfxx::unwrap(try_attach(data)); }
#endif
 
    [[nodiscard]] size_t copy_into(std::span<std::byte> dst) const noexcept;
 
    [[nodiscard]] result<void> try_attach(std::span<const std::byte> data);
 
private:
    friend class stream_channel;
    friend class datagram_channel;
    friend class raw_channel;
    friend class detail::connectionless_channel;
 
    explicit buffer(::netbuf* buf) noexcept
        : _buf(buf) {}
 
    ::netbuf* _buf = nullptr;
};
 
} // namespace idfxx::net::netconn
 
// A `segment_view` iterator points into the owning buffer's netbuf chain, not
// into the view object itself, so it stays valid after the view is destroyed
// (as long as the buffer lives). That makes the view a borrowed range: piping a
// temporary's segments through a view adaptor — `buf.segments() | views::…` —
// does not dangle.
template<>
inline constexpr bool std::ranges::enable_borrowed_range<idfxx::net::netconn::buffer::segment_view> = true;