arser::Arser Class Reference

#include <arser.h>

Public Member Functions
	Arser (const std::string &program_description={})
Argument &	add_argument (const std::string &arg_name)
Argument &	add_argument (const std::vector< std::string > &arg_name_vec)
template<typename... Ts>
Argument &	add_argument (const std::string &arg_name, Ts... arg_names)
void	validate_arguments (void)
void	parse (int argc, char **argv)
bool	operator[] (const std::string &arg_name)
template<typename T >
T	get_impl (const std::string &arg_name, T *)
template<typename T >
std::vector< T >	get_impl (const std::string &arg_name, std::vector< T > *)
template<typename T >
std::vector< std::vector< T > >	get_impl (const std::string &arg_name, std::vector< std::vector< T > > *)
template<typename T >
T	get (const std::string &arg_name)

Friends
std::ostream &	operator<< (std::ostream &stream, const Arser &parser)

Detailed Description

Definition at line 329 of file arser.h.

Constructor & Destructor Documentation

Arser()

arser::Arser::Arser ( const std::string &  program_description = {} )

inlineexplicit

Definition at line 332 of file arser.h.

                                                        {})
    : _program_description{program_description}
  {
    add_argument("-h", "--help").help("Show help message and exit").nargs(0);
  }

Member Function Documentation

add_argument() [1/3]

Argument & arser::Arser::add_argument ( const std::string &  arg_name )

inline

Definition at line 338 of file arser.h.

  {
    if (arg_name.at(0) != '-') /* positional */
    {
      _positional_arg_vec.emplace_back(arg_name);
      _arg_map[arg_name] = &_positional_arg_vec.back();
    }
    else /* optional */
    {
      // The length of optional argument name must be 2 or more.
      // And it shouldn't be hard to recognize. e.g. '-', '--'
      if (arg_name.size() < 2)
      {
        throw std::runtime_error("Too short name. The length of argument name must be 2 or more.");
      }
      if (arg_name == "--")
      {
        throw std::runtime_error(
          "Too short name. Option name must contain at least one character other than dash.");
      }
      _optional_arg_vec.emplace_back(arg_name);
      _optional_arg_vec.back()._short_name = arg_name;
      _arg_map[arg_name] = &_optional_arg_vec.back();
    }
    return *_arg_map[arg_name];
  }

Referenced by add_argument().

add_argument() [2/3]

template<typename... Ts>

Argument & arser::Arser::add_argument ( const std::string &  arg_name, Ts...  arg_names  )

inline

Definition at line 407 of file arser.h.

  {
    if (sizeof...(arg_names) == 0)
    {
      return add_argument(arg_name);
    }
    // sizeof...(arg_names) > 0
    else
    {
      return add_argument(std::vector<std::string>{arg_name, arg_names...});
    }
  }

References add_argument().

add_argument() [3/3]

Argument & arser::Arser::add_argument ( const std::vector< std::string > &  arg_name_vec )

inline

Definition at line 365 of file arser.h.

  {
    assert(arg_name_vec.size() >= 2);
    std::string long_opt, short_opt;
    // find long and short option
    for (const auto &arg_name : arg_name_vec)
    {
      if (arg_name.at(0) != '-')
      {
        throw std::runtime_error("Invalid argument. "
                                 "Positional argument cannot have short option.");
      }
      assert(arg_name.size() >= 2);
      if (long_opt.empty() && arg_name.at(0) == '-' && arg_name.at(1) == '-')
      {
        long_opt = arg_name;
      }
      if (short_opt.empty() && arg_name.at(0) == '-' && arg_name.at(1) != '-')
      {
        short_opt = arg_name;
      }
    }
    // If one of the two is empty, fill it with the non-empty one for pretty printing.
    if (long_opt.empty())
    {
      assert(not short_opt.empty());
      long_opt = short_opt;
    }
    if (short_opt.empty())
    {
      assert(not long_opt.empty());
      short_opt = long_opt;
    }
 
    _optional_arg_vec.emplace_back(short_opt, long_opt, arg_name_vec);
    for (const auto &arg_name : arg_name_vec)
    {
      _arg_map[arg_name] = &_optional_arg_vec.back();
    }
    return _optional_arg_vec.back();
  }

get()

template<typename T >

T arser::Arser::get

(

const std::string &

arg_name

)

Definition at line 747 of file arser.h.

{
  return get_impl(arg_name, static_cast<T *>(nullptr));
}

References get_impl().

get_impl() [1/3]

template<typename T >

std::vector< std::vector< T > > arser::Arser::get_impl	(	const std::string &	arg_name,
		std::vector< std::vector< T > > *
	)

Definition at line 714 of file arser.h.

