g4b::UserActionFactory Class Reference

#include "UserActionFactory.h"

Classes
struct	Cleaner

Public Member Functions
g4b::UserAction *	GetUserAction (const std::string &)
bool	IsKnownUserAction (const std::string &)
const std::vector< std::string > &	AvailableUserActions () const
bool	RegisterCreator (std::string name, UserActionCtorFuncPtr_t ctorptr, bool *ptr)

Static Public Member Functions
static UserActionFactory &	Instance ()

Private Member Functions
	UserActionFactory ()
virtual	~UserActionFactory ()
	UserActionFactory (const UserActionFactory &)
void	operator= (const UserActionFactory &)

Private Attributes
std::map< std::string, UserActionCtorFuncPtr_t >	fFunctionMap
std::map< std::string, bool * >	fBoolPtrMap
std::vector< std::string >	listnames

Static Private Attributes
static UserActionFactory *	fgTheInstance

Friends
struct	Cleaner

Detailed Description

Definition at line 34 of file UserActionFactory.h.

Constructor & Destructor Documentation

g4b::UserActionFactory::UserActionFactory ( )

private

Definition at line 21 of file UserActionFactory.cxx.

References fgTheInstance.

Referenced by Instance().

{
  fgTheInstance = this;   // record created self in static pointer
}

g4b::UserActionFactory::~UserActionFactory ( )

privatevirtual

Definition at line 26 of file UserActionFactory.cxx.

References fgTheInstance.

{
  fgTheInstance = 0;
}

g4b::UserActionFactory::UserActionFactory ( const UserActionFactory &  )

private

Member Function Documentation

const std::vector< std::string > & g4b::UserActionFactory::AvailableUserActions

(

)

const

Definition at line 78 of file UserActionFactory.cxx.

References fFunctionMap, and listnames.

{
  // list of names might be out of date due to new registrations
  // rescan the std::map on each call (which won't be frequent)
  listnames.clear();

  // scan map for registered names
  std::map<std::string, UserActionCtorFuncPtr_t>::const_iterator itr;
  for ( itr = fFunctionMap.begin(); itr != fFunctionMap.end(); ++itr )
    listnames.push_back(itr->first);

  return listnames;
}

UserAction * g4b::UserActionFactory::GetUserAction

(

const std::string &

name

)

Definition at line 46 of file UserActionFactory.cxx.

References fFunctionMap, and g4b::UserAction::SetName().

{
  UserAction* p = 0;
  
  // we don't want map creating an entry if it doesn't exist
  // so use map::find() not map::operator[]
  std::map<std::string, UserActionCtorFuncPtr_t>::iterator itr
    = fFunctionMap.find(name);
  if ( fFunctionMap.end() != itr ) { 
    // found an appropriate entry in the list
    UserActionCtorFuncPtr_t foo = itr->second;  // this is the function
    p = (*foo)();  // use function to create the UserAction
    p->SetName(name); // let object know its name
  }
  if ( ! p ) {
    mf::LogWarning("UserAction") << "### UserActionFactory WARNING: "
                                 << "UserAction " << name << " is not known";
  }
  return p;
}

UserActionFactory & g4b::UserActionFactory::Instance ( )

static

Definition at line 31 of file UserActionFactory.cxx.

References fgTheInstance, g4b::UserActionFactory::Cleaner::UseMe(), and UserActionFactory().

{
  // Cleaner dtor calls UserActionFactory dtor at job end
  static Cleaner cleaner;

  if ( ! fgTheInstance ) {
    // need to create one
    cleaner.UseMe();   // dummy call to quiet compiler warnings
    fgTheInstance = new UserActionFactory();
  }
  
  return *fgTheInstance;
}

bool g4b::UserActionFactory::IsKnownUserAction

(

const std::string &

name

)

Definition at line 67 of file UserActionFactory.cxx.

References fFunctionMap.

{
  //  check if we know the name
  bool res = false;
  std::map<std::string, UserActionCtorFuncPtr_t>::iterator itr
    = fFunctionMap.find(name);
  if ( fFunctionMap.end() != itr ) res = true;
  return res;
}

void g4b::UserActionFactory::operator= ( const UserActionFactory &  )

private

bool g4b::UserActionFactory::RegisterCreator	(	std::string	name,
		UserActionCtorFuncPtr_t	ctorptr,
		bool *	ptr
	)

Definition at line 92 of file UserActionFactory.cxx.

References fBoolPtrMap, and fFunctionMap.

{
  // record new functions for creating processes
  fFunctionMap[name] = foo;
  fBoolPtrMap[name]  = boolptr;
  return true;
}

Friends And Related Function Documentation

friend struct Cleaner

friend

Definition at line 88 of file UserActionFactory.h.

Member Data Documentation

std::map<std::string, bool*> g4b::UserActionFactory::fBoolPtrMap

private

Definition at line 60 of file UserActionFactory.h.

Referenced by RegisterCreator().

std::map<std::string, UserActionCtorFuncPtr_t> g4b::UserActionFactory::fFunctionMap

private

Definition at line 57 of file UserActionFactory.h.

Referenced by AvailableUserActions(), GetUserAction(), IsKnownUserAction(), and RegisterCreator().

UserActionFactory * g4b::UserActionFactory::fgTheInstance

staticprivate

Definition at line 54 of file UserActionFactory.h.

Referenced by Instance(), UserActionFactory(), g4b::UserActionFactory::Cleaner::~Cleaner(), and ~UserActionFactory().

std::vector<std::string> g4b::UserActionFactory::listnames

mutableprivate

Definition at line 62 of file UserActionFactory.h.

Referenced by AvailableUserActions().

---

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

• nug4/G4Base/UserActionFactory.h
• nug4/G4Base/UserActionFactory.cxx