edmtest::AcquireIntESProducer Class Reference

Inheritance diagram for edmtest::AcquireIntESProducer:

Classes
class	TestValue

Public Member Functions
int	acquire (ESTestRecordI const &, edm::WaitingTaskWithArenaHolder)
	AcquireIntESProducer (edm::ParameterSet const &)
	AcquireIntESProducer (const AcquireIntESProducer &)=delete
	AcquireIntESProducer (AcquireIntESProducer &&)=delete
std::optional< std::vector< TestValue > >	acquireOptional (ESTestRecordI const &, edm::WaitingTaskWithArenaHolder)
std::unique_ptr< TestValue >	acquireUniquePtr (ESTestRecordI const &, edm::WaitingTaskWithArenaHolder)
void	initConcurrentIOVs (EventSetupRecordKey const &, unsigned int nConcurrentIOVs) override
AcquireIntESProducer &	operator= (const AcquireIntESProducer &)=delete
AcquireIntESProducer &	operator= (AcquireIntESProducer &&)=delete
std::unique_ptr< ESTestDataI >	produce (ESTestRecordI const &, int)
std::unique_ptr< ESTestDataB >	produceESTestDataB (ESTestRecordB const &)
std::unique_ptr< ESTestDataI >	produceOptional (ESTestRecordI const &, std::optional< std::vector< TestValue >>)
std::unique_ptr< ESTestDataI >	produceUniquePtr (ESTestRecordI const &, std::unique_ptr< TestValue >)
	~AcquireIntESProducer () override
Public Member Functions inherited from edm::ESProducerExternalWork
	ESProducerExternalWork ()
template<typename T >
auto	setWhatAcquiredProduced (T *iThis, const es::Label &iLabel={})
template<typename T >
auto	setWhatAcquiredProduced (T *iThis, const char *iLabel)
template<typename T >
auto	setWhatAcquiredProduced (T *iThis, const std::string &iLabel)
template<typename T , typename TDecorator >
auto	setWhatAcquiredProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})
template<typename T , typename TAcquireReturn , typename TProduceReturn , typename TRecord >
auto	setWhatAcquiredProduced (T *iThis, TAcquireReturn(T::*iAcquireMethod)(const TRecord &, WaitingTaskWithArenaHolder), TProduceReturn(T::*iProduceMethod)(const TRecord &, TAcquireReturn), const es::Label &iLabel={})
template<typename T , typename TAcquireReturn , typename TProduceReturn , typename TRecord , typename TDecorator >
auto	setWhatAcquiredProduced (T *iThis, TAcquireReturn(T::*iAcquireMethod)(const TRecord &, WaitingTaskWithArenaHolder), TProduceReturn(T ::*iProduceMethod)(const TRecord &, TAcquireReturn), const TDecorator &iDec, const es::Label &iLabel={})
template<typename TAcquireFunc , typename TProduceFunc >
auto	setWhatAcquiredProducedWithLambda (TAcquireFunc &&acquireFunc, TProduceFunc &&produceFunc, const es::Label &iLabel={})
template<typename TAcquireReturn , typename TProduceReturn , typename TRecord , typename TAcquireFunc , typename TProduceFunc , typename TDecorator >
ESConsumesCollectorT< TRecord >	setWhatAcquiredProducedWithLambda (TAcquireFunc &&acquireFunc, TProduceFunc &&produceFunc, TDecorator &&iDec, const es::Label &iLabel={})
Public Member Functions inherited from edm::ESProducer
	ESProducer ()
	ESProducer (const ESProducer &)=delete
	ESProducer (ESProducer &&)=delete
ESResolverIndex const *	getTokenIndices (unsigned int iIndex) const
ESRecordIndex const *	getTokenRecordIndices (unsigned int iIndex) const
bool	hasMayConsumes () const noexcept
size_t	numberOfTokenIndices (unsigned int iIndex) const
ESProducer &	operator= (const ESProducer &)=delete
ESProducer &	operator= (ESProducer &&)=delete
SerialTaskQueueChain &	queue ()
template<typename Record >
std::optional< std::vector< ESResolverIndex > >	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const
void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &) final
	~ESProducer () noexcept(false) override
