#include "WorkerT.h"

Inheritance diagram for art::WorkerT< T >:

Public Types
using	ModuleType = T

using	WorkerType = WorkerT< T >

enum	State { Ready, Pass, Fail, Working, Exception }

Public Member Functions
	WorkerT (std::unique_ptr< T > &&, ModuleDescription const &, WorkerParams const &)

bool	modifiesEvent () const override

template<typename T >
bool	doWork (typename T::MyPrincipal &, CurrentProcessingContext const *cpc)

void	beginJob ()

void	endJob ()

void	respondToOpenInputFile (FileBlock const &fb)

void	respondToCloseInputFile (FileBlock const &fb)

void	respondToOpenOutputFiles (FileBlock const &fb)

void	respondToCloseOutputFiles (FileBlock const &fb)

void	reset ()

ModuleDescription const &	description () const

ModuleDescription const *	descPtr () const

void	setActivityRegistry (cet::exempt_ptr< ActivityRegistry > areg)

void	clearCounters ()

std::size_t	timesRun () const

std::size_t	timesVisited () const

std::size_t	timesPassed () const

std::size_t	timesFailed () const

std::size_t	timesExcept () const

State	state () const

std::string const &	label () const

Protected Member Functions
T &	module ()

T const &	module () const

Private Member Functions
bool	implDoProcess (EventPrincipal &ep, CurrentProcessingContext const *cpc, CountingStatistics &) override

bool	implDoBegin (RunPrincipal &rp, CurrentProcessingContext const *cpc) override

bool	implDoEnd (RunPrincipal &rp, CurrentProcessingContext const *cpc) override

bool	implDoBegin (SubRunPrincipal &srp, CurrentProcessingContext const *cpc) override

bool	implDoEnd (SubRunPrincipal &srp, CurrentProcessingContext const *cpc) override

void	implBeginJob () override

void	implEndJob () override

void	implRespondToOpenInputFile (FileBlock const &fb) override

void	implRespondToCloseInputFile (FileBlock const &fb) override

void	implRespondToOpenOutputFiles (FileBlock const &fb) override

void	implRespondToCloseOutputFiles (FileBlock const &fb) override

std::string	workerType () const override

Private Attributes
std::unique_ptr< T >	module_

Detailed Description

template<typename T>
class art::WorkerT< T >

Definition at line 22 of file WorkerT.h.

Member Typedef Documentation

template<typename T>

using art::WorkerT< T >::ModuleType = T

Definition at line 24 of file WorkerT.h.

template<typename T>

using art::WorkerT< T >::WorkerType = WorkerT<T>

Definition at line 25 of file WorkerT.h.

Member Enumeration Documentation

enum art::Worker::State

inherited

Enumerator
Ready
Pass
Fail
Working
Exception

Definition at line 53 of file Worker.h.

53 { Ready, Pass, Fail, Working, Exception };

art::Worker::Working

Definition: Worker.h:53

art::Worker::Ready

Definition: Worker.h:53

art::Worker::Fail

Definition: Worker.h:53

art::Worker::Pass

Definition: Worker.h:53

art::Worker::Exception

Definition: Worker.h:53

Constructor & Destructor Documentation

template<typename T>

art::WorkerT< T >::WorkerT	(	std::unique_ptr< T > &&	module,
		ModuleDescription const &	md,
		WorkerParams const &	wp
	)

inline

Definition at line 73 of file WorkerT.h.

References art::WorkerT< T >::module(), and art::WorkerT< T >::module_.

     : Worker{md, wp}, module_{std::move(module)}
   {
     module_->setModuleDescription(md);
     module_->registerProducts(wp.reg_, wp.producedProducts_, md);
   }

Member Function Documentation

void art::Worker::beginJob ( )

inherited

Definition at line 18 of file Worker.cc.

