TemplateFactory< BaseModule, OptionsType > Class Template Reference

#include <TemplateFactory.h>

List of all members.

Classes

struct  PerModule

Public Types

typedef BaseModule *(* ModuleMaker )(OptionsType *)
typedef std::vector< std::string > ArgumentsVector

Public Member Functions

void registerModule (const std::string &, ModuleMaker, const std::string &out="")
 Add a ModuleMaker function to the list of makers.
virtual BaseModule * createModule (const std::string &, OptionsType *opts=NULL)
 Create a module with options.
bool canCreate (const std::string &name) const
 Check if a module with this name has been registered.
void addOptions (const std::string &name, OptionsType *opts)
void addArguments (const std::string &all_args)
void addArgument (const std::string &module, const std::string &argument)
void addArgument (const std::string &argument)
std::string GetArgumentName (const std::string &module, const int &argument)
std::string GetProduct (const std::string &module)
void SetDebug (bool debug=true)
void PrintPossibleModules () const

Protected Member Functions

 TemplateFactory (const std::string &name)
virtual ~TemplateFactory ()

Private Types

typedef std::map< std::string,
PerModule > 		ModuleList

Private Member Functions

const PerModule & GetModuleDetails (const std::string &) const

Private Attributes

ModuleList fModules
std::string fMostRecentRegister
bool fDebug
std::string fName

Detailed Description

template<typename BaseModule, typename OptionsType>
class TemplateFactory< BaseModule, OptionsType >

Definition at line 14 of file TemplateFactory.h.

Member Typedef Documentation

template<typename BaseModule, typename OptionsType>
typedef std::vector<std::string> TemplateFactory< BaseModule, OptionsType >::ArgumentsVector

Definition at line 18 of file TemplateFactory.h.

template<typename BaseModule, typename OptionsType>
typedef std::map<std::string, PerModule> TemplateFactory< BaseModule, OptionsType >::ModuleList [private]

Definition at line 28 of file TemplateFactory.h.

template<typename BaseModule, typename OptionsType>
typedef BaseModule*(* TemplateFactory< BaseModule, OptionsType >::ModuleMaker)(OptionsType *)

Definition at line 17 of file TemplateFactory.h.

Constructor & Destructor Documentation

template<typename BaseModule, typename OptionsType>
TemplateFactory< BaseModule, OptionsType >::TemplateFactory ( const std::string &  name  )  [inline, protected]

protected constructor only callable by derived class as this shoule be a singleton class

Definition at line 33 of file TemplateFactory.h.

00033 :fName(name){};

template<typename BaseModule, typename OptionsType>
virtual TemplateFactory< BaseModule, OptionsType >::~TemplateFactory (  )  [inline, protected, virtual]

Definition at line 34 of file TemplateFactory.h.

00034                                   {
00035             fModules.clear();
00036         }

Member Function Documentation

template<typename BaseModule , typename OptionsType >
void TemplateFactory< BaseModule, OptionsType >::addArgument ( const std::string &  argument  )  [inline]

Definition at line 5 of file TemplateFactory.tpl.

References TemplateFactory< BaseModule, OptionsType >::addArgument(), and TemplateFactory< BaseModule, OptionsType >::fMostRecentRegister.

00006                                  {
00007     addArgument(fMostRecentRegister,argument);
00008 }

template<typename BaseModule , typename OptionsType >
void TemplateFactory< BaseModule, OptionsType >::addArgument ( const std::string &  module,
const std::string &  argument 
) [inline]

Definition at line 11 of file TemplateFactory.tpl.

References TemplateFactory< BaseModule, OptionsType >::fModules.

Referenced by TemplateFactory< BaseModule, OptionsType >::addArgument(), and TemplateFactory< BaseModule, OptionsType >::addArguments().

00012                                                          {
00013     fModules[module].arguments.push_back(argument);
00014 }

template<typename BaseModule , typename OptionsType >
void TemplateFactory< BaseModule, OptionsType >::addArguments ( const std::string &  all_args  )  [inline]

Definition at line 75 of file TemplateFactory.tpl.

