OccurrenceForOutput.h

Go to the documentation of this file.

#ifndef FWCore_Framework_OccurrenceForOutput_h
#define FWCore_Framework_OccurrenceForOutput_h

// -*- C++ -*-
//
// Package:     Framework
// Class  :     OccurrenceForOutput
//
/*----------------------------------------------------------------------
----------------------------------------------------------------------*/

#include "DataFormats/Common/interface/BasicHandle.h"
#include "DataFormats/Common/interface/ConvertHandle.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DataFormats/Common/interface/Wrapper.h"
#include "DataFormats/Provenance/interface/BranchListIndex.h"

#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/PrincipalGetAdapter.h"
#include "FWCore/Utilities/interface/TypeID.h"
#include "FWCore/Utilities/interface/EDGetToken.h"
#include "FWCore/Utilities/interface/propagate_const.h"

#include <memory>
#include <string>
#include <typeinfo>
#include <vector>

class testEventGetRefBeforePut;

namespace edmtest {
  class TestOutputModule;
}

namespace edm {

  class BranchDescription;
  class ModuleCallingContext;
  class Principal;
  class EDConsumerBase;

  class OccurrenceForOutput {
  public:
    OccurrenceForOutput(Principal const& ep, ModuleDescription const& md, ModuleCallingContext const*, bool isAtEnd);
    virtual ~OccurrenceForOutput();

    //Used in conjunction with EDGetToken
    void setConsumer(EDConsumerBase const* iConsumer);

    ProcessHistoryID const& processHistoryID() const;

    BasicHandle getByToken(EDGetToken token, TypeID const& typeID) const;

    template <typename PROD>
    bool getByToken(EDGetToken token, Handle<PROD>& result) const;

    template <typename PROD>
    bool getByToken(EDGetTokenT<PROD> token, Handle<PROD>& result) const;

    template <typename PROD>
    Handle<PROD> getHandle(EDGetTokenT<PROD> token) const;

    Provenance getProvenance(BranchID const& theID) const;

    void getAllProvenance(std::vector<Provenance const*>& provenances) const;

    void getAllStableProvenance(std::vector<StableProvenance const*>& provenances) const;

    virtual ProcessHistory const& processHistory() const;

    size_t size() const;

  protected:
    Principal const& principal() const;

  private:
    friend class edmtest::TestOutputModule;  // For testing
    ModuleCallingContext const* moduleCallingContext() const { return moduleCallingContext_; }

    PrincipalGetAdapter provRecorder_;

    ModuleCallingContext const* moduleCallingContext_;
  };

  template <typename PROD>
  bool OccurrenceForOutput::getByToken(EDGetToken token, Handle<PROD>& result) const {
    if (!provRecorder_.checkIfComplete<PROD>()) {
      principal_get_adapter_detail::throwOnPrematureRead("RunOrLumi", TypeID(typeid(PROD)), token);
    }
    BasicHandle bh = provRecorder_.getByToken_(TypeID(typeid(PROD)), PRODUCT_TYPE, token, moduleCallingContext_);
    result = convert_handle<PROD>(std::move(bh));  // throws on conversion error
    if (result.failedToGet()) {
      return false;
    }
    return true;
  }

  template <typename PROD>
  bool OccurrenceForOutput::getByToken(EDGetTokenT<PROD> token, Handle<PROD>& result) const {
    if (!provRecorder_.checkIfComplete<PROD>()) {
      principal_get_adapter_detail::throwOnPrematureRead("RunOrLumi", TypeID(typeid(PROD)), token);
    }
    BasicHandle bh = provRecorder_.getByToken_(TypeID(typeid(PROD)), PRODUCT_TYPE, token, moduleCallingContext_);
    result = convert_handle<PROD>(std::move(bh));  // throws on conversion error
    if (result.failedToGet()) {
      return false;
    }
    return true;
  }

  template <typename PROD>
  Handle<PROD> OccurrenceForOutput::getHandle(EDGetTokenT<PROD> token) const {
    if (!provRecorder_.checkIfComplete<PROD>()) {
      principal_get_adapter_detail::throwOnPrematureRead("RunOrLumi", TypeID(typeid(PROD)), token);
    }
    BasicHandle bh = provRecorder_.getByToken_(TypeID(typeid(PROD)), PRODUCT_TYPE, token, moduleCallingContext_);
    return convert_handle<PROD>(std::move(bh));  // throws on conversion error
  }

}  // namespace edm
#endif