EvtTimeDistFactory.cxx

Go to the documentation of this file.

#include "EvtDataOverlay/EvtTimeDistFactory.h"
#include <iostream>

namespace simb {

// Define static variable which holds the one-and-only instance
EvtTimeDistFactory* EvtTimeDistFactory::fgTheInstance;

EvtTimeDistFactory::EvtTimeDistFactory() 
{
  fgTheInstance = this;   // record created self in static pointer
}

EvtTimeDistFactory::~EvtTimeDistFactory()
{
  fgTheInstance = 0;
}

EvtTimeDistFactory& EvtTimeDistFactory::Instance()
{
  // Cleaner dtor calls EvtTimeDistFactory dtor at job end
  static Cleaner cleaner;

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

simb::EvtTimeDistI* 
EvtTimeDistFactory::GetEvtTimeDist(const std::string& name,
                                   const std::string& config)
{
  simb::EvtTimeDistI* 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, EvtTimeDistICtorFuncPtr_t>::iterator itr
    = fFunctionMap.find(name);
  if ( fFunctionMap.end() != itr ) { 
    // found an appropriate entry in the list
    EvtTimeDistICtorFuncPtr_t foo = itr->second;  // this is the function
    p = (*foo)(config);  // use function to create the EvtTimeDistI
  }
  if ( ! p ) {
    std::cerr << "### EvtTimeDistFactory WARNING: "
              << "EvtTimeDistI " << name << " is not known" << std::endl;
  }
  return p;
}
  
bool EvtTimeDistFactory::IsKnownEvtTimeDist(const std::string& name)
{
  //  check if we know the name
  bool res = false;
  std::map<std::string, EvtTimeDistICtorFuncPtr_t>::iterator itr
    = fFunctionMap.find(name);
  if ( fFunctionMap.end() != itr ) res = true;
  return res;
}

const std::vector<std::string>& 
EvtTimeDistFactory::AvailableEvtTimeDist() const
{
  // 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, EvtTimeDistICtorFuncPtr_t>::const_iterator itr;
  for ( itr = fFunctionMap.begin(); itr != fFunctionMap.end(); ++itr )
    listnames.push_back(itr->first);

  return listnames;
}

bool EvtTimeDistFactory::RegisterCreator(std::string name, 
                                         EvtTimeDistICtorFuncPtr_t foo,
                                         bool* boolptr)
{
  // record new functions for creating processes
  fFunctionMap[name] = foo;
  fBoolPtrMap[name]  = boolptr;
  return true;
}

} // namespace simb

---