References art::Worker::actReg_, art::errors::BadExceptionType, art::Worker::description(), e, art::Worker::implBeginJob(), art::Worker::md_, art::errors::OtherArt, s, art::errors::StdException, art::errors::Unknown, and art::Worker::workerType().

                         {
   assert(actReg_.get() != nullptr);
   actReg_->sPreModuleBeginJob.invoke(md_);
   implBeginJob();
   actReg_->sPostModuleBeginJob.invoke(md_);
 }
 catch (cet::exception& e) {
   // should event id be included?
   LogError("BeginJob") << "A cet::exception is going through " << workerType()
                        << ":\n";
 
   e << "A cet::exception is going through " << workerType() << ":\n"
     << description();
   throw art::Exception(errors::OtherArt, std::string(), e);
 }
 catch (std::bad_alloc& e) {
   LogError("BeginJob") << "A std::bad_alloc is going through " << workerType()
                        << ":\n"
                        << description() << "\n";
   throw;
 }
 catch (std::exception& e) {
   LogError("BeginJob") << "A std::exception is going through " << workerType()
                        << ":\n"
                        << description() << "\n";
   throw art::Exception(errors::StdException)
     << "A std::exception is going through " << workerType() << ":\n"
     << description() << "\n";
 }
 catch (std::string& s) {
   LogError("BeginJob") << "module caught an std::string during beginJob\n";
 
   throw art::Exception(errors::BadExceptionType)
     << "std::string = " << s << "\n"
     << description() << "\n";
 }
 catch (char const* c) {
   LogError("BeginJob") << "module caught an const char* during beginJob\n";
 
   throw art::Exception(errors::BadExceptionType) << "cstring = " << c << "\n"
                                                  << description();
 }
 catch (...) {
   LogError("BeginJob") << "An unknown Exception occurred in\n"
                        << description() << "\n";
   throw art::Exception(errors::Unknown) << "An unknown Exception occurred in\n"
                                         << description() << "\n";
 }

void art::Worker::clearCounters ( )

inlineinherited

Definition at line 88 of file Worker.h.

References art::Worker::counts_.

   {
     counts_ = CountingStatistics{};
   }

ModuleDescription const* art::Worker::descPtr ( ) const

inlineinherited

Definition at line 79 of file Worker.h.

References art::Worker::md_, and art::Worker::setActivityRegistry().

   {
     return &md_;
   }

ModuleDescription const& art::Worker::description ( ) const

inlineinherited

Definition at line 74 of file Worker.h.

References art::Worker::md_.

Referenced by art::Worker::beginJob(), art::OutputWorker::closeFile(), art::Worker::endJob(), art::OutputWorker::openFile(), and art::OutputWorker::OutputWorker().

   {
     return md_;
   }

template<typename T >

bool art::Worker::doWork	(	typename T::MyPrincipal &	p,
		CurrentProcessingContext const *	cpc
	)

inherited

Definition at line 218 of file Worker.h.

