gen_module.cc

Go to the documentation of this file.

// $Id: gen_module.cc,v 1.3 2005/05/26 11:47:30 tagg Exp $
//
// Utility to write template code for job modules based on the
// response to several questions.
//
// messier@huhepl.harvard.edu
#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <vector>
#include "Util/UtilString.h"

// A single parameter in the module configuration
//
class ConfigParam {
public:
  ConfigParam() : fName(""), fType(""), fValue("") { }
public:
  std::string fName;  // Name of parameter 
  std::string fType;  // Type of parameter (bool, int, float, string)
  std::string fValue; // Default value of parameter
};
typedef std::vector<ConfigParam> ModuleConfig;


// A set of options used to construct a module
//
class ModuleOptions {
public:
  ModuleOptions() :
    fPackageName(""), fClassName(""), fModuleName(""), 
    fDescription(""), fEmailAddr(""),    
    fNeedAna(false),      fNeedReco(false),          fNeedBeginJob(false),
    fNeedEndJob(false),   fNeedBeginFile(false),     fNeedEndFile(false),
    fNeedBeginRun(false), fNeedEndRun(false),        fNeedGet(false),
    fNeedPut(false),      fNeedConfig(false),        fNeedHelp(false),
    fNeedReport(false),   fNeedReset(false),         fNeedHandleCommand(false),
    fNeedMsg(false),      fPackagePrefix("") 
  { }
public:
  std::string fPackageName; // Name of package where module lives
  std::string fClassName;   // Class name of module
  std::string fModuleName;  // Human readable name of module
  std::string fDescription; // Short description of what module does
  std::string fEmailAddr;   // Author's e-mail address

  bool fNeedAna;       // Generate an Ana       method?
  bool fNeedReco;      // Generate a  Reco      method?
  bool fNeedBeginJob;  // Generate a  BeginJob  method?
  bool fNeedEndJob;    // Generate an EndFile   method?
  bool fNeedBeginFile; // Generate a  BeginFile method?
  bool fNeedEndFile;   // Generate a  EndFile   method?
  bool fNeedBeginRun;  // Generate a  BeginRun  method?
  bool fNeedEndRun;    // Generate a  EndRun    method?
  bool fNeedGet;       // Generate a  Get       method?
  bool fNeedPut;       // Generate a  Put       method?

  bool fNeedConfig;    // Generate the config methods?

  bool fNeedHelp;          // Generate Help   method?
  bool fNeedReport;        // Generate Report method?
  bool fNeedReset;         // Generate Reset  method?
  bool fNeedHandleCommand; // Generate handle command method?

  bool        fNeedMsg;       // Plan to use the message service?
  std::string fPackagePrefix; // Package prefix
};

//......................................................................

static bool yn_querry(const char* t, bool deflt) 
{
//======================================================================
// Prompt user with a yes/no question. Print text t. deflt is the
// default response if user provides none.
//======================================================================
  if (deflt) std::cout << t << "[y] : " << std::flush;
  else       std::cout << t << "[n] : " << std::flush;

  std::string s;
  getline(std::cin,s);
  
  if (s=="y" || s=="Y" || s=="yes" || s=="YES") return true;
  if (s=="n" || s=="N" || s=="no"  || s=="NO")  return false;

  return deflt;
}

//......................................................................

static std::string str_querry(const char* t, const char* deflt) 
{
//======================================================================
// Prompt user for string response. Print text t. Return deflt is user
// provides no input.
//======================================================================
  if (deflt==0 || deflt=="") std::cout << t << " : ";
  else                       std::cout << t << "[" << deflt << "] :";
  std::cout << std::flush;

  std::string s;
  getline(std::cin, s);

  return s;
}

//......................................................................

static void setupNames(ModuleOptions& m) 
{
//======================================================================
// Querry user for names of things in the module
//======================================================================
  m.fClassName  =str_querry("Class name",0);
  m.fPackageName=str_querry("Package name",0);
  m.fModuleName =str_querry("Human readable name of the module",0);
  m.fDescription=str_querry("Short description of what the module does",0);
  m.fEmailAddr  =str_querry("Your e-mail address",0);
}

//......................................................................

