PrincipalGetAdapter.h

Go to the documentation of this file.

#ifndef FWCore_Framework_PrincipalGetAdapter_h
#define FWCore_Framework_PrincipalGetAdapter_h

// -*- C++ -*-
//

// Class  :     PrincipalGetAdapter
// 
/*----------------------------------------------------------------------

----------------------------------------------------------------------*/
#include <cassert>
#include <typeinfo>
#include <string>
#include <vector>
#include <boost/type_traits.hpp>

#include "DataFormats/Common/interface/EDProductfwd.h"
#include "DataFormats/Provenance/interface/ProvenanceFwd.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"

#include "DataFormats/Common/interface/traits.h"

#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 "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/Utilities/interface/EDGetToken.h"
#include "FWCore/Utilities/interface/ProductKindOfType.h"
#include "FWCore/Utilities/interface/ProductLabels.h"
#include "FWCore/Utilities/interface/propagate_const.h"


namespace edm {

  class ModuleCallingContext;
  class SharedResourcesAcquirer;

  namespace principal_get_adapter_detail {
    void
    throwOnPutOfNullProduct(char const* principalType, TypeID const& productType, std::string const& productInstanceName);
    void
    throwOnPrematureRead(char const* principalType, TypeID const& productType, std::string const& moduleLabel, std::string const& productInstanceName);
    void
    throwOnPrematureRead(char const* principalType, TypeID const& productType);

    void
    throwOnPrematureRead(char const* principalType, TypeID const& productType, EDGetToken);

  }
  class PrincipalGetAdapter {
  public:
    PrincipalGetAdapter(Principal const& pcpl,
         ModuleDescription const& md);

    ~PrincipalGetAdapter();

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

    //size_t size() const;
    
    void setConsumer(EDConsumerBase const* iConsumer) {
      consumer_ = iConsumer;
    }
    
    void setSharedResourcesAcquirer(SharedResourcesAcquirer* iSra) {
      resourcesAcquirer_ = iSra;
    }


    bool isComplete() const;

    template <typename PROD>
    bool 
    checkIfComplete() const;

    template <typename PROD>
    void 
    getManyByType(std::vector<Handle<PROD> >& results, ModuleCallingContext const* mcc) const;

    ProcessHistory const&
    processHistory() const;

    Principal const& principal() const {return principal_;}

    BranchDescription const&
    getBranchDescription(TypeID const& type, std::string const& productInstanceName) const;

    typedef std::vector<BasicHandle>  BasicHandleVec;

    //------------------------------------------------------------
    // Protected functions.
    //

    // The following 'get' functions serve to isolate the PrincipalGetAdapter class
    // from the Principal class.

    BasicHandle 
    getByLabel_(TypeID const& tid, InputTag const& tag,
                ModuleCallingContext const* mcc) const;

    BasicHandle 
    getByLabel_(TypeID const& tid,
                std::string const& label,
                std::string const& instance,
                std::string const& process,
                ModuleCallingContext const* mcc) const;

    BasicHandle
    getByToken_(TypeID const& id, KindOfType kindOfType, EDGetToken token,
                ModuleCallingContext const* mcc) const;

    BasicHandle
    getMatchingSequenceByLabel_(TypeID const& typeID,
                                InputTag const& tag,
                                ModuleCallingContext const* mcc) const;

    BasicHandle
    getMatchingSequenceByLabel_(TypeID const& typeID,
                                std::string const& label,
                                std::string const& instance,
                                std::string const& process,
                                ModuleCallingContext const* mcc) const;
    
    void 
    getManyByType_(TypeID const& tid, 
           BasicHandleVec& results,
                   ModuleCallingContext const* mcc) const;

    // Also isolates the PrincipalGetAdapter class
    // from the Principal class.
    EDProductGetter const* prodGetter() const;

    void labelsForToken(EDGetToken const& iToken, ProductLabels& oLabels) const;

  private:
    // Is this an Event, a LuminosityBlock, or a Run.
    BranchType const& branchType() const;

    BasicHandle
    makeFailToGetException(KindOfType,TypeID const&,EDGetToken) const;

    void
    throwAmbiguousException(TypeID const& productType, EDGetToken token) const;

