Observable.hpp

#pragma once
 
#include <Core/Utils/Log.hpp>
 
#include <functional>
#include <map>
 
namespace Ra {
namespace Core {
namespace Utils {
 
 
template <typename... Args>
class Observable
{
  public:
    using Observer = std::function<void( Args... )>;
 
    Observable()                               = default;
    Observable( const Observable& )            = delete;
    Observable& operator=( const Observable& ) = delete;
    virtual ~Observable()                      = default;
 
    void copyObserversTo( Observable& other ) const {
        for ( const auto& o : m_observers ) {
            other.attach( o.second );
        }
    }
 
    inline int attach( Observer observer ) {
        m_observers.insert( { ++m_currentId, observer } );
        return m_currentId;
    }
 
    template <typename T>
    int attachMember( T* object, void ( T::*observer )( Args... ) ) {
        return attach( bind( observer, object ) );
    }
    inline void notify( Args... p ) const {
        for ( const auto& o : m_observers )
            o.second( std::forward<Args>( p )... );
    }
 
    inline void detachAll() { m_observers.clear(); }
 
    inline void detach( int observerId ) { m_observers.erase( observerId ); }
 
  private:
    // from https://stackoverflow.com/questions/21192659/variadic-templates-and-stdbind
    template <typename R, typename T, typename U>
    std::function<R( Args... )> bind( R ( T::*f )( Args... ), U p ) {
        return [p, f]( Args... args ) -> R { return ( p->*f )( args... ); };
    }
 
    std::map<int, Observer> m_observers;
    int m_currentId { 0 };
};
 
class RA_CORE_API ObservableVoid : public Observable<>
{};
 
} // namespace Utils
} // namespace Core
} // namespace Ra