EDLooperBase.h

Go to the documentation of this file.

#ifndef FWCore_Framework_EDLooperBase_h
#define FWCore_Framework_EDLooperBase_h
// -*- C++ -*-
//
// Package:     Framework
// Module:      EDLooperBase
//
//
// Author:      Chris Jones
// Created:     Mon Aug  9 12:42:17 EDT 2010
//

#include "DataFormats/Provenance/interface/ModuleDescription.h"
#include "FWCore/Framework/interface/EDConsumerBase.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/ServiceRegistry/interface/ModuleCallingContext.h"
#include "FWCore/Utilities/interface/propagate_const.h"

#include <set>
#include <memory>

namespace edm {
  namespace eventsetup {
    class EventSetupRecordKey;
    class EventSetupProvider;
  }  // namespace eventsetup
  class ExceptionToActionTable;
  class ProcessContext;
  class ScheduleInfo;
  class StreamContext;
  class ModuleChanger;
  class ProcessingController;
  class ActivityRegistry;
  class ServiceToken;
  class WaitingTaskHolder;

  class EDLooperBase : public EDConsumerBase {
  public:
    enum Status { kContinue, kStop };

    EDLooperBase();
    ~EDLooperBase() noexcept(false) override;

    EDLooperBase(EDLooperBase const&) = delete;             // Disallow copying and moving
    EDLooperBase& operator=(EDLooperBase const&) = delete;  // Disallow copying and moving

    void doStartingNewLoop();
    Status doDuringLoop(EventPrincipal& eventPrincipal, EventSetupImpl const& es, ProcessingController&, StreamContext*);
    Status doEndOfLoop(EventSetupImpl const& es);
    void prepareForNextLoop(eventsetup::EventSetupProvider* esp);
    void doBeginRun(RunPrincipal&, EventSetupImpl const&, ProcessContext*);
    void doEndRun(RunPrincipal&, EventSetupImpl const&, ProcessContext*);
    void doBeginLuminosityBlock(LuminosityBlockPrincipal&, EventSetupImpl const&, ProcessContext*);
    void doEndLuminosityBlock(LuminosityBlockPrincipal&, EventSetupImpl const&, ProcessContext*);

    void beginOfJob(EventSetupImpl const&);
    //This interface is deprecated
    virtual void beginOfJob(EventSetup const&);
    virtual void beginOfJob();

    virtual void endOfJob();

    void prefetchAsync(WaitingTaskHolder iTask,
                       ServiceToken const& token,
                       Transition iTrans,
                       Principal const& iPrincipal,
                       EventSetupImpl const& iImpl) const noexcept;

    void esPrefetchAsync(WaitingTaskHolder iTask,
                         EventSetupImpl const& iImpl,
                         Transition iTrans,
                         ServiceToken const& iToken) const noexcept;

    virtual void attachTo(ActivityRegistry&);

    void setActionTable(ExceptionToActionTable const* actionTable) { act_table_ = actionTable; }

    virtual std::set<eventsetup::EventSetupRecordKey> modifyingRecords() const;

    void copyInfo(ScheduleInfo const&);
    void setModuleChanger(ModuleChanger*);

  protected:
    ModuleChanger* moduleChanger();
    ScheduleInfo const* scheduleInfo() const;

  private:
    virtual void startingNewLoop(unsigned int) = 0;

    virtual Status duringLoop(Event const&, EventSetup const&, ProcessingController&) = 0;

    virtual Status endOfLoop(EventSetup const&, unsigned int iCounter) = 0;

    virtual void beginRun(Run const&, EventSetup const&);

    virtual void endRun(Run const&, EventSetup const&);

    virtual void beginLuminosityBlock(LuminosityBlock const&, EventSetup const&);

    virtual void endLuminosityBlock(LuminosityBlock const&, EventSetup const&);

    void edPrefetchAsync(WaitingTaskHolder iTask,
                         ServiceToken const& token,
                         Principal const& iPrincipal) const noexcept;

    unsigned int iCounter_;
    ExceptionToActionTable const* act_table_;

    edm::propagate_const<std::unique_ptr<ScheduleInfo>> scheduleInfo_;
    edm::propagate_const<ModuleChanger*> moduleChanger_;

    ModuleDescription moduleDescription_;
    ModuleCallingContext moduleCallingContext_;
  };
}  // namespace edm

#endif