static void setupMethods(ModuleOptions& m) 
{
//======================================================================
// Ask users what methods they want in their job module
//======================================================================
  std::cout << "Which methods do you need? (Select [y/n])"<<std::endl;
  m.fNeedAna           = yn_querry("  Ana()           ? ", true);
  m.fNeedReco          = yn_querry("  Reco()          ? ", true);
  m.fNeedBeginJob      = yn_querry("  BeginJob()      ? ", true);
  m.fNeedEndJob        = yn_querry("  EndJob()        ? ", false);
  m.fNeedBeginFile     = yn_querry("  BeginFile()     ? ", false);
  m.fNeedEndFile       = yn_querry("  EndFile()       ? ", false);
  m.fNeedBeginRun      = yn_querry("  BeginRun()      ? ", false);
  m.fNeedEndRun        = yn_querry("  EndRun()        ? ", false);
  m.fNeedGet           = yn_querry("  Get()           ? ", false);
  m.fNeedPut           = yn_querry("  Put()           ? ", false);
  m.fNeedHelp          = yn_querry("  Help()          ? ", false);
  m.fNeedReport        = yn_querry("  Report()        ? ", false);
  m.fNeedReset         = yn_querry("  Reset()         ? ", false);
  m.fNeedHandleCommand = yn_querry("  HandleCommand() ? ", false);
}

//......................................................................

static void setupServices(ModuleOptions& m) 
{
//======================================================================
// Querry user about what services their module will use
//======================================================================
  m.fNeedMsg = yn_querry("Do you plan to use the MessageService? ",true);
  if (m.fNeedMsg) {
    m.fPackagePrefix = str_querry("  What's the package prefix? ",0);
  }
}

//......................................................................

static void parseCfg(std::string str, ConfigParam& p) 
{
//======================================================================
// Extract information about parameter name, type, and value from a
// string like "name=10.0"
//======================================================================
  std::string name;
  std::string value;
  const char* s = str.c_str();
  const char* c;
  
  name  = "";
  value = "";
  bool passedEqual = false;
  for (c=s; *c!='\0'; ++c) {
    switch (*c) {
    case '=': passedEqual = true; break;
    case ' ': continue;           break;
    default:
      if (passedEqual) value += *c;
      else name += *c;
    }
  }
  p.fName  = name;
  p.fValue = value;

  // Assign type to value. Test for float must preceed int
  s = p.fValue.c_str();
  p.fType = "string";
  if (UtilString::IsBool(s))  { p.fType = "bool";  }
  if (UtilString::IsFloat(s)) { p.fType = "float"; }
  if (UtilString::IsInt(s))   { p.fType = "int";   }
}

//......................................................................

static void setupConfig(ModuleOptions& m, ModuleConfig& cfg) 
{
//======================================================================
// Querry user for information about their module's configuration
//======================================================================
  m.fNeedConfig = 
    yn_querry("Do you want to set up the module's configuration parameters? ",
              true);
  if (m.fNeedConfig == false) {
    return;
  }
  
  std::cout << "  Enter parameter list following these examples:"<<std::endl;
  std::cout << "    bool parameter:   > DoTest    = true"<<std::endl;
  std::cout << "    int parameter:    > NhitMax   = 20"<<std::endl;
  std::cout << "    real parameter:   > ChiSqrCut = 10.0"<<std::endl;
  std::cout << "    string parameter: > UseStream = DaqSnarl"<<std::endl;
  std::cout << "  Enter 'q' to end\n";
  
  bool more = true;
  std::string s;
  while (more) {
    s = str_querry("[name = default_value] ",0);
    if (s == "q" || s == "Q" || s=="" || s==" ") { 
      more = false; 
    }
    else {
      ConfigParam p;
      parseCfg(s,p);
      cfg.push_back(p);
    }
  }
}

//......................................................................

static const char* gsDocComment = 
"

static const char* gsSlashDivider = 
"

static const char* gsEqualsDivider =
"

static const char* gsDotDivider =
"//......................................................................";

//......................................................................

