DataProxyTemplate.h

Go to the documentation of this file.

#ifndef FWCore_Framework_DataProxyTemplate_h
#define FWCore_Framework_DataProxyTemplate_h
// -*- C++ -*-
//
// Package:     Framework
// Class  :     DataProxyTemplate
//
//
// Author:      Chris Jones
// Created:     Thu Mar 31 12:45:32 EST 2005
//
 
// system include files
 
// user include files
#include "FWCore/Framework/interface/DataProxy.h"
#include "FWCore/Framework/interface/EventSetupRecord.h"
#include "FWCore/ServiceRegistry/interface/ServiceRegistry.h"
#include "FWCore/ServiceRegistry/interface/ESParentContext.h"
#include "FWCore/Concurrency/interface/WaitingTaskList.h"
#include "FWCore/Concurrency/interface/WaitingTaskHolder.h"
#include <cassert>
#include <limits>
#include <atomic>
 
// forward declarations
 
namespace edm {
 
  class EventSetupImpl;
 
  namespace eventsetup {
 
    template <class RecordT, class DataT>
    class DataProxyTemplate : public DataProxy {
    public:
      typedef DataT value_type;
      typedef RecordT record_type;
 
      DataProxyTemplate() {}
 
      void prefetchAsyncImpl(WaitingTaskHolder iTask,
                             const EventSetupRecordImpl& iRecord,
                             const DataKey& iKey,
                             EventSetupImpl const* iEventSetupImpl,
                             edm::ServiceToken const& iToken,
                             edm::ESParentContext const& iParent) override {
        assert(iRecord.key() == RecordT::keyForClass());
        bool expected = false;
        bool doPrefetch = prefetching_.compare_exchange_strong(expected, true);
        taskList_.add(iTask);
 
        if (doPrefetch) {
          iTask.group()->run([this, &iRecord, iKey, iEventSetupImpl, iToken, iParent]() {
            try {
              RecordT rec;
              rec.setImpl(&iRecord, std::numeric_limits<unsigned int>::max(), nullptr, iEventSetupImpl, &iParent, true);
              ServiceRegistry::Operate operate(iToken);
              this->make(rec, iKey);
            } catch (...) {
              this->taskList_.doneWaiting(std::current_exception());
              return;
            }
            this->taskList_.doneWaiting(std::exception_ptr{});
          });
        }
      }
 
    protected:
      void invalidateCache() override {
        taskList_.reset();
        prefetching_ = false;
      }
 
      virtual const DataT* make(const RecordT&, const DataKey&) = 0;
 
    private:
      WaitingTaskList taskList_;
      std::atomic<bool> prefetching_{false};
    };
 
  }  // namespace eventsetup
}  // namespace edm
#endif