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/DataKey.h"
#include "FWCore/Framework/interface/NoProxyException.h"
#include "FWCore/Framework/interface/ValidityInterval.h"
#include "FWCore/Utilities/interface/ESInputTag.h"

// system include files
#include <map>
#include <vector>

// forward declarations
namespace cms {
   class Exception;
}

namespace edm {
   class ESInputTag;
   class EventSetup;

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

      class EventSetupRecord {

      public:
         EventSetupRecord();
         virtual ~EventSetupRecord();

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

         template<typename HolderT>
         void get(HolderT& iHolder) const {
            typename HolderT::value_type const* value = 0;
            ComponentDescription const* desc = 0;
            this->getImplementation(value, "", desc, iHolder.transientAccessOnly);

            iHolder = HolderT(value, desc);
         }

         template<typename HolderT>
         void get(char const* iName, HolderT& iHolder) const {
            typename HolderT::value_type const* value = 0;
            ComponentDescription const* desc = 0;
            this->getImplementation(value, iName, desc, iHolder.transientAccessOnly);
            iHolder = HolderT(value, desc);
         }
         template<typename HolderT>
         void get(std::string const& iName, HolderT& iHolder) const {
            typename HolderT::value_type const* value = 0;
            ComponentDescription const* desc = 0;
            this->getImplementation(value, iName.c_str(), desc, iHolder.transientAccessOnly);
            iHolder = HolderT(value, desc);
         }

         template<typename HolderT>
         void get(ESInputTag const& iTag, HolderT& iHolder) const {
            typename HolderT::value_type const* value = 0;
            ComponentDescription const* desc = 0;
            this->getImplementation(value, iTag.data().c_str(), desc, iHolder.transientAccessOnly);
            validate(desc, iTag);
            iHolder = HolderT(value, desc);
         }



         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 cacheIdentifier_;
         }

         void fillRegisteredDataKeys(std::vector<DataKey>& oToFill) 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 cacheReset() ;
         bool transientReset() ;
         void set(ValidityInterval const&);
         void setEventSetup(EventSetup const* iEventSetup) {eventSetup_ = iEventSetup; }
      protected:

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

         EventSetup 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:
         EventSetupRecord(EventSetupRecord const&); // stop default

         EventSetupRecord const& operator=(EventSetupRecord const&); // stop default

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

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

            void const* pValue = this->getFromProxy(dataKey, iDesc, iTransientAccessOnly);
            if(0 == pValue) {
               throw NoProxyException<DataT>(this->key(), dataKey);
            }
            iData = reinterpret_cast<DataT const*> (pValue);
         }

         // ---------- member data --------------------------------
         ValidityInterval validity_;
         std::map<DataKey, DataProxy const*> proxies_ ;
         EventSetup const* eventSetup_;
         unsigned long long cacheIdentifier_;
         mutable bool transientAccessRequested_;
      };
   }
}
#endif