ConditionAccessorHolder.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2019 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <Gaudi/Property.h>
#include <GaudiKernel/EventContext.h>
#include <GaudiKernel/StateMachine.h>
#include <GaudiKernel/StatusCode.h>
#include <any>
#include <mutex>
#include <string>
 
namespace Gaudi::Examples::Conditions {
  namespace details {
    class ConditionsStore {
    public:
      using ConditionContext = int;
      using ConditionKey     = std::string;
 
      static ConditionsStore& instance();
 
      void declareKey( const ConditionKey& key );
 
      const ConditionContext& getConditionContext( const EventContext& ctx ) const;
 
      template <typename T>
      const T& getCondition( const ConditionKey& key, const ConditionContext& ctx ) const {
        return *std::any_cast<T>( getConditionAny( key, ctx ) );
      }
 
    private:
      ConditionsStore() = default;
      const std::any* getConditionAny( const ConditionKey& key, const ConditionContext& ctx ) const;
 
      using IOVSlot  = std::map<ConditionKey, std::any>;
      using IOVSlots = std::map<ConditionContext, IOVSlot>;
 
      mutable std::mutex     m_storageMtx;
      mutable IOVSlots       m_storage;
      std::set<ConditionKey> m_requestedKeys;
    };
  } // namespace details
 
  template <typename Base>
  class ConditionAccessorHolder : public Base {
  public:
    using Base::Base;
 
    using base_class = ConditionAccessorHolder<Base>;
 
    using ConditionContext = details::ConditionsStore::ConditionContext;
 
    using ConditionKey = details::ConditionsStore::ConditionKey;
 
    template <typename T>
    class ConditionAccessor {
    public:
      ConditionAccessor( base_class* owner, const std::string& keyName, const ConditionKey& keyDefault,
                         const std::string& keyDoc = "" )
          : m_key{ owner, keyName, keyDefault, keyDoc } {
        owner->registerConditionAccessor( *this );
      }
 
      const ConditionKey& key() const { return m_key; }
 
      const T& get( const ConditionContext& ctx ) const {
        return details::ConditionsStore::instance().getCondition<T>( key(), ctx );
      }
 
    private:
      Gaudi::Property<ConditionKey> m_key;
    };
 
    StatusCode initialize() override {
      auto sc = Base::initialize();
      if ( !sc ) return sc;
 
      // backend-specific initialization
 
      // trigger delayed registrations
      for ( auto& action : m_delayedRegistrations ) { action(); }
      m_delayedRegistrations.clear();
 
      return sc;
    }
 
    const ConditionContext& getConditionContext( const EventContext& ctx ) const {
      return details::ConditionsStore::instance().getConditionContext( ctx );
    }
 
  private:
    template <typename T>
    friend class ConditionAccessor;
 
    template <typename T>
    void registerConditionAccessor( ConditionAccessor<T>& accessor ) {
      if ( this->targetFSMState() == Gaudi::StateMachine::INITIALIZED ) {
        details::ConditionsStore::instance().declareKey( accessor.key() );
      } else {
        m_delayedRegistrations.push_back( [this, &accessor]() { registerConditionAccessor( accessor ); } );
      }
    }
 
    std::list<std::function<void()>> m_delayedRegistrations;
  };
} // namespace Gaudi::Examples::Conditions