event_impl.hpp

// Copyright (c) 2000-2023 TeamDev Ltd. All rights reserved.
// TeamDev PROPRIETARY and CONFIDENTIAL.
// Use is subject to license terms.
 
#ifndef MOLYBDEN_EVENT_IMPL_HPP
#define MOLYBDEN_EVENT_IMPL_HPP
 
#include <memory>
#include <mutex>
#include <unordered_map>
 
#include "molybden/base/internal/subscription_impl.hpp"
 
namespace molybden {
namespace internal {
 
template <typename T>
class EventImpl : SubscriptionObserver {
 public:
  ~EventImpl() override;
 
  using Signature = void(const T& e);
 
  std::shared_ptr<Subscription> operator+=(std::function<Signature> observer);
 
  void notify(const T& args);
 
 private:
  void onCanceled(int32_t id) override;
 
  std::vector<std::shared_ptr<internal::SubscriptionImpl<T>>> subscriptions();
 
  std::mutex subscriptions_mutex_;
  std::unordered_map<int32_t, std::shared_ptr<internal::SubscriptionImpl<T>>>
      subscriptions_;
};
 
template <typename T>
std::vector<std::shared_ptr<internal::SubscriptionImpl<T>>>
EventImpl<T>::subscriptions() {
  std::vector<std::shared_ptr<internal::SubscriptionImpl<T>>> subscriptions;
  for (auto it : subscriptions_) {
    subscriptions.push_back(it.second);
  }
  return subscriptions;
}
 
template <typename T>
EventImpl<T>::~EventImpl() {
  std::lock_guard<std::mutex> guard(subscriptions_mutex_);
  for (auto subscription : subscriptions()) {
    subscription->setObserver(nullptr);
  }
}
 
template <typename T>
std::shared_ptr<Subscription> EventImpl<T>::operator+=(
    std::function<Signature> observer) {
  static std::atomic<int32_t> next_id(0);
  int32_t id = ++next_id;
  auto subscription = std::make_shared<internal::SubscriptionImpl<T>>(id,
                                                                      observer);
  subscription->setObserver(this);
  {
    std::lock_guard<std::mutex> guard(subscriptions_mutex_);
    subscriptions_.emplace(id, subscription);
  }
  return subscription;
}
 
template <typename T>
void EventImpl<T>::notify(const T& args) {
  std::lock_guard<std::mutex> guard(subscriptions_mutex_);
  for (auto subscription : subscriptions()) {
    subscription->notify(args);
  }
}
 
template <typename T>
void EventImpl<T>::onCanceled(int32_t id) {
  std::lock_guard<std::mutex> guard(subscriptions_mutex_);
  subscriptions_.erase(id);
}
 
}  // namespace internal
}  // namespace molybden
 
#endif  // MOLYBDEN_EVENT_IMPL_HPP