ProgramOptions.h

// Copyright (C) 2022, Antoine Basset
// SPDX-License-Identifier: LGPL-3.0-or-later

#ifndef _PROGRAMOPTIONS_H
#define _PROGRAMOPTIONS_H

#include <boost/program_options.hpp>
#include <sstream>

namespace Kast {

/**
 * @brief Helper class to declare positional, named and flag options, as well as some help message.
 * @details
 * Here is an example use case for the following command line:
 * \verbatim Program <positional> --named1 <value1> --flag --named2 <value2> \endverbatim
 * 
 * Here's an example program to handle it:
 * \code
 * std::pair<OptionsDescription, PositionalOptionsDescription> defineProgramArguments() override {
 * auto options = ProgramOptions::fromAuxdir("help.txt");
 * options.positional("positional", value<std::string>(), "Positional option");
 * options.named("named1", value<int>(), "Named option 1");
 * options.named("named2", value<int>(), "Named option 2");
 * return options.asPair();
 * }
 * \endcode
 */
class ProgramOptions {

public:

 using OptionsDescription = boost::program_options::options_description;
 using PositionalOptionsDescription = boost::program_options::positional_options_description;
 using ValueSemantics = boost::program_options::value_semantic;

 /**
 * @brief Make a `ProgramOptions` with optional description string.
 */
 ProgramOptions(const std::string& description = "") :
 m_named(makeDesc(description)),
 m_add(m_named.add_options()),
 m_positional(),
 m_variables() {}

 /**
 * @brief Declare a positional option.
 */
 template <typename T>
 void positional(const char* name, const char* description) {
 positional(name, boost::program_options::value<T>(), description);
 }

 /**
 * @brief Declare a positional option with default value.
 */
 template <typename T>
 void positional(const char* name, const char* description, T defaultValue) {
 positional(name, boost::program_options::value<T>()->default_value(defaultValue), description);
 }

 /**
 * @brief Declare a positional option with custom semantics.
 */
 void positional(const char* name, const ValueSemantics* value, const char* description) {
 m_add(name, value, description);
 const int maxArgs = value->max_tokens();
 m_positional.add(name, maxArgs);
 }

 /**
 * @brief Declare a named option.
 * @details
 * A short form (1-character) of the option can be provided, separated by a comma.
 */
 template <typename T>
 void named(const char* name, const char* description) {
 named(name, boost::program_options::value<T>(), description);
 }

 /**
 * @brief Declare a named option with default value.
 * @details
 * A short form (1-character) of the option can be provided, separated by a comma.
 */
 template <typename T>
 void named(const char* name, const char* description, T defaultValue) {
 named(name, boost::program_options::value<T>()->default_value(defaultValue), description);
 }

 /**
 * @brief Declare a named option with custom semantics.
 * @details
 * A short form (1-character) of the option can be provided, separated by a comma.
 */
 void named(const char* name, const ValueSemantics* value, const char* description) {
 m_add(name, value, description);
 }

 /**
 * @brief Declare a flag option.
 */
 void flag(const char* name, const char* description) {
 named(name, boost::program_options::value<bool>()->default_value(false)->implicit_value(true), description);
 }

 
 /**
 * @brief Get the named (flags included) and positional options as a pair.
 */
 std::pair<OptionsDescription, PositionalOptionsDescription> asPair() const {
 return std::make_pair(m_named, m_positional);
 }

 /**
 * @brief Parse a command line (`main`-like).
 */
 void parse(int argc, const char* const argv[]) {
 boost::program_options::store(
 boost::program_options::command_line_parser(argc, argv).options(m_named).positional(m_positional).run(),
 m_variables);
 boost::program_options::notify(m_variables);
 }

 /**
 * @brief Parse a command line (vector of `const char*` arguments).
 */
 void parse(const std::vector<const char*>& args) {
 parse(args.size(), args.data());
 }

 /**
 * @brief Parse a command line (vector of string arguments).
 */
 void parse(const std::vector<std::string>& args) {
 std::vector<const char*> cstr(args.size());
 std::transform(args.begin(), args.end(), cstr.begin(), [](const auto& a) { return a.c_str(); });
 parse(cstr);
 }

 /**
 * @brief Parse a command line (space-separated arguments as a single string).
 */
 void parse(const std::string& args) {
 std::istringstream iss(args);
 parse(std::vector<std::string>(
 std::istream_iterator<std::string>{iss},
 std::istream_iterator<std::string>()));
 }

 /**
 * @brief Check whether a given option is set.
 */
 bool has(const char* name) const {
 return m_variables.count(name);
 }

 /**
 * @brief Get the value of a given option.
 * @details
 * Throws if the option is not set.
 */
 template <typename T>
 T as(const char* name) const {
 return m_variables[name].as<T>();
 }

private:
 
 static std::string makeDesc(const std::string& description) {
 const std::string optionsGroup = "Options:";
 if (description.length() > 0) {
 return description + "\n\n" + optionsGroup;
 }
 return optionsGroup;
 }

 OptionsDescription m_named;
 boost::program_options::options_description_easy_init m_add;
 PositionalOptionsDescription m_positional;
 boost::program_options::variables_map m_variables;

};

}

#endif