  private:
    //------------------------------------------------------------
    // Data members
    //

    // Each PrincipalGetAdapter must have an associated Principal, used as the
    // source of all 'gets' and the target of 'puts'.
    Principal const& principal_;

    // Each PrincipalGetAdapter must have a description of the module executing the
    // "transaction" which the PrincipalGetAdapter represents.
    ModuleDescription const& md_;
    
    EDConsumerBase const* consumer_;
    SharedResourcesAcquirer* resourcesAcquirer_; // We do not use propagate_const because the acquirer is itself mutable.
  };

  template <typename PROD>
  inline
  std::ostream& 
  operator<<(std::ostream& os, Handle<PROD> const& h) {
    os << h.product() << " " << h.provenance() << " " << h.id();
    return os;
  }


  //------------------------------------------------------------
  // Metafunction support for compile-time selection of code used in
  // PrincipalGetAdapter::put member template.
  //

  // has_postinsert is a metafunction of one argument, the type T.  As
  // with many metafunctions, it is implemented as a class with a data
  // member 'value', which contains the value 'returned' by the
  // metafunction.
  //
  // has_postinsert<T>::value is 'true' if T has the post_insert
  // member function (with the right signature), and 'false' if T has
  // no such member function.

  namespace detail {
    typedef char (& no_tag)[1]; // type indicating FALSE
    typedef char (& yes_tag)[2]; // type indicating TRUE

    // Definitions forthe following struct and function templates are
    // not needed; we only require the declarations.
    template <typename T, void (T::*)()>  struct postinsert_function;
    template <typename T> no_tag  has_postinsert_helper(...);
    template <typename T> yes_tag has_postinsert_helper(postinsert_function<T, &T::post_insert> * p);


    template<typename T>
    struct has_postinsert {
      static bool const value = 
    sizeof(has_postinsert_helper<T>(nullptr)) == sizeof(yes_tag) &&
    !boost::is_base_of<DoNotSortUponInsertion, T>::value;
    };


    // has_donotrecordparents<T>::value is true if we should not
    // record parentage for type T, and false otherwise.

    template <typename T>
    struct has_donotrecordparents {
      static bool const value = 
    boost::is_base_of<DoNotRecordParents,T>::value;
    };

  }

  //------------------------------------------------------------

  // The following function objects are used by Event::put, under the
  // control of a metafunction if, to either call the given object's
  // post_insert function (if it has one), or to do nothing (if it
  // does not have a post_insert function).
  template <typename T>
  struct DoPostInsert {
    void operator()(T* p) const { p->post_insert(); }
  };

  template <typename T>
  struct DoNotPostInsert {
    void operator()(T*) const { }
  };

  // Implementation of  PrincipalGetAdapter  member templates. See  PrincipalGetAdapter.cc for the
  // implementation of non-template members.
  //

  template <typename PROD>
  inline
  bool 
  PrincipalGetAdapter::checkIfComplete() const { 
    return isComplete() || !detail::has_mergeProduct_function<PROD>::value;
  }

  template <typename PROD>
  inline
  void 
  PrincipalGetAdapter::getManyByType(std::vector<Handle<PROD> >& results,
                                     ModuleCallingContext const* mcc) const { 
    BasicHandleVec bhv;
    this->getManyByType_(TypeID(typeid(PROD)), bhv, mcc);
    
    // Go through the returned handles; for each element,
    //   1. create a Handle<PROD> and
    //
    // This function presents an exception safety difficulty. If an
    // exception is thrown when converting a handle, the "got
    // products" record will be wrong.
    //
    // Since EDProducers are not allowed to use this function,
    // the problem does not seem too severe.
    //
    // Question: do we even need to keep track of the "got products"
    // for this function, since it is *not* to be used by EDProducers?
    std::vector<Handle<PROD> > products;

    typename BasicHandleVec::iterator it = bhv.begin();
    typename BasicHandleVec::iterator end = bhv.end();

    while (it != end) {
      Handle<PROD> result;
      convert_handle(std::move(*it), result);  // throws on conversion error
      products.push_back(result);
      ++it;
    }
    results.swap(products);
  }
}
#endif