argstream.h

Go to the documentation of this file.

/* Copyright (C) 2004 Xavier Décoret <Xavier.Decoret@imag.fr>
*
 * argsteam is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * Foobar is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with Foobar; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 */

#ifndef ARGSTREAM_H
#define ARGSTREAM_H


#include <string>
#include <list>
#include <deque>
#include <map>
#include <stdexcept>
#include <sstream>
#include <iostream> 
#include <cstdlib>

namespace 
{
  class argstream;

  template<class T>
  class ValueHolder;
  
  template <typename T>
  argstream& operator>> (argstream&, const ValueHolder<T>&);
  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  // Interface of ValueHolder<T>
  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  template<class T>
  class ValueHolder
  {
  public:
    ValueHolder(char s,
                const char* l,
                T& b,
                const char* desc,
                bool mandatory);
    ValueHolder(const char* l,
                T& b,
                const char* desc,
                bool mandatory);
    ValueHolder(char s,
                T& b,
                const char* desc,
                bool mandatory);
    friend argstream& operator>><>(argstream& s,const ValueHolder<T>& v);
    std::string name() const;
    std::string description() const;
  private:
    std::string shortName_;
    std::string longName_;
    T*          value_;
    T           initialValue_;
    std::string description_;  
    bool        mandatory_;
  };
  template <class T>
  inline ValueHolder<T>
  parameter(char s,
            const char* l,
            T& b,
            const char* desc="",
            bool mandatory = true)
  {
    return ValueHolder<T>(s,l,b,desc,mandatory);
  }
  template <class T>
  inline ValueHolder<T>
  parameter(char s,
            T& b,
            const char* desc="",
            bool mandatory = true)
  {
    return ValueHolder<T>(s,b,desc,mandatory);
  }
  template <class T>
  inline ValueHolder<T>
  parameter(const char* l,
            T& b,
            const char* desc="",
            bool mandatory = true)
  {
    return ValueHolder<T>(l,b,desc,mandatory);
  }
  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  // Interface of OptionHolder
  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  class OptionHolder
  {
  public:
    inline OptionHolder(char s,
                        const char* l,
                        bool& b,
                        const char* desc);
    inline OptionHolder(const char* l,
                        bool& b,
                        const char* desc);
    inline OptionHolder(char s,
                        bool& b,
                        const char* desc);
    friend argstream& operator>>(argstream& s,const OptionHolder& v);
    inline std::string name() const;
    inline std::string description() const;
  protected:
    inline OptionHolder(char s,
                        const char* l,
                        const char* desc);  
    friend OptionHolder help(char s='h',
                             const char* l="help",
                             const char* desc="Display this help");
  private:
    std::string shortName_;
    std::string longName_;
    bool*       value_;
    std::string description_;  
  };
  inline OptionHolder
  option(char s,
         const char* l,
         bool& b,
         const char* desc="")
  {
    return OptionHolder(s,l,b,desc);
  }
  inline OptionHolder
  option(char s,
         bool& b,
         const char* desc="")
  {
    return OptionHolder(s,b,desc);
  }
  inline OptionHolder
  option(const char* l,
         bool& b,
         const char* desc="")
  {
    return OptionHolder(l,b,desc);
  }
  inline OptionHolder
  help(char s,
       const char* l,
       const char* desc)
  {
    return OptionHolder(s,l,desc);
  }
  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  // Interface of ValuesHolder
  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  template<class T,class O>
  class ValuesHolder
  {
  public:
    ValuesHolder(const O& o,
                 const char* desc,
                 int len);
    friend argstream& operator>><>(argstream& s,const ValuesHolder<T,O>& v);
    std::string name() const;
    std::string description() const;
    typedef T value_type;
  private:
    mutable O   value_;
    std::string description_;  
    int         len_;
    char        letter_;
  };
  template<class T,class O>
  inline ValuesHolder<T,O>
  values(const O& o,
         const char* desc="",
         int len=-1)
  {
    return ValuesHolder<T,O>(o,desc,len);
  }
  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  // Interface of ValueParser
  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  template <class T>
  class ValueParser
  {
  public:
    inline T operator()(const std::string& s) const
      {
        std::istringstream is(s);
        T t;
        is>>t;
        return t;
      }
  };
  // We need to specialize for string otherwise parsing of a value that
  // contains space (for example a string with space passed in quotes on the
  // command line) would parse only the first element of the value!!!
  template <>
  class ValueParser<std::string>
  {
  public:
    inline std::string operator()(const std::string& s) const
      {
        return s;
      }
  };  
  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  // Interface of argstream
  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  class argstream
  {
  public:
    inline argstream(int argc,char** argv);
    inline argstream(const char* c);
    template<class T>
    friend argstream& operator>>(argstream& s,const ValueHolder<T>& v);
    friend inline argstream& operator>>(argstream& s,const OptionHolder& v);
    template<class T,class O>
    friend argstream& operator>>(argstream& s,const ValuesHolder<T,O>& v);

    inline bool helpRequested() const;
    inline bool isOk() const;
    inline std::string errorLog() const;
    inline std::string usage() const;
    inline void defaultErrorHandling(bool ignoreUnused=false) const;
    static inline char uniqueLetter();
  protected:
    void parse(int argc,char** argv);
  private:
    typedef std::list<std::string>::iterator value_iterator;
    typedef std::pair<std::string,std::string> help_entry;
    std::string                          progName_;
    std::map<std::string,value_iterator> options_;
    std::list<std::string>               values_;
    bool                                 minusActive_;
    bool                                 isOk_;
    std::deque<help_entry>               argHelps_;
    std::string                          cmdLine_;
    std::deque<std::string>              errors_;
    bool                                 helpRequested_;
  };
  //************************************************************
  // Implementation of ValueHolder<T>
  //************************************************************
  template<class T>
  ValueHolder<T>::ValueHolder(char s,
                              const char* l,
                              T& v,
                              const char* desc,
                              bool mandatory)
    :  shortName_(1,s),
       longName_(l),
       value_(&v),
       initialValue_(v),
       description_(desc),
       mandatory_(mandatory)
  {
  }
  template<class T>
  ValueHolder<T>::ValueHolder(const char* l,
                              T& v,
                              const char* desc,
                              bool mandatory)
    :  longName_(l),
       value_(&v),
       initialValue_(v),
       description_(desc),
       mandatory_(mandatory)
  {
  }
  template<class T>
  ValueHolder<T>::ValueHolder(char s,
                              T& v,
                              const char* desc,
                              bool mandatory)
    :  shortName_(1,s),
       value_(&v),
       initialValue_(v),
       description_(desc),
       mandatory_(mandatory)
  {
  }
  template<class T>
  std::string
  ValueHolder<T>::name() const
  {
    std::ostringstream  os;
    if (!shortName_.empty()) os<<'-'<<shortName_;
    if (!longName_.empty()) {      
      if (!shortName_.empty()) os<<'/';
      os<<"--"<<longName_;
    }
    return os.str();
  }
  template<class T>
  std::string
  ValueHolder<T>::description() const
  {
    std::ostringstream  os;  
    os<<description_;
    if (mandatory_)
    {
      os<<"(mandatory)";
    }
    else
    {
      os<<"(default="<<initialValue_<<")";
    }
    return os.str();
  }
  //************************************************************
  // Implementation of OptionHolder
  //************************************************************
  inline OptionHolder::OptionHolder(char s,
                                    const char* l,
                                    bool& b,
                                    const char* desc)
    : shortName_(1,s),
      longName_(l),
      value_(&b),
      description_(desc)
  {
  }
  inline OptionHolder::OptionHolder(const char* l,
                                    bool& b,
                                    const char* desc)
    : longName_(l),
      value_(&b),
      description_(desc)
  {
  }
  inline OptionHolder::OptionHolder(char s,
                                    bool& b,
                                    const char* desc)
    : shortName_(1,s),
      value_(&b),
      description_(desc)
  {
  }
  inline OptionHolder::OptionHolder(char s,
                                    const char* l,
                                    const char* desc)
    : shortName_(1,s),
      longName_(l),
      value_(NULL),
      description_(desc)
  {
  }
  inline std::string
  OptionHolder::name() const
  {
    std::ostringstream  os;
    if (!shortName_.empty()) os<<'-'<<shortName_;
    if (!longName_.empty())
    {
      if (!shortName_.empty()) os<<'/';
      os<<"--"<<longName_;
    }
    return os.str();
  }
  inline std::string
  OptionHolder::description() const
  {
    return description_;
  }
  //************************************************************
  // Implementation of ValuesHolder<T,O>
  //************************************************************
  template<class T,class O>
  ValuesHolder<T,O>::ValuesHolder(const O& o,
                                  const char* desc,
                                  int len)
    : value_(o),
      description_(desc),
      len_(len)
  {
    letter_ = argstream::uniqueLetter();
  }
  template <class T,class O>
  std::string
  ValuesHolder<T,O>::name() const
  {
    std::ostringstream  os;
    os<<letter_<<"i";
    return os.str();
  }
  template <class T,class O>
  std::string
  ValuesHolder<T,O>::description() const
  {
    return description_;
  }
  //************************************************************
  // Implementation of argstream
  //************************************************************
  inline
  argstream::argstream(int argc,char** argv)
    : progName_(argv[0]),
      minusActive_(true),
      isOk_(true)
  {
    parse(argc,argv);
  }
  inline
  argstream::argstream(const char* c)
    : progName_(""),
      minusActive_(true),
      isOk_(true)
  {
    std::string s(c);
    // Build argc, argv from s. We must add a dummy first element for
    // progName because parse() expects it!!
    std::deque<std::string> args;
    args.push_back("");
    std::istringstream is(s);
    while (is.good())
    {
      std::string t;
      is>>t;
      args.push_back(t);
    }
    char* pargs[args.size()];
    char** p = pargs;
    for (std::deque<std::string>::const_iterator
           iter = args.begin();
         iter != args.end();++iter)
    {
      *p++ = const_cast<char*>(iter->c_str());
    }
    parse(args.size(),pargs);
  }
  inline void
  argstream::parse(int argc,char** argv)
  {
    // Run thru all arguments.
    // * it has -- in front : it is a long name option, if remainder is empty,
    //                        it is an error
    // * it has - in front  : it is a sequence of short name options, if
    //                        remainder is empty, deactivates option (- will
    //                        now be considered a char).
    // * if any other char, or if option was deactivated
    //                      : it is a value. Values are split in parameters
    //                      (immediately follow an option) and pure values.
    // Each time a value is parsed, if the previously parsed argument was an
    // option, then the option is linked to the value in case of it is a
    // option with parameter.  The subtle point is that when several options
    // are given with short names (ex: -abc equivalent to -a -b -c), the last
    // parsed option is -c).
    // Since we use map for option, any successive call overides the previous
    // one: foo -a -b -a hello is equivalent to foo -b -a hello
    // For values it is not true since we might have several times the same
    // value. 
    value_iterator* lastOption = NULL;
    for (char** a = argv,**astop=a+argc;++a!=astop;)
    {
      std::string s(*a);
      if (minusActive_ && s[0] == '-')
      {
        if (s.size() > 1 && s[1] == '-')
        {
          if (s.size() == 2)
          {
            minusActive_ = false;
            continue;
          }
          lastOption = &(options_[s.substr(2)] = values_.end());
        }
        else 
        {
          if (s.size() > 1)
          {
            // Parse all chars, if it is a minus we have an error
            for (std::string::const_iterator cter = s.begin();
                 ++cter != s.end();)
            {
              if (*cter == '-')
              {
                isOk_ = false;
                std::ostringstream os;
                os<<"- in the middle of a switch "<<a;
                errors_.push_back(os.str());
                break;
              }
              lastOption = &(options_[std::string(1,*cter)] = values_.end());
            }
          }
          else
          {
            isOk_ = false;
            errors_.push_back("Invalid argument -");
            break;
          }
        }
      }
      else
      {
        values_.push_back(s);
        if (lastOption != NULL)
        {
          *lastOption = --values_.end();
        }
        lastOption = NULL;
      }
    }
#ifdef ARGSTREAM_DEBUG
    for (std::map<std::string,value_iterator>::const_iterator
           iter = options_.begin();iter != options_.end();++iter)
    {
      std::cout<<"DEBUG: option "<<iter->first;
      if (iter->second != values_.end())
      {
        std::cout<<" -> "<<*(iter->second);
      }
      std::cout<<std::endl;
    }
    for (std::list<std::string>::const_iterator
           iter = values_.begin();iter != values_.end();++iter)
    {
      std::cout<<"DEBUG: value  "<<*iter<<std::endl;
    }
#endif // ARGSTREAM_DEBUG
  }
  inline bool
  argstream::isOk() const
  {
    return isOk_;
  }
  inline bool
  argstream::helpRequested() const
  {
    return helpRequested_;
  }
  inline std::string
  argstream::usage() const
  {
    std::ostringstream os;
    os<<"usage: "<<progName_<<cmdLine_<<'\n';
    unsigned int lmax = 0;
    for (std::deque<help_entry>::const_iterator
           iter = argHelps_.begin();iter != argHelps_.end();++iter)
    {
      if (lmax<iter->first.size()) lmax = iter->first.size();
    }  
    for (std::deque<help_entry>::const_iterator
           iter = argHelps_.begin();iter != argHelps_.end();++iter)
    {
      os<<'\t'<<iter->first<<std::string(lmax-iter->first.size(),' ')
        <<" : "<<iter->second<<'\n';
    }
    return os.str();
  }
  inline std::string
  argstream::errorLog() const
  {
    std::string s;
    for(std::deque<std::string>::const_iterator iter = errors_.begin();
        iter != errors_.end();++iter)
    {
      s += *iter;
      s += '\n';
    }
    return s;
  }
  inline char
  argstream::uniqueLetter()
  {
    static unsigned int c = 'a';
    return c++;
  }
  template<class T>
  argstream&
  operator>>(argstream& s,const ValueHolder<T>& v)
  {
    // Search in the options if there is any such option defined either with a
    // short name or a long name. If both are found, only the last one is
    // used.
#ifdef ARGSTREAM_DEBUG    
    std::cout<<"DEBUG: searching "<<v.shortName_<<" "<<v.longName_<<std::endl;
#endif    
    s.argHelps_.push_back(argstream::help_entry(v.name(),v.description()));
    if (v.mandatory_)
    {
      if (!v.shortName_.empty())
      {
        s.cmdLine_ += " -";
        s.cmdLine_ += v.shortName_;
      }
      else
      {
        s.cmdLine_ += " --";
        s.cmdLine_ += v.longName_;
      }
      s.cmdLine_ += " value";
    }
    else
    {
      if (!v.shortName_.empty())
      {
        s.cmdLine_ += " [-";
        s.cmdLine_ += v.shortName_;
      }
      else
      {
        s.cmdLine_ += " [--";
        s.cmdLine_ += v.longName_;
      }  
      s.cmdLine_ += " value]";

    }
    std::map<std::string,argstream::value_iterator>::iterator iter =
      s.options_.find(v.shortName_);
    if (iter == s.options_.end())
    {
      iter = s.options_.find(v.longName_);
    }
    if (iter != s.options_.end())
    {
      // If we find counterpart for value holder on command line, either it
      // has an associated value in which case we assign it, or it has not, in
      // which case we have an error.
      if (iter->second != s.values_.end())
      {
#ifdef ARGSTREAM_DEBUG
        std::cout<<"DEBUG: found value "<<*(iter->second)<<std::endl;
#endif  
        ValueParser<T> p;
        *(v.value_) = p(*(iter->second));
        // The option and its associated value are removed, the subtle thing
        // is that someother options might have this associated value too,
        // which we must invalidate.
        s.values_.erase(iter->second);      
        for (std::map<std::string,argstream::value_iterator>::iterator
               jter = s.options_.begin();jter != s.options_.end();++jter)
        {
          if (jter->second == iter->second)
          {
            jter->second = s.values_.end();
          }
        }
        s.options_.erase(iter);
      }
      else
      {
        s.isOk_ = false;
        std::ostringstream  os;
        os<<"No value following switch "<<iter->first
          <<" on command line";
        s.errors_.push_back(os.str());
      }
    }
    else
    {
      if (v.mandatory_)
      {
        s.isOk_ = false;
        std::ostringstream  os;
        os<<"Mandatory parameter ";
        if (!v.shortName_.empty()) os<<'-'<<v.shortName_;
        if (!v.longName_.empty())
        {
          if (!v.shortName_.empty()) os<<'/';
          os<<"--"<<v.longName_;
        }
        os<<" missing";
        s.errors_.push_back(os.str());
      }
    }
    return s;
  }
  inline argstream&
  operator>>(argstream& s,const OptionHolder& v)
  {
    // Search in the options if there is any such option defined either with a
    // short name or a long name. If both are found, only the last one is
    // used.
#ifdef ARGSTREAM_DEBUG    
    std::cout<<"DEBUG: searching "<<v.shortName_<<" "<<v.longName_<<std::endl;
#endif
    s.argHelps_.push_back(argstream::help_entry(v.name(),v.description()));
    {
      std::string c;
      if (!v.shortName_.empty())
      {
        c += " [-";
        c += v.shortName_;
      }
      else
      {
        c += " [--";
        c += v.longName_;
      }      
      c += "]";
      s.cmdLine_ = c+s.cmdLine_;
    }
    std::map<std::string,argstream::value_iterator>::iterator iter =
      s.options_.find(v.shortName_);
    if (iter == s.options_.end())
    {
      iter = s.options_.find(v.longName_);
    }
    if (iter != s.options_.end())
    {
      // If we find counterpart for value holder on command line then the
      // option is true and if an associated value was found, it is ignored
      if (v.value_ != NULL)
      {
        *(v.value_) = true;
      }
      else
      {
        s.helpRequested_ = true;
      }
      // The option only is removed
      s.options_.erase(iter);
    }
    else
    {
      if (v.value_ != NULL)
      {
        *(v.value_) = false;
      }
      else
      {
        s.helpRequested_ = false;
      }
    }
    return s;
  }
  template<class T,class O>
  argstream&
  operator>>(argstream& s,const ValuesHolder<T,O>& v)
  {
    s.argHelps_.push_back(argstream::help_entry(v.name(),v.description()));
    {
      std::ostringstream os;
      os<<' '<<v.letter_<<'1';
      switch (v.len_)
      {
      case -1:
        os<<"...";
        break;
      case 1:
        break;
      default:
        os<<"..."<<v.letter_<<v.len_;
        break;
      }
      s.cmdLine_ += os.str();
    }
    std::list<std::string>::iterator first = s.values_.begin();
    // We add to the iterator as much values as we can, limited to the length
    // specified (if different of -1)
    int n = v.len_ != -1?v.len_:s.values_.size();
    while (first != s.values_.end() && n-->0)
    {
      // Read the value from the string *first
      ValueParser<T> p;
      *(v.value_++) = p(*first );
      s.argHelps_.push_back(argstream::help_entry(v.name(),v.description()));
      // The value we just removed was maybe "remembered" by an option so we
      // remove it now.
      for (std::map<std::string,argstream::value_iterator>::iterator
             jter = s.options_.begin();jter != s.options_.end();++jter)
      {
        if (jter->second == first)
        {
          jter->second = s.values_.end();
        }
      }
      ++first;
    }
    // Check if we have enough values
    if (n != 0)
    {
      s.isOk_ = false;
      std::ostringstream  os;
      os<<"Expecting "<<v.len_<<" values";
      s.errors_.push_back(os.str());
    }
    // Erase the values parsed
    s.values_.erase(s.values_.begin(),first);
    return s;
  }
  inline void
  argstream::defaultErrorHandling(bool ignoreUnused) const
  {
    if (helpRequested_)
    {
      std::cout<<usage();
      exit(1);
    }
    if (!isOk_)
    {
      std::cerr<<errorLog();
      exit(1);
    }
    if (!ignoreUnused &&
        (!values_.empty() || !options_.empty()))
    {
      std::cerr<<"Unused arguments"<<std::endl;
      exit(1);
    }
  }
};
#endif // ARGSTREAM_H

---