ProductResolverWrapper< RecordT, DataT, Initializer > Class Template Reference

#include <ProductResolver.h>

Inheritance diagram for ProductResolverWrapper< RecordT, DataT, Initializer >:

Public Types
typedef ::cond::ProductResolver< RecordT, DataT, Initializer >	ProductResolver
Public Types inherited from cond::ProductResolverWrapperBase
typedef std::pair< std::string, std::string >	Args
typedef std::shared_ptr< edm::eventsetup::ESProductResolver >	esResolverP
typedef std::shared_ptr< cond::persistency::BasePayloadProxy >	ProxyP

Public Member Functions
esResolverP	esResolver (unsigned int iovIndex) const override
void	initConcurrentIOVs (unsigned int nConcurrentIOVs) override
void	lateInit (cond::persistency::Session &iSession, const std::string &tag, const boost::posix_time::ptime &snapshotTime, std::string const &il, std::string const &cs, edm::SerialTaskQueue *queue, std::mutex *mutex) override
	ProductResolverWrapper (const char *source=nullptr)
ProxyP	proxy (unsigned int iovIndex) const override
edm::eventsetup::TypeTag	type () const override
Public Member Functions inherited from cond::ProductResolverWrapperBase
void	addInfo (std::string const &il, std::string const &cs, std::string const &tag)
std::string const &	connString () const
Iov_t const &	currentIov () const
persistency::IOVProxy &	iovProxy ()
persistency::IOVProxy const &	iovProxy () const
std::string const &	label () const
void	loadTag (std::string const &tag)
void	loadTag (std::string const &tag, boost::posix_time::ptime const &snapshotTime)
	ProductResolverWrapperBase ()
void	reload ()
std::shared_ptr< std::vector< Iov_t > > const &	requests () const
persistency::Session &	session ()
persistency::Session const &	session () const
ValidityInterval	setIntervalFor (Time_t target)
void	setSession (persistency::Session const &v)
std::string const &	tag () const
TimeType	timeType () const
virtual	~ProductResolverWrapperBase ()

Private Attributes
std::vector< std::shared_ptr< ProductResolver > >	m_esResolvers
std::vector< std::shared_ptr< cond::persistency::PayloadProxy< DataT > > >	m_proxies
std::string	m_source
edm::eventsetup::TypeTag	m_type

Detailed Description

template<class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT>>
class ProductResolverWrapper< RecordT, DataT, Initializer >

Definition at line 123 of file ProductResolver.h.

Member Typedef Documentation

ProductResolver

template<class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT>>

typedef ::cond::ProductResolver<RecordT, DataT, Initializer> ProductResolverWrapper< RecordT, DataT, Initializer >::ProductResolver

Definition at line 125 of file ProductResolver.h.

Constructor & Destructor Documentation

ProductResolverWrapper()

template<class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT>>

ProductResolverWrapper< RecordT, DataT, Initializer >::ProductResolverWrapper ( const char *  source = nullptr )

inlineexplicit

Definition at line 128 of file ProductResolver.h.

                                                                : m_source(source ? source : "") {
    //NOTE: We do this so that the type 'DataT' will get registered
    // when the plugin is dynamically loaded
    m_type = edm::eventsetup::DataKey::makeTypeTag<DataT>();
  }

Member Function Documentation

esResolver()

template<class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT>>

esResolverP ProductResolverWrapper< RecordT, DataT, Initializer >::esResolver ( unsigned int  iovIndex ) const

inlineoverridevirtual

Implements cond::ProductResolverWrapperBase.

Definition at line 175 of file ProductResolver.h.

{ return m_esResolvers.at(iovIndex); }

initConcurrentIOVs()

template<class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT>>

void ProductResolverWrapper< RecordT, DataT, Initializer >::initConcurrentIOVs ( unsigned int  nConcurrentIOVs )

inlineoverridevirtual

Implements cond::ProductResolverWrapperBase.

