SDL3pp_net.h

#ifndef SDL3PP_NET_H_
#define SDL3PP_NET_H_
 
#include "SDL3pp_properties.h"
#include "SDL3pp_version.h"
 
#ifdef SDL3PP_ENABLE_NET
 
#include <SDL3_net/SDL_net.h>
 
namespace SDL {

 
// Forward decl
struct AddressBase;
 
// Forward decl
struct Address;

using AddressRaw = NET_Address*;

using AddressRef = ResourceRefT<AddressBase>;
 
// Forward decl
struct StreamSocketBase;
 
// Forward decl
struct StreamSocket;

using StreamSocketRaw = NET_StreamSocket*;

using StreamSocketRef = ResourceRefT<StreamSocketBase>;
 
// Forward decl
struct ServerBase;
 
// Forward decl
struct Server;

using ServerRaw = NET_Server*;

using ServerRef = ResourceRefT<ServerBase>;
 
// Forward decl
struct DatagramSocketBase;
 
// Forward decl
struct DatagramSocket;

using DatagramSocketRaw = NET_DatagramSocket*;

using DatagramSocketRef = ResourceRefT<DatagramSocketBase>;
 
// Forward decl
struct DatagramBase;
 
// Forward decl
struct Datagram;

using DatagramRaw = NET_Datagram*;

using DatagramRawConst = const NET_Datagram*;

using DatagramRef = ResourceRefT<DatagramBase>;

using DatagramConstRef = ResourceConstRef<DatagramRaw, DatagramRawConst>;
 
#ifdef SDL3PP_DOC

#define SDL_NET_MAJOR_VERSION

#define SDL_NET_MINOR_VERSION

#define SDL_NET_MICRO_VERSION

#define SDL_NET_VERSION                                                        \
  SDL_VERSIONNUM(                                                              \
    SDL_NET_MAJOR_VERSION, SDL_NET_MINOR_VERSION, SDL_NET_MICRO_VERSION)

#define SDL_NET_VERSION_ATLEAST(X, Y, Z)                                       \
  ((SDL_NET_MAJOR_VERSION >= X) &&                                             \
   (SDL_NET_MAJOR_VERSION > X || SDL_NET_MINOR_VERSION >= Y) &&                \
   (SDL_NET_MAJOR_VERSION > X || SDL_NET_MINOR_VERSION > Y ||                  \
    SDL_NET_MICRO_VERSION >= Z))
 
#endif /* SDL3PP_DOC */
 
namespace NET {

inline int Version() { return NET_Version(); }

inline void Init() { CheckError(NET_Init()); }

inline void Quit() { NET_Quit(); }
 
} // namespace NET

using Status = NET_Status;
 
constexpr Status FAILURE =
  NET_FAILURE; 

constexpr Status WAITING = NET_WAITING;
 
constexpr Status SUCCESS =
  NET_SUCCESS; 

struct AddressBase : ResourceBaseT<AddressRaw>
{
  using ResourceBaseT::ResourceBaseT;

  void Unref();

  Status WaitUntilResolved(Sint32 timeout);

  Status GetStatus();

  const char* GetString();

  const void* GetBytes(int* num_bytes);

  int Compare(AddressRef b) const;

  bool operator==(const AddressBase& other) const;

  auto operator<=>(const AddressBase& other) const;

  StreamSocket CreateClient(Uint16 port, PropertiesRef props);

  Server CreateServer(Uint16 port, PropertiesRef props);

  DatagramSocket CreateDatagramSocket(Uint16 port, PropertiesRef props);
};

struct Address : AddressBase
{
  using AddressBase::AddressBase;

  constexpr explicit Address(AddressRaw resource) noexcept
    : AddressBase(resource)
  {
  }

  constexpr Address(Address&& other) noexcept
    : Address(other.release())
  {
  }

  Address(StringParam host);

  Address(const Address& address);

  static Address borrow(AddressRaw resource)
  {
    if (resource) {
      NET_RefAddress(resource);
      return Address(resource);
    }
    return {};
  }

  ~Address() { NET_UnrefAddress(get()); }

  constexpr Address& operator=(Address&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }

  Address& operator=(const Address& other)
  {
    if (get() != other.get()) {
      Address tmp(other);
      swap(*this, tmp);
    }
    return *this;
  }
};

inline Address ResolveHostname(StringParam host) { return Address(host); }
 
inline Address::Address(StringParam host)
  : Address(CheckError(NET_ResolveHostname(host)))
{
}
 
inline Address::Address(const Address& address)
  : Address(address ? NET_RefAddress(address.get()) : nullptr)
{
}

inline Status WaitUntilResolved(AddressRef address, Sint32 timeout)
{
  return NET_WaitUntilResolved(address, timeout);
}
 
inline Status AddressBase::WaitUntilResolved(Sint32 timeout)
{
  return SDL::WaitUntilResolved(get(), timeout);
}

inline Status GetAddressStatus(AddressRef address)
{
  return NET_GetAddressStatus(address);
}
 
inline Status AddressBase::GetStatus() { return SDL::GetAddressStatus(get()); }

inline const char* GetAddressString(AddressRef address)
{
  return CheckError(NET_GetAddressString(address));
}
 
inline const char* AddressBase::GetString()
{
  return SDL::GetAddressString(get());
}

inline const void* GetAddressBytes(AddressRef address, int* num_bytes)
{
  return CheckError(NET_GetAddressBytes(address, num_bytes));
}
 
inline const void* AddressBase::GetBytes(int* num_bytes)
{
  return SDL::GetAddressBytes(get(), num_bytes);
}

inline Address RefAddress(AddressRef address) { return Address(address); }

inline void UnrefAddress(AddressRaw address) { NET_UnrefAddress(address); }
 
inline void AddressBase::Unref() { UnrefAddress(release()); }

inline void SimulateAddressResolutionLoss(int percent_loss)
{
  NET_SimulateAddressResolutionLoss(percent_loss);
}

inline int CompareAddresses(AddressRef a, AddressRef b)
{
  return NET_CompareAddresses(a, b);
}
 
inline int AddressBase::Compare(AddressRef b) const
{
  return SDL::CompareAddresses(get(), b);
}
 
inline bool AddressBase::operator==(const AddressBase& other) const
{
  return Compare(other) == 0;
}
 
inline auto AddressBase::operator<=>(const AddressBase& other) const
{
  return Compare(other) <=> 0;
}

struct LocalAddressesArrayDeleter
{
  static void operator()(AddressRef* addresses);
};

using LocalAddressesArray = OwnArray<AddressRef, LocalAddressesArrayDeleter>;

inline LocalAddressesArray GetLocalAddresses()
{
  int count;
  auto* addrs = CheckError(NET_GetLocalAddresses(&count));
  return LocalAddressesArray(reinterpret_cast<AddressRef*>(addrs), count);
}

inline void FreeLocalAddresses(AddressRef* addresses)
{
  NET_FreeLocalAddresses(reinterpret_cast<AddressRaw*>(addresses));
}
 
inline void LocalAddressesArrayDeleter::operator()(AddressRef* addresses)
{
  FreeLocalAddresses(addresses);
}

struct StreamSocketBase : ResourceBaseT<StreamSocketRaw>
{
  using ResourceBaseT::ResourceBaseT;

  void Destroy();

  Status WaitUntilConnected(Sint32 timeout);

  Address GetAddress();

  Status GetConnectionStatus();

  bool WriteTo(const void* buf, int buflen);

  int GetPendingWrites();

  int WaitUntilDrained(Sint32 timeout);

  int ReadFrom(void* buf, int buflen);

  void SimulateStreamPacketLoss(int percent_loss);
};

struct StreamSocket : StreamSocketBase
{
  using StreamSocketBase::StreamSocketBase;

  constexpr explicit StreamSocket(StreamSocketRaw resource) noexcept
    : StreamSocketBase(resource)
  {
  }

  constexpr StreamSocket(StreamSocket&& other) noexcept
    : StreamSocket(other.release())
  {
  }

  StreamSocket(AddressRef address, Uint16 port, PropertiesRef props);

  ~StreamSocket() { NET_DestroyStreamSocket(get()); }

  constexpr StreamSocket& operator=(StreamSocket&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }
};

inline StreamSocket CreateClient(AddressRef address,
                                 Uint16 port,
                                 PropertiesRef props)
{
  return StreamSocket(address, port, props);
}
 
inline StreamSocket AddressBase::CreateClient(Uint16 port, PropertiesRef props)
{
  return StreamSocket(get(), port, props);
}
 
inline StreamSocket::StreamSocket(AddressRef address,
                                  Uint16 port,
                                  PropertiesRef props)
  : StreamSocket(CheckError(NET_CreateClient(address, port, props)))
{
}

inline Status WaitUntilConnected(StreamSocketRef sock, Sint32 timeout)
{
  return NET_WaitUntilConnected(sock, timeout);
}
 
inline Status StreamSocketBase::WaitUntilConnected(Sint32 timeout)
{
  return SDL::WaitUntilConnected(get(), timeout);
}

struct ServerBase : ResourceBaseT<ServerRaw>
{
  using ResourceBaseT::ResourceBaseT;

  void Destroy();

