socket_extensions.hpp

#pragma once
 
#include "nalchi/alloca.hpp"
#include "nalchi/export.hpp"
#include "nalchi/shared_payload.hpp"
#include "nalchi/typed_input_range.hpp"
 
#include <steam/isteamnetworkingsockets.h>
#include <steam/isteamnetworkingutils.h>
#include <steam/steamnetworkingtypes.h>
 
#include <cstdint>
#include <span>
#include <type_traits>
 
namespace nalchi
{
 
class socket_extensions
{
public:
    NALCHI_API static void unicast(ISteamNetworkingSockets* sockets, HSteamNetConnection connection,
                                   nalchi::shared_payload payload, int logical_bytes_length, int send_flags,
                                   std::int64_t* out_message_number_or_result, std::uint16_t lane = 0,
                                   std::int64_t user_data = 0);
 
    template <typed_input_range<HSteamNetConnection> ConnectionRange>
    static void multicast(ISteamNetworkingSockets* sockets, ConnectionRange&& connections,
                          nalchi::shared_payload payload, int logical_bytes_length, int send_flags,
                          std::span<std::int64_t> out_message_number_or_result, std::uint16_t lane = 0,
                          std::int64_t user_data = 0)
    {
        const auto connections_count = std::ranges::size(connections);
 
        // If no connections to send,
        if (0 == connections_count)
        {
            // Force deallocate the payload, and return without sending.
            shared_payload::force_deallocate(payload);
            return;
        }
 
        // No dynamic allocation vs. Stack overflow safety.
        // I chose the former, because I think it's not common to multicast to more than 10k connections at once.
        auto** messages = static_cast<SteamNetworkingMessage_t**>(
            NALCHI_ALLOCA(connections_count * sizeof(SteamNetworkingMessage_t*)));
 
        std::remove_const_t<decltype(connections_count)> i = 0;
        for (const auto conn : connections)
        {
            // TODO: Pool message instead of allocating.
            messages[i] = SteamNetworkingUtils()->AllocateMessage(0);
 
            // Setup the message to send to `conn`.
            payload.add_to_message(messages[i], logical_bytes_length);
            messages[i]->m_conn = conn;
            messages[i]->m_nFlags = send_flags;
            messages[i]->m_idxLane = lane;
            messages[i]->m_nUserData = user_data;
 
            ++i;
        }
 
        // Send all messages.
        sockets->SendMessages(static_cast<int>(connections_count), messages,
                              reinterpret_cast<int64*>(out_message_number_or_result.data()));
    }
 
    NALCHI_API static void multicast(ISteamNetworkingSockets* sockets, unsigned connections_count,
                                     const HSteamNetConnection* connections, nalchi::shared_payload payload,
                                     int logical_bytes_length, int send_flags,
                                     std::int64_t* out_message_number_or_result, std::uint16_t lane = 0,
                                     std::int64_t user_data = 0);
};
 
} // namespace nalchi