EventStore.h

Go to the documentation of this file.

#pragma once

// -- std headers
#include <string>
#include <memory>
#include <typeindex>

// -- marlinmt headers
#include <marlinmt/Extensions.h>

namespace marlinmt {

  class EventStore {
  public:
    EventStore() = default ;
    ~EventStore() = default ;
    EventStore(const EventStore &) = delete ;
    EventStore &operator=(const EventStore &) = delete ;
    EventStore(EventStore &&) = default ;
    EventStore &operator=(EventStore &&) = default ;

    void setUID( std::size_t uid ) ;

    std::size_t uid() const ;

    template <typename T>
    std::shared_ptr<T> event() const ;

    template <typename T>
    std::shared_ptr<T> takeEvent() ;

    template <typename T>
    bool isType() const ;

    const std::type_index &type() const ;

    template <typename T>
    void setEvent( std::shared_ptr<T> evt ) ;

    template <typename T>
    void setBareEvent( T *evt, bool owner ) ;

    template <typename T, typename ...Args>
    std::shared_ptr<T> allocate(Args && ...args) ;

    void reset() ;

    Extensions &extensions() ;

    const Extensions &extensions() const ;

  private:
    std::size_t                 _uid {0} ;
    std::shared_ptr<void>       _event {nullptr} ;
    std::type_index             _eventType {typeid(nullptr)} ;
    Extensions                  _extensions {} ;
  };

  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------

  inline void EventStore::setUID( std::size_t id ) {
    _uid = id ;
  }

  //--------------------------------------------------------------------------

  inline std::size_t EventStore::uid() const {
    return _uid ;
  }

  //--------------------------------------------------------------------------

  template <typename T>
  inline std::shared_ptr<T> EventStore::event() const {
    return std::static_pointer_cast<T>( _event ) ;
  }

  //--------------------------------------------------------------------------

  template <typename T>
  inline std::shared_ptr<T> EventStore::takeEvent() {
    _eventType = std::type_index( typeid(nullptr) ) ;
    return std::static_pointer_cast<T>( _event ) ;
  }

  //--------------------------------------------------------------------------

  template <typename T>
  inline bool EventStore::isType() const {
    // FIXME: use std::decay_t
    return (std::type_index(typeid(T)) == _eventType) ;
  }

  //--------------------------------------------------------------------------

  inline const std::type_index &EventStore::type() const {
    return _eventType ;
  }

  //--------------------------------------------------------------------------

  template <typename T>
  inline void EventStore::setEvent( std::shared_ptr<T> evt ) {
    _eventType = std::type_index(typeid(T)) ;
    _event = evt ;
  }

  //--------------------------------------------------------------------------

  template <typename T>
  inline void EventStore::setBareEvent( T *evt, bool owner ) {
    if( owner ) {
      _event = std::shared_ptr<T>( evt ) ;
    }
    else {
      _event = std::shared_ptr<T>( evt, [](T *ptr){/* nop */} ) ;
    }
    _eventType = std::type_index(typeid(T)) ;
  }

  //--------------------------------------------------------------------------

  template <typename T, typename ...Args>
  inline std::shared_ptr<T> EventStore::allocate(Args && ...args) {
    auto ptr = std::make_shared<T>( args... ) ;
    setEvent( ptr ) ;
    return ptr ;
  }

  //--------------------------------------------------------------------------

  inline void EventStore::reset() {
    _eventType = std::type_index(typeid(nullptr)) ;
    _event.reset() ;
  }

  //--------------------------------------------------------------------------

  inline Extensions &EventStore::extensions() {
    return _extensions ;
  }

  //--------------------------------------------------------------------------

  inline const Extensions &EventStore::extensions() const {
    return _extensions ;
  }

}