Public Member Functions inherited from edm::ESProductResolverFactoryProducer
	ESProductResolverFactoryProducer ()
	ESProductResolverFactoryProducer (const ESProductResolverFactoryProducer &)=delete
const ESProductResolverFactoryProducer &	operator= (const ESProductResolverFactoryProducer &)=delete
	~ESProductResolverFactoryProducer () noexcept(false) override
Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
void	createKeyedResolvers (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)
const ComponentDescription &	description () const
	ESProductResolverProvider ()
	ESProductResolverProvider (const ESProductResolverProvider &)=delete
void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const
bool	isUsingRecord (const EventSetupRecordKey &key) const
KeyedResolvers &	keyedResolvers (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)
const ESProductResolverProvider &	operator= (const ESProductResolverProvider &)=delete
void	setAppendToDataLabel (const edm::ParameterSet &)
void	setDescription (const ComponentDescription &iDescription)
std::set< EventSetupRecordKey >	usingRecords () const
virtual	~ESProductResolverProvider () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &)
Static Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
static void	prevalidate (ConfigurationDescriptions &)

Private Attributes
std::vector< test_acquire::Cache >	caches_
std::vector< TestValue * >	lambdaOptionalTestPointers_
std::vector< TestValue * >	lambdaUniqueTestPointers_
const unsigned int	numberOfIOVsToAccumulate_
std::vector< TestValue * >	optionalTestPointers_
const unsigned int	secondsToWaitForWork_
std::unique_ptr< test_acquire::WaitingServer >	server_
edm::ESGetToken< IOVTestInfo, ESTestRecordI >	token_
std::vector< TestValue * >	uniqueTestPointers_

Additional Inherited Members
Protected Types inherited from edm::ESProductResolverFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey
Protected Types inherited from edm::eventsetup::ESProductResolverProvider
using	KeyedResolversVector = std::vector< std::pair< DataKey, std::shared_ptr< ESProductResolver > >>
Protected Member Functions inherited from edm::ESProducer
ESConsumesInfo *	consumesInfoPushBackNew ()
unsigned int	consumesInfoSize () const
template<typename CallbackT , typename TList , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>> iCallback, const TList *, const TRecord *iRecord, const es::Label &iLabel)
template<typename CallbackT , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>>, const eventsetup::produce::Null *, const TRecord *, const es::Label &)
template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})
template<typename T >
auto	setWhatProduced (T *iThis, const char *iLabel)
template<typename T >
auto	setWhatProduced (T *iThis, const std::string &iLabel)
template<typename T , typename TDecorator >
auto	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})
template<typename T , typename TReturn , typename TRecord >
auto	setWhatProduced (T *iThis, TReturn(T::*iMethod)(const TRecord &), const es::Label &iLabel={})
template<typename T , typename TReturn , typename TRecord , typename TDecorator >
auto	setWhatProduced (T *iThis, TReturn(T ::*iMethod)(const TRecord &), const TDecorator &iDec, const es::Label &iLabel={})
template<typename TFunc >
auto	setWhatProduced (TFunc &&func, const es::Label &iLabel={})
template<typename TReturn , typename TRecord , typename TFunc , typename TDecorator >
ESConsumesCollectorT< TRecord >	setWhatProduced (TFunc &&func, TDecorator &&iDec, const es::Label &iLabel={})
void	usesResources (std::vector< std::string > const &)
Protected Member Functions inherited from edm::ESProductResolverFactoryProducer
template<class TFactory >
void	registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())
virtual void	registerFactoryWithKey (const EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ESProductResolverFactoryBase > iFactory, const std::string &iLabel=std::string())
KeyedResolversVector	registerResolvers (const EventSetupRecordKey &, unsigned int iovIndex) override
Protected Member Functions inherited from edm::eventsetup::ESProductResolverProvider
template<class T >
void	usingRecord ()
void	usingRecordWithKey (const EventSetupRecordKey &key)

Detailed Description

Description: Used in tests of the asynchronous ESProducer.

Definition at line 46 of file AcquireIntESProducer.cc.

Constructor & Destructor Documentation

AcquireIntESProducer() [1/3]

edmtest::AcquireIntESProducer::AcquireIntESProducer

