UnixDatagramSocket.hxx

#pragma once
 
// C++
#include <optional>
 
// cosmos
#include <cosmos/net/Socket.hxx>
#include <cosmos/net/UnixAddress.hxx>
#include <cosmos/net/UnixOptions.hxx>
 
namespace cosmos {
 
 
class UnixDatagramSocket :
                public Socket {
public: // types
 
        static inline constexpr auto TYPE = SocketType::DGRAM;
 
public: // functions
 
        explicit UnixDatagramSocket(const SocketFlags flags = SocketFlags{SocketFlag::CLOEXEC}) :
                        Socket{SocketFamily::UNIX, TYPE, flags} {
        }
 
        explicit UnixDatagramSocket(const FileDescriptor fd, const AutoCloseFD auto_close = AutoCloseFD{true}) :
                        Socket{fd, auto_close} {}
 
        auto unixOptions() {
                return UnixOptions{this->m_fd};
        }
 
        auto unixOptions() const {
                return UnixOptions{this->m_fd};
        }
 
 
        void bind(const UnixAddress &addr) {
                return Socket::bind(addr);
        }
 
 
        void connect(const UnixAddress &addr) {
                return Socket::connect(addr);
        }
 
        std::pair<size_t, std::optional<UnixAddress>> receiveFrom(
                        void *buf, size_t length, const MessageFlags flags = MessageFlags{}) {
                UnixAddress addr;
                auto [len, filled] = Socket::receiveFrom(buf, length, addr, flags);
 
                return {len, filled ? std::optional<UnixAddress>{addr} : std::nullopt};
        }
 
        auto sendTo(const void *buf, size_t length, const UnixAddress &addr, const MessageFlags flags = MessageFlags{}) {
                return Socket::sendTo(buf, length, addr, flags);
        }
 
        auto sendTo(const std::string_view data, const UnixAddress &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 UnixAddress &addr) {
                return Socket::sendMessage(header, &addr);
        }
 
        void receiveMessage(ReceiveMessageHeader &header) {
                (void)Socket::receiveMessage(header);
        }
 
        std::optional<UnixAddress> receiveMessageFrom(ReceiveMessageHeader &header) {
                UnixAddress addr;
                auto filled = Socket::receiveMessage(header, &addr);
 
                return filled ? std::optional<UnixAddress>{addr} : std::nullopt;
        }
};
 
} // end ns