static void write_h(const ModuleOptions& m,ModuleConfig& cfg) 
{
//======================================================================
// Write header file for job module
//======================================================================
  std::string filename = m.fClassName;
  filename += ".h";
  std::ofstream ofs(filename.c_str());

  std::string inc_tag = UtilString::ToUpper(m.fClassName);
  inc_tag += "_H";

  //

  ofs << gsSlashDivider << std::endl;
  ofs << "
  ofs << "
  ofs << gsDocComment << std::endl;
  ofs << "
  ofs << "
  ofs << gsSlashDivider << std::endl;
  ofs << "#ifndef " << inc_tag << std::endl;
  ofs << "#define " << inc_tag << std::endl;
  ofs << "#include \"JobControl/JobCModule.h\"" << std::endl;
  ofs << std::endl;
  ofs << "class "<<m.fClassName<<" : public JobCModule"<<std::endl;
  ofs << "{" << std::endl;
  ofs << "public:" << std::endl;
  ofs << "  " << m.fClassName << "();" << std::endl;
  ofs << "  ~" << m.fClassName << "();" << std::endl;
  ofs << std::endl;
  ofs << "public:" << std::endl;
  if (m.fNeedBeginJob  || m.fNeedEndJob ||
      m.fNeedBeginFile || m.fNeedEndFile ||
      m.fNeedBeginRun  || m.fNeedEndRun) {
    ofs << "  // Handle job status changes" << std::endl;
    if (m.fNeedBeginJob)  ofs << "  void BeginJob();"  << std::endl;
    if (m.fNeedEndJob)    ofs << "  void EndJob();"    << std::endl;
    if (m.fNeedBeginFile) ofs << "  void BeginFile();" << std::endl;
    if (m.fNeedEndFile)   ofs << "  void EndFile();"   << std::endl;
    if (m.fNeedBeginRun)  ofs << "  void BeginRun();"  << std::endl;
    if (m.fNeedEndRun)    ofs << "  void EndRun();"    << std::endl;
    ofs << std::endl;
  }
  if (m.fNeedAna || m.fNeedReco) {
    ofs << "  // Analysis and Reconstruction methods" << std::endl;
    if (m.fNeedAna)  
      ofs << "  JobCResult Ana(const MomNavigator* mom);" << std::endl;
    if (m.fNeedReco) 
      ofs << "  JobCResult Reco(MomNavigator* mom);" << std::endl;
    ofs << std::endl;
  }
  if (m.fNeedGet || m.fNeedPut) {
    ofs << "  // I/O methods" << std::endl;
    if (m.fNeedGet)  
      ofs << "  JobCResult Get(MomNavigator* mom);" << std::endl;
    if (m.fNeedPut)  
      ofs << "  JobCResult Put(const MomNavigator* mom);" << std::endl;
    ofs << std::endl;
  }
  if (m.fNeedConfig) {
    ofs << "  // Module configuration" << std::endl;
    ofs << "  const Registry& DefaultConfig() const;" << std::endl;
    ofs << "  void            Config(const Registry& r);" << std::endl;
    ofs << std::endl;
  }
  if (m.fNeedHelp  || m.fNeedReport || 
      m.fNeedReset || m.fNeedHandleCommand) {
    ofs << "  // User interface methods" << std::endl;
    if (m.fNeedHelp) 
      ofs << "  void Help();" << std::endl;
    if (m.fNeedReport) 
      ofs << "  void Report();" << std::endl;
    if (m.fNeedReset)
      ofs << "  void Reset();" << std::endl;
    if (m.fNeedHandleCommand)
      ofs << "  void HandleCommand(JobCommand* c);" << std::endl;
    ofs << std::endl;
  }
  ofs << std::endl;
  ofs << "private:" << std::endl;
  ofs << "  // Module configuration" << std::endl;
  if(m.fNeedConfig) {
    ModuleConfig::const_iterator itr(cfg.begin());
    ModuleConfig::const_iterator itrEnd(cfg.end());
    for (itr=cfg.begin(); itr!=itrEnd; ++itr) {
      if (itr->fType == "bool")   { ofs << "  Bool_t      "; }
      if (itr->fType == "int")    { ofs << "  Int_t       "; }
      if (itr->fType == "float")  { ofs << "  Double_t    "; }
      if (itr->fType == "string") { ofs << "  std::string "; }
      ofs << "f" << itr->fName << ";" << std::endl;    
    }
  }
  ofs << std::endl;
  ofs << "  // Module member data" << std::endl;
  ofs << std::endl;
  ofs << "};" << std::endl;
  ofs << "#endif // " << inc_tag << std::endl;
  ofs << gsSlashDivider << std::endl;
}