(

edm::ParameterSet const &

pset

)

Definition at line 92 of file AcquireIntESProducer.cc.

References acquireOptional(), acquireUniquePtr(), Exception, SiStripGain_Fake_cff::Label, lambdaOptionalTestPointers_, lambdaUniqueTestPointers_, eostools::move(), produceESTestDataB(), produceOptional(), produceUniquePtr(), Hcal_FrontierConditions_cff::record, edm::ESProducerExternalWork::setWhatAcquiredProduced(), edm::ESProducerExternalWork::setWhatAcquiredProducedWithLambda(), edm::ESProducer::setWhatProduced(), and token_.

      : numberOfIOVsToAccumulate_(pset.getUntrackedParameter<unsigned int>("numberOfIOVsToAccumulate")),
        secondsToWaitForWork_(pset.getUntrackedParameter<unsigned int>("secondsToWaitForWork")) {
    auto collector = setWhatAcquiredProduced(this, "fromAcquireIntESProducer");
    token_ = collector.consumes<IOVTestInfo>(edm::ESInputTag{"", ""});

    setWhatProduced(this, &edmtest::AcquireIntESProducer::produceESTestDataB);

    setWhatAcquiredProduced(this,
                            &AcquireIntESProducer::acquireUniquePtr,
                            &AcquireIntESProducer::produceUniquePtr,
                            edm::es::Label("uniquePtr"));

    setWhatAcquiredProduced(this,
                            &AcquireIntESProducer::acquireOptional,
                            &AcquireIntESProducer::produceOptional,
                            edm::es::Label("optional"));

    setWhatAcquiredProducedWithLambda(
        [this](ESTestRecordI const& record, edm::WaitingTaskWithArenaHolder holder) {
          std::this_thread::sleep_for(200ms);
          auto returnValue = std::make_unique<TestValue>(kAcquireTestValueUniquePtr1);
          lambdaUniqueTestPointers_[record.iovIndex()] = returnValue.get();
          return returnValue;
        },
        [this](ESTestRecordI const& record, auto testValue) {
          std::this_thread::sleep_for(200ms);
          if (testValue.get() != lambdaUniqueTestPointers_[record.iovIndex()]) {
            throw cms::Exception("TestFailure") << "AcquireIntESProducer::<lambda produceUniquePtr>"
                                                << " unexpected value passed in as argument";
          }
          return std::make_unique<ESTestDataI>(kAcquireTestValueUniquePtr2);
        },
        edm::es::Label("uniquePtrLambda"));

    setWhatAcquiredProducedWithLambda(
        [this](ESTestRecordI const& record, edm::WaitingTaskWithArenaHolder holder) {
          std::this_thread::sleep_for(200ms);
          std::vector<TestValue> testVector;
          testVector.push_back(kAcquireTestValueOptional1);
          auto returnValue = std::make_optional<std::vector<TestValue>>(std::move(testVector));
          lambdaOptionalTestPointers_[record.iovIndex()] = &returnValue.value()[0];
          return returnValue;
        },
        [this](ESTestRecordI const& record, std::optional<std::vector<TestValue>> testValue) {
          std::this_thread::sleep_for(200ms);
          if (&testValue.value()[0] != lambdaOptionalTestPointers_[record.iovIndex()]) {
            throw cms::Exception("TestFailure") << "AcquireIntESProducer::<lambda produceOptional>"
                                                << " unexpected value passed in as argument";
          }
          return std::make_unique<ESTestDataI>(kAcquireTestValueOptional2);
        },
        edm::es::Label("optionalLambda"));
  }

~AcquireIntESProducer()

edmtest::AcquireIntESProducer::~AcquireIntESProducer ( )

override

Definition at line 147 of file AcquireIntESProducer.cc.

References server_.

                                              {
    if (server_) {
      server_->stop();
    }
    server_.reset();
  }

AcquireIntESProducer() [2/3]

edmtest::AcquireIntESProducer::AcquireIntESProducer ( const AcquireIntESProducer &  )

delete

AcquireIntESProducer() [3/3]

edmtest::AcquireIntESProducer::AcquireIntESProducer ( AcquireIntESProducer &&  )

delete

Member Function Documentation