References art::Worker::actions_, art::Worker::actReg_, art::errors::BadAlloc, art::errors::BadExceptionType, art::Worker::cached_exception_, art::Worker::counts_, e, art::Event, art::Worker::Exception, art::detail::exceptionContext(), art::Worker::Fail, art::actions::FailModule, art::actions::FailPath, art::ActionTable::find(), art::actions::IgnoreCompletely, art::CurrentProcessingContext::isEndPath(), art::Worker::md_, art::errors::OtherArt, art::Worker::Pass, art::Worker::Ready, art::actions::Rethrow, s, art::errors::ScheduleExecutionFailure, art::actions::SkipEvent, art::Worker::state_, art::errors::StdException, art::errors::Unknown, and art::Worker::Working.

 {
   MaybeIncrementCounts<T::level, decltype(counts_)> counts{counts_};
   counts.template increment<stats::Visited>();
 
   switch (state_) {
     case Ready:
       break;
     case Pass:
       return true;
     case Fail:
       return false;
     case Exception: {
       // Rethrow the cached exception again. It seems impossible to
       // get here a second time unless a cet::exception has been
       // thrown previously.
       mf::LogWarning("repeat")
         << "A module has been invoked a second time even though"
            " it caught an exception during the previous invocation."
            "\nThis may be an indication of a configuration problem.\n";
       throw *cached_exception_;
     }
     case Working:
       break; // See below.
   }
 
   bool rc{false};
   try {
     if (state_ == Working) {
       // Not part of the switch statement above because we want the
       // exception to be caught by our handling mechanism.
       throw art::Exception(errors::ScheduleExecutionFailure)
         << "A Module has been invoked while it is still being executed.\n"
         << "Product dependencies have invoked a module execution cycle.\n";
     }
 
     assert(actReg_.get() != nullptr);
     state_ = Working;
 
     T::preModuleSignal(*actReg_, md_);
     rc = ImplDoWork<T::processing_action>::invoke(this, p, cpc);
     T::postModuleSignal(*actReg_, md_);
 
     state_ = Pass;
 
     if (T::level == Level::Event && !rc)
       state_ = Fail;
   }
   catch (cet::exception& e) {
 
     // NOTE: the warning printed as a result of ignoring or failing a
     // module will only be printed during the full true processing
     // pass of this module.
 
     // Get the action corresponding to this exception.  However, if
     // processing something other than an event (e.g. run, subRun)
     // always rethrow.
     actions::ActionCodes action{T::level == Level::Event ?
                                   actions_.find(e.root_cause()) :
                                   actions::Rethrow};
 
     // If we are processing an endPath, treat SkipEvent or FailPath as
     // FailModule, so any subsequent OutputModules are still run.
     if (cpc && cpc->isEndPath()) {
       if (action == actions::SkipEvent || action == actions::FailPath)
         action = actions::FailModule;
     }
 
     switch (action) {
       case actions::IgnoreCompletely: {
         rc = true;
         counts.template increment<stats::Passed>();
         state_ = Pass;
         mf::LogWarning("IgnoreCompletely") << "Module ignored an exception\n"
                                            << e.what();
         break;
       }
       case actions::FailModule: {
         rc = true;
         mf::LogWarning("FailModule") << "Module failed due to an exception\n"
                                      << e.what();
         counts.template increment<stats::Failed>();
         state_ = Fail;
         break;
       }
       default: {
         // We should not need to include the event/run/module names in
         // the exception because the error logger will pick this up
         // automatically.  I'm leaving it in until this is verified.
 
         // here we simply add a small amount of data to the exception to
         // add some context, we could have rethrown it as something else
         // and embedded with this exception as an argument to the
         // constructor.
         counts.template increment<stats::ExceptionThrown>();
         state_ = Exception;
         e << "cet::exception going through module ";
         detail::exceptionContext(md_, p, e);
         if (auto edmEx = dynamic_cast<art::Exception*>(&e)) {
           cached_exception_ = std::make_shared<art::Exception>(*edmEx);
         } else {
           cached_exception_ = std::make_shared<art::Exception>(
             errors::OtherArt, std::string(), e);
         }
         throw;
       }
     }
   }
   catch (std::bad_alloc const& bda) {
     counts.template increment<stats::ExceptionThrown>();
     state_ = Exception;
     cached_exception_ = std::make_shared<art::Exception>(errors::BadAlloc);
     *cached_exception_
       << "A std::bad_alloc exception occurred during a call to the module ";
     detail::exceptionContext(md_, p, *cached_exception_)
       << "The job has probably exhausted the virtual memory available to the "
          "process.\n";
     throw *cached_exception_;
   }
   catch (std::exception const& e) {
     counts.template increment<stats::ExceptionThrown>();
     state_ = Exception;
     cached_exception_ = std::make_shared<art::Exception>(errors::StdException);
     *cached_exception_
       << "A std::exception occurred during a call to the module ";
     detail::exceptionContext(md_, p, *cached_exception_)
       << "and cannot be repropagated.\n"
       << "Previous information:\n"
       << e.what();
     throw *cached_exception_;
   }
   catch (std::string const& s) {
     counts.template increment<stats::ExceptionThrown>();
     state_ = Exception;
     cached_exception_ =
       std::make_shared<art::Exception>(errors::BadExceptionType, "std::string");
     *cached_exception_ << "A std::string thrown as an exception occurred "
                           "during a call to the module ";
     detail::exceptionContext(md_, p, *cached_exception_)
       << "and cannot be repropagated.\n"
       << "Previous information:\n string = " << s;
     throw *cached_exception_;
   }
   catch (char const* c) {
     counts.template increment<stats::ExceptionThrown>();
     state_ = Exception;
     cached_exception_ = std::make_shared<art::Exception>(
       errors::BadExceptionType, "const char *");
     *cached_exception_ << "A const char* thrown as an exception occurred "
                           "during a call to the module ";
     detail::exceptionContext(md_, p, *cached_exception_)
       << "and cannot be repropagated.\n"
       << "Previous information:\n const char* = " << c << "\n";
     throw *cached_exception_;
   }
   catch (...) {
     counts.template increment<stats::ExceptionThrown>();
     state_ = Exception;
     cached_exception_ =
       std::make_shared<art::Exception>(errors::Unknown, "repeated");
     *cached_exception_
       << "An unknown occurred during a previous call to the module ";
     detail::exceptionContext(md_, p, *cached_exception_)
       << "and cannot be repropagated.\n";
     throw *cached_exception_;
   }
 
   return rc;
 }