//......................................................................

static void write_method(const char* type_s, 
                         const char* meth,
                         const char* return_s,
                         const ModuleOptions& m, std::ofstream& ofs) 
{
//======================================================================
// Write a single method for the implementation file:
// type_s : return type
// meth   : method name
// return_s : what to return from method
// m : module definition
// ofs : stream to write to
//======================================================================
  ofs << gsDotDivider << std::endl;
  ofs << std::endl;
  if (type_s!=0 && type_s!="")
    ofs << type_s << " " << m.fClassName << "::" << meth << std::endl;
  else
    ofs << m.fClassName << "::" << meth << std::endl;
  ofs << "{" << std::endl;
  ofs << "  " << gsEqualsDivider << std::endl;
  ofs << "  " << gsDocComment << std::endl;
  ofs << "  " << gsEqualsDivider << std::endl;
  if (return_s!=0 && return_s != "")
    ofs << "  return " << return_s << std::endl;
  ofs << "}" << std::endl;
  ofs << std::endl;
}

//......................................................................

static void write_constructor(const ModuleOptions& m,
                              const ModuleConfig& cfg, 
                              std::ofstream& ofs)
{
  ofs << gsDotDivider << std::endl;
  ofs << std::endl;
  ofs << m.fClassName << "::" << m.fClassName << "()";
  if(m.fNeedConfig) {
    ofs << " : ";
    ModuleConfig::const_iterator itr(cfg.begin());
    ModuleConfig::const_iterator itrEnd(cfg.end());
    for (itr=cfg.begin(); itr!=itrEnd; ++itr) {
      ofs << std::endl;
      ofs << "  f" << itr->fName << "(";
      if (itr->fType == "bool")   { ofs << "false"; }
      if (itr->fType == "int")    { ofs << "0"; }
      if (itr->fType == "float")  { ofs << "0.0"; }
      if (itr->fType == "string") { ofs << "\"\""; }
      ofs << ")";
      if(itr+1 != itrEnd) ofs << ",";
    }
  }
  ofs << std::endl;
  ofs << "{" << std::endl;
  ofs << "  " << gsEqualsDivider << std::endl;
  ofs << "  " << gsDocComment << std::endl;
  ofs << "  " << gsEqualsDivider << std::endl;
  ofs << "}" << std::endl;
   
 
}


static void write_default_config_method(const ModuleOptions& m,
                                        const ModuleConfig& cfg, 
                                        std::ofstream& ofs)
{
//======================================================================
// Write the method which supplies the default configuration
//======================================================================
  ofs << gsDotDivider << std::endl;
  ofs << std::endl;
  ofs << "const Registry& " << m.fClassName << "::DefaultConfig() const"
      << std::endl;
  ofs << "{" << std::endl;
  ofs << "  " << gsEqualsDivider << std::endl;
  ofs << "  /// Supply the default configuration for the module" << std::endl;
  ofs << "  " << gsEqualsDivider << std::endl;
  ofs << "  static Registry r; // Default configuration for module" 
      << std::endl;
  ofs << std::endl;
  ofs << "  // Set name of config" << std::endl;
  ofs << "  std::string name = this->GetName();" << std::endl;
  ofs << "  name += \".config.default\";" << std::endl;
  ofs << "  r.SetName(name.c_str());" << std::endl;
  ofs << std::endl;
  ofs << "  // Set values in configuration" << std::endl;
  ofs << "  r.UnLockValues();" << std::endl;
  ModuleConfig::const_iterator itr(cfg.begin());
  ModuleConfig::const_iterator itrEnd(cfg.end());
  unsigned int w = 0;
  for (; itr!=itrEnd; ++itr) {
    if (itr->fName.size() > w) w = itr->fName.size();
  }
  for (itr = cfg.begin(); itr!=itrEnd; ++itr) {
    ofs << "  r.Set(\"" << itr->fName << "\",";
    for (unsigned int i=itr->fName.size(); i<w; ++i) ofs << " ";
    if (itr->fType == "string") {
      ofs << "\"" << itr->fValue << "\");" << std::endl;
    }
    else if (itr->fType == "bool") {
      if (UtilString::atob(itr->fValue.c_str()))
        ofs << " true);"  << std::endl;
      else
        ofs << " false);" << std::endl;
    }
    else {
      ofs << " " << itr->fValue << ");" << std::endl;
    }
  }
  ofs << "  r.LockValues();" << std::endl;
  ofs << std::endl;
  ofs << "  return r;" << std::endl;
  ofs << "}" << std::endl;
  ofs << std::endl;
}