acquire()

int edmtest::AcquireIntESProducer::acquire	(	ESTestRecordI const &	record,
		edm::WaitingTaskWithArenaHolder	holder
	)

Definition at line 167 of file AcquireIntESProducer.cc.

References edmtest::IOVTestInfo::cacheIdentifier_, caches_, Exception, edm::ValidityInterval::first(), edmtest::IOVTestInfo::iovEndLumi_, edmtest::IOVTestInfo::iovEndRun_, edmtest::IOVTestInfo::iovIndex_, edmtest::IOVTestInfo::iovStartLumi_, edmtest::IOVTestInfo::iovStartRun_, edm::ValidityInterval::last(), edm::IOVSyncValue::luminosityBlockNumber(), edmtest::test_acquire::Cache::processed(), Hcal_FrontierConditions_cff::record, edmtest::test_acquire::Cache::retrieved(), server_, and token_.

                                                                                                     {
    std::this_thread::sleep_for(200ms);

    test_acquire::Cache& iovCache = caches_[record.iovIndex()];
    iovCache.retrieved().clear();
    iovCache.processed().clear();

    // Get some data and push it into the input cache for the ExternalWork.
    // There is no significance to the particular data we are using.
    // Using anything from the EventSetup would be good enough for the test.
    // I already had test modules around that would make IOVTestInfo
    // data, so that was easy to use. We put in known values and later
    // check that we get the expected result (they get incremented by one
    // to simulate some "external work", then summed in the produce method
    // calculate a result we can check easily).
    IOVTestInfo const& iovTestInfo = record.get(token_);
    std::vector<int>& retrieved = iovCache.retrieved();
    retrieved.push_back(iovTestInfo.iovStartRun_);
    retrieved.push_back(iovTestInfo.iovStartLumi_);
    retrieved.push_back(iovTestInfo.iovEndRun_);
    retrieved.push_back(iovTestInfo.iovEndLumi_);
    retrieved.push_back(iovTestInfo.cacheIdentifier_);

    server_->requestValuesAsync(record.iovIndex(), &iovCache.retrieved(), &iovCache.processed(), holder);

    edm::ValidityInterval iov = record.validityInterval();
    if (iovTestInfo.iovStartLumi_ != iov.first().luminosityBlockNumber() ||
        iovTestInfo.iovEndLumi_ != iov.last().luminosityBlockNumber() || iovTestInfo.iovIndex_ != record.iovIndex() ||
        iovTestInfo.cacheIdentifier_ != record.cacheIdentifier()) {
      throw cms::Exception("TestFailure") << "AcquireIntESProducer::acquire"
                                          << "read values do not agree with record";
    }
    return kAcquireTestValue;
  }

acquireOptional()

std::optional< std::vector< AcquireIntESProducer::TestValue > > edmtest::AcquireIntESProducer::acquireOptional	(	ESTestRecordI const &	record,
		edm::WaitingTaskWithArenaHolder	holder
	)

Definition at line 249 of file AcquireIntESProducer.cc.

References eostools::move(), optionalTestPointers_, and Hcal_FrontierConditions_cff::record.

Referenced by AcquireIntESProducer().

                                                                         {
    std::this_thread::sleep_for(200ms);
    std::vector<TestValue> testVector;
    testVector.push_back(kAcquireTestValueOptional1);
    auto returnValue = std::make_optional<std::vector<TestValue>>(std::move(testVector));
    optionalTestPointers_[record.iovIndex()] = &returnValue.value()[0];
    return returnValue;
  }

acquireUniquePtr()

std::unique_ptr< AcquireIntESProducer::TestValue > edmtest::AcquireIntESProducer::acquireUniquePtr	(	ESTestRecordI const &	record,
		edm::WaitingTaskWithArenaHolder	holder
	)

Definition at line 231 of file AcquireIntESProducer.cc.

References Hcal_FrontierConditions_cff::record, and uniqueTestPointers_.

Referenced by AcquireIntESProducer().

                                                                         {
    std::this_thread::sleep_for(200ms);
    auto returnValue = std::make_unique<TestValue>(kAcquireTestValueUniquePtr1);
    uniqueTestPointers_[record.iovIndex()] = returnValue.get();
    return returnValue;
  }