void art::Worker::endJob ( )

inherited

Definition at line 68 of file Worker.cc.

References art::Worker::actReg_, art::errors::BadExceptionType, art::Worker::description(), e, art::Worker::implEndJob(), art::Worker::md_, art::errors::OtherArt, s, art::errors::StdException, art::errors::Unknown, and art::Worker::workerType().

Referenced by art::EndPathExecutor::endJob(), and art::Schedule::endJob().

                       {
   assert(actReg_.get() != nullptr);
   actReg_->sPreModuleEndJob.invoke(md_);
   implEndJob();
   actReg_->sPostModuleEndJob.invoke(md_);
 }
 catch (cet::exception& e) {
   LogError("EndJob") << "A cet::exception is going through " << workerType()
                      << ":\n";
 
   // should event id be included?
   e << "A cet::exception is going through " << workerType() << ":\n"
     << description();
   throw art::Exception(errors::OtherArt, std::string(), e);
 }
 catch (std::bad_alloc& e) {
   LogError("EndJob") << "A std::bad_alloc is going through " << workerType()
                      << ":\n"
                      << description() << "\n";
   throw;
 }
 catch (std::exception& e) {
   LogError("EndJob") << "An std::exception is going through " << workerType()
                      << ":\n"
                      << description() << "\n";
   throw art::Exception(errors::StdException)
     << "A std::exception is going through " << workerType() << ":\n"
     << description() << "\n"
     << e.what();
 }
 catch (std::string& s) {
   LogError("EndJob") << "module caught an std::string during endJob\n";
 
   throw art::Exception(errors::BadExceptionType)
     << "std::string = " << s << "\n"
     << description() << "\n";
 }
 catch (char const* c) {
   LogError("EndJob") << "module caught an const char* during endJob\n";
 
   throw art::Exception(errors::BadExceptionType) << "cstring = " << c << "\n"
                                                  << description() << "\n";
 }
 catch (...) {
   LogError("EndJob") << "An unknown Exception occurred in\n"
                      << description() << "\n";
   throw art::Exception(errors::Unknown) << "An unknown Exception occurred in\n"
                                         << description() << "\n";
 }

template<typename T >

void art::WorkerT< T >::implBeginJob ( )

overrideprivatevirtual

Implements art::Worker.

Definition at line 130 of file WorkerT.h.

References art::WorkerT< T >::module_.

Referenced by art::WorkerT< OutputModule >::module().

   {
     module_->doBeginJob();
   }

template<typename T >

bool art::WorkerT< T >::implDoBegin	(	RunPrincipal &	rp,
		CurrentProcessingContext const *	cpc
	)

overrideprivatevirtual

Implements art::Worker.

Definition at line 93 of file WorkerT.h.

References art::WorkerT< T >::module_.

Referenced by art::WorkerT< OutputModule >::module().

   {
     return module_->doBeginRun(rp, cpc);
   }

template<typename T >

bool art::WorkerT< T >::implDoBegin	(	SubRunPrincipal &	srp,
		CurrentProcessingContext const *	cpc
	)

overrideprivatevirtual

Implements art::Worker.

Definition at line 107 of file WorkerT.h.

References art::WorkerT< T >::module_.

   {
     return module_->doBeginSubRun(srp, cpc);
   }

template<typename T >

bool art::WorkerT< T >::implDoEnd	(	RunPrincipal &	rp,
		CurrentProcessingContext const *	cpc
	)

overrideprivatevirtual

Implements art::Worker.

Definition at line 100 of file WorkerT.h.

References art::WorkerT< T >::module_.

Referenced by art::WorkerT< OutputModule >::module().

   {
     return module_->doEndRun(rp, cpc);
   }

template<typename T >

bool art::WorkerT< T >::implDoEnd	(	SubRunPrincipal &	srp,
		CurrentProcessingContext const *	cpc
	)