//......................................................................

static void write_config_method(const ModuleOptions& m,
                                const ModuleConfig& cfg, 
                                std::ofstream& ofs) 
{
//======================================================================
// Write some template code for the Config() method
//======================================================================
  ofs << gsDotDivider << std::endl;
  ofs << std::endl;
  ofs << "void " << m.fClassName << "::Config(const Registry& r)"
      << std::endl;
  ofs << "{" << std::endl;
  ofs << "  " << gsEqualsDivider << std::endl;
  ofs << "  /// Configure the module given the Registry r" << std::endl;
  ofs << "  " << gsEqualsDivider << std::endl;
  
  ModuleConfig::const_iterator itr(cfg.begin());
  ModuleConfig::const_iterator itrEnd(cfg.end());
  for (; itr!=itrEnd; ++itr) {
    ofs << "  f" << itr->fName << " = ";
    if (itr->fType == "bool")   ofs << "r.GetInt";
    if (itr->fType == "int")    ofs << "r.GetInt";
    if (itr->fType == "float")  ofs << "r.GetDouble";
    if (itr->fType == "string") ofs << "r.GetCharString";
    ofs << "(\"" << itr->fName << "\");" << std::endl;
  }
  ofs << "}" << std::endl;
  ofs << std::endl;

  return;

  /*
  bool need_tmpb = false;
  bool need_tmpi = false;
  bool need_tmpd = false;
  bool need_tmps = false;

  ModuleConfig::const_iterator itr(cfg.begin());
  ModuleConfig::const_iterator itrEnd(cfg.end());
  for (; itr!=itrEnd; ++itr) {
    if (itr->fType == "bool")   need_tmpb = true;
    if (itr->fType == "int")    need_tmpi = true;
    if (itr->fType == "float")  need_tmpd = true;
    if (itr->fType == "string") need_tmps = true;
  }

  ofs << gsDotDivider << std::endl;
  ofs << std::endl;
  ofs << "void " << m.fClassName << "::Config(const Registry& r)"
      << std::endl;
  ofs << "{" << std::endl;
  ofs << gsEqualsDivider << std::endl;
  ofs << "// Configure the module given the Registry r" << std::endl;
  ofs << gsEqualsDivider << std::endl;

  // On most systems, the bool's get implicitly converted to int's
  if (need_tmpb) ofs << "  int    tmpb;" << std::endl;
  if (need_tmpi) ofs << "  int    tmpi;" << std::endl;
  if (need_tmpd) ofs << "  double tmpd;" << std::endl;
  if (need_tmps) ofs << "  const char* tmps;" << std::endl;
  ofs << std::endl;
  
  for (itr=cfg.begin(); itr!=itrEnd; ++itr) {
    ofs << "  if (r.Get(\"" << itr->fName << "\",";
    if (itr->fType == "bool")   { ofs << "tmpb"; }
    if (itr->fType == "int")    { ofs << "tmpi"; }
    if (itr->fType == "float")  { ofs << "tmpd"; }
    if (itr->fType == "string") { ofs << "tmps"; }
    ofs << ")) { fData = ";
    if (itr->fType == "bool")   { ofs << "tmpb"; }
    if (itr->fType == "int")    { ofs << "tmpi"; }
    if (itr->fType == "float")  { ofs << "tmpd"; }
    if (itr->fType == "string") { ofs << "tmps"; }
    ofs << "; }" << std::endl;
  }
  ofs << "}" << std::endl;
  ofs << std::endl;
  */
}

//......................................................................

static void write_config_methods(const ModuleOptions& m,
                                 const ModuleConfig& cfg, 
                                 std::ofstream& ofs) 
{
//======================================================================
// Write the methods which handle the module configuration
//======================================================================
  write_default_config_method(m,cfg,ofs);
  write_config_method(m,cfg,ofs);
}


