UdsChannel.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <cstring>
#include <string>
#include <utility>
 
#include "corium/Events.hpp"
#include "corium/ipc/DomainSocket.hpp"
 
namespace corium::ipc {
 
template <
    typename EventVariant = DefaultEvents,
    std::size_t MaxPacketSize = 512
>
class UdsChannel {
    static_assert(sizeof(EventVariant) <= MaxPacketSize, "EventVariant size exceeds MaxPacketSize");
    static_assert(std::is_trivially_copyable_v<EventVariant>,
        "UdsChannel EventVariant must be trivially copyable for datagram socket transmission.");
 
public:
    UdsChannel() = default;
 
    bool listen(const std::string& socketPath, bool nonBlocking = true) noexcept
    {
        if (!_socket.bind(socketPath)) {
            return false;
        }
        if (nonBlocking) {
            _socket.setNonBlocking(true);
        }
        return true;
    }
 
    bool connect(const std::string& serverPath, const std::string& clientPath = "") noexcept
    {
        return _socket.connect(serverPath, clientPath);
    }
 
    template <typename EventType>
    bool post(EventType&& event) noexcept
    {
        EventVariant ev{std::forward<EventType>(event)};
        const int bytesSent = _socket.send(&ev, sizeof(EventVariant));
        return bytesSent == static_cast<int>(sizeof(EventVariant));
    }
 
    bool tryPop(EventVariant& outEvent) noexcept
    {
        const int bytesReceived = _socket.receive(&outEvent, sizeof(EventVariant));
        return bytesReceived == static_cast<int>(sizeof(EventVariant));
    }
 
    template <typename SinkType>
    std::size_t pumpInto(const SinkType& sink, std::size_t maxEvents = 0)
    {
        std::size_t count = 0;
        EventVariant ev;
        while (tryPop(ev)) {
            sink.post(std::move(ev));
            count++;
            if (maxEvents > 0 && count >= maxEvents) {
                break;
            }
        }
        return count;
    }
 
    void close() noexcept
    {
        _socket.close();
    }
 
    [[nodiscard]] bool isOpen() const noexcept
    {
        return _socket.isOpen();
    }
 
    [[nodiscard]] DomainSocket& socket() noexcept
    {
        return _socket;
    }
 
private:
    DomainSocket _socket;
};
 
} // namespace corium::ipc