DuneToolManager Class Reference

#include <DuneToolManager.h>

Classes
class	SharedToolEntry
class	TSharedToolEntry

Public Types
using	Name = std::string
using	NameVector = std::vector< Name >
using	SharedToolPtr = std::unique_ptr< SharedToolEntry >
using	SharedToolMap = std::map< Name, SharedToolPtr >

Public Member Functions
	DuneToolManager (std::string fclname)
template<class T >
std::unique_ptr< T >	getPrivate (std::string name)
template<class T >
T *	getShared (std::string name)
int	deleteShared (std::string name)
const std::vector< std::string > &	toolNames () const
void	print () const

Static Public Member Functions
static std::string	fclFilename (std::string setName="", int dbg=1)
static DuneToolManager *	instance (std::string fclname="", int dbg=1)
static void	help ()

Private Member Functions
int	makeParameterSet (std::string scfg, fhicl::ParameterSet &ps)

Private Attributes
std::string	m_fclname
fhicl::ParameterSet	m_pstools
NameVector	m_toolNames
SharedToolMap	m_sharedTools

Detailed Description

Definition at line 34 of file DuneToolManager.h.

Member Typedef Documentation

using DuneToolManager::Name = std::string

Definition at line 38 of file DuneToolManager.h.

using DuneToolManager::NameVector = std::vector<Name>

Definition at line 39 of file DuneToolManager.h.

using DuneToolManager::SharedToolMap = std::map<Name, SharedToolPtr>

Definition at line 58 of file DuneToolManager.h.

using DuneToolManager::SharedToolPtr = std::unique_ptr<SharedToolEntry>

Definition at line 57 of file DuneToolManager.h.

Constructor & Destructor Documentation

DuneToolManager::DuneToolManager ( std::string  fclname )

explicit

Definition at line 131 of file DuneToolManager.cxx.

: m_fclname(fclname) {
  cet::filepath_lookup_nonabsolute policy("FHICL_FILE_PATH");
  m_pstools =
    fhicl::ParameterSet::make(fhicl::parse_document(fclname, policy)).
    get<fhicl::ParameterSet>("tools");
  m_toolNames = m_pstools.get_pset_names();
}

Member Function Documentation

int DuneToolManager::deleteShared

(

std::string

name

)

Definition at line 142 of file DuneToolManager.cxx.

                                                {
  SharedToolMap::iterator itoo = m_sharedTools.find(tnam);
  if ( itoo == m_sharedTools.end() ) return 1;
  m_sharedTools.erase(tnam);
  return 0;
}

string DuneToolManager::fclFilename ( std::string  setName = "", int  dbg = 1  )

static

Definition at line 22 of file DuneToolManager.cxx.

                                                             {
  const string myname = "DuneToolManager::fclFilename: ";
  if ( dbg >= 2 ) cout << myname << "Called with " << a_fclname << endl;
  static string fclname;
  bool haveName = fclname.size();
  bool setName = a_fclname.size();
  if ( !haveName && !setName ) {
    // Use ps to discover the command line.
    Index pid = getpid();
    ostringstream ssftmp;
    ssftmp << "tmpproc" << pid << ".tmp";
    string sftmp = ssftmp.str();
    ostringstream sscom;
    sscom << "ps -fwwp " << pid << " >" << sftmp;
    string scom = sscom.str();
    system(scom.c_str());
    ifstream fin(sftmp.c_str());
    string hdrline;
    getline(fin, hdrline);   // Skip header
    string::size_type iposCom = hdrline.find("CMD");
    string longline;
    getline(fin, longline);
    string line = longline.substr(iposCom);
    scom = "rm " + sftmp;
    system(scom.c_str());
    if ( dbg >= 1 ) cout << myname << "Taking fcl name from command line: " << line << endl;
    // Split command line into words.
    NameVector words;
    bool newWord = true;
    for ( string::size_type ipos=0; ipos<line.size(); ++ipos ) {
      char ch = line[ipos];
      //if ( ch == '\0' || ch == 0 || isspace(ch) ) {
      if ( isspace(ch) ) {
        newWord = true;
      } else {
        if ( newWord ) {
          newWord = false;
          words.emplace_back();
        }
        words.back() += ch;
      }
    }
    // Find the flag "-c" or "--config" and use following text as the fcl name.
    for ( Index iwrd=0; iwrd<words.size(); ++iwrd ) {
      string word = words[iwrd];
      if ( word == "-c" || word == "--config") {
        if ( words.size() > iwrd+1 ) fclname = words[iwrd+1];
      } else if ( word.substr(0,2) == "-c" ) {
        fclname = word.substr(2);
      }
    }
    // If name was not found, switch to a default.
    if ( fclname.empty() ) {
      cout << myname << "ERROR: unable to retrieve configuration file name from command line." << endl;
      fclname = "tools_dune.fcl";
    }
  } else if ( !haveName && setName ) {
    fclname = a_fclname;
  } else if ( haveName && setName ) {
    if ( a_fclname != fclname ) {
      cout << myname << "WARNING: Ignoring inconsistent configuration name: "
           << a_fclname << " != " << fclname << endl;
    }
  }
  if ( fclname.empty() ) {
    cout << myname << "ERROR: Unexpected empty file name!" << endl;
    fclname = "nosuchfile.fcl";
  }
  return fclname;
}

template<class T >

std::unique_ptr<T> DuneToolManager::getPrivate ( std::string  name )

inline