{
  auto arg = _arg_map.find(arg_name);
  if (arg == _arg_map.end())
    throw std::runtime_error("Invalid argument. "
                             "There is no argument you are looking for: " +
                             arg_name);
 
  if (not arg->second->_is_accumulated)
    throw std::runtime_error("Type mismatch. "
                             "You called get using a type different from the one you specified: " +
                             arg_name);
 
  if (arg->second->_type != TypeName<std::vector<T>>::Get())
    throw std::runtime_error(
      "Type mismatch. "
      "You called get using a type different from the one you specified."
      "Accumulated argument is returned as std::vector of the specified type: " +
      arg_name);
 
  std::vector<std::vector<T>> result;
  for (auto values : arg->second->_accum_values)
  {
    std::vector<T> data;
    std::transform(values.begin(), values.end(), std::back_inserter(data),
                   [](std::string str) -> T { return internal::lexical_cast<T>(str); });
    result.emplace_back(data);
  }
 
  return result;
}

get_impl() [2/3]

template<typename T >

std::vector< T > arser::Arser::get_impl	(	const std::string &	arg_name,
		std::vector< T > *
	)

Definition at line 674 of file arser.h.

{
  auto arg = _arg_map.find(arg_name);
  if (arg == _arg_map.end())
    throw std::runtime_error("Invalid argument. "
                             "There is no argument you are looking for: " +
                             arg_name);
 
  // Accumulated arguments with scalar type (e.g., STR)
  if (arg->second->_is_accumulated)
  {
    if (arg->second->_type != TypeName<T>::Get())
      throw std::runtime_error(
        "Type mismatch. "
        "You called get using a type different from the one you specified: " +
        arg_name);
 
    std::vector<T> data;
    for (auto values : arg->second->_accum_values)
    {
      assert(values.size() == 1);
      data.emplace_back(internal::lexical_cast<T>(values[0]));
    }
    return data;
  }
 
  if (arg->second->_type != TypeName<std::vector<T>>::Get())
    throw std::runtime_error(
      "Type mismatch. "
      ". You called get using a type different from the one you specified: " +
      arg_name);
 
  std::vector<T> data;
  std::transform(arg->second->_values.begin(), arg->second->_values.end(), std::back_inserter(data),
                 [](std::string str) -> T { return internal::lexical_cast<T>(str); });
  return data;
}

get_impl() [3/3]

template<typename T >

T arser::Arser::get_impl	(	const std::string &	arg_name,
		T *
	)

Definition at line 642 of file arser.h.

{
  auto arg = _arg_map.find(arg_name);
  if (arg == _arg_map.end())
    throw std::runtime_error("Invalid argument. "
                             "There is no argument you are looking for: " +
                             arg_name);
 
  if (arg->second->_is_accumulated)
    throw std::runtime_error(
      "Type mismatch. "
      "You called get using a type different from the one you specified."
      "Accumulated argument is returned as std::vector of the specified type: " +
      arg_name);
 
  if (arg->second->_type != TypeName<T>::Get())
    throw std::runtime_error("Type mismatch. "
                             "You called get() method with a type different "
                             "from the one you specified. "
                             "Please check the type of what you specified in "
                             "add_argument() method: " +
                             arg_name);
 
  if (arg->second->_values.size() == 0)
    throw std::runtime_error("Wrong access. "
                             "You must make sure that the argument is given before accessing it. "
                             "You can do it by calling arser[\"" +
                             arg_name + "\"].");
 
  return internal::lexical_cast<T>(arg->second->_values[0]);
}

Referenced by get().

operator[]()

bool arser::Arser::operator[] ( const std::string &  arg_name )

inline

Definition at line 521 of file arser.h.

  {
    auto arg = _arg_map.find(arg_name);
    if (arg == _arg_map.end())
      return false;
 
    if (arg->second->_is_accumulated)
      return arg->second->_accum_values.size() > 0 ? true : false;
 
    return arg->second->_values.size() > 0 ? true : false;
  }

parse()

void arser::Arser::parse ( int  argc, char **  argv  )

inline