  void AcceptClient(NET_StreamSocket** client_stream);
};

struct Server : ServerBase
{
  using ServerBase::ServerBase;

  constexpr explicit Server(ServerRaw resource) noexcept
    : ServerBase(resource)
  {
  }

  constexpr Server(Server&& other) noexcept
    : Server(other.release())
  {
  }

  Server(AddressRef addr, Uint16 port, PropertiesRef props);

  ~Server() { NET_DestroyServer(get()); }

  constexpr Server& operator=(Server&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }
};

inline Server CreateServer(AddressRef addr, Uint16 port, PropertiesRef props)
{
  return Server(addr, port, props);
}
 
inline Server AddressBase::CreateServer(Uint16 port, PropertiesRef props)
{
  return Server(get(), port, props);
}
 
inline Server::Server(AddressRef addr, Uint16 port, PropertiesRef props)
  : Server(CheckError(NET_CreateServer(addr, port, props)))
{
}
 
namespace prop::Server {
 
constexpr auto REUSEADDR_BOOLEAN =
  NET_PROP_SERVER_REUSEADDR_BOOLEAN; 
 
} // namespace prop::Server

inline void AcceptClient(ServerRef server, NET_StreamSocket** client_stream)
{
  CheckError(NET_AcceptClient(server, client_stream));
}
 
inline void ServerBase::AcceptClient(NET_StreamSocket** client_stream)
{
  SDL::AcceptClient(get(), client_stream);
}

inline void DestroyServer(ServerRaw server) { NET_DestroyServer(server); }
 
inline void ServerBase::Destroy() { DestroyServer(release()); }

inline Address GetStreamSocketAddress(StreamSocketRef sock)
{
  return Address(CheckError(NET_GetStreamSocketAddress(sock)));
}
 
inline Address StreamSocketBase::GetAddress()
{
  return SDL::GetStreamSocketAddress(get());
}

inline Status GetConnectionStatus(StreamSocketRef sock)
{
  return NET_GetConnectionStatus(sock);
}
 
inline Status StreamSocketBase::GetConnectionStatus()
{
  return SDL::GetConnectionStatus(get());
}

inline bool WriteToStreamSocket(StreamSocketRef sock,
                                const void* buf,
                                int buflen)
{
  return NET_WriteToStreamSocket(sock, buf, buflen);
}
 
inline bool StreamSocketBase::WriteTo(const void* buf, int buflen)
{
  return SDL::WriteToStreamSocket(get(), buf, buflen);
}

inline int GetStreamSocketPendingWrites(StreamSocketRef sock)
{
  return NET_GetStreamSocketPendingWrites(sock);
}
 
inline int StreamSocketBase::GetPendingWrites()
{
  return SDL::GetStreamSocketPendingWrites(get());
}

inline int WaitUntilStreamSocketDrained(StreamSocketRef sock, Sint32 timeout)
{
  return NET_WaitUntilStreamSocketDrained(sock, timeout);
}
 
inline int StreamSocketBase::WaitUntilDrained(Sint32 timeout)
{
  return SDL::WaitUntilStreamSocketDrained(get(), timeout);
}

inline int ReadFromStreamSocket(StreamSocketRef sock, void* buf, int buflen)
{
  return NET_ReadFromStreamSocket(sock, buf, buflen);
}
 
inline int StreamSocketBase::ReadFrom(void* buf, int buflen)
{
  return SDL::ReadFromStreamSocket(get(), buf, buflen);
}

inline void SimulateStreamPacketLoss(StreamSocketRef sock, int percent_loss)
{
  NET_SimulateStreamPacketLoss(sock, percent_loss);
}
 
inline void StreamSocketBase::SimulateStreamPacketLoss(int percent_loss)
{
  SDL::SimulateStreamPacketLoss(get(), percent_loss);
}

inline void DestroyStreamSocket(StreamSocketRaw sock)
{
  NET_DestroyStreamSocket(sock);
}
 
inline void StreamSocketBase::Destroy() { DestroyStreamSocket(release()); }

struct DatagramSocketBase : ResourceBaseT<DatagramSocketRaw>
{
  using ResourceBaseT::ResourceBaseT;

  void Destroy();

  bool SendDatagram(AddressRef address,
                    Uint16 port,
                    const void* buf,
                    int buflen);

  bool ReceiveDatagram(Datagram& dgram);

  Datagram ReceiveDatagram();

  void SimulateDatagramPacketLoss(int percent_loss);
};

struct DatagramSocket : DatagramSocketBase
{
  using DatagramSocketBase::DatagramSocketBase;

  constexpr explicit DatagramSocket(DatagramSocketRaw resource) noexcept
    : DatagramSocketBase(resource)
  {
  }