Definition at line 82 of file DuneToolManager.h.

                                              {
    std::string myname = "DuneToolManager::getPrivate: ";
    fhicl::ParameterSet psTool;
    if ( name.size() == 0 ) {
      std::cout << myname << "Tool name is blank" << std::endl;
      return nullptr;
    } else if ( name[0] == '{' ) {    // Name is a tool cfg string
      makeParameterSet(name, psTool);
    } else if ( std::find(m_toolNames.begin(), m_toolNames.end(), name) != m_toolNames.end() ) {
      psTool = m_pstools.get<fhicl::ParameterSet>(name);
    } else {
      std::cout << myname << "No such tool name: " << name << std::endl;
      return nullptr;
    }
    return art::make_tool<T>(psTool);
  }

template<class T >

T* DuneToolManager::getShared ( std::string  name )

inline

Definition at line 101 of file DuneToolManager.h.

                               {
    std::string myname = "DuneToolManager::getShared: ";
    SharedToolMap::iterator itoo = m_sharedTools.find(name);
    if ( itoo != m_sharedTools.end() ) {
      SharedToolPtr& pent = itoo->second;
      if ( pent ) {
        TSharedToolEntry<T>* ptent = dynamic_cast<TSharedToolEntry<T>*>(pent.get());
        return ptent->get();
      } else {
        std::cout << myname << "ERROR: Null tool pointer for " << name << "." << std::endl;
      }
    }
    if ( std::find(m_toolNames.begin(), m_toolNames.end(), name) != m_toolNames.end() ) {
      fhicl::ParameterSet psTool = m_pstools.get<fhicl::ParameterSet>(name);
      std::unique_ptr<T> ptoo = art::make_tool<T>(psTool);
      TSharedToolEntry<T>* ptent(new TSharedToolEntry<T>(ptoo));
      SharedToolEntry* pent = ptent;
      //m_sharedTools[name] = pent;
      m_sharedTools.emplace(name, pent);
      return ptent->get();
    } else {
      std::cout << myname << "No such tool name: " << name << std::endl;
      return nullptr;
    }
  }

void DuneToolManager::help ( )

static

Definition at line 106 of file DuneToolManager.cxx.

                           {
  cout << "DuneToolManager provides access to named tools." << endl;
  cout << "It is typically accessed a singleton, e.g." << endl;
  cout << "  DuneToolManager* ptm = DuneToolManger::instance();" << endl;
  cout << "The name of the fcl file defining the tools may be provided as an argument." << endl;
  cout << endl;
  cout << "Available tools may be listed with:" << endl;
  cout << "  ptm->print()      // Displays the names of available tools." << endl;
  cout << "  ptm->toolNames()  // Returns a vector of the tool names." << endl;
  cout << endl;
  cout << "A private instance of a tool with type MyTool may be otained with:" << endl;
  cout << "  ptm->getPrivate<MyTool>(\"tnam\")" << endl;
  cout << "The tool configuration is taken from the fcl block tools.tnam." << endl;
  cout << "A unique pointer is returned so the tool instance is destroyed with that pointer." << endl;
  cout << endl;
  cout << "A shared instance of a tool may be obtained with:" << endl;
  cout << "  ptm->getShared<MyTool>(\"tnam\")" << endl;
  cout << "A bare pointer is returned and subsequent callers receive the same pointer." << endl;
  cout << "The tool manager deletes all shared tools when it is destroyed." << endl;
  cout << endl;
  cout << "In either case, tool instances are created only when they are obtained." << endl;
}

DuneToolManager * DuneToolManager::instance ( std::string  fclname = "", int  dbg = 1  )

static

Definition at line 95 of file DuneToolManager.cxx.

                                                                    {
  const string myname = "DuneToolManager::instance: ";
  if ( dbg >= 2 ) cout << myname << "Called with " << a_fclname << endl;
  static std::unique_ptr<DuneToolManager> pins;
  string fclname = fclFilename(a_fclname, dbg);
  if ( !pins ) pins.reset(new DuneToolManager(fclname));
  return pins.get();
}

int DuneToolManager::makeParameterSet ( std::string  scfg, fhicl::ParameterSet &  ps  )

private

Definition at line 166 of file DuneToolManager.cxx.

                                                                             {
  // Strip surrounding braces.
  if ( scfgin.size() < 1 ) return 1;
  string scfg;
  if ( scfgin[0] == '{' ) {
    if ( scfgin[scfgin.size()-1] != '}' ) return 2;
    scfg = scfgin.substr(1, scfgin.size()-2);
  } else {
    scfg = scfgin;
  }
  // Parse the configuration string.
  ps = fhicl::ParameterSet::make(scfg);
  return 0;
}

void DuneToolManager::print

(

)

const

Definition at line 157 of file DuneToolManager.cxx.

                                  {
  cout << "Tools for " << m_fclname << ":" << endl;
  for ( string name : toolNames() ) {
    cout << "  " << name << endl;
  }
}

const std::vector< std::string > & DuneToolManager::toolNames

(

)

const

Definition at line 151 of file DuneToolManager.cxx.

                                                             {
  return m_toolNames;
}

Member Data Documentation

std::string DuneToolManager::m_fclname

private

Definition at line 142 of file DuneToolManager.h.

fhicl::ParameterSet DuneToolManager::m_pstools

private

Definition at line 143 of file DuneToolManager.h.

SharedToolMap DuneToolManager::m_sharedTools

private

Definition at line 145 of file DuneToolManager.h.

NameVector DuneToolManager::m_toolNames

private

Definition at line 144 of file DuneToolManager.h.

---

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

• dunecore/dunecore/ArtSupport/DuneToolManager.h
• dunecore/dunecore/ArtSupport/DuneToolManager.cxx