ComLine.H

Go to the documentation of this file.

#ifndef _COMLINE_H_
#define _COMLINE_H_
#include <string>
#include <vector>
#include <map>
#include <istream>
#include <ostream>
#include <utility>
#include <sstream>


namespace ix { 

  namespace util {

    class ComLineObject : public std::vector< std::pair<char,std::string> >
    {
      friend std::ostream &operator<<(std::ostream &Out,const ComLineObject &cl);
      friend std::istream &operator>>(std::istream &In,ComLineObject &cl);
    protected:
      std::string _description; 
      std::string _notes;
      std::string _program_name; 
      std::string _line;         
      std::vector<std::string> _error_messages; 
      std::vector<std::string> _nonops; 
      std::map<char,std::string> _options;
      std::map<char,std::string> _help;     
      std::map<char,std::string> _argname;
      std::map<char,int> _type;       
      std::vector<std::pair<std::string,int> > _args;
      std::map<std::string,std::string> _arghelp;
      std::vector<std::string> _toks;
    public:
      ComLineObject(){};
      ComLineObject(const char *args[])
      {
        Record(args);
      };
      ComLineObject(ComLineObject &incom);
      void Copy(ComLineObject &incom);
      int ProcessCommandLine(const char *args[])
      {
        Record(args);
        return(ProcessOptions());
      };
      std::string GetRawComLine() const { return (_program_name+std::string(" ")+_line);};
      void SetRawComLine(const std::string &incl);
      int ProcessOptions();
      void Record(const char *args[]);
      void AddOption(char s,const std::string &l,int = 0);
      void AddOption(char s,const std::string &l,int,const std::string argname);
      void AddArgument(const std::string &a,int reqd = 0)
      {
        //_args.push_back(std::make_pair<std::string,int>(a,reqd));
        _args.push_back(std::make_pair(a,reqd));
      };
      void AddArgHelp(const std::string &a,const std::string &help)
      {
        _arghelp[a] = help;
      };
      void SetArgName(const std::string opstr,const std::string argname)
      {
        _argname[GetShort(opstr)] = argname;
      };
      void SetArgName(char s,const std::string &argname)
      {
        _argname[s] = argname;
      };
      void AddHelp(char s,const std::string &help){ _help[s] = help;};
      void AddHelp(const std::string &l,const std::string &help)
      {
        _help[GetShort(l)] = help;
      };
      std::string GetOpStringByType(int mintype,int maxtype); 
      std::string GetHelp(char s){return(_help[s]);};
      std::string GetHelp(const std::string &l){return(_help[GetShort(l)]);};
      char GetShort(const std::string &l);
      std::string GetLong(const char &s);
      std::string ShortUsage();
      std::string LongUsage();
      std::string GetOption(const char &s){return(_options[s]);};
      std::string GetOption(const std::string &l){return(_options[GetShort(l)]);};
      std::string ErrorReport();
      std::string ProgramName() const { return _program_name;};
      std::vector<std::string> GetArgs() const { return _nonops;};
      void SetDescription(const std::string &desc){ _description.assign(desc); };
      void SetNotes(const std::string &notes){ _notes.assign(notes); };
      void WriteRC(std::ostream &Ostr) const;
      void ReadRC(const std::string &RCString);
      template<typename NumType>
      void ProcessRange(NumType &t1,NumType &t2,const std::string stinter)
      {
        if(!stinter.empty()){
          std::string::size_type x = stinter.find(":");
          std::string t1s = stinter;
          std::string t2s = stinter;
          if(x != std::string::npos){
            t1s = stinter.substr(0,x);
            t2s = stinter.substr(x+1);
            if(!t2s.empty()){
              std::istringstream Istr(t2s);
              Istr >> t2;
            }
          }
          else {
            t1s.erase();
          }
          if(!t1s.empty()){
            std::istringstream Istr(t1s);
            Istr >> t1;
          }
          if(!t2s.empty()){
            std::istringstream Istr(t2s);
            Istr >> t2;
          }
  
        }
      };
      template<typename NumType>
      void ResolveOption(NumType &t2,const std::string stinter)
      {
        if(stinter == ".true." || stinter == ".TRUE."){
          t2 = 1;
          return;
        }
        if(stinter == ".false." || stinter == ".FALSE."){
          t2 = 0;
          return;
        }
        if(!stinter.empty()){
          std::istringstream Istr(stinter);
          Istr >> t2;
        }
      };
      virtual void Initialize(void){};
      virtual void UserInitialize(void){};

      virtual ~ComLineObject(){};
    };
  };
};
#endif