Definition at line 153 of file ProductResolver.h.

                                                                 {
    // Create additional PayloadProxy objects if we are allowing
    // multiple IOVs to run concurrently.
    if (m_proxies.size() != nConcurrentIOVs) {
      assert(m_proxies.size() == 1);
      auto queue = m_esResolvers.front()->queue();
      auto mutex = m_esResolvers.front()->mutex();
      for (unsigned int i = 1; i < nConcurrentIOVs; ++i) {
        m_proxies.push_back(std::make_shared<cond::persistency::PayloadProxy<DataT>>(
            &currentIov(), &session(), &requests(), m_source.empty() ? (const char*)nullptr : m_source.c_str()));
        m_esResolvers.push_back(std::make_shared<ProductResolver>(m_proxies[i], queue, mutex));
        // This does nothing except in the special case of a KeyList PayloadProxy.
        // They all need to have copies of the same IOVProxy object.
        m_proxies[i]->initKeyList(*m_proxies[0]);
      }
      assert(m_proxies.size() == nConcurrentIOVs);
    }
    assert(m_proxies.size() == m_esResolvers.size());
  }

lateInit()

template<class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT>>

void ProductResolverWrapper< RecordT, DataT, Initializer >::lateInit ( cond::persistency::Session &  iSession, const std::string &  tag, const boost::posix_time::ptime &  snapshotTime, std::string const &  il, std::string const &  cs, edm::SerialTaskQueue *  queue, std::mutex *  mutex  )

inlineoverridevirtual

Implements cond::ProductResolverWrapperBase.

Definition at line 135 of file ProductResolver.h.

                                          {
    setSession(iSession);
    // set the IOVProxy
    loadTag(tag, snapshotTime);
    // Only make the first PayloadProxy object now because we don't know yet
    // how many we will need.
    m_proxies.push_back(std::make_shared<cond::persistency::PayloadProxy<DataT>>(
        &currentIov(), &session(), &requests(), m_source.empty() ? (const char*)nullptr : m_source.c_str()));
    m_esResolvers.push_back(std::make_shared<ProductResolver>(m_proxies[0], queue, mutex));
    addInfo(il, cs, tag);
  }

proxy()

template<class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT>>

ProxyP ProductResolverWrapper< RecordT, DataT, Initializer >::proxy ( unsigned int  iovIndex ) const

inlineoverridevirtual

Implements cond::ProductResolverWrapperBase.

Definition at line 174 of file ProductResolver.h.

{ return m_proxies.at(iovIndex); }

type()

template<class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT>>

edm::eventsetup::TypeTag ProductResolverWrapper< RecordT, DataT, Initializer >::type ( ) const

inlineoverridevirtual

Implements cond::ProductResolverWrapperBase.

Definition at line 173 of file ProductResolver.h.

{ return m_type; }

Member Data Documentation

m_esResolvers

template<class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT>>

std::vector<std::shared_ptr<ProductResolver> > ProductResolverWrapper< RecordT, DataT, Initializer >::m_esResolvers

private

Definition at line 181 of file ProductResolver.h.

Referenced by ProductResolverWrapper< ExDwarfListRcd, cond::persistency::KeyList >::esResolver(), ProductResolverWrapper< ExDwarfListRcd, cond::persistency::KeyList >::initConcurrentIOVs(), and ProductResolverWrapper< ExDwarfListRcd, cond::persistency::KeyList >::lateInit().

m_proxies

template<class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT>>

std::vector<std::shared_ptr<cond::persistency::PayloadProxy<DataT> > > ProductResolverWrapper< RecordT, DataT, Initializer >::m_proxies

private

Definition at line 180 of file ProductResolver.h.

Referenced by ProductResolverWrapper< ExDwarfListRcd, cond::persistency::KeyList >::initConcurrentIOVs(), ProductResolverWrapper< ExDwarfListRcd, cond::persistency::KeyList >::lateInit(), and ProductResolverWrapper< ExDwarfListRcd, cond::persistency::KeyList >::proxy().

m_source

template<class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT>>

std::string ProductResolverWrapper< RecordT, DataT, Initializer >::m_source

private

Definition at line 178 of file ProductResolver.h.

Referenced by ProductResolverWrapper< ExDwarfListRcd, cond::persistency::KeyList >::initConcurrentIOVs(), and ProductResolverWrapper< ExDwarfListRcd, cond::persistency::KeyList >::lateInit().

m_type

template<class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT>>

edm::eventsetup::TypeTag ProductResolverWrapper< RecordT, DataT, Initializer >::m_type

private

Definition at line 179 of file ProductResolver.h.

Referenced by ProductResolverWrapper< ExDwarfListRcd, cond::persistency::KeyList >::ProductResolverWrapper(), and ProductResolverWrapper< ExDwarfListRcd, cond::persistency::KeyList >::type().