OccurrenceForOutput.cc

Go to the documentation of this file.

#include "FWCore/Framework/interface/OccurrenceForOutput.h"

#include "DataFormats/Common/interface/TriggerResults.h"
#include "DataFormats/Provenance/interface/ProcessHistoryRegistry.h"
#include "DataFormats/Provenance/interface/Provenance.h"
#include "DataFormats/Provenance/interface/StableProvenance.h"
#include "FWCore/Common/interface/TriggerResultsByName.h"
#include "FWCore/Framework/interface/Principal.h"
#include "FWCore/ParameterSet/interface/Registry.h"
#include "FWCore/Utilities/interface/Algorithms.h"
#include "FWCore/Utilities/interface/InputTag.h"

namespace edm {

  OccurrenceForOutput::OccurrenceForOutput(Principal const& p,
                                           ModuleDescription const& md,
                                           ModuleCallingContext const* moduleCallingContext,
                                           bool isAtEnd)
      : provRecorder_(p, md, isAtEnd), moduleCallingContext_(moduleCallingContext) {}

  OccurrenceForOutput::~OccurrenceForOutput() {}

  void OccurrenceForOutput::setConsumer(EDConsumerBase const* iConsumer) { provRecorder_.setConsumer(iConsumer); }

  Principal const& OccurrenceForOutput::principal() const { return provRecorder_.principal(); }

  ProcessHistoryID const& OccurrenceForOutput::processHistoryID() const { return principal().processHistoryID(); }

  Provenance OccurrenceForOutput::getProvenance(BranchID const& bid) const {
    return provRecorder_.principal().getProvenance(bid, moduleCallingContext_);
  }

  void OccurrenceForOutput::getAllProvenance(std::vector<Provenance const*>& provenances) const {
    provRecorder_.principal().getAllProvenance(provenances);
  }

  void OccurrenceForOutput::getAllStableProvenance(std::vector<StableProvenance const*>& provenances) const {
    provRecorder_.principal().getAllStableProvenance(provenances);
  }

  ProcessHistory const& OccurrenceForOutput::processHistory() const { return provRecorder_.processHistory(); }

  size_t OccurrenceForOutput::size() const { return provRecorder_.principal().size(); }

  BasicHandle OccurrenceForOutput::getByToken(EDGetToken token, TypeID const& typeID) const {
    auto result = provRecorder_.getByToken_(typeID, PRODUCT_TYPE, token, moduleCallingContext_);
    if (result.failedToGet()) {
      return result;
    }
    if (!provRecorder_.isComplete() && result.wrapper()->isMergeable()) {
      principal_get_adapter_detail::throwOnPrematureRead("RunOrLumi", typeID, token);
    }
    return result;
  }
}  // namespace edm