Event.h

Aller à la documentation de ce fichier.

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2023 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Event.h                                                     (C) 2000-2023 */
/*                                                                           */
/* Gestionnaires d'évènements.                                               */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_UTILS_EVENT_H
#define ARCANE_UTILS_EVENT_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/UtilsTypes.h"
#include "arcane/utils/Array.h"
 
#include <functional>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class EventObserverBase;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_UTILS_EXPORT EventObservableBase
{
  friend class EventObserverBase;
  class Impl;
 public:
  EventObservableBase();
  virtual ~EventObservableBase();
 public:
  bool hasObservers() const;
  void detachAllObservers();
 protected:
  void _attachObserver(EventObserverBase* obs,bool is_auto_destroy);
  void _detachObserver(EventObserverBase* obs);
  ConstArrayView<EventObserverBase*> _observers() const;
 private:
  Impl* m_p;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_UTILS_EXPORT EventObserverBase
{
  friend class EventObservableBase;
 public:
  EventObserverBase() : m_observable(nullptr) {}
  virtual ~EventObserverBase() ARCANE_NOEXCEPT_FALSE;
 protected:
  void _notifyDetach();
  void _notifyAttach(EventObservableBase* obs);
 private:
  EventObservableBase* m_observable;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename... Args>
class EventObserver
: public EventObserverBase
{
 public:
  typedef EventObservable<Args...> ObservableType;
 public:
  EventObserver() {}
  EventObserver(const std::function<void(Args...)>& func)
  : m_functor(func){}
  EventObserver(std::function<void(Args...)>&& func)
  : m_functor(func){}
  void observerUpdate(Args... args)
  {
    if (m_functor)
      m_functor(args...);
  }
 private:
  std::function<void(Args...)> m_functor;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_UTILS_EXPORT EventObserverPool
{
 public:
  ~EventObserverPool();
 public:
  void add(EventObserverBase* x);
  void clear();
 private:
  UniqueArray<EventObserverBase*> m_observers;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename... Args>
class EventObservable
: public EventObservableBase
{
 public:
 
  typedef EventObserver<Args...> ObserverType;
 
 public:
 
  EventObservable() {}
 
 public:
 
  EventObservable(const EventObservable<Args...>& rhs) = delete;
  void operator=(const EventObservable<Args...>& rhs) = delete;
 
 public:
 
  void attach(ObserverType* o) { _attachObserver(o,false); }
  void detach(ObserverType* o) { _detachObserver(o); }
 
  template<typename Lambda>
  void attach(EventObserverPool& pool,const Lambda& lambda)
  {
    auto x = new ObserverType(lambda);
    _attachObserver(x,false);
    pool.add(x);
  }
 
  void notify(Args... args)
  {
    if (!hasObservers())
      return;
    for( auto o : _observers() )
      ((ObserverType*)o)->observerUpdate(args...);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif