cpp-argument-parser/include/program_args/arguments.h

#pragma once

#include <map>
#include <set>
#include <string>
#include <vector>

namespace program {

template <typename Impl> class Arguments {
private:
  using option_id = std::string;
  struct Argument;
  struct Flag;
  struct Option;
  template <typename, typename> struct WithDefault;

public:
  Arguments() = default;
  Arguments(int argc, char const * const * const argv);

protected:
  auto argument(size_t index, std::string const & name,
                std::string const & description = "");
  auto flag(std::string const & name, std::string const & description = "");
  auto flag(std::string const & name, char abbrev,
            std::string const & description = "");
  auto option(std::string const & name, std::string const & description = "");
  auto option(std::string const & name, char abbrev,
              std::string const & description = "");

private:
  void usage() const;
  void add_options(std::string const & name, char abbrev,
                   std::string const & description,
                   std::vector<std::string> aliases = {});
  option_id id(std::string const & arg) const;
  option_id id(char arg) const { return id({'-', arg}); }
  bool is_option(std::string const & arg) const;
  bool is_option(char arg) const { return is_option({'-', arg}); }
  bool is_flag(std::string const & arg) const;
  bool is_flag(char arg) const { return is_flag({'-', arg}); }

private:
  // Metadata variables
  bool primed_{false};
  std::map<option_id, std::string> argument_descriptions;
  std::map<size_t, option_id> argument_names;
  std::map<option_id, std::string> option_descriptions;
  std::map<std::string, option_id> option_names;
  std::set<option_id> flag_names;

  // Data/Output variables
  std::string program;
  size_t optional_from{std::numeric_limits<size_t>::max()};
  std::vector<std::string> arguments;
  std::map<std::string, std::vector<std::string>> options;
  std::map<std::string, int> flags;
};

template <typename Impl> struct Arguments<Impl>::Argument {
  Arguments<Impl> * self;
  size_t index;
  bool is_optional;
  std::string name;
  std::string description;

  template <typename T> auto operator=(T && value);
  template <typename T> operator T() const;
  bool primed() const;
  explicit operator bool() const;
};

template <typename Impl> struct Arguments<Impl>::Flag {
  Arguments<Impl> * self;
  std::string name;
  char abbrev;
  std::string description;
  bool default_value;

  auto operator=(bool && value);
  operator bool() const;
  template <typename T> operator T() const;
  bool primed(bool inv) const;
};

template <typename Impl> struct Arguments<Impl>::Option {
  Arguments<Impl> * self;
  std::string name;
  char abbrev;
  std::string description;

  template <typename T> auto operator=(T && value);
  template <typename T> operator T() const;
  bool primed() const;
  explicit operator bool() const;
};

template <typename Impl>
template <typename B, typename V>
struct Arguments<Impl>::WithDefault {
  B impl;
  V default_value;
  template <typename T> operator T() const { return impl ?: T(default_value); }
};

}

#include "arguments_impl.hpp"

#define TYPED_MAIN(tname)                                                      \
  int typed_main(tname const & args);                                          \
  int main(int argc, char const * const * const argv) try {                    \
    return typed_main(tname(argc, argv));                                      \
  } catch (program::ProgramArgumentsError const & pae) {                       \
    std::cerr << "Error in program argument handling: " << pae.what() << "\n"; \
  }                                                                            \
  int typed_main(tname const & args)