//......................................................................

static void write_cxx(const ModuleOptions& m, const ModuleConfig& cfg) 
{
//======================================================================
// Write the implementation file for the module
//======================================================================
  std::string filename = m.fClassName;
  filename += ".cxx";
  std::ofstream ofs(filename.c_str());

  ofs << gsSlashDivider << std::endl;
  ofs << "
  ofs << "
  ofs << gsDocComment << std::endl;
  ofs << "
  ofs << "
  ofs << gsSlashDivider << std::endl;
  
  // Includes...
  ofs << 
    "#include \""<<m.fClassName<<".h\""<<std::endl;
  if (m.fNeedMsg) {
    ofs << "#include \"MessageService/MsgService.h\"" << std::endl;
  }
  ofs << "#include \"MinosObjectMap/MomNavigator.h\"" << std::endl;
  ofs << "#include \"JobControl/JobCModuleRegistry.h\" // For JOBMODULE macro"
      << std::endl;
  ofs << std::endl;

  // Global static data
  ofs << "JOBMODULE(" << m.fClassName << ", \"" << m.fModuleName << "\",\n"
      << "          \"" << m.fDescription << "\");" << std::endl;
  if (m.fNeedMsg) {
    ofs << "CVSID(\"$Id: gen_module.cc,v 1.3 2005/05/26 11:47:30 tagg Exp $\");" << std::endl;
  }

  // Constructor
  write_constructor(m,cfg,ofs);
  //std::string s = m.fClassName; s+= "()";
  //write_method("", s.c_str(), "", m, ofs);

  // Destructor
  std::string s = "~"; s += m.fClassName; s+= "()";
  write_method("", s.c_str(), "", m, ofs);

  // Status change handlers
  if (m.fNeedBeginJob)  write_method("void", "BeginJob()",  "", m, ofs);
  if (m.fNeedEndJob)    write_method("void", "EndJob()",    "", m, ofs);
  if (m.fNeedBeginFile) write_method("void", "BeginFile()", "", m, ofs);
  if (m.fNeedEndFile)   write_method("void", "EndFile()",   "", m, ofs);
  if (m.fNeedBeginRun)  write_method("void", "BeginRun()",  "", m, ofs);
  if (m.fNeedEndRun)    write_method("void", "EndRun()",    "", m, ofs);

  if (m.fNeedAna) 
    write_method("JobCResult",
                 "Ana(const MomNavigator* mom)", 
                 "JobCResult::kPassed; // kNoDecision, kFailed, etc.",
                 m, ofs);
  if (m.fNeedReco)
    write_method("JobCResult",
                 "Reco(MomNavigator* mom)", 
                 "JobCResult::kPassed; // kNoDecision, kFailed, etc.",
                 m, ofs);
  if (m.fNeedGet)
    write_method("JobCResult",
                 "Get(MomNavigator* mom)",
                 "JobCResult::kPassed; // kNoDecision, kFailed, etc.",
                 m, ofs);
  if (m.fNeedPut)
    write_method("JobCResult",
                 "Put(const MomNavigator* mom)",
                 "JobCResult::kPassed; // kNoDecision, kFailed, etc.",
                 m, ofs);
  if (m.fNeedConfig)        write_config_methods(m,cfg,ofs);
  if (m.fNeedHelp)          write_method("void","Help()",  "",m,ofs);
  if (m.fNeedReport)        write_method("void","Report()","",m,ofs);
  if (m.fNeedReset)         write_method("void","Reset()", "",m,ofs);
  if (m.fNeedHandleCommand) 
    write_method("void","HandleCommand(JobCommand* c)", "",m,ofs);
  ofs << gsSlashDivider << std::endl;
}

//......................................................................

static void getSetup(ModuleOptions& m, ModuleConfig& cfg) {
  setupNames(m);
  setupMethods(m);
  setupServices(m);
  setupConfig(m,cfg);
}

//......................................................................

static void doWrite(ModuleOptions& m, ModuleConfig& cfg) {
  write_h(m,cfg);
  write_cxx(m,cfg);
}

//......................................................................

int main(void) {
  ModuleOptions m;
  ModuleConfig  cfg;
  
  getSetup(m,cfg);
  doWrite(m,cfg);
}

---