ConfigHandler.hh

Go to the documentation of this file.

//Copyright 2013 Ben Loer
//This file is part of the ConfigHandler library
//It is released under the terms of the GNU General Public License v3

#ifndef CONFIGHANDLER_h
#define CONFIGHANDLER_h 1
#include <string>
#include <set>
#include <vector>
#include "ParameterList.hh"
#include "phrase.hh"


class ConfigHandler : public ParameterList{
public:
  static ConfigHandler* const GetInstance()
  { 
    static ConfigHandler config;
    return &config;
  }
    
  template<class Action> 
  int AddCommandSwitch(char shortname,
                       const std::string& longname,
                       const std::string& helptext,
                       Action action,
                       const std::string& parameter = "");
  int RemoveCommandSwitch(char shortname, const std::string& longname);
  
  void PrintSwitches(bool quit=true, std::ostream& out = std::cout,
                     bool escape=false);
  void SetProgramUsageString(const std::string& usage){ _program_usage=usage;}
  std::string GetProgramUsageString(){ return _program_usage; }
  void SetProgramDescription(const std::string& d){ _program_description=d;}
  std::string GetProgramDescription(){ return _program_description; }
  
  int ProcessCommandLine(int& argc, char** argv);
  
  int GetNCommandArgs() { return _cmd_args.size(); }
  
  const char* GetCommandArg(size_t n) { return _cmd_args.at(n); }
  
  //functions for loading a saved parameter list
  void SetSavedCfgFile(const std::string& fname){ _saved_cfg = fname; }
  const std::string& GetSavedCfgFile(){ return _saved_cfg; }
  template<class T> bool LoadCreateParameterList(T*& par, std::string key="",
                                                 bool registerme = false);
  template<class T> bool LoadParameterList(T* par, std::string key="",
                                           bool registerme = false);
  void SetNotes(const std::string& newnotes) { _notes = newnotes; }
  const std::string& GetNotes(){ return _notes; }

  void SetDefaultCfgFile(const std::string& file) { _default_cfg_file = file; }
  const std::string& GetDefaultCfgFile(){ return _default_cfg_file; }
  
  //search multiple paths for a config file
  std::string FindConfigFile(const std::string& fname);
 
private:
  std::string _program_usage;      
  std::string _program_description; 

  std::string _notes;                
  std::string _default_cfg_file;    
  std::string _saved_cfg;             

  std::vector<std::string> _cfg_paths; 
  
  ConfigHandler(); 
  ~ConfigHandler();
  
  ConfigHandler(const ConfigHandler& right) : ParameterList(),
                                              _switches(right._switches) {}
  ConfigHandler& operator=(const ConfigHandler& right)
  { _switches = right._switches; return *this; }
  
  std::vector<char*> _cmd_args;  
  
  
  class VCommandSwitch{
  public:
    char shortname;               
    std::string longname;         
    std::string helptext;         
    std::string parameter;        

    VCommandSwitch(char short_name, const std::string& long_name,
                   const std::string& help_text, const std::string& par) :
      shortname(short_name), longname(long_name), helptext(help_text), 
      parameter(par) {}
    virtual ~VCommandSwitch() {}
    virtual int Process(const char* arg) = 0;
  };
  
  template<class Action> class CommandSwitch : public VCommandSwitch{
    Action do_action;
  public:
    CommandSwitch(char short_name, const std::string& long_name,
                  const std::string& help_text, const std::string& par,
                  Action action) : 
      VCommandSwitch(short_name, long_name, help_text, par), 
      do_action(action) {}
    virtual ~CommandSwitch() {}
    virtual int Process(const char* arg);
  };
  
  struct OrderCommandSwitchPointers{
    bool operator()(VCommandSwitch* a, VCommandSwitch* b);
  };

  typedef std::set<VCommandSwitch*, OrderCommandSwitchPointers> SwitchSet;
  SwitchSet _switches; 
};

//templates must be defined in header
template<class Action> 
int ConfigHandler::AddCommandSwitch(char shortname,
                                    const std::string& longname,
                                    const std::string& helptext,
                                    Action action,
                                    const std::string& parameter)
{
  //Make sure both shortname and longname aren't empty
  if(shortname == ' ' && longname == ""){
    std::cerr<<"Error: At least one of shortname and longname must be non-empty for switches!"<<std::endl;
    return -1;
  }
  //Make sure there isn't already a registered switch  with the same keys
  for( SwitchSet::iterator it = _switches.begin(); it != _switches.end(); it++){
    if( shortname != ' ' && shortname == (*it)->shortname){
      std::cerr<<"Switch already registered with shortname '"
               <<shortname<<"'"<<std::endl;
      return -2;
    }
    else if( longname != "" && longname == (*it)->longname){
      std::cerr<<"Switch already registered with longname \""
               <<longname<<"\""<<std::endl;
      return -3;
    }
  }
  _switches.insert(new CommandSwitch<Action>(shortname, longname, helptext,
                                             parameter, action) );
  return 0;
}


template<class Action> inline
int ConfigHandler::CommandSwitch<Action>::Process(const char* arg)
{
  return do_action(arg);
}


//load a saved parameter list
template<class T> inline
bool ConfigHandler::LoadCreateParameterList(T*& par, 
                                            std::string key, 
                                            bool registerme)
{
  if(!par){
    boost::shared_ptr<VParameterNode> ptr(par = new T);
    //..par = ptr.get();
    _deleter.push_back(ptr);
  }
  return LoadParameterList(par, key, registerme);
}

template<class T> inline 
bool ConfigHandler::LoadParameterList(T* par,
                                      std::string key,
                                      bool registerme)
{
  bool err=1;
  if(key == "")
    key = par->GetDefaultKey();
  if(registerme)
    RegisterParameter(key, *par);
  if(_saved_cfg != "")
    err = !(par->ReadFromFile(_saved_cfg.c_str(), key, true));
  return err;
}

#endif