overrideprivatevirtual

Implements art::Worker.

Definition at line 115 of file WorkerT.h.

References art::WorkerT< T >::module_.

   {
     return module_->doEndSubRun(srp, cpc);
   }

template<typename T >

bool art::WorkerT< T >::implDoProcess	(	EventPrincipal &	ep,
		CurrentProcessingContext const *	cpc,
		CountingStatistics &	stats
	)

overrideprivatevirtual

Implements art::Worker.

Definition at line 84 of file WorkerT.h.

References art::WorkerT< T >::module_.

Referenced by art::WorkerT< OutputModule >::module().

   {
     return module_->doEvent(ep, cpc, stats);
   }

template<typename T >

void art::WorkerT< T >::implEndJob ( )

overrideprivatevirtual

Implements art::Worker.

Definition at line 137 of file WorkerT.h.

References art::WorkerT< T >::module_.

Referenced by art::WorkerT< OutputModule >::module().

   {
     module_->doEndJob();
   }

template<typename T >

void art::WorkerT< T >::implRespondToCloseInputFile ( FileBlock const & fb )

overrideprivatevirtual

Implements art::Worker.

Definition at line 151 of file WorkerT.h.

References art::WorkerT< T >::module_.

Referenced by art::WorkerT< OutputModule >::module().

   {
     module_->doRespondToCloseInputFile(fb);
   }

template<typename T >

void art::WorkerT< T >::implRespondToCloseOutputFiles ( FileBlock const & fb )

overrideprivatevirtual

Implements art::Worker.

Definition at line 165 of file WorkerT.h.

References art::WorkerT< T >::module_.

Referenced by art::WorkerT< OutputModule >::module().

   {
     module_->doRespondToCloseOutputFiles(fb);
   }

template<typename T >

void art::WorkerT< T >::implRespondToOpenInputFile ( FileBlock const & fb )

overrideprivatevirtual

Implements art::Worker.

Definition at line 144 of file WorkerT.h.

References art::WorkerT< T >::module_.

Referenced by art::WorkerT< OutputModule >::module().

   {
     module_->doRespondToOpenInputFile(fb);
   }

template<typename T >

void art::WorkerT< T >::implRespondToOpenOutputFiles ( FileBlock const & fb )

overrideprivatevirtual

Implements art::Worker.

Definition at line 158 of file WorkerT.h.

References art::WorkerT< T >::module_.

Referenced by art::WorkerT< OutputModule >::module().

   {
     module_->doRespondToOpenOutputFiles(fb);
   }

std::string const& art::Worker::label ( ) const

inlineinherited

Definition at line 127 of file Worker.h.

References art::Worker::implBeginJob(), art::Worker::implDoBegin(), art::Worker::implDoEnd(), art::Worker::implDoProcess(), art::Worker::implEndJob(), art::Worker::md_, art::ModuleDescription::moduleLabel(), and art::Worker::workerType().

Referenced by art::EndPathExecutor::closeAllOutputFiles(), art::EndPathExecutor::openAllOutputFiles(), and art::OutputWorker::OutputWorker().

   {
     return md_.moduleLabel();
   }

template<typename T>

bool art::WorkerT< T >::modifiesEvent ( ) const

inlineoverridevirtual

Implements art::Worker.

Definition at line 32 of file WorkerT.h.

     {
       return module_->modifiesEvent();
     }

template<typename T>

T& art::WorkerT< T >::module ( )

inlineprotected

Definition at line 39 of file WorkerT.h.

Referenced by art::WorkerT< T >::WorkerT().

     {
       return *module_;
     }

template<typename T>

T const& art::WorkerT< T >::module ( ) const

inlineprotected

Definition at line 44 of file WorkerT.h.

     {
       return *module_;
     }

void art::Worker::reset ( void )

inlineinherited

Definition at line 68 of file Worker.h.

References art::Worker::Ready, and art::Worker::state_.

   {
     state_ = Ready;
   }

void art::Worker::respondToCloseInputFile ( FileBlock const & fb )

inherited

Definition at line 128 of file Worker.cc.

