cpp-argument-parser/include/program_args/arguments_impl.hpp

#pragma once

#include <utility>

#include "arguments.h"
#include "exception.h"
#include "utilities.h"

namespace program {

template <typename Impl>
template <typename T>
Arguments<Impl>::Argument::operator T() const {
  if (!primed()) {
    return T();
  } else if (self->arguments.size() > index) {
    return convert<T>(self->arguments.at(index));
  }
  throw IllegalPositionError("No argument provided", index);
}

template <typename Impl> Arguments<Impl>::Argument::operator bool() const {
  return primed() && self->arguments.size() > index;
}

template <typename Impl>
template <typename T>
auto Arguments<Impl>::Argument::operator=(T && value) {
  is_optional = true;
  return WithDefault<Argument, T>{*this, std::forward<T>(value)};
}

template <typename Impl> bool Arguments<Impl>::Argument::primed() const {
  if (self->primed_) { return true; }
  if (is_optional) {
    self->optional_from = std::min(self->optional_from, index);
  } else if (self->optional_from < index) {
    throw ArgumentStructureError{"Required positional after optional", name};
  }
  if (!self->argument_names.emplace(index, name).second) {
    throw IllegalPositionError("Duplicate positional", index);
  }
  self->argument_descriptions.emplace(name, description);
  return false;
}

}

namespace program {

template <typename Impl>
template <typename T>
Arguments<Impl>::Flag::operator T() const {
  return primed(false) ? static_cast<T>(self->flags.at(name)) : T();
}

template <typename Impl> Arguments<Impl>::Flag::operator bool() const {
  return primed(true) ? static_cast<bool>(self->flags.at(name)) : default_value;
}

template <typename Impl> auto Arguments<Impl>::Flag::operator=(bool && value) {
  default_value = value;
  return *this;
}

template <typename Impl> bool Arguments<Impl>::Flag::primed(bool inv) const {
  if (self->primed_) { return self->flags.count(name); }
  std::vector<std::string> aliases{"--" + name};
  if (abbrev) { aliases.emplace_back(std::string{'-', abbrev}); }
  if (inv) { aliases.emplace_back("--no-" + name); };
  for (auto & alias : aliases) {
    if (!self->option_names.emplace(alias, name).second) {
      throw ArgumentStructureError("Duplicate option string", alias);
    }
  }
  self->option_descriptions.emplace(join("/", aliases), description);
  self->flag_names.emplace(name);
  return false;
}

}

namespace program {

template <typename Impl>
template <typename T>
Arguments<Impl>::Option::operator T() const {
  return (*this) ? convert<T>(self->options.at(name)) : T();
}

template <typename Impl> Arguments<Impl>::Option::operator bool() const {
  return primed() && self->options.count(name);
}

template <typename Impl>
template <typename T>
auto Arguments<Impl>::Option::operator=(T && value) {
  return WithDefault<Option, T>{*this, std::forward<T>(value)};
}

template <typename Impl> bool Arguments<Impl>::Option::primed() const {
  if (self->primed_) { return true; }
  std::vector<std::string> aliases{"--" + name};
  if (abbrev) { aliases.emplace_back(std::string{'-', abbrev}); }
  for (auto & alias : aliases) {
    if (!self->option_names.emplace(alias, name).second) {
      throw ArgumentStructureError("Duplicate option string", alias);
    }
  }
  self->option_descriptions.emplace(join("/", aliases), description);
  return false;
}

}

#define arg_equals(str) !strncmp(argv[i], str, sizeof(str))
#define arg_starts_with(str) !strncmp(argv[i], str, strlen(str))
namespace program {

template <typename Impl>
Arguments<Impl>::Arguments(int argc, char const * const * const argv) {
  Impl generator;
  *this = static_cast<Arguments const &>(generator);
  if (argument_names.rbegin()->first != argument_names.size() - 1) {
    throw IllegalPositionError("Higher positional than number recorded",
                               argument_names.rbegin()->first);
  }

  primed_ = true;
  program = argv[0];
  for (size_t i = 1; i < argc; ++i) {
    if (arg_equals("--help")) {
      usage();
      std::exit(0); // TODO: ???
    } else if (arg_equals("--")) {
      // TODO: Special arguments store for passthroughs
      arguments.insert(arguments.end(), &argv[i + 1], &argv[argc]);
      break;
    } else if (argv[i][0] == '-') {
      auto it = option_names.find(argv[i]);
      if (it == option_names.end()) { throw NotAnArgumentError(argv[i]); }
      auto & name = it->second;
      // TODO: Flag handling for e.g. -v2 -vv
      if (!flag_names.count(name)) {
        options[name].emplace_back(argv[i + 1]);
        // TODO: Arity
        ++i;
      } else if (arg_starts_with("--no-")) {
        flags[name] = 0;
      } else {
        ++flags[name];
      }
    } else {
      arguments.emplace_back(argv[i]);
    }
  }
}

template <typename Impl> void Arguments<Impl>::usage() const {
  std::cout << program << " [options...]";
  for (auto & [index, name] : argument_names) {
    std::cout << " " << (index == optional_from ? "[" : "") << name;
  }
  if (optional_from != std::numeric_limits<size_t>::max()) { std::cout << "]"; }
  std::cout << "\nArgument Arguments:\n";
  for (auto & [name, desc] : argument_descriptions) {
    std::cout << "  " << name << ": " << desc << "\n";
  }
  std::cout << "Options:\n";
  for (auto & [opt, desc] : option_descriptions) {
    std::cout << "  " << opt << ": " << desc << "\n";
  }
}

template <typename Impl>
auto Arguments<Impl>::argument(size_t index, std::string const & name,
                               std::string const & description) {
  return Argument{this, index, false, name, description};
}

template <typename Impl>
auto Arguments<Impl>::flag(std::string const & name,
                           std::string const & description) {
  return Flag{this, name, 0, description, false};
}

template <typename Impl>
auto Arguments<Impl>::flag(std::string const & name, char abbrev,
                           std::string const & description) {
  return Flag{this, name, abbrev, description, false};
}

template <typename Impl>
auto Arguments<Impl>::option(std::string const & name,
                             std::string const & description) {
  return Option{this, name, 0, description};
}

template <typename Impl>
auto Arguments<Impl>::option(std::string const & name, char abbrev,
                             std::string const & description) {
  return Option{this, name, abbrev, description};
}

}
#undef arg_equals
#undef arg_starts_with