UDPSocket.hxx

#pragma once
 
// C++
#include <optional>
 
// cosmos
#include <cosmos/net/IPAddress.hxx>
#include <cosmos/net/IPSocket.hxx>
#include <cosmos/net/UDPOptions.hxx>
 
namespace cosmos {
 
 
template <SocketFamily FAMILY>
class UDPSocketT :
                public IPSocketT<FAMILY> {
public: // types
 
        using IPAddress = typename IPSocketT<FAMILY>::IPAddress;
        static inline constexpr auto TYPE = SocketType::DGRAM;
 
public: // functions
 
        explicit UDPSocketT(const SocketFlags flags = SocketFlags{SocketFlag::CLOEXEC}) :
                        IPSocketT<FAMILY>{TYPE, flags} {
        }
 
        auto udpOptions() {
                return UDPOptions{this->m_fd};
        }
 
        auto udpOptions() const {
                return UDPOptions{this->m_fd};
        }
 
 
        void bind(const IPAddress &addr) {
                return Socket::bind(addr);
        }
 
 
        void connect(const IPAddress &addr) {
                return Socket::connect(addr);
        }
 
 
        std::pair<size_t, std::optional<IPAddress>> receiveFrom(
                        void *buf, size_t length, const MessageFlags flags = MessageFlags{}) {
                IPAddress addr;
                auto [len, filled] = Socket::receiveFrom(buf, length, addr, flags);
 
                return {len, filled ? std::optional<IPAddress>{addr} : std::nullopt};
        }
 
 
        auto sendTo(const void *buf, size_t length, const IPAddress &addr, const MessageFlags flags = MessageFlags{}) {
                return Socket::sendTo(buf, length, addr, flags);
        }
 
        auto sendTo(const std::string_view data, const IPAddress &addr, const MessageFlags flags = MessageFlags{}) {
                return sendTo(data.data(), data.size(), addr, flags);
        }
 
        using Socket::send;
        using Socket::receive;
 
        void sendMessage(SendMessageHeader &header) {
                return Socket::sendMessage(header);
        }
 
        void sendMessageTo(SendMessageHeader &header, const IPAddress &addr) {
                return Socket::sendMessage(header, &addr);
        }
 
        void receiveMessage(ReceiveMessageHeader &header) {
                (void)Socket::receiveMessage(header);
        }
 
        std::optional<IPAddress> receiveMessageFrom(ReceiveMessageHeader &header) {
                IPAddress addr;
                auto filled = Socket::receiveMessage(header, &addr);
 
                return filled ? std::optional<IPAddress>{addr} : std::nullopt;
        }
};
 
using UDP4Socket = UDPSocketT<SocketFamily::INET>;
using UDP6Socket = UDPSocketT<SocketFamily::INET6>;
 
} // end ns