EventSetupRecordImpl.h

Go to the documentation of this file.

#ifndef FWCore_Framework_EventSetupRecordImpl_h
#define FWCore_Framework_EventSetupRecordImpl_h
// -*- C++ -*-
//
// Package:     Framework
// Class  :     EventSetupRecordImpl
//
//
// Author:      Chris Jones
// Created:     Fri Mar 25 14:38:35 EST 2005
//

// user include files
#include "FWCore/Framework/interface/FunctorESHandleExceptionFactory.h"
#include "FWCore/Framework/interface/DataKey.h"
#include "FWCore/Framework/interface/NoProxyException.h"
#include "FWCore/Framework/interface/ValidityInterval.h"
#include "FWCore/Framework/interface/EventSetupRecordKey.h"
#include "FWCore/Utilities/interface/propagate_const.h"
#include "FWCore/Utilities/interface/ESInputTag.h"
#include "FWCore/Utilities/interface/ESIndices.h"

// system include files
#include <exception>
#include <map>
#include <memory>
#include <utility>
#include <vector>
#include <atomic>
#include <cassert>

// forward declarations
namespace cms {
  class Exception;
}

namespace edm {
  class ESHandleExceptionFactory;
  class ESInputTag;
  class EventSetupImpl;

  namespace eventsetup {
    struct ComponentDescription;
    class DataProxy;

    class EventSetupRecordImpl {
      friend class EventSetupRecord;

    public:
      EventSetupRecordImpl(const EventSetupRecordKey& iKey);

      // ---------- const member functions ---------------------
      ValidityInterval const& validityInterval() const { return validity_; }

      bool doGet(DataKey const& aKey, bool aGetTransiently = false) const;

      bool wasGotten(DataKey const& aKey) const;

      ComponentDescription const* providerDescription(DataKey const& aKey) const;

      EventSetupRecordKey const& key() const { return key_; }

      unsigned long long cacheIdentifier() const { return cacheIdentifier_; }

      void fillRegisteredDataKeys(std::vector<DataKey>& oToFill) const;
      std::vector<ComponentDescription const*> componentsForRegisteredDataKeys() const;
      // ---------- static member functions --------------------

      // ---------- member functions ---------------------------

      // The following member functions should only be used by EventSetupRecordProvider
      bool add(DataKey const& iKey, DataProxy const* iProxy);
      void clearProxies();
      void cacheReset();
      bool transientReset();

      void set(ValidityInterval const&);
      void setEventSetup(EventSetupImpl const* iEventSetup) { eventSetup_ = iEventSetup; }

      void getESProducers(std::vector<ComponentDescription const*>& esproducers);
      //protected:

      DataProxy const* find(DataKey const& aKey) const;

      EventSetupImpl const& eventSetup() const { return *eventSetup_; }

      void validate(ComponentDescription const*, ESInputTag const&) const;

      void addTraceInfoToCmsException(cms::Exception& iException,
                                      char const* iName,
                                      ComponentDescription const*,
                                      DataKey const&) const;
      void changeStdExceptionToCmsException(char const* iExceptionWhatMessage,
                                            char const* iName,
                                            ComponentDescription const*,
                                            DataKey const&) const;

      void transientAccessRequested() const { transientAccessRequested_ = true; }

    private:
      EventSetupRecordImpl(EventSetupRecordImpl const&) = delete;

      EventSetupRecordImpl const& operator=(EventSetupRecordImpl const&) = delete;

      void const* getFromProxy(DataKey const& iKey,
                               ComponentDescription const*& iDesc,
                               bool iTransientAccessOnly) const;

      void const* getFromProxy(ESProxyIndex iProxyIndex,
                               bool iTransientAccessOnly,
                               ComponentDescription const*& iDesc,
                               DataKey const*& oGottenKey) const;

      template <typename DataT>
      void getImplementation(DataT const*& iData,
                             char const* iName,
                             ComponentDescription const*& iDesc,
                             bool iTransientAccessOnly,
                             std::shared_ptr<ESHandleExceptionFactory>& whyFailedFactory) const {
        DataKey dataKey(DataKey::makeTypeTag<DataT>(), iName, DataKey::kDoNotCopyMemory);

        void const* pValue = this->getFromProxy(dataKey, iDesc, iTransientAccessOnly);
        if (nullptr == pValue) {
          whyFailedFactory = makeESHandleExceptionFactory([=] {
            NoProxyException<DataT> ex(this->key(), dataKey);
            return std::make_exception_ptr(ex);
          });
        }
        iData = reinterpret_cast<DataT const*>(pValue);
      }

      template <typename DataT>
      void getImplementation(DataT const*& iData,
                             ESProxyIndex iProxyIndex,
                             bool iTransientAccessOnly,
                             ComponentDescription const*& oDesc,
                             std::shared_ptr<ESHandleExceptionFactory>& whyFailedFactory) const {
        DataKey const* dataKey = nullptr;
        if (iProxyIndex.value() == std::numeric_limits<int>::max()) {
          whyFailedFactory = makeESHandleExceptionFactory([=] {
            NoProxyException<DataT> ex(this->key(), {});
            return std::make_exception_ptr(ex);
          });
          iData = nullptr;
          return;
        }
        assert(iProxyIndex.value() > -1 and
               iProxyIndex.value() < static_cast<ESProxyIndex::Value_t>(keysForProxies_.size()));
        void const* pValue = this->getFromProxy(iProxyIndex, iTransientAccessOnly, oDesc, dataKey);
        if (nullptr == pValue) {
          whyFailedFactory = makeESHandleExceptionFactory([=] {
            NoProxyException<DataT> ex(this->key(), *dataKey);
            return std::make_exception_ptr(ex);
          });
        }
        iData = reinterpret_cast<DataT const*>(pValue);
      }

      // ---------- member data --------------------------------
      ValidityInterval validity_;
      EventSetupRecordKey key_;
      std::vector<DataKey> keysForProxies_;
      std::vector<DataProxy const*> proxies_;
      EventSetupImpl const* eventSetup_;
      unsigned long long cacheIdentifier_;
      mutable std::atomic<bool> transientAccessRequested_;
    };
  }  // namespace eventsetup
}  // namespace edm
#endif