Definition at line 434 of file arser.h.

  {
    validate_arguments();
    _program_name = argv[0];
    _program_name.erase(0, _program_name.find_last_of("/\\") + 1);
    if (argc >= 2)
    {
      if (!std::strcmp(argv[1], "--help") || !std::strcmp(argv[1], "-h"))
      {
        std::cout << *this;
        std::exit(0);
      }
      else
      {
        for (const auto &arg : _arg_map)
        {
          const auto &func = arg.second->_func;
          if (func && !std::strcmp(argv[1], arg.first.c_str()))
          {
            func();
            std::exit(0);
          }
        }
      }
    }
    /*
    ** ./program_name [optional argument] [positional argument]
    */
    // get the number of positioanl argument
    size_t parg_num = _positional_arg_vec.size();
    // get the number of "required" optional argument
    size_t required_oarg_num = 0;
    for (auto arg : _optional_arg_vec)
    {
      if (arg._is_required)
        required_oarg_num++;
    }
    // parse argument
    for (int c = 1; c < argc;)
    {
      std::string arg_name{argv[c++]};
      auto arg = _arg_map.find(arg_name);
      // check whether arg is positional or not
      if (arg == _arg_map.end())
      {
        if (parg_num)
        {
          auto it = _positional_arg_vec.begin();
          std::advance(it, _positional_arg_vec.size() - parg_num);
          (*it)._values.clear();
          (*it)._values.emplace_back(arg_name);
          parg_num--;
        }
        else
          throw std::runtime_error("Invalid argument. "
                                   "You've given more positional argument than necessary.");
      }
      else // optional argument
      {
        // check whether arg is required or not
        if (arg->second->_is_required)
          required_oarg_num--;
        arg->second->_values.clear();
        for (uint32_t n = 0; n < arg->second->_nargs; n++)
        {
          if (c >= argc)
            throw std::runtime_error("Invalid argument. "
                                     "You must have missed some argument.");
          arg->second->_values.emplace_back(argv[c++]);
        }
        // accumulate values
        if (arg->second->_is_accumulated)
        {
          arg->second->_accum_values.emplace_back(arg->second->_values);
        }
        if (arg->second->_nargs == 0)
        {
          // TODO std::boolalpha for true or false
          arg->second->_values.emplace_back("1");
        }
      }
    }
    if (parg_num || required_oarg_num)
      throw std::runtime_error("Invalid argument. "
                               "You must have missed some argument.");
  }

References validate_arguments().

validate_arguments()

void arser::Arser::validate_arguments ( void  )

inline

Definition at line 420 of file arser.h.

  {
    // positional argument is always required.
    for (const auto &arg : _positional_arg_vec)
    {
      if (arg._is_required)
      {
        throw std::runtime_error("Invalid arguments. Positional argument must always be required.");
      }
    }
    // TODO accumulated arguments shouldn't be enabled to positional arguments.
    // TODO accumulated arguments shouldn't be enabled to optional arguments whose `narg` == 0.
  }

Referenced by parse().

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream &  stream, const Arser &  parser  )

friend

Definition at line 542 of file arser.h.

  {
    // print description
    if (!parser._program_description.empty())
    {
      stream << "What " << parser._program_name << " does: " << parser._program_description
             << "\n\n";
    }
    /*
    ** print usage
    */
    auto print_usage_arg = [&](const arser::Argument &arg) {
      stream << " ";
      std::string arg_name = arser::internal::remove_dash(arg._long_name);
      std::for_each(arg_name.begin(), arg_name.end(),
                    [&stream](const char &c) { stream << static_cast<char>(::toupper(c)); });
    };
    stream << "Usage: ./" << parser._program_name << " ";
    // required optional argument
    for (const auto &arg : parser._optional_arg_vec)
    {
      if (!arg._is_required)
        continue;
      stream << arg._short_name;
      print_usage_arg(arg);
      stream << " ";
    }
    // rest of the optional argument
    for (const auto &arg : parser._optional_arg_vec)
    {
      if (arg._is_required)
        continue;
      stream << "[" << arg._short_name;
      if (arg._nargs)
      {
        print_usage_arg(arg);
      }
      stream << "]"
             << " ";
    }
    // positional arguement
    for (const auto &arg : parser._positional_arg_vec)
    {
      stream << arg._long_name << " ";
    }
    stream << "\n\n";
    /*
    ** print argument list and its help message
    */
    // get the length of the longest argument
    size_t length_of_longest_arg = 0;
    for (const auto &arg : parser._positional_arg_vec)
    {
      length_of_longest_arg = std::max(length_of_longest_arg,
                                       arser::internal::make_comma_concatenated(arg._names).size());
    }
    for (const auto &arg : parser._optional_arg_vec)
    {
      length_of_longest_arg = std::max(length_of_longest_arg,
                                       arser::internal::make_comma_concatenated(arg._names).size());
    }
 
    const size_t message_width = 60;
    auto print_help_args = [&](const std::list<Argument> &args, const std::string &title) {
      if (!args.empty())
      {
        stream << title << std::endl;
        for (const auto &arg : args)
        {
          stream.width(length_of_longest_arg);
          stream << std::left << arser::internal::make_comma_concatenated(arg._names) << "\t";
          for (size_t i = 0; i < arg._help_message.size(); i++)
          {
            for (size_t j = 0; j < arg._help_message[i].length(); j += message_width)
            {
              if (i || j)
                stream << std::string(length_of_longest_arg, ' ') << "\t";
              stream << arg._help_message[i].substr(j, message_width) << std::endl;
            }
          }
        }
        std::cout << std::endl;
      }
    };
    // positional argument
    print_help_args(parser._positional_arg_vec, "[Positional argument]");
    // optional argument
    print_help_args(parser._optional_arg_vec, "[Optional argument]");
 
    return stream;
  }

---

The documentation for this class was generated from the following file:

• compiler/arser/include/arser/arser.h