  constexpr DatagramSocket(DatagramSocket&& other) noexcept
    : DatagramSocket(other.release())
  {
  }

  DatagramSocket(AddressRef addr, Uint16 port, PropertiesRef props);

  ~DatagramSocket() { NET_DestroyDatagramSocket(get()); }

  constexpr DatagramSocket& operator=(DatagramSocket&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }
};

struct DatagramBase : ResourceBaseT<DatagramRaw, DatagramRawConst>
{
  using ResourceBaseT::ResourceBaseT;

  constexpr operator DatagramConstRef() const noexcept { return get(); }

  void Destroy();

  bool Receive(DatagramSocketRef sock);
};

struct Datagram : DatagramBase
{
  using DatagramBase::DatagramBase;

  constexpr explicit Datagram(DatagramRaw resource) noexcept
    : DatagramBase(resource)
  {
  }

  constexpr Datagram(Datagram&& other) noexcept
    : Datagram(other.release())
  {
  }

  Datagram(DatagramSocketRef sock);

  ~Datagram() { NET_DestroyDatagram(get()); }

  constexpr Datagram& operator=(Datagram&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }
};

inline DatagramSocket CreateDatagramSocket(AddressRef addr,
                                           Uint16 port,
                                           PropertiesRef props)
{
  return DatagramSocket(addr, port, props);
}
 
inline DatagramSocket AddressBase::CreateDatagramSocket(Uint16 port,
                                                        PropertiesRef props)
{
  return DatagramSocket(get(), port, props);
}
 
inline DatagramSocket::DatagramSocket(AddressRef addr,
                                      Uint16 port,
                                      PropertiesRef props)
  : DatagramSocket(CheckError(NET_CreateDatagramSocket(addr, port, props)))
{
}
 
namespace prop::DatagramSocket {
 
constexpr auto REUSEADDR_BOOLEAN =
  NET_PROP_DATAGRAM_SOCKET_REUSEADDR_BOOLEAN; 
 
constexpr auto ALLOW_BROADCAST_BOOLEAN =
  NET_PROP_DATAGRAM_SOCKET_ALLOW_BROADCAST_BOOLEAN; 
 
} // namespace prop::DatagramSocket

inline bool SendDatagram(DatagramSocketRef sock,
                         AddressRef address,
                         Uint16 port,
                         const void* buf,
                         int buflen)
{
  return NET_SendDatagram(sock, address, port, buf, buflen);
}
 
inline bool DatagramSocketBase::SendDatagram(AddressRef address,
                                             Uint16 port,
                                             const void* buf,
                                             int buflen)
{
  return SDL::SendDatagram(get(), address, port, buf, buflen);
}

inline bool ReceiveDatagram(DatagramSocketRef sock, Datagram& dgram)
{
  return dgram.Receive(sock);
}

inline Datagram ReceiveDatagram(DatagramSocketRef sock)
{
  Datagram dgram;
  dgram.Receive(sock);
  return dgram;
}
 
inline bool DatagramSocketBase::ReceiveDatagram(Datagram& dgram)
{
  return dgram.Receive(*this);
}
 
inline Datagram DatagramSocketBase::ReceiveDatagram()
{
  return SDL::ReceiveDatagram(get());
}
 
inline Datagram::Datagram(DatagramSocketRef sock)
  : Datagram(sock.ReceiveDatagram())
{
}
 
inline bool DatagramBase::Receive(DatagramSocketRef sock)
{
  DatagramRaw dgram;
  if (!NET_ReceiveDatagram(sock, &dgram)) return false;
  *this = Datagram(dgram);
  return true;
}

inline void DestroyDatagram(DatagramRaw dgram) { NET_DestroyDatagram(dgram); }
 
inline void DatagramBase::Destroy() { DestroyDatagram(release()); }

inline void SimulateDatagramPacketLoss(DatagramSocketRef sock, int percent_loss)
{
  NET_SimulateDatagramPacketLoss(sock, percent_loss);
}
 
inline void DatagramSocketBase::SimulateDatagramPacketLoss(int percent_loss)
{
  SDL::SimulateDatagramPacketLoss(get(), percent_loss);
}

inline void DestroyDatagramSocket(DatagramSocketRaw sock)
{
  NET_DestroyDatagramSocket(sock);
}
 
inline void DatagramSocketBase::Destroy() { DestroyDatagramSocket(release()); }

inline int WaitUntilInputAvailable(void** vsockets,
                                   int numsockets,
                                   Sint32 timeout)
{
  return NET_WaitUntilInputAvailable(vsockets, numsockets, timeout);
}

 
} // namespace SDL
 
#endif /* SDL3PP_ENABLE_NET */
 
#endif /* SDL3PP_NET_H_ */