References art::Worker::actReg_, art::Worker::implRespondToCloseInputFile(), and art::Worker::md_.

 {
   assert(actReg_.get() != nullptr);
   actReg_->sPreModuleRespondToCloseInputFile.invoke(md_);
   implRespondToCloseInputFile(fb);
   actReg_->sPostModuleRespondToCloseInputFile.invoke(md_);
 }

void art::Worker::respondToCloseOutputFiles ( FileBlock const & fb )

inherited

Definition at line 146 of file Worker.cc.

References art::Worker::actReg_, art::Worker::implRespondToCloseOutputFiles(), and art::Worker::md_.

 {
   assert(actReg_.get() != nullptr);
   actReg_->sPreModuleRespondToCloseOutputFiles.invoke(md_);
   implRespondToCloseOutputFiles(fb);
   actReg_->sPostModuleRespondToCloseOutputFiles.invoke(md_);
 }

void art::Worker::respondToOpenInputFile ( FileBlock const & fb )

inherited

Definition at line 119 of file Worker.cc.

References art::Worker::actReg_, art::Worker::implRespondToOpenInputFile(), and art::Worker::md_.

 {
   assert(actReg_.get() != nullptr);
   actReg_->sPreModuleRespondToOpenInputFile.invoke(md_);
   implRespondToOpenInputFile(fb);
   actReg_->sPostModuleRespondToOpenInputFile.invoke(md_);
 }

void art::Worker::respondToOpenOutputFiles ( FileBlock const & fb )

inherited

Definition at line 137 of file Worker.cc.

References art::Worker::actReg_, art::Worker::implRespondToOpenOutputFiles(), and art::Worker::md_.

 {
   assert(actReg_.get() != nullptr);
   actReg_->sPreModuleRespondToOpenOutputFiles.invoke(md_);
   implRespondToOpenOutputFiles(fb);
   actReg_->sPostModuleRespondToOpenOutputFiles.invoke(md_);
 }

void art::Worker::setActivityRegistry ( cet::exempt_ptr< ActivityRegistry > areg )

inherited

The signals are required to live longer than the last call to 'doWork' this was done to improve performance based on profiling

Definition at line 12 of file Worker.cc.

References art::Worker::actReg_.

Referenced by art::Worker::descPtr().

 {
   actReg_ = std::move(areg);
 }

State art::Worker::state ( ) const

inlineinherited

Definition at line 119 of file Worker.h.

References art::Worker::modifiesEvent(), and art::Worker::state_.

   {
     return state_;
   }

std::size_t art::Worker::timesExcept ( ) const

inlineinherited

Definition at line 114 of file Worker.h.

References art::Worker::counts_, and art::ExecutionCounts< ARGS >::times().

   {
     return counts_.times<stats::ExceptionThrown>();
   }

std::size_t art::Worker::timesFailed ( ) const

inlineinherited

Definition at line 109 of file Worker.h.

References art::Worker::counts_, and art::ExecutionCounts< ARGS >::times().

   {
     return counts_.times<stats::Failed>();
   }

std::size_t art::Worker::timesPassed ( ) const

inlineinherited

Definition at line 104 of file Worker.h.

References art::Worker::counts_, and art::ExecutionCounts< ARGS >::times().

   {
     return counts_.times<stats::Passed>();
   }

std::size_t art::Worker::timesRun ( ) const

inlineinherited

Definition at line 94 of file Worker.h.

References art::Worker::counts_, and art::ExecutionCounts< ARGS >::times().

   {
     return counts_.times<stats::Run>();
   }

std::size_t art::Worker::timesVisited ( ) const

inlineinherited

Definition at line 99 of file Worker.h.

References art::Worker::counts_, and art::ExecutionCounts< ARGS >::times().

   {
     return counts_.times<stats::Visited>();
   }

template<typename T >

std::string art::WorkerT< T >::workerType ( ) const

overrideprivatevirtual

Implements art::Worker.

Definition at line 123 of file WorkerT.h.

References art::WorkerT< T >::module_.

Referenced by art::WorkerT< OutputModule >::module().

   {
     return module_->workerType();
   }

Member Data Documentation

template<typename T>

std::unique_ptr<T> art::WorkerT< T >::module_

private

Definition at line 69 of file WorkerT.h.

The documentation for this class was generated from the following file:

art/Framework/Core/WorkerT.h

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

template<typename T> class art::WorkerT< T >

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename T>
class art::WorkerT< T >