BLT/include/blt/parse/argparse.h

250 lines
7.9 KiB
C
Raw Normal View History

/*
* Created by Brett on 28/07/23.
* Licensed under GNU General Public License V3.0
* See LICENSE file for license detail
*/
#ifndef BLT_TESTS_ARGPARSE_H
#define BLT_TESTS_ARGPARSE_H
#include <vector>
#include <string>
#include <initializer_list>
#include <optional>
#include <blt/std/hashmap.h>
2023-08-01 13:43:00 -04:00
#include <variant>
2023-07-29 13:38:19 -04:00
namespace blt::parser {
2023-08-01 13:43:00 -04:00
enum class arg_action_t {
2023-07-29 13:38:19 -04:00
STORE,
STORE_CONST,
STORE_TRUE,
STORE_FALSE,
APPEND,
APPEND_CONST,
COUNT,
HELP,
VERSION,
EXTEND
};
2023-08-01 13:43:00 -04:00
enum class arg_result_t {
BOOL,
VALUE,
VECTOR
};
2023-08-01 13:43:00 -04:00
class arg_vector_t {
private:
std::vector<std::string> names;
std::vector<std::string> flags;
void insertAndSort(const std::string& str);
2023-07-29 13:38:19 -04:00
public:
2023-08-01 13:43:00 -04:00
arg_vector_t() = default;
2023-07-29 13:38:19 -04:00
2023-08-01 13:43:00 -04:00
arg_vector_t(const std::vector<std::string>& args);
2023-07-29 13:38:19 -04:00
2023-08-01 13:43:00 -04:00
arg_vector_t(std::initializer_list<std::string> args);
2023-07-29 13:38:19 -04:00
2023-08-01 13:43:00 -04:00
arg_vector_t(const std::string& arg);
2023-07-29 13:38:19 -04:00
2023-08-01 13:43:00 -04:00
arg_vector_t(const char* arg);
2023-08-01 13:43:00 -04:00
arg_vector_t& operator=(const std::string& arg);
2023-07-29 13:38:19 -04:00
2023-08-01 13:43:00 -04:00
arg_vector_t& operator=(const char* arg);
2023-07-29 13:38:19 -04:00
2023-08-01 13:43:00 -04:00
arg_vector_t& operator=(std::initializer_list<std::string>& args);
2023-07-29 13:38:19 -04:00
2023-08-01 13:43:00 -04:00
arg_vector_t& operator=(std::vector<std::string>& args);
2023-07-29 13:38:19 -04:00
[[nodiscard]] inline std::vector<std::string>& getNames() {
return names;
}
2023-07-29 13:38:19 -04:00
[[nodiscard]] inline std::vector<std::string>& getFlags() {
return flags;
}
2023-07-29 14:04:46 -04:00
[[nodiscard]] inline const std::vector<std::string>& getNames() const {
return names;
}
[[nodiscard]] inline const std::vector<std::string>& getFlags() const {
return flags;
}
2023-08-01 13:43:00 -04:00
struct equals {
bool operator()(const arg_vector_t& a1, const arg_vector_t& a2) const {
// arg cannot have both
if (!a1.names.empty()) {
// match all pos arg
return std::ranges::all_of(a1.names, [&a2](const auto& n) -> bool {
if (std::find(a2.names.begin(), a2.names.end(), n) == a2.names.end())
return false;
return true;
});
} else {
// match any flag (--foo or -f)
return std::ranges::all_of(a1.flags, [&a2](const auto& f) -> bool {
if (std::find(a2.flags.begin(), a2.flags.end(), f) != a2.flags.end())
return true;
return false;
});
}
}
};
struct hash {
size_t operator()(const arg_vector_t& a) const {
size_t v = 0;
std::hash<std::string> hash;
for (const auto& n : a.names) {
v >>= 8;
v += hash(n);
}
for (const auto& f : a.flags) {
v >>= 8;
v += hash(f);
}
return v;
}
};
};
2023-08-01 13:43:00 -04:00
class arg_nargs_t {
private:
2023-08-01 13:43:00 -04:00
friend class argparse;
static constexpr int UNKNOWN = 0x1;
static constexpr int ALL = 0x2;
static constexpr int ALL_REQUIRED = 0x4;
2023-08-01 13:43:00 -04:00
// 0 means default behaviour (consume 1 if presented otherwise ignore)
int args = 0;
2023-08-01 13:43:00 -04:00
// 0 indicates args is used
int flags = 0;
2023-07-29 13:38:19 -04:00
void decode(char c);
2023-07-29 13:38:19 -04:00
public:
2023-08-01 13:43:00 -04:00
arg_nargs_t() = default;
2023-07-29 13:38:19 -04:00
2023-08-01 13:43:00 -04:00
arg_nargs_t(int args): args(args) {}
2023-07-29 13:38:19 -04:00
2023-08-01 13:43:00 -04:00
arg_nargs_t(char c);
2023-07-29 13:38:19 -04:00
2023-08-01 13:43:00 -04:00
arg_nargs_t(std::string s);
2023-07-29 13:38:19 -04:00
2023-08-01 13:43:00 -04:00
arg_nargs_t(const char* s);
2023-07-29 13:38:19 -04:00
2023-08-01 13:43:00 -04:00
arg_nargs_t& operator=(const std::string& s);
2023-07-29 13:38:19 -04:00
2023-08-01 13:43:00 -04:00
arg_nargs_t& operator=(const char* s);
2023-07-29 13:38:19 -04:00
2023-08-01 13:43:00 -04:00
arg_nargs_t& operator=(char c);
2023-07-29 13:38:19 -04:00
2023-08-01 13:43:00 -04:00
arg_nargs_t& operator=(int args);
};
2023-08-01 13:43:00 -04:00
struct arg_properties_t {
private:
public:
2023-08-01 13:43:00 -04:00
arg_vector_t a_flags;
arg_action_t a_action = arg_action_t::STORE;
arg_nargs_t a_nargs = 0;
std::optional<std::string> a_const{};
std::string a_default{};
std::string a_def{};
std::string a_help{};
std::string a_metavar{};
bool a_required = false;
};
2023-08-01 13:43:00 -04:00
class arg_tokenizer_t {
2023-07-29 13:38:19 -04:00
private:
static constexpr char FLAG = '-';
std::vector<std::string> args;
size_t nextIndex = 0;
2023-08-01 13:43:00 -04:00
inline const std::string& get(size_t i) {
2023-07-29 13:38:19 -04:00
return args[i];
}
2023-08-01 13:43:00 -04:00
inline bool hasNext(size_t i) {
return (size_t) i < args.size();
2023-07-29 13:38:19 -04:00
}
2023-08-01 13:43:00 -04:00
2023-07-29 13:38:19 -04:00
public:
2023-08-01 13:43:00 -04:00
arg_tokenizer_t() = default;
2023-07-29 13:38:19 -04:00
2023-08-01 13:43:00 -04:00
arg_tokenizer_t(size_t argc, const char** argv);
2023-07-29 13:38:19 -04:00
inline void forward() {
nextIndex++;
}
inline const std::string& get() {
return get(nextIndex);
}
inline const std::string& next() {
2023-07-31 13:53:10 -04:00
return get(nextIndex++);
2023-07-29 13:38:19 -04:00
}
inline bool hasNext() {
return hasNext(nextIndex);
}
2023-08-01 13:43:00 -04:00
inline bool isFlag(size_t i) {
2023-07-31 13:53:10 -04:00
return get(i).starts_with(FLAG);
}
2023-07-29 13:38:19 -04:00
inline bool isFlag() {
return isFlag(nextIndex);
}
};
class argparse {
2023-08-01 13:43:00 -04:00
public:
typedef std::variant<std::string, bool, std::vector<std::string>> arg_data_t;
2023-07-29 13:38:19 -04:00
private:
struct {
2023-08-01 13:43:00 -04:00
friend argparse;
private:
std::vector<arg_properties_t> arg_storage;
public:
std::vector<std::pair<std::string, arg_properties_t*>> name_associations;
HASHMAP<std::string, arg_properties_t*> flag_associations;
HASHSET<arg_vector_t, arg_vector_t::hash, arg_vector_t::equals> required_vars;
} user_args;
struct arg_results {
2023-08-01 13:43:00 -04:00
friend argparse;
private:
HASHSET<arg_vector_t, arg_vector_t::hash, arg_vector_t::equals> found_required;
public:
std::string program_name;
HASHMAP <arg_vector_t, arg_data_t, arg_vector_t::hash, arg_vector_t::equals> positional_args;
HASHMAP <arg_vector_t, arg_data_t, arg_vector_t::hash, arg_vector_t::equals> flag_args;
} loaded_args;
2023-08-01 13:43:00 -04:00
private:
static bool validateArgument(const arg_properties_t& args);
bool consumeFlagArguments(arg_tokenizer_t& arg_tokenizer, const arg_properties_t& properties, arg_data_t& arg_data);
void handlePositionalArgument(arg_tokenizer_t& arg_tokenizer, size_t& last_pos);
void handleFlagArgument(arg_tokenizer_t& arg_tokenizer);
2023-07-29 13:38:19 -04:00
public:
argparse() = default;
2023-08-01 13:43:00 -04:00
void addArgument(const arg_properties_t& args);
const arg_results& parse_args(int argc, const char** argv);
2023-08-01 13:43:00 -04:00
void printHelp();
};
}
#endif //BLT_TESTS_ARGPARSE_H