Scroom::Utils::Observable< T > Class Template Reference

#include <observable.hh>

Inheritance diagram for Scroom::Utils::Observable< T >:

Collaboration diagram for Scroom::Utils::Observable< T >:

Public Types
using	Observer = boost::shared_ptr< T >
using	Ptr = boost::shared_ptr< Observable< T > >

Public Member Functions
	Observable ()
	~Observable () override
	Observable (const Observable &)=delete
	Observable (Observable &&)=delete
Observable	operator= (const Observable &)=delete
Observable	operator= (Observable &&)=delete
Scroom::Bookkeeping::Token	registerStrongObserver (Observer const &observer)
Scroom::Bookkeeping::Token	registerObserver (ObserverWeak const &observer)

Protected Member Functions
std::list< Observer >	getObservers ()
virtual void	observerAdded (Observer const &observer, Scroom::Bookkeeping::Token const &token)

Private Types
using	ObserverWeak = boost::weak_ptr< T >
using	Registration = Detail::Registration< T >

Private Member Functions
void	unregisterObserver (ObserverWeak const &observer)

Private Attributes
Scroom::Bookkeeping::Map< ObserverWeak, typename Registration::Ptr >::Ptr	registrationMap

Friends
class	Detail::Registration< T >

Detailed Description

template<typename T>
class Scroom::Utils::Observable< T >

Base class for something that accepts observers.

Upon registering, observers are given a Registration. If the same Observer registers twice (using the same method), he'll still receive events only once. When the Observer destroys his Registration, he'll be unregistered.

There are two ways of registering: One can register a shared_ptr, or a weak_ptr, depending on whether you want the Observable to keep the Observer from being destructed.

Note

When you register one Observer with both a shared_ptr and a weak_ptr, unpredictable things will happen.

Member Typedef Documentation

Observer

template<typename T >

using Scroom::Utils::Observable< T >::Observer = boost::shared_ptr<T>

ObserverWeak

template<typename T >

using Scroom::Utils::Observable< T >::ObserverWeak = boost::weak_ptr<T>

private

Ptr

template<typename T >

using Scroom::Utils::Observable< T >::Ptr = boost::shared_ptr<Observable<T> >

Registration

template<typename T >

using Scroom::Utils::Observable< T >::Registration = Detail::Registration<T>

private

Constructor & Destructor Documentation

Observable() [1/3]

template<typename T >

Scroom::Utils::Observable< T >::Observable

  {
    registrationMap = Scroom::Bookkeeping::Map<ObserverWeak, typename Registration::Ptr>::create();
  }

~Observable()

template<typename T >

Scroom::Utils::Observable< T >::~Observable

override

  {
    // Destroy strong references to any observers
    //
    // The one holding the token of the registration is in control
    // of the lifetime of the registration objects. Hence, as long
    // as the Token is valid, a reference to the Registration will
    // exist, which may, in turn, contain a (strong) reference to an
    // Observer. This is not desirable. As soon as the observable is
    // deleted (which is now), it should no longer hold any
    // references to any Observers. Hence, we should manually reset
    // references to observers here.
    for(const typename Registration::Ptr& registration: registrationMap->values())
    {
      registration->o.reset();
    }
  }

Observable() [2/3]

template<typename T >

Scroom::Utils::Observable< T >::Observable ( const Observable< T > &  )

delete

Observable() [3/3]

template<typename T >

Scroom::Utils::Observable< T >::Observable ( Observable< T > &&  )

delete

Member Function Documentation

getObservers()

template<typename T >

std::list< typename Observable< T >::Observer > Scroom::Utils::Observable< T >::getObservers

protected

Retrieve a list of current observers.

Always, a list of shared_ptr objects is returned, regardless of whether the Observer registered a shared_ptr or a weak_ptr.

  {
    std::list<typename Observable<T>::Observer> result;
    for(const typename Registration::Ptr& registration: registrationMap->values())
    {
      Observer const o = registration->observer.lock();
      if(o)
      {
        result.push_back(o);
      }
    }
 
    return result;
  }

Referenced by PresentationBase::close(), TestObservable::getObservers(), and PresentationBase::open().

Here is the caller graph for this function:

observerAdded()

template<typename T >

void Scroom::Utils::Observable< T >::observerAdded ( Observer const &  observer, Scroom::Bookkeeping::Token const &  token  )

protectedvirtual

Override this function if you want to be notified of new observers registering.

Reimplemented in CompressedTile, CompressedTile, and TestRecursiveObservable.

  {
    // Do nothing
  }

operator=() [1/2]

template<typename T >

Observable Scroom::Utils::Observable< T >::operator= ( const Observable< T > &  )

delete

operator=() [2/2]

template<typename T >

Observable Scroom::Utils::Observable< T >::operator= ( Observable< T > &&  )

delete

registerObserver()

template<typename T >

Scroom::Bookkeeping::Token Scroom::Utils::Observable< T >::registerObserver

(

ObserverWeak const &

observer

)

  {
    Scroom::Bookkeeping::Token            t = registrationMap->reReserve(observer);
    typename Detail::Registration<T>::Ptr r = registrationMap->get(observer);
    if(r)
    {
      r->set(observer);
    }
    else
    {
      r = Detail::Registration<T>::create(shared_from_this<Observable<T>>(), observer);
      registrationMap->set(observer, r);
    }
 
    observerAdded(typename Observable<T>::Observer(observer), t);
 
    return t;
  }

Referenced by CompressedTile::registerObserver().

Here is the caller graph for this function:

registerStrongObserver()

template<typename T >

Scroom::Bookkeeping::Token Scroom::Utils::Observable< T >::registerStrongObserver

(

Observer const &

observer

)

  {
    Scroom::Bookkeeping::Token            t = registrationMap->reReserve(observer);
    typename Detail::Registration<T>::Ptr r = registrationMap->get(observer);
    if(r)
    {
      r->set(observer);
    }
    else
    {
      r = Detail::Registration<T>::create(shared_from_this<Observable<T>>(), observer);
      registrationMap->set(observer, r);
    }
 
    observerAdded(observer, t);
 
    return t;
  }

Referenced by CompressedTile::registerStrongObserver().

Here is the caller graph for this function:

unregisterObserver()

template<typename T >

void Scroom::Utils::Observable< T >::unregisterObserver ( ObserverWeak const &  observer )

private

  {
    registrationMap->remove(observer);
  }

Friends And Related Function Documentation

Detail::Registration< T >

template<typename T >

friend class Detail::Registration< T >

friend

Member Data Documentation

registrationMap

template<typename T >

Scroom::Bookkeeping::Map<ObserverWeak, typename Registration::Ptr>::Ptr Scroom::Utils::Observable< T >::registrationMap

private

Map all registrations to their registration data

---

The documentation for this class was generated from the following file:

• inc/scroom/observable.hh