RunPrincipal.h

Go to the documentation of this file.

#ifndef FWCore_Framework_RunPrincipal_h
#define FWCore_Framework_RunPrincipal_h
 
/*----------------------------------------------------------------------
 
RunPrincipal: This is the class responsible for management of
per run EDProducts. It is not seen by reconstruction code;
such code sees the Run class, which is a proxy for RunPrincipal.
 
The major internal component of the RunPrincipal
is the DataBlock.
 
----------------------------------------------------------------------*/
 
#include <string>
#include <vector>
 
#include <memory>
 
#include "DataFormats/Provenance/interface/RunAuxiliary.h"
#include "DataFormats/Provenance/interface/ProcessHistoryID.h"
#include "FWCore/Utilities/interface/propagate_const.h"
#include "FWCore/Utilities/interface/RunIndex.h"
#include "FWCore/Framework/interface/Principal.h"
 
namespace edm {
 
  class HistoryAppender;
  class MergeableRunProductProcesses;
  class MergeableRunProductMetadata;
  class ModuleCallingContext;
  class ProcessHistoryRegistry;
 
  class RunPrincipal : public Principal {
  public:
    typedef RunAuxiliary Auxiliary;
    typedef Principal Base;
 
    RunPrincipal(std::shared_ptr<RunAuxiliary> aux,
                 std::shared_ptr<ProductRegistry const> reg,
                 ProcessConfiguration const& pc,
                 HistoryAppender* historyAppender,
                 unsigned int iRunIndex,
                 bool isForPrimaryProcess = true,
                 MergeableRunProductProcesses const* mergeableRunProductProcesses = nullptr);
    ~RunPrincipal() override;
 
    void fillRunPrincipal(ProcessHistoryRegistry const& processHistoryRegistry, DelayedReader* reader = nullptr);
 
    RunIndex index() const { return index_; }
 
    RunAuxiliary const& aux() const { return *aux_; }
 
    RunNumber_t run() const { return aux().run(); }
 
    ProcessHistoryID const& reducedProcessHistoryID() const { return m_reducedHistoryID; }
 
    RunID const& id() const { return aux().id(); }
 
    Timestamp const& beginTime() const { return aux().beginTime(); }
 
    Timestamp const& endTime() const { return aux().endTime(); }
 
    void setEndTime(Timestamp const& time) { aux_->setEndTime(time); }
 
    void mergeAuxiliary(RunAuxiliary const& aux) { return aux_->mergeAuxiliary(aux); }
 
    void put(BranchDescription const& bd, std::unique_ptr<WrapperBase> edp) const;
 
    void put(ProductResolverIndex index, std::unique_ptr<WrapperBase> edp) const;
 
    void putOrMerge(BranchDescription const& bd, std::unique_ptr<WrapperBase> edp) const;
 
    MergeableRunProductMetadata* mergeableRunProductMetadata() { return mergeableRunProductMetadataPtr_.get(); }
 
    void preReadFile();
 
  private:
    unsigned int transitionIndex_() const override;
 
    edm::propagate_const<std::shared_ptr<RunAuxiliary>> aux_;
    ProcessHistoryID m_reducedHistoryID;
    RunIndex index_;
 
    // For the primary input RunPrincipals created by the EventProcessor,
    // there should be one MergeableRunProductMetadata object created
    // per concurrent run. In all other cases, this should just be null.
    edm::propagate_const<std::unique_ptr<MergeableRunProductMetadata>> mergeableRunProductMetadataPtr_;
  };
}  // namespace edm
#endif