Changeset 1486


Ignore:
Timestamp:
08/10/08 22:51:34 (6 years ago)
Author:
wehart
Message:

Fixes to OptionParser? to get it working with POSIX style options.

Added a hook to a generic word-wraping output, which still needs to be flushed
out.

Location:
utilib/trunk/src/io/utilib
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • utilib/trunk/src/io/utilib/OptionParser.h

    r1485 r1486  
    44#include <list> 
    55#include <utility> 
     6#include <utilib/string_ops.h> 
    67#include <utilib/ParameterSet.h> 
    7  
    8 namespace utilib { 
     8#include <utilib/ParameterList.h> 
     9 
     10namespace utilib 
     11{ 
    912 
    1013/// 
     
    1619public: 
    1720 
    18   typedef std::list<std::string> arg_t; 
    19  
    20   /// Constructor 
    21   OptionParser(const char* _usage=0, const char* _description=0) 
    22         { 
    23         if (_usage != 0) 
    24            usage=_usage; 
    25          if (_description != 0) 
    26            description=_description; 
    27         } 
    28  
    29   /// TODO: add() method for POSIX arguments 
    30  
    31   /// 
    32   template <class T> 
    33   void add_long(const std::string& name, T& data, const std::string& description) 
    34     { 
    35     std::ostringstream buf; 
    36     buf << data; 
    37     pnames.push_back(name); 
    38     params.create_parameter(name,data,typeid(data).name(),buf.str(),description); 
    39     } 
    40  
    41   /// 
    42   void write(std::ostream& os) const; 
    43  
    44   /// 
    45   std::string usage; 
    46  
    47   /// 
    48   std::string description; 
    49  
    50   /// 
    51   void add_argument(const std::string& name, const std::string& description) 
    52         { 
    53         arg_definitions.push_back( std::pair<std::string,std::string>(name,description) ); 
    54         } 
    55  
    56   /// 
    57   arg_t& parse_args(int argc, char** argv); 
    58  
    59   /// 
    60   arg_t& args() 
    61         { return processed_args; } 
    62  
    63   /// 
    64   const arg_t& args() const 
    65         { return processed_args; } 
     21   typedef std::list<std::string> arg_t; 
     22 
     23   /// Constructor 
     24   OptionParser(const char* _usage = 0, const char* _description = 0) 
     25   { 
     26      if (_usage != 0) 
     27         usage = _usage; 
     28      if (_description != 0) 
     29         description = _description; 
     30   } 
     31 
     32   /// 
     33   template <class T> 
     34   void add(const std::string& long_name, const char& short_name, T& data, const std::string& description) 
     35   { 
     36      std::ostringstream buf; 
     37      buf << data; 
     38      if (long_name != "") 
     39      { 
     40         long_names.push_back(long_name); 
     41         params.create_parameter(long_name, data, typeid(data).name(), 
     42                                 buf.str(), description); 
     43      } 
     44      else 
     45      { 
     46         std::string tmp; 
     47         tmp = "_"; 
     48         tmp += short_name; 
     49         tmp += "_posix"; 
     50         long_names.push_back(tmp); 
     51         params.create_parameter(tmp, data, typeid(data).name(), 
     52                                 buf.str(), description); 
     53         std::string alias; 
     54         alias = short_name; 
     55         params.alias_parameter(tmp, alias); 
     56      } 
     57      short_names.push_back(short_name); 
     58   } 
     59 
     60   /// 
     61   template <class T> 
     62   void add(const char& short_name, const std::string& long_name, T& data, const std::string& description) 
     63   { 
     64    add(long_name,short_name,data,description); 
     65}     
     66 
     67   /// 
     68   template <class T> 
     69   void add(const char& short_name, T& data, const std::string& description) 
     70   { 
     71      std::string tmp = ""; 
     72      add(tmp, short_name, data, description); 
     73   } 
     74 
     75   /// 
     76   template <class T> 
     77   void add(const std::string& long_name, T& data, const std::string& description) 
     78   { 
     79      char tmp = 0; 
     80      add(long_name, tmp, data, description); 
     81   } 
     82 
     83   /// 
     84   void write(std::ostream& os) const; 
     85 
     86   /// 
     87   std::string usage; 
     88 
     89   /// 
     90   std::string description; 
     91 
     92   /// 
     93   void add_argument(const std::string& name, const std::string& description) 
     94   { 
     95      arg_definitions.push_back(std::pair<std::string, std::string>(name, description)); 
     96   } 
     97 
     98   /// 
     99   arg_t& parse_args(int argc, char** argv); 
     100 
     101   /// 
     102   arg_t& args() 
     103   { return processed_args; } 
     104 
     105   /// 
     106   const arg_t& args() const 
     107      { return processed_args; } 
    66108 
    67109protected: 
    68110 
    69   /// 
    70   ParameterSet params; 
    71  
    72   /// 
    73   std::list<std::string> pnames; 
    74  
    75   /// 
    76   std::list< std::pair<std::string,std::string> > arg_definitions; 
    77  
    78   /// 
    79   arg_t processed_args; 
     111   /// 
     112   ParameterSet params; 
     113 
     114   /// 
     115   std::list<std::string> long_names; 
     116 
     117   /// 
     118   std::list<char> short_names; 
     119 
     120   /// 
     121   std::list< std::pair<std::string, std::string> > arg_definitions; 
     122 
     123   /// 
     124   arg_t processed_args; 
    80125 
    81126}; 
     
    85130inline void OptionParser::write(std::ostream& os) const 
    86131{ 
    87 os << "Usage: " << usage << std::endl; 
    88 os << description << std::endl; 
    89 os << std::endl; 
    90 os << "options:" << std::endl; 
    91 { 
    92 std::list<std::string>::const_iterator curr = pnames.begin(); 
    93 std::list<std::string>::const_iterator end  = pnames.end(); 
    94 while (curr != end) { 
    95   const Parameter pinfo = params.get_raw_info(*curr); 
    96   std::ostringstream tmp; 
    97   tmp << "     --" << *curr; 
    98   os << tmp.str(); 
    99   int tmplen=strlen(tmp.str().c_str()); 
    100   if (tmplen < 30) { 
    101      for (int i=tmplen; i<30; i++) 
    102        os << " "; 
    103      os << pinfo.description << std::endl; 
    104   } 
    105   else  
    106      os << "                " << pinfo.description << std::endl; 
    107   curr++; 
    108   } 
     132   os << "Usage: " << usage << std::endl; 
     133   os << description << std::endl; 
     134   os << std::endl; 
     135   os << "options:" << std::endl; 
     136   { 
     137      std::list<std::string>::const_iterator curr = long_names.begin(); 
     138      std::list<std::string>::const_iterator end  = long_names.end(); 
     139      std::list<char>::const_iterator scurr = short_names.begin(); 
     140      while (curr != end) 
     141      { 
     142         const Parameter pinfo = params.get_raw_info(*curr); 
     143         std::ostringstream tmp; 
     144         char sname = *scurr; 
     145         if (sname == (char)0) 
     146            tmp << "    "; 
     147         else 
     148            tmp << "  -" << sname; 
     149         if ((*curr)[0] != '_') { 
     150            if (sname == (char)0) 
     151               tmp << "  --" << *curr; 
     152            else 
     153               tmp << ", --" << *curr; 
     154         } 
     155         const char* cstr = tmp.str().c_str(); 
     156         int tmplen = strlen(cstr); 
     157         if (tmplen < 30) 
     158         { 
     159            std::string line; 
     160            line = cstr; 
     161            for (int i = tmplen; i < 30; i++) 
     162               line += " "; 
     163            line += pinfo.description; 
     164            wordwrap_printing(os,line, "                              "); 
     165         } 
     166         else { 
     167            os << cstr << std::endl; 
     168            wordwrap_printing(os,pinfo.description, "                              "); 
     169         } 
     170         curr++; 
     171         scurr++; 
     172      } 
     173   } 
     174   os << std::endl; 
     175   os << "arguments:" << std::endl; 
     176   { 
     177      std::list<std::pair<std::string, std::string> >::const_iterator curr = arg_definitions.begin(); 
     178      std::list<std::pair<std::string, std::string> >::const_iterator end  = arg_definitions.end(); 
     179      while (curr != end) 
     180      { 
     181         os << "  " << curr->first << "\t" << curr->second << std::endl; 
     182         curr++; 
     183      } 
     184   } 
    109185} 
    110 os << std::endl; 
    111 os << "arguments:" << std::endl; 
    112 { 
    113 std::list<std::pair<std::string,std::string> >::const_iterator curr = arg_definitions.begin(); 
    114 std::list<std::pair<std::string,std::string> >::const_iterator end  = arg_definitions.end(); 
    115 while (curr != end) { 
    116     os << "    " << curr->first << "\t" << curr->second << std::endl; 
    117     curr++; 
    118   } 
     186 
     187 
     188 
     189inline OptionParser::arg_t& OptionParser::parse_args(int argc, char** argv) 
     190{ 
     191   ParameterList plist; 
     192   plist.process_parameters(argc, argv, 0); 
     193   plist.write_parameters(std::cout); 
     194   params.set_parameters(plist); 
     195   for (int i = 0; i < argc; i++) 
     196   { 
     197      processed_args.push_back(argv[i]); 
     198   } 
     199 
     200   return processed_args; 
    119201} 
     202 
     203 
    120204} 
    121  
    122  
    123  
    124 inline OptionParser::arg_t& OptionParser::parse_args(int argc, char** argv) 
    125 { 
    126 params.process_parameters(argc,argv); 
    127 for (int i=0; i<argc; i++) { 
    128   processed_args.push_back(argv[i]); 
    129   } 
    130  
    131 return processed_args; 
    132 } 
    133  
    134  
    135 } 
  • utilib/trunk/src/io/utilib/ParameterList.cpp

    r1420 r1486  
    1515 
    1616namespace utilib { 
     17 
     18  void ParameterList::add_posix_parameters(const std::string& label,  
     19                                    const std::string& value, 
     20                                    bool process_param) 
     21  { 
     22  std::string::const_iterator curr = label.begin(); 
     23  std::string::const_iterator end  = label.end(); 
     24  while (curr != end) { 
     25    std::string tmp; 
     26    tmp = *curr; 
     27    add_parameter(tmp,value,process_param); 
     28    curr++; 
     29    } 
     30  } 
    1731 
    1832  void ParameterList::add_parameter(const std::string& label,  
     
    149163  // 
    150164  int i=1; 
    151   while ((i < (argc-(int)min_num_required_args)) &&  
    152          ((argv[i][0] == '-') && (argv[i][1] == '-'))) { 
     165  while ((i < (argc-(int)min_num_required_args)) && (argv[i][0] == '-')) { 
    153166    // 
    154     // Process an argument 
     167    // Set tmp to the value of the argument 
    155168    // 
    156169    char* tmp = strchr(argv[i],'='); 
     
    158171    if (tmp && (*tmp != '\000')) { 
    159172      *(tmp-1) = '\000'; 
    160       add_parameter( &(argv[i][2]), tmp); 
     173      if (argv[i][1] == '-') 
     174         add_parameter( &(argv[i][2]), tmp); 
     175      else 
     176         add_posix_parameters( &(argv[i][1]), tmp); 
    161177      i += 1; 
    162178    } 
    163179    else if (tmp && (*tmp == '\000')) { 
    164180      *(tmp-1) = '\000'; 
    165       add_parameter( &(argv[i][2]), "true"); 
     181      if (argv[i][1] == '-') 
     182         add_parameter( &(argv[i][2]), "true"); 
     183      else 
     184         add_posix_parameters( &(argv[i][1]), "true"); 
    166185      i += 1; 
    167186    } 
    168187    else if ( ((i+1) == (argc-(int)min_num_required_args)) || 
    169               ((argv[i+1][0] == '-') && (argv[i+1][1] == '-'))) { 
     188              (argv[i+1][0] == '-')) { 
    170189      // 
    171190      // Implicitly true flag 
    172191      // Example: --flush --help 
    173192      // 
    174       add_parameter( &(argv[i][2]), "true"); 
     193      if (argv[i][1] == '-') 
     194         add_parameter( &(argv[i][2]), "true"); 
     195      else 
     196         add_posix_parameters( &(argv[i][1]), "true"); 
    175197      i++; 
    176198    } 
    177199    else { 
    178       add_parameter( &(argv[i][2]), &(argv[i+1][0]) ); 
     200      if (argv[i][1] == '-') 
     201         add_parameter( &(argv[i][2]), &(argv[i+1][0]) ); 
     202      else 
     203         add_posix_parameters( &(argv[i][1]), &(argv[i+1][0]) ); 
    179204      i += 2; 
    180205    } 
     
    191216  // Check to ensure that first 'required arg' does not look like a parameter 
    192217  // 
    193   if ((i < argc) && (argv[i][0] == '-') && (argv[i][1] == '-')) 
     218  if ((i < argc) && (argv[i][0] == '-')) 
    194219     EXCEPTION_MNGR(runtime_error, 
    195220                    "ParameterList::process_parameters " 
  • utilib/trunk/src/io/utilib/ParameterList.h

    r1188 r1486  
    9898                                bool process_param=true); 
    9999 
     100  /// Add posix parameters 
     101  void add_posix_parameters(const std::string& params, const std::string& value, 
     102                                bool process_param=true); 
     103 
    100104  /// Register a parameter 
    101105  void register_parameters(ParameterSet& pset); 
Note: See TracChangeset for help on using the changeset viewer.