parsecl.hpp

Go to the documentation of this file.

#ifndef _PARSECL_H
#define _PARSECL_H

#include <list>
#include <vector>
#include <cstring>
#include <string>
#include <iostream>
#include <sstream>
#include <typeinfo>

namespace Arak {

  namespace Util {

    class CommandLine {

    public:

      class Option {

  friend class CommandLine;

      protected:

  const char* sflag;

  const char* lflag;

  const char* desc;

  bool _supplied;

  const bool required;

  bool matches(const char* flag) const {
    int len = strlen(flag);
    return ((strncmp(flag, sflag, len) == 0) ||
      (strncmp(flag, lflag, len) == 0));
  }

  virtual bool read(const char* str) {
    return false;
  }

  virtual void printUsage(std::ostream& out) const {
    out << "  " 
        << sflag << "|" 
        << lflag << " : " 
        << desc;
  }

      public:

  Option(const char* sflag, const char* lflag, const char* desc,
         bool required = false) 
    : sflag(sflag), lflag(lflag), desc(desc),
      _supplied(false), required(false) { }

  virtual ~Option() { } 

  virtual bool supplied() const { return _supplied; }

  virtual bool hasArg() { return false; }
  
      };

      template <class T>
      class Parameter : public Option {

  friend class CommandLine;

      private:

  T val;

  virtual void printUsage(std::ostream& out) const {
    out << "  " 
        << sflag << "|" 
        << lflag << " <" 
        << typeid(val).name() << "> : " 
        << desc;
  }

      protected:

  virtual bool read(const char* str) {
    std::string string(str);
    std::istringstream in(string);
    in >> val;
    return !in.bad();
  }

      public:

  Parameter(const char* sflag, 
      const char* lflag, 
      const char* desc,
      const T& def,
      bool required = false) 
    : Option(sflag, lflag, desc, required), val(def) { }

  virtual ~Parameter() { }  

  const T& value() const { return val; }

  virtual bool hasArg() { return true; }
  
      }; // end of class: CommandLine::Parameter

      template <class T>
      class MultiParameter : public Option {

  friend class CommandLine;

      private:

  std::vector<T> vals;

  virtual void printUsage(std::ostream& out) const {
    T t;
    out << "  " 
        << sflag << "|" 
        << lflag << " <" 
        << typeid(t).name() << "> : " 
        << desc;
  }

      protected:

  virtual bool read(const char* str) {
    std::string string(str);
    std::istringstream in(string);
    T val;
    in >> val;
    vals.push_back(val);
    return !in.bad();
  }

      public:

  MultiParameter(const char* sflag, 
           const char* lflag, 
           const char* desc) 
    : Option(sflag, lflag, desc, false), vals() { }

  virtual ~MultiParameter() { } 

  const std::vector<T>& values() const { return vals; }

  virtual bool hasArg() { return true; }
  
      };

    protected:
      
      const char* name;

      std::list<Option*> options;

    public:

      CommandLine() : name(""), options() { }

      ~CommandLine() { }
      
      bool parse(int argc, char** argv, std::ostream& err) {
  typedef std::list<Option*> OptionList;
  name = argv[0];
  for (int i = 1; i < argc; i++) {
    const char* flag = argv[i];
    // Search for a unique match to the flag.
    Option* match = NULL;
    for (OptionList::const_iterator it = options.begin();
         it != options.end(); it++) {
      Option* opt = *it;
      if (opt->matches(flag)) {
        if (match != NULL) {
    err << "error: ambiguous flag: " << flag << std::endl;
    return false;
        }
        match = opt;
      }
    }
    // Make sure there is a match.
    if (match == NULL) {
      err << "error: unrecognized flag: " << flag << std::endl;
      return false;
    }
    // Parse the flag.
    match->_supplied = true;
    if (match->hasArg()) {
      i++;
      const char* arg = argv[i];
      if (!(match->read(arg))) {
        err << "error: cannot parse value " << arg 
      << " for flag " << flag << std::endl;
        return false;
      }
    }
  }
  // Check that all required options have been supplied.
  for (OptionList::const_iterator it = options.begin();
       it != options.end(); it++) {
    Option* opt = *it;
    if (opt->required && !(opt->_supplied)) {
      err << "error: required flag " << opt->sflag
    << " not supplied" << std::endl;
      return false;
    }
  }
  return true;
      }

      void printUsage(std::ostream& out) const {
  out << name << std::endl;
  typedef std::list<Option*> OptionList;
  for (OptionList::const_iterator it = options.begin();
       it != options.end(); it++) {
    Option* opt = *it;
    opt->printUsage(out);
    out << std::endl;
  }
      }

      void add(Option& opt) {
  options.push_front(&opt);
      }

    }; // end of class: CommmandLine

  } // end of namespace: Arak::Util

} // end of namespace: Arak

#endif

---