Publisher.hpp

Go to the documentation of this file.

// Copyright (c) 2026 EduArt Robotik GmbH

 
#pragma once
 
#include <functional>
#include <mutex>
#include <unordered_map>
#include <vector>
 
#include "sensorring/subscription/SubscriberToken.hpp"
#include "sensorring/subscription/Subscription.hpp"
 
namespace eduart {
 
namespace sensorring {
 
namespace subscription {

template <typename... Args> class Publisher {
public:
  using Callback = std::function<void(Args...)>;
 
  Publisher() = default;

  Subscription subscribe(Callback callback) {
    if (!callback) {
      return Subscription();
    }
    auto token = SubscriberToken::getNextToken();
    {
      std::lock_guard<std::mutex> lock(_mutex);
      _subscribers.emplace(token, std::move(callback));
    }
    return Subscription(token, [this, token]() {
      unsubscribe(token);
    });
  }

  void unsubscribe(SubscriberToken token) {
    std::lock_guard<std::mutex> lock(_mutex);
    _subscribers.erase(token);
  }

  void publish(Args... args) const {
    auto callbacks = copySubscribers();
    for (const auto& cb : callbacks) {
      try {
        cb(args...);
      } catch (...) {
      }
    }
  }

  std::vector<Callback> copySubscribers() const {
    std::vector<Callback> callbacks;
    {
      std::lock_guard<std::mutex> lock(_mutex);
      callbacks.reserve(_subscribers.size());
      for (const auto& [token, cb] : _subscribers) {
        if (cb) {
          callbacks.push_back(cb);
        }
      }
    }
    return callbacks;
  }
 
private:
  mutable std::mutex _mutex;
  std::unordered_map<SubscriberToken, Callback> _subscribers;
};
 
} // namespace subscription
 
} // namespace sensorring
 
} // namespace eduart