ip_io_socket_base.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 `stream_socket` and `connectionless_socket_base`
// (i.e. by every socket type on which peer-oriented I/O makes sense: stream,
// datagram, raw). Adds `connect`, `peer_endpoint`, `recv`, the send-side
// timeout/buffer options, and `wait_writable` on top of `ip_socket_base`.
//
// `listener` inherits `ip_socket_base` directly and so does not pick up any of
// these members.
 
#include "sdkconfig.h"
 
#include <idfxx/net/detail/ip_socket_base.hpp>
#include <idfxx/net/endpoint>
#include <idfxx/net/error>
 
#include <chrono>
#include <cstddef>
#include <span>
 
namespace idfxx::net::detail {
 
class ip_io_socket_base : public ip_socket_base {
public:
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] endpoint peer_endpoint() const { return idfxx::unwrap(try_peer_endpoint()); }
#endif
 
    [[nodiscard]] result<endpoint> try_peer_endpoint() const;
 
#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
    [[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);
 
    void set_send_buffer(size_t bytes) noexcept;
 
    template<typename Rep, typename Period>
    void set_send_timeout(const std::chrono::duration<Rep, Period>& t) noexcept {
        _set_send_timeout(std::chrono::ceil<std::chrono::milliseconds>(t));
    }
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    template<typename Rep, typename Period>
    void wait_writable(const std::chrono::duration<Rep, Period>& timeout) {
        idfxx::unwrap(_try_wait_writable(std::chrono::ceil<std::chrono::milliseconds>(timeout)));
    }
#endif
 
    template<typename Rep, typename Period>
    [[nodiscard]] result<void> try_wait_writable(const std::chrono::duration<Rep, Period>& timeout) {
        return _try_wait_writable(std::chrono::ceil<std::chrono::milliseconds>(timeout));
    }
 
    [[nodiscard]] size_t get_send_buffer() const noexcept;
 
protected:
    using ip_socket_base::ip_socket_base;
 
    void _set_send_timeout(std::chrono::milliseconds t) noexcept;
    [[nodiscard]] result<void> _try_wait_writable(std::chrono::milliseconds timeout);
};
 
} // namespace idfxx::net::detail