subscription_impl.hpp

// Copyright (c) 2000-2023 TeamDev Ltd. All rights reserved.
// TeamDev PROPRIETARY and CONFIDENTIAL.
// Use is subject to license terms.
 
#ifndef MOLYBDEN_SUBSCRIPTION_IMPL_HPP
#define MOLYBDEN_SUBSCRIPTION_IMPL_HPP
 
#include <algorithm>
#include <functional>
#include <utility>
#include <vector>
 
#include "molybden/base/subscription.hpp"
 
namespace molybden {
namespace internal {
 
class SubscriptionObserver {
 public:
  virtual ~SubscriptionObserver() = default;
 
  virtual void onCanceled(int32_t id){};
};
 
template <typename T>
class SubscriptionImpl : public Subscription {
 public:
  SubscriptionImpl(int32_t id, std::function<void(const T& e)> observer);
 
  void notify(const T& event);
 
  void cancel() override;
 
  void addObserver(SubscriptionObserver* observer);
 
  void removeObserver(SubscriptionObserver* observer);
 
 private:
  int32_t id_;
  std::function<void(const T& e)> observer_;
 
  std::vector<SubscriptionObserver*> observers_;
};
 
template <typename T>
SubscriptionImpl<T>::SubscriptionImpl(int32_t id,
                                      std::function<void(const T&)> observer)
    : id_(id), observer_(std::move(observer)) {}
 
template <typename T>
void SubscriptionImpl<T>::notify(const T& event) {
  if (observer_) {
    observer_(event);
  }
}
 
template <typename T>
void SubscriptionImpl<T>::cancel() {
  observer_ = {};
  for (auto* observer : observers_) {
    observer->onCanceled(id_);
  }
}
 
template <typename T>
void SubscriptionImpl<T>::addObserver(SubscriptionObserver* observer) {
  observers_.push_back(observer);
}
 
template <typename T>
void SubscriptionImpl<T>::removeObserver(SubscriptionObserver* observer) {
  auto it = std::find(observers_.begin(), observers_.end(), observer);
  if (it != observers_.end()) {
    observers_.erase(it);
  }
}
 
}  // namespace internal
}  // namespace molybden
 
#endif  // MOLYBDEN_SUBSCRIPTION_IMPL_HPP