References TemplateFactory< BaseModule, OptionsType >::addArgument(), and modules::parser::TokeniseByDelimiter().

00075                                                                                    {
00076     std::vector<std::string> args;
00077     modules::parser::TokeniseByDelimiter(all_args,args,", ");
00078     for(unsigned i=0;i<args.size();i++){
00079         addArgument(args[i]);
00080     }
00081 }

template<typename BaseModule , typename OptionsType>
void TemplateFactory< BaseModule, OptionsType >::addOptions ( const std::string &  name,
OptionsType *  opts 
) [inline]

Definition at line 69 of file TemplateFactory.tpl.

References TemplateFactory< BaseModule, OptionsType >::fModules.

00070                                                   {
00071     fModules[name].opts=opts;
00072 }

template<typename BaseModule, typename OptionsType>
bool TemplateFactory< BaseModule, OptionsType >::canCreate ( const std::string &  name  )  const [inline]

Check if a module with this name has been registered.

Definition at line 44 of file TemplateFactory.h.

Referenced by modules::navigator::MakeModules().

00044 {return (bool) fModules.count(name);};

template<typename BaseModule , typename OptionsType>
BaseModule * TemplateFactory< BaseModule, OptionsType >::createModule ( const std::string &  name,
OptionsType *  opts = NULL 
) [inline, virtual]

Create a module with options.

Definition at line 23 of file TemplateFactory.tpl.

References TemplateFactory< BaseModule, OptionsType >::fName, TemplateFactory< BaseModule, OptionsType >::GetModuleDetails(), TemplateFactory< BaseModule, OptionsType >::PerModule::maker, module(), and TemplateFactory< BaseModule, OptionsType >::PerModule::opts.

Referenced by MakeAnalysedPulses::AddGenerator(), MakeMuonEvents::BeforeFirstEntry(), load_config_file(), MakeDetectorPulses::MakeGenerator(), and modules::navigator::MakeModules().

00024                                                  {
00025     // get the maker for the requested module
00026     BaseModule* module=NULL;
00027     const PerModule& details=GetModuleDetails(name);
00028     // make the module
00029     try{
00030         module=details.maker(opts?opts:details.opts);
00031     }catch(modules::missing_option& e){
00032         std::cout<<fName<<"::createModule: Error: "<<e.what()<<std::endl;
00033         return NULL;
00034     }catch(modules::bad_value& e){
00035         std::cout<<fName<<"::createModule: Error: "<<e.what()<<std::endl;
00036         return NULL;
00037     }
00038     return module;
00039 }

template<typename BaseModule , typename OptionsType >
std::string TemplateFactory< BaseModule, OptionsType >::GetArgumentName ( const std::string &  module,
const int &  argument 
) [inline]

Definition at line 17 of file TemplateFactory.tpl.

References TemplateFactory< BaseModule, OptionsType >::fModules.

Referenced by TDPGeneratorOptions::AddArgument(), TAPGeneratorOptions::AddArgument(), and modules::options::AddArgument().

00018                                                     {
00019         return fModules.at(module).arguments.at(argument);
00020 }

template<typename BaseModule , typename OptionsType >
const TemplateFactory< BaseModule, OptionsType >::PerModule & TemplateFactory< BaseModule, OptionsType >::GetModuleDetails ( const std::string &  name  )  const [inline, private]

Definition at line 57 of file TemplateFactory.tpl.

References TemplateFactory< BaseModule, OptionsType >::fModules, TemplateFactory< BaseModule, OptionsType >::fName, and TemplateFactory< BaseModule, OptionsType >::PrintPossibleModules().

Referenced by TemplateFactory< BaseModule, OptionsType >::createModule(), and TemplateFactory< BaseModule, OptionsType >::GetProduct().

00058                                 {
00059     typename ModuleList::const_iterator it  = fModules.find(name);
00060     if(it == fModules.end() ){
00061         std::cout<<fName<<"::GetModuleDetails: Error: I don't know how to make : "<<name<<std::endl;
00062         PrintPossibleModules();
00063         throw std::out_of_range(("unknown: "+name).c_str());
00064     }
00065     return it->second;
00066 }