fillDescriptions()

void edmtest::AcquireIntESProducer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 269 of file AcquireIntESProducer.cc.

References edm::ConfigurationDescriptions::addDefault(), and submitPVResolutionJobs::desc.

                                                                                        {
    edm::ParameterSetDescription desc;
    desc.addUntracked<unsigned int>("numberOfIOVsToAccumulate", 8);
    desc.addUntracked<unsigned int>("secondsToWaitForWork", 1);
    descriptions.addDefault(desc);
  }

initConcurrentIOVs()

void edmtest::AcquireIntESProducer::initConcurrentIOVs ( EventSetupRecordKey const &  key, unsigned int  nConcurrentIOVs  )

overridevirtual

Reimplemented from edm::eventsetup::ESProductResolverProvider.

Definition at line 154 of file AcquireIntESProducer.cc.

References caches_, submitPVResolutionJobs::key, lambdaOptionalTestPointers_, lambdaUniqueTestPointers_, ConfigBuilder::nConcurrentIOVs, numberOfIOVsToAccumulate_, optionalTestPointers_, secondsToWaitForWork_, server_, and uniqueTestPointers_.

                                                                                                            {
    if (key == EventSetupRecordKey::makeKey<ESTestRecordI>()) {
      caches_.resize(nConcurrentIOVs);
      server_ = std::make_unique<test_acquire::WaitingServer>(
          nConcurrentIOVs, numberOfIOVsToAccumulate_, secondsToWaitForWork_);
      server_->start();
      uniqueTestPointers_.resize(nConcurrentIOVs);
      optionalTestPointers_.resize(nConcurrentIOVs);
      lambdaUniqueTestPointers_.resize(nConcurrentIOVs);
      lambdaOptionalTestPointers_.resize(nConcurrentIOVs);
    }
  }

operator=() [1/2]

AcquireIntESProducer& edmtest::AcquireIntESProducer::operator= ( const AcquireIntESProducer &  )

delete

operator=() [2/2]

AcquireIntESProducer& edmtest::AcquireIntESProducer::operator= ( AcquireIntESProducer &&  )

delete

produce()

std::unique_ptr< ESTestDataI > edmtest::AcquireIntESProducer::produce	(	ESTestRecordI const &	record,
		int	valueReturnedByAcquire
	)

Definition at line 202 of file AcquireIntESProducer.cc.

References edmtest::IOVTestInfo::cacheIdentifier_, caches_, Exception, edm::ValidityInterval::first(), edmtest::IOVTestInfo::iovEndLumi_, edmtest::IOVTestInfo::iovIndex_, edmtest::IOVTestInfo::iovStartLumi_, edm::ValidityInterval::last(), edm::IOVSyncValue::luminosityBlockNumber(), edmtest::test_acquire::Cache::processed(), Hcal_FrontierConditions_cff::record, token_, and findQualityFiles::v.

                                                                                                                  {
    std::this_thread::sleep_for(200ms);

    if (valueReturnedByAcquire != kAcquireTestValue) {
      throw cms::Exception("TestFailure") << "AcquireIntESProducer::produce"
                                          << " unexpected value passed in as argument";
    }

    edm::ESHandle<IOVTestInfo> iovTestInfo = record.getHandle(token_);
    edm::ValidityInterval iov = record.validityInterval();
    if (iovTestInfo->iovStartLumi_ != iov.first().luminosityBlockNumber() ||
        iovTestInfo->iovEndLumi_ != iov.last().luminosityBlockNumber() || iovTestInfo->iovIndex_ != record.iovIndex() ||
        iovTestInfo->cacheIdentifier_ != record.cacheIdentifier()) {
      throw cms::Exception("TestFailure") << "AcquireIntESProducer::produce"
                                          << "read values do not agree with record";
    }

    test_acquire::Cache& iovCache = caches_[record.iovIndex()];
    int sum = 0;
    for (auto v : iovCache.processed()) {
      sum += v;
    }
    return std::make_unique<ESTestDataI>(sum);
  }

produceESTestDataB()

std::unique_ptr< ESTestDataB > edmtest::AcquireIntESProducer::produceESTestDataB

