ModuleMacros.h File Reference

#include "art/Framework/Core/ModuleBase.h"
#include "art/Framework/Core/ProcessingFrame.h"
#include "art/Framework/Core/WorkerT.h"
#include "art/Framework/Core/detail/ModuleTypeDeducer.h"
#include "art/Framework/Principal/WorkerParams.h"
#include "art/Persistency/Provenance/ModuleDescription.h"
#include "art/Persistency/Provenance/ModuleType.h"
#include "cetlib/ProvideFilePathMacro.h"
#include "fhiclcpp/ParameterSet.h"
#include "fhiclcpp/types/AllowedConfigurationMacro.h"
#include <memory>
#include <type_traits>

Go to the source code of this file.

Classes
struct	art::detail::config_impl< T, typename >
struct	art::detail::config_impl< T, std::void_t< typename T::Parameters > >

Namespaces
	art::detail

Macros
#define	DEFINE_ART_MODULE(klass)

Typedefs
using	art::detail::ModuleMaker_t = ModuleBase *(fhicl::ParameterSet const &, ProcessingFrame const &)
using	art::detail::WorkerFromModuleMaker_t = Worker *(std::shared_ptr< ModuleBase >, ModuleDescription const &, WorkerParams const &)
using	art::detail::WorkerMaker_t = Worker *(WorkerParams const &, ModuleDescription const &)
using	art::detail::ModuleTypeFunc_t) = ModuleType(
using	art::detail::ModuleThreadingTypeFunc_t) = ModuleThreadingType(
template<typename T >
using	art::detail::Config = typename config_impl< T >::type

Functions
template<typename T , typename Config >
T *	art::detail::make_module (Config const &config, ProcessingFrame const &frame)

Macro Definition Documentation

#define DEFINE_ART_MODULE

(

klass

)

Value:

extern "C" {                                                                 \
  CET_PROVIDE_FILE_PATH()                                                      \
  FHICL_PROVIDE_ALLOWED_CONFIGURATION(klass)                                   \
  art::ModuleBase*                                                             \
  make_module(fhicl::ParameterSet const& pset,                                 \
              art::ProcessingFrame const& frame)                               \
  {                                                                            \
    /* Reference below to avoid copy if Config<klass> is a ParameterSet. */    \
    art::detail::Config<klass> const& config{pset};                            \
    return art::detail::make_module<klass>(config, frame);                     \
  }                                                                            \
  art::Worker*                                                                 \
  make_worker_from_module(std::shared_ptr<art::ModuleBase> mod,                \
                          art::ModuleDescription const& md,                    \
                          art::WorkerParams const& wp)                         \
  {                                                                            \
    return new klass::WorkerType(                                              \
      std::dynamic_pointer_cast<klass::ModuleType>(mod), md, wp);              \
  }                                                                            \
  art::ModuleType                                                              \
  moduleType()                                                                 \
  {                                                                            \
    return art::detail::ModuleTypeDeducer<klass::ModuleType>::value;           \
  }                                                                            \
  art::ModuleThreadingType                                                     \
  moduleThreadingType()                                                        \
  {                                                                            \
    return art::detail::ModuleThreadingTypeDeducer<klass::ModuleType>::value;  \
  }                                                                            \
  }

Definition at line 67 of file ModuleMacros.h.