service_discovery.hpp

Go to the documentation of this file.

#pragma once
 
// pulp::events::ServiceBrowser / ServicePublisher — RAII wrappers around
// NetworkServiceDiscovery for the common single-publish / single-browse
// shapes.
//
// The underlying NSD object remains the configurable dispatcher when a
// caller needs install_backend / multiple browses; these wrappers exist
// because 80% of consumers want "publish this service, stop publishing
// on scope exit" or "browse this type, stop browsing on scope exit"
// without managing the NSD lifecycle by hand.
 
#include <pulp/events/volume_detector.hpp>
 
#include <functional>
#include <memory>
#include <string>
#include <string_view>
 
namespace pulp::events {

enum class ServiceDiscoveryAction {
    ServiceFound,
    ServiceLost,
};

bool install_default_backend(NetworkServiceDiscovery& nsd);

class ServicePublisher {
public:
    ServicePublisher(std::string_view name,
                     std::string_view type,
                     uint16_t port,
                     NetworkServiceDiscovery::TxtRecords txt_records = {});
    ~ServicePublisher();
 
    ServicePublisher(const ServicePublisher&) = delete;
    ServicePublisher& operator=(const ServicePublisher&) = delete;
 
    bool is_published() const noexcept { return published_; }

    NetworkServiceDiscovery& nsd() noexcept { return nsd_; }

    static std::unique_ptr<ServicePublisher> with_backend(
        std::unique_ptr<NetworkServiceDiscovery::Backend> backend,
        std::string_view name,
        std::string_view type,
        uint16_t port,
        NetworkServiceDiscovery::TxtRecords txt_records = {});
 
private:
    struct WithBackendTag {};
    ServicePublisher(WithBackendTag,
                     std::unique_ptr<NetworkServiceDiscovery::Backend> backend,
                     std::string_view name,
                     std::string_view type,
                     uint16_t port,
                     NetworkServiceDiscovery::TxtRecords txt_records);
 
    NetworkServiceDiscovery nsd_;
    bool published_ = false;
};

class ServiceBrowser {
public:
    using Callback = std::function<void(ServiceDiscoveryAction,
                                        const NetworkServiceDiscovery::Service&)>;
 
    ServiceBrowser(std::string_view service_type, Callback callback);
    ~ServiceBrowser();
 
    ServiceBrowser(const ServiceBrowser&) = delete;
    ServiceBrowser& operator=(const ServiceBrowser&) = delete;
 
    bool is_browsing() const noexcept { return has_backend_; }
 
    NetworkServiceDiscovery& nsd() noexcept { return nsd_; }

    static std::unique_ptr<ServiceBrowser> with_backend(
        std::unique_ptr<NetworkServiceDiscovery::Backend> backend,
        std::string_view service_type,
        Callback callback);
 
private:
    struct WithBackendTag {};
    ServiceBrowser(WithBackendTag,
                   std::unique_ptr<NetworkServiceDiscovery::Backend> backend,
                   std::string_view service_type,
                   Callback callback);
 
    void wire_callbacks(Callback callback);
 
    NetworkServiceDiscovery nsd_;
    bool has_backend_ = false;
};
 
}  // namespace pulp::events