(

ESTestRecordB const &

)

Definition at line 227 of file AcquireIntESProducer.cc.

Referenced by AcquireIntESProducer().

                                                                                          {
    return std::make_unique<ESTestDataB>(11);
  }

produceOptional()

std::unique_ptr< ESTestDataI > edmtest::AcquireIntESProducer::produceOptional

(

ESTestRecordI const &

)

Definition at line 259 of file AcquireIntESProducer.cc.

References Exception, optionalTestPointers_, and Hcal_FrontierConditions_cff::record.

Referenced by AcquireIntESProducer().

                                                                                                                  {
    std::this_thread::sleep_for(200ms);
    if (&testValue.value()[0] != optionalTestPointers_[record.iovIndex()]) {
      throw cms::Exception("TestFailure") << "AcquireIntESProducer::produceOptional"
                                          << " unexpected value passed in as argument";
    }
    return std::make_unique<ESTestDataI>(kAcquireTestValueOptional2);
  }

produceUniquePtr()

std::unique_ptr< ESTestDataI > edmtest::AcquireIntESProducer::produceUniquePtr	(	ESTestRecordI const &	record,
		std::unique_ptr< TestValue >	testValue
	)

Definition at line 239 of file AcquireIntESProducer.cc.

References Exception, Hcal_FrontierConditions_cff::record, and uniqueTestPointers_.

Referenced by AcquireIntESProducer().

                                                                                                          {
    std::this_thread::sleep_for(200ms);
    if (testValue.get() != uniqueTestPointers_[record.iovIndex()]) {
      throw cms::Exception("TestFailure") << "AcquireIntESProducer::produceUniquePtr"
                                          << " unexpected value passed in as argument";
    }
    return std::make_unique<ESTestDataI>(kAcquireTestValueUniquePtr2);
  }

Member Data Documentation

caches_

std::vector<test_acquire::Cache> edmtest::AcquireIntESProducer::caches_

private

Definition at line 82 of file AcquireIntESProducer.cc.

Referenced by acquire(), initConcurrentIOVs(), and produce().

lambdaOptionalTestPointers_

std::vector<TestValue*> edmtest::AcquireIntESProducer::lambdaOptionalTestPointers_

private

Definition at line 89 of file AcquireIntESProducer.cc.

Referenced by AcquireIntESProducer(), and initConcurrentIOVs().

lambdaUniqueTestPointers_

std::vector<TestValue*> edmtest::AcquireIntESProducer::lambdaUniqueTestPointers_

private

Definition at line 88 of file AcquireIntESProducer.cc.

Referenced by AcquireIntESProducer(), and initConcurrentIOVs().

numberOfIOVsToAccumulate_

const unsigned int edmtest::AcquireIntESProducer::numberOfIOVsToAccumulate_

private

Definition at line 84 of file AcquireIntESProducer.cc.

Referenced by initConcurrentIOVs().

optionalTestPointers_

std::vector<TestValue*> edmtest::AcquireIntESProducer::optionalTestPointers_

private

Definition at line 87 of file AcquireIntESProducer.cc.

Referenced by acquireOptional(), initConcurrentIOVs(), and produceOptional().

secondsToWaitForWork_

const unsigned int edmtest::AcquireIntESProducer::secondsToWaitForWork_

private

Definition at line 85 of file AcquireIntESProducer.cc.

Referenced by initConcurrentIOVs().

server_

std::unique_ptr<test_acquire::WaitingServer> edmtest::AcquireIntESProducer::server_

private

Definition at line 83 of file AcquireIntESProducer.cc.

Referenced by acquire(), initConcurrentIOVs(), and ~AcquireIntESProducer().

token_

edm::ESGetToken<IOVTestInfo, ESTestRecordI> edmtest::AcquireIntESProducer::token_

private

Definition at line 81 of file AcquireIntESProducer.cc.

Referenced by acquire(), AcquireIntESProducer(), and produce().

uniqueTestPointers_

std::vector<TestValue*> edmtest::AcquireIntESProducer::uniqueTestPointers_

private

Definition at line 86 of file AcquireIntESProducer.cc.

Referenced by acquireUniquePtr(), initConcurrentIOVs(), and produceUniquePtr().