template<typename BaseModule , typename OptionsType >
std::string TemplateFactory< BaseModule, OptionsType >::GetProduct ( const std::string &  module  )  [inline]

Definition at line 52 of file TemplateFactory.tpl.

References TemplateFactory< BaseModule, OptionsType >::GetModuleDetails(), and TemplateFactory< BaseModule, OptionsType >::PerModule::product.

00052                                                                                     {
00053     return GetModuleDetails(module).product;
00054 }

template<typename BaseModule , typename OptionsType >
void TemplateFactory< BaseModule, OptionsType >::PrintPossibleModules (  )  const [inline]

Definition at line 84 of file TemplateFactory.tpl.

References TemplateFactory< BaseModule, OptionsType >::fModules.

Referenced by TemplateFactory< BaseModule, OptionsType >::GetModuleDetails(), and modules::reader::ProcessGlobalOption().

00084                                                                        {
00085   std::cout<<"Available modules are:"<<std::endl;
00086   for(typename ModuleList::const_iterator it=fModules.begin();
00087                                  it!=fModules.end(); it++){
00088                                  std::cout<<"  "<<it->first<<std::endl;
00089  }
00090 }

template<typename BaseModule , typename OptionsType >
void TemplateFactory< BaseModule, OptionsType >::registerModule ( const std::string &  name,
TemplateFactory< BaseModule, OptionsType >::ModuleMaker  make,
const std::string &  out = "" 
) [inline]

Add a ModuleMaker function to the list of makers.

Definition at line 42 of file TemplateFactory.tpl.

References TemplateFactory< BaseModule, OptionsType >::fModules, and TemplateFactory< BaseModule, OptionsType >::fMostRecentRegister.

00045                           {
00046     fModules[name].maker=make;
00047     fModules[name].product=out;
00048     fMostRecentRegister=name;
00049 }

template<typename BaseModule, typename OptionsType>
void TemplateFactory< BaseModule, OptionsType >::SetDebug ( bool  debug = true  )  [inline]

Definition at line 53 of file TemplateFactory.h.

Referenced by modules::reader::SetDebug().

00053 {fDebug=debug;};

Member Data Documentation

template<typename BaseModule, typename OptionsType>
bool TemplateFactory< BaseModule, OptionsType >::fDebug [private]

Definition at line 67 of file TemplateFactory.h.

Referenced by TemplateFactory< modules::BaseModule, modules::options >::SetDebug().

template<typename BaseModule, typename OptionsType>
ModuleList TemplateFactory< BaseModule, OptionsType >::fModules [private]

Definition at line 61 of file TemplateFactory.h.

Referenced by TemplateFactory< BaseModule, OptionsType >::addArgument(), TemplateFactory< BaseModule, OptionsType >::addOptions(), TemplateFactory< modules::BaseModule, modules::options >::canCreate(), TemplateFactory< BaseModule, OptionsType >::GetArgumentName(), TemplateFactory< BaseModule, OptionsType >::GetModuleDetails(), TemplateFactory< BaseModule, OptionsType >::PrintPossibleModules(), TemplateFactory< BaseModule, OptionsType >::registerModule(), and TemplateFactory< modules::BaseModule, modules::options >::~TemplateFactory().

template<typename BaseModule, typename OptionsType>
std::string TemplateFactory< BaseModule, OptionsType >::fMostRecentRegister [private]

Definition at line 64 of file TemplateFactory.h.

Referenced by TemplateFactory< BaseModule, OptionsType >::addArgument(), and TemplateFactory< BaseModule, OptionsType >::registerModule().

template<typename BaseModule, typename OptionsType>
std::string TemplateFactory< BaseModule, OptionsType >::fName [private]

Definition at line 68 of file TemplateFactory.h.

Referenced by TemplateFactory< BaseModule, OptionsType >::createModule(), and TemplateFactory< BaseModule, OptionsType >::GetModuleDetails().

The documentation for this class was generated from the following files:
Generated on 15 Jun 2016 for AlcapDAQ by  doxygen 1.6.1