connectionless_channel.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
 
// Internal base class shared by `datagram_channel` and `raw_channel`, the
// connectionless netconn-API channel types. Provides the connect / disconnect /
// send / recv operations that have the same shape on both — per-message
// addressing, default-peer support, and the buffer/span send and recv overloads.
// Mirrors the BSD-side `connectionless_socket_base`.
 
#include "base_channel.hpp"
#include "sdkconfig.h"
 
#include <idfxx/net/endpoint>
#include <idfxx/net/error>
#include <idfxx/net/netconn/buffer>
 
#include <cstddef>
#include <span>
 
namespace idfxx::net::netconn::detail {
 
class connectionless_channel : public base_channel {
public:
    using datagram = ::idfxx::net::datagram;
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void connect(const endpoint& peer) { idfxx::unwrap(try_connect(peer)); }
#endif
 
    [[nodiscard]] result<void> try_connect(const endpoint& peer);
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    void disconnect() { idfxx::unwrap(try_disconnect()); }
#endif
 
    result<void> try_disconnect();
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    size_t send(buffer& buf) { return idfxx::unwrap(try_send(buf)); }
#endif
 
    [[nodiscard]] result<size_t> try_send(buffer& buf);
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    size_t send(std::span<const std::byte> data) { return idfxx::unwrap(try_send(data)); }
#endif
 
    [[nodiscard]] result<size_t> try_send(std::span<const std::byte> data);
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    size_t send_to(buffer& buf, const endpoint& to) { return idfxx::unwrap(try_send_to(buf, to)); }
#endif
 
    [[nodiscard]] result<size_t> try_send_to(buffer& buf, const endpoint& to);
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    size_t send_to(std::span<const std::byte> data, const endpoint& to) { return idfxx::unwrap(try_send_to(data, to)); }
#endif
 
    [[nodiscard]] result<size_t> try_send_to(std::span<const std::byte> data, const endpoint& to);
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] buffer recv() { return idfxx::unwrap(try_recv()); }
#endif
 
    [[nodiscard]] result<buffer> try_recv();
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] std::span<std::byte> recv(std::span<std::byte> buf) { return idfxx::unwrap(try_recv(buf)); }
#endif
 
    [[nodiscard]] result<std::span<std::byte>> try_recv(std::span<std::byte> buf);
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] datagram recv_from(std::span<std::byte> buf) { return idfxx::unwrap(try_recv_from(buf)); }
#endif
 
    [[nodiscard]] result<datagram> try_recv_from(std::span<std::byte> buf);
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] endpoint peer_endpoint() const { return idfxx::unwrap(try_peer_endpoint()); }
#endif
 
    [[nodiscard]] result<endpoint> try_peer_endpoint() const { return _try_getaddr(false); }
 
protected:
    using base_channel::base_channel;
};
 
} // namespace idfxx::net::netconn::detail