/**
* diargs.hpp
* Copyright (c) 2022 Jon Santmyer <jon@jonsantmyer.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* diargs - An alternative to GNU getopt for modern C++
* Provides tools to parse command line arguments for C++17 programs
*
* Usage: Instantiate an ArgumentParser class, passing in a fallback
* error function, an ArgumentList struct, and an argc,argv pair.
*
* Example:
*
* void printusage(int err) {
* std::cout << "-h --help : Print this message" << std::endl;
* std::exit(err);
* }
*
* int main(int argc, char **argv) {
* bool helpflag;
*
* ArgsPair args{argc, argv};
* ArgumentList argslist(
* ToggleArgument("help", 'h', helpflag, true)
* );
* ArgumentParser parser(printusage, argslist, args);
* return 0;
* }
*/
#ifndef DIARGS_HPP
#define DIARGS_HPP 1
#include <string>
#include <sstream>
#include <vector>
#include <memory>
#include <optional>
#include <algorithm>
namespace diargs {
/*Passed to ArgumentParser*/
struct ArgsPair {
int argc {};
char **argv {};
};
/*Interface for argument types. Makes the whole system tick*/
struct IArgument
{
std::string longform {}; /*Name parsed when passed through with '--'*/
char shortform {}; /*Character parsed when passed through with '-'*/
IArgument() = default;
IArgument(const std::string &Longform, char Shortform) :
longform(Longform), shortform(Shortform) {}
virtual ~IArgument() = default;
virtual std::optional<std::vector<std::string_view>::iterator> parse(
std::vector<std::string_view> &argv,
std::vector<std::string_view>::iterator arg) = 0;
};
template<typename T>
struct MultiArgument : public IArgument
{
T *flag; /*Value set when encountered. Taken from next argument
i.e. --arg [VALUE]*/
MultiArgument(T &Flag) : flag(&Flag) {}
MultiArgument(const std::string &Longform, T &Flag) :
IArgument(Longform, 0), flag(&Flag) {}
MultiArgument(const std::string &Longform, char Shortform, T &Flag) :
IArgument(Longform, Shortform), flag(&Flag) {}
~MultiArgument() {}
std::optional<std::vector<std::string_view>::iterator> parse(
std::vector<std::string_view> &argv,
std::vector<std::string_view>::iterator arg) {
if(++arg == argv.end()) return std::nullopt; /*Not having the
value is an error case*/
std::stringstream ss((*arg).data());
ss >> std::noskipws >> *flag;
return arg;
}
};
template<typename T>
struct ToggleArgument : public IArgument
{
T *flag; /*Value set to [set] when encountered*/
T set; /*Value that [flag] is set to when parsed*/
ToggleArgument(T &Flag, const T Set) :
flag(&Flag), set(Set) {}
ToggleArgument(const std::string &Longform, T &Flag, const T Set) :
IArgument(Longform, 0), flag(&Flag), set(&Set) {}
ToggleArgument(const std::string &Longform, char Shortform,
T &Flag, const T Set) :
IArgument(Longform, Shortform), flag(&Flag), set(&Set) {}
~ToggleArgument() {}
std::optional<std::vector<std::string_view>::iterator> parse(
std::vector<std::string_view> &argv,
std::vector<std::string_view>::iterator arg) {
*flag = set;
return arg;
}
};
/*Type for values not denoted with '-' or '--'*/
template<typename T>
struct OrderedArgument : public IArgument
{
T *flag; /*Value set when passed arg is not any other type*/
std::optional<T> dflt;
OrderedArgument(T &Flag) :
flag(&Flag), dflt(std::nullopt) {}
OrderedArgument(T &Flag, T Dflt) :
flag(&Flag), dflt(Dflt) {}
~OrderedArgument() {}
std::optional<std::vector<std::string_view>::iterator> parse(
std::vector<std::string_view> &argv,
std::vector<std::string_view>::iterator arg) {
std::stringstream ss((*arg).data());
ss >> std::noskipws >> *flag;
return arg;
}
};
/*Container for argument checking*/
struct ArgumentList
{
std::vector<std::unique_ptr<IArgument>> arguments;
void addArgument() {}
template<class T, class... ArgumentPack>
void addArgument(T arg, ArgumentPack... args) {
arguments.push_back(std::make_unique<T>(arg));
addArgument(args...);
}
template<class... ArgumentPack>
ArgumentList(ArgumentPack... arguments) {
addArgument(arguments...);
}
};
/*Instantiation results in parsed arguments*/
class ArgumentParser
{
public:
ArgumentParser(
void (*failfunc)(int),
ArgumentList &arguments,
ArgsPair argcv);
};
}
#endif
