Arguments.cpp

#include "Arguments.h"
#include "Sct/LogicErrors.h"
#include "Sct/SctNames.h"
#include <boost/lexical_cast.hpp>

namespace SctService {
  using std::string;
  using std::list;
  using std::endl;
  using Sct::InvalidArgumentError;
  using Sct::SctNames;

  Arguments::Arguments(int argc, char** argv) : 
    m_nworkers(1), m_recovery(false){
    m_list = makeList(argc,argv);
  }
  
  void Arguments::parse(){
    for (list<string>::iterator i=m_list.begin(); i!=m_list.end(); ++i){
      if (*i == "-help"){
    SctNames::Mrs() << "HELP_MESSAGE" << MRS_TEXT(printHelp()) << MRS_INFORMATION << ENDM; exit(1);     
      }else if (*i == "-recover"){
    m_recovery=true;
      } else if (*i == "-input"){
    string server=next(i);
    string regexp=next(i);
    m_input.push_back(Subscription(server,regexp));
      } else if (*i == "-name"){
    m_instanceName=next(i);
      } else if (*i == "-status"){
    m_status_name=next(i);
      } else if (*i == "-output"){
    m_output=next(i);
      } else if (*i == "-nworkers"){
    unsigned requested_workers=boost::lexical_cast<int>(next(i));
    m_nworkers=requested_workers;
    if (m_nworkers>MAX_WORKERS) {
      m_nworkers=MAX_WORKERS;
      std::cerr << "Number of workers requested (" << requested_workers
            << ") too large - limited to 10" << std::endl;
    }
      }
    }
  }
  
  string Arguments::next(list<string>::iterator& i) const{
    if (++i==m_list.end()) throw InvalidArgumentError(printHelp(), __FILE__, __LINE__);
    return *i;
  }

  list<string> Arguments::makeList(int argc, char** argv){
    list<std::string> theList;
    for (int i=1; i<argc; ++i){
      theList.push_back(argv[i]);
    }
    return theList;
  }

  std::string Arguments::printHelp() const{
    std::ostringstream oss;
    printHelp(oss);
    return oss.str();
  }

  std::string Arguments::print() const{
    std::ostringstream oss;
    print(oss);
    return oss.str();
  }
  
  Arguments::~Arguments(){}

  void Arguments::printHelp(std::ostream& oss) const{
    oss << "ServiceArguments:" << endl
    << "  -name <name>                   : name (in IPC) for this service" << endl
    << "  -status <name>                 : IS name to publish status information to" << endl
    << "  -nworkers <nworkers>           : number of worker threads" << endl
    << "  -recover (switch)              : try to do auto-recovery" << endl
    << "  -input <server name> <regexp>  : add IS server from which to receive data (can be used many times)" << endl
    << "  -output <server name>          : set IS server to write output data to" << endl
    << "  -help                          : print this help message" << endl;
  }

  void Arguments::print(std::ostream& oss) const{
    oss << "Initial arguments were: ";
    for (list<string>::const_iterator i=m_list.begin(); i!=m_list.end(); ++i){
      oss << " " << *i;
    }
    oss << endl;
  }
  unsigned Arguments::getNWorkers() const{
    return m_nworkers;
  }

  std::string Arguments::getOutputISServer() const{
    return m_output;
  }
  
  std::list<Arguments::Subscription> Arguments::getInputISServers() const{
    return m_input;
  }
  
  bool Arguments::recoveryMode() const{
    return m_recovery;
  }

  std::string Arguments::instanceName() const{
    return m_instanceName;
  }

  std::string Arguments::getISStatusName() const{
    return m_status_name;
  }

  void Arguments::setInstanceName(const std::string& n){
    m_instanceName=n;
  }

  void Arguments::setNWorkers(const unsigned n){
    m_nworkers=n;
  }

  void Arguments::setOutputISServer(const std::string &s){
    m_output=s;
  }

  void Arguments::setISStatusName(const std::string& s){
    m_status_name=s;
  }
  
  void Arguments::setRecoveryMode(const bool b){
    m_recovery=b;
  }

  Arguments::Subscription::Subscription(string server, string regexp) : 
    server (server), regexp(regexp)
  {
  }
}

---