EventSetupRecord.h

Go to the documentation of this file.

#ifndef FWCore_Framework_EventSetupRecord_h
#define FWCore_Framework_EventSetupRecord_h
// -*- C++ -*-
//
// Package:     Framework
// Class  :     EventSetupRecord
//
//
// 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/EventSetupRecordImpl.h"
#include "FWCore/Utilities/interface/ESGetToken.h"
#include "FWCore/Utilities/interface/ESInputTag.h"
#include "FWCore/Utilities/interface/ESIndices.h"
#include "FWCore/Utilities/interface/Likely.h"

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

// forward declarations
namespace cms {
  class Exception;
}

class testEventsetup;
class testEventsetupRecord;

namespace edm {
  template <typename T>
  class ESHandle;
  class ESHandleExceptionFactory;
  class ESInputTag;
  class EventSetupImpl;

  namespace eventsetup {
    struct ComponentDescription;
    class DataProxy;
    class EventSetupRecordKey;

    class EventSetupRecord {
      friend class ::testEventsetup;
      friend class ::testEventsetupRecord;

    public:
      EventSetupRecord();
      EventSetupRecord(EventSetupRecord&&) = default;
      EventSetupRecord& operator=(EventSetupRecord&&) = default;

      EventSetupRecord(EventSetupRecord const&) = default;
      EventSetupRecord& operator=(EventSetupRecord const&) = default;
      virtual ~EventSetupRecord();

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

      void setImpl(EventSetupRecordImpl const* iImpl, unsigned int transitionID, ESProxyIndex const* getTokenIndices) {
        impl_ = iImpl;
        transitionID_ = transitionID;
        getTokenIndices_ = getTokenIndices;
      }

      template <typename HolderT>
      bool get(HolderT& iHolder) const {
        return get("", iHolder);
      }

      template <typename HolderT>
      bool get(char const* iName, HolderT& iHolder) const {
        typename HolderT::value_type const* value = nullptr;
        ComponentDescription const* desc = nullptr;
        std::shared_ptr<ESHandleExceptionFactory> whyFailedFactory;
        impl_->getImplementation(value, iName, desc, iHolder.transientAccessOnly, whyFailedFactory);

        if (value) {
          iHolder = HolderT(value, desc);
          return true;
        } else {
          iHolder = HolderT(std::move(whyFailedFactory));
          return false;
        }
      }
      template <typename HolderT>
      bool get(std::string const& iName, HolderT& iHolder) const {
        return get(iName.c_str(), iHolder);
      }

      template <typename HolderT>
      bool get(ESInputTag const& iTag, HolderT& iHolder) const {
        typename HolderT::value_type const* value = nullptr;
        ComponentDescription const* desc = nullptr;
        std::shared_ptr<ESHandleExceptionFactory> whyFailedFactory;
        impl_->getImplementation(value, iTag.data().c_str(), desc, iHolder.transientAccessOnly, whyFailedFactory);

        if (value) {
          validate(desc, iTag);
          iHolder = HolderT(value, desc);
          return true;
        } else {
          iHolder = HolderT(std::move(whyFailedFactory));
          return false;
        }
      }

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

      bool wasGotten(DataKey const& aKey) const;

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

      virtual EventSetupRecordKey key() const = 0;

      unsigned long long cacheIdentifier() const { return impl_->cacheIdentifier(); }

      void fillRegisteredDataKeys(std::vector<DataKey>& oToFill) const { impl_->fillRegisteredDataKeys(oToFill); }

    protected:
      template <template <typename> typename H, typename T, typename R>
      H<T> getHandleImpl(ESGetToken<T, R> const& iToken) const {
        assert(iToken.transitionID() == transitionID());
        assert(iToken.isInitialized());
        assert(getTokenIndices_);
        //need to check token has valid index
        if
          UNLIKELY(not iToken.hasValidIndex()) { return invalidTokenHandle<H>(iToken); }

        auto proxyIndex = getTokenIndices_[iToken.index().value()];
        if
          UNLIKELY(proxyIndex.value() == std::numeric_limits<int>::max()) { return noProxyHandle<H>(iToken); }

        T const* value = nullptr;
        ComponentDescription const* desc = nullptr;
        std::shared_ptr<ESHandleExceptionFactory> whyFailedFactory;
        impl_->getImplementation(value, proxyIndex, H<T>::transientAccessOnly, desc, whyFailedFactory);

        if
          UNLIKELY(not value) { return H<T>(std::move(whyFailedFactory)); }
        return H<T>(value, desc);
      }

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

      EventSetupImpl const& eventSetup() const { return impl_->eventSetup(); }

      ESProxyIndex const* getTokenIndices() const { return getTokenIndices_; }

      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;

      EventSetupRecordImpl const* impl() const { return impl_; }

      unsigned int transitionID() const { return transitionID_; }

    private:
      template <template <typename> typename H, typename T, typename R>
      H<T> invalidTokenHandle(ESGetToken<T, R> const& iToken) const {
        auto const key = this->key();
        return H<T>{
            makeESHandleExceptionFactory([key] { return makeInvalidTokenException(key, DataKey::makeTypeTag<T>()); })};
      }

      template <template <typename> typename H, typename T, typename R>
      H<T> noProxyHandle(ESGetToken<T, R> const& iToken) const {
        auto const key = this->key();
        auto name = iToken.name();
        return H<T>{makeESHandleExceptionFactory([key, name] {
          NoProxyException<T> ex(key, DataKey{DataKey::makeTypeTag<T>(), name});
          return std::make_exception_ptr(ex);
        })};
      }

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

      static std::exception_ptr makeInvalidTokenException(EventSetupRecordKey const&, TypeTag const&);
      // ---------- member data --------------------------------
      EventSetupRecordImpl const* impl_ = nullptr;
      ESProxyIndex const* getTokenIndices_ = nullptr;
      unsigned int transitionID_ = std::numeric_limits<unsigned int>::max();
    };

    class EventSetupRecordGeneric : public EventSetupRecord {
    public:
      EventSetupRecordGeneric(EventSetupRecordImpl const* iImpl,
                              unsigned int iTransitionID,
                              ESProxyIndex const* getTokenIndices) {
        setImpl(iImpl, iTransitionID, getTokenIndices);
      }

      EventSetupRecordKey key() const final { return impl()->key(); }
    };
  }  // namespace eventsetup
}  // namespace edm
#endif