simple_arg_parser.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/util/string.hpp>
#include <kernel/util/string_mapped.hpp>
 
// includes, system
#include <deque>
#include <map>
#include <utility>
 
namespace FEAT
{
  class SimpleArgParser
  {
  private:
    int _num_skipped_args;
    std::deque<String> _args;
    std::map<String, std::pair<int, std::deque<String> > > _opts;
    std::map<String, String> _supported;
 
  public:
    explicit SimpleArgParser(int argc, const char* const * const argv) :
      _num_skipped_args(0),
      _args(),
      _opts()
    {
      for(int i(0); i < argc; ++i)
        _args.push_back(String(argv[i]));
      _process();
    }
 
    int num_args() const
    {
      return int(_args.size());
    }
 
    int num_skipped_args() const
    {
      return _num_skipped_args;
    }
 
    String get_arg(int i) const
    {
      if((i < 0) || (i >= int(_args.size())))
        return String();
      return _args.at(std::size_t(i));
    }
 
    std::deque<String> skipped_args() const
    {
      std::deque<String> dsa;
      for(std::size_t i(0); i < std::size_t(_num_skipped_args); ++i)
        dsa.push_back(_args.at(i));
      return dsa;
    }
 
    void support(const String& option, const String& description = String())
    {
      _supported.emplace(option, description);
    }
 
    String get_supported_help(bool double_newline = true) const
    {
      String s;
      for(auto it = _supported.begin(); it != _supported.end(); ++it)
      {
        if(!s.empty())
          s += (double_newline ? "\n\n" : "\n");
        s += "--" + it->first + " " + it->second;
      }
      return s;
    }
 
    std::deque<std::pair<int,String> > query_unsupported() const
    {
      std::deque<std::pair<int,String> > result;
 
      // loop over all given options
      for(auto it = _opts.begin(); it != _opts.end(); ++it)
      {
        // get the option name and its index
        String name = it->first;
        int idx = it->second.first;
 
        // does the option start with a triple-hyphen? if so then don't check it
        if(name.starts_with('-'))
          continue;
 
        // check whether we support that option
        if(_supported.find(name) == _supported.end())
        {
          // unsupported option; so push it
          result.push_back(std::make_pair(idx, name));
        }
      }
 
      // return our result
      return result;
    }
 
    int check(const String& option) const
    {
      auto it =_opts.find(option);
      if(it == _opts.end())
        return -1;
      return int(it->second.second.size());
    }
 
    const std::pair<int, std::deque<String> >* query(const String& option) const
    {
      auto it = _opts.find(option);
      if(it == _opts.end())
        return nullptr;
      return &(it->second);
    }
 
    template<typename... Prms_>
    int parse(const String& option, Prms_&&... prms) const
    {
      // try to find the option
      auto it = _opts.find(option);
      if(it == _opts.end())
        return 0;
 
      // try to parse arguments
      return _parse(it->second, std::size_t(0), std::forward<Prms_>(prms)...);
    }
 
    template<typename T_>
    T_ parse_default(const String& option, T_ default_value) const
    {
      T_ val(default_value);
      return parse(option, val) == 1 ? val : default_value;
    }
 
  private:
    void _process()
    {
      // get an option iterator
      auto opt = _opts.end();
 
      // we definitely skip the first argument
      _num_skipped_args = 1;
 
      // loop over all arguments
      for(int i(1); i < int(_args.size()); ++i)
      {
        // get the trimmed argument
        String arg = _args.at(std::size_t(i)).trim();
 
        // does it start with '--' ?
        if((arg.size() > std::size_t(1)) && (arg[0] == '-') && (arg[1] == '-'))
        {
          // it's an option
          String optname = arg.substr(2).trim();
 
          // let's insert it
          auto ik = _opts.insert(std::make_pair(optname, std::make_pair(i, std::deque<String>())));
          opt = ik.first;
 
          // clear existing deque
          if(!ik.second)
          {
            // option was already given, so overwrite it
            opt->second.first = i;
            opt->second.second.clear();
          }
        }
        else if(opt != _opts.end())
        {
          // push this argument as a parameter for the last processed option
          opt->second.second.push_back(arg);
        }
        else
        {
          // We did not process any options yet, so we skip this argument
          _num_skipped_args = i + 1;
        }
      }
    }
 
    template<typename Prm_>
    int _parse_prm(const std::pair<int,std::deque<String> >& isd, std::size_t offset, Prm_&& prm) const
    {
      // check whether we have another parameter
      if(offset >= isd.second.size())
        return 0;
 
      // try to parse the argument
      if(isd.second.at(offset).parse(std::forward<Prm_>(prm)))
        return +1; // success
      else
        return -isd.first - int(offset) - 1; // fail; return negative argument index
    }
 
    // overload for StringMapped
    template<typename ValueType_>
    int _parse_prm(const std::pair<int,std::deque<String> >& isd, std::size_t offset, StringMapped<ValueType_>&& prm) const
    {
      // check whether we have another parameter
      if(offset >= isd.second.size())
        return 0;
 
      // try to parse the argument
      if(prm.lookup(isd.second.at(offset)))
        return +1; // success
      else
        return -isd.first - int(offset) - 1; // fail; return negative argument index
    }
 
    template<typename Prm1_>
    int _parse(const std::pair<int,std::deque<String> >& isd, std::size_t offset, Prm1_&& prm1) const
    {
      int rtn = _parse_prm(isd, offset, std::forward<Prm1_>(prm1));
      if(rtn > 0)
      {
        // parse successful; no more arguments to be parsed
        return int(offset) + 1;
      }
      else if(rtn == 0)
      {
        // parameter missing
        return int(offset);
      }
      else
      {
        // failed to parse
        return rtn;
      }
    }
 
    template<typename Prm1_, typename... Prms_>
    int _parse(const std::pair<int,std::deque<String> >& isd, std::size_t offset, Prm1_&& prm1, Prms_&&... prms) const
    {
      int rtn = _parse_prm(isd, offset, std::forward<Prm1_>(prm1));
      if(rtn > 0)
      {
        // parse successful; continue parsing remaining parameters
        return _parse(isd, ++offset, std::forward<Prms_>(prms)...);
      }
      else if(rtn == 0)
      {
        // no more parameters, quit here
        return int(offset);
      }
      else
      {
        // failed to parse
        return rtn;
      }
    }
  }; // class SimpleArgParser
} // namespace FEAT