Peter M. Groen / CLI11

Browse Code »

Commit 2db15139cb34e799aebaadf876f9d96035bc0da9

Authored by Henry Fredrick Schreiner 2017-01-25 17:28:39 -0500

0 parents

Initial commit of CLI library. A few things working, but not much

Inline Side-by-side

Showing 5 changed files with 831 additions and 0 deletions

CLI.hpp 0 → 100644

View file @2db1513

	1	+++ a/CLI.hpp
	1	+#pragma once
	2	+
	3	+#include <string>
	4	+#include <regex>
	5	+#include <iostream>
	6	+#include <functional>
	7	+#include <tuple>
	8	+#include <exception>
	9	+#include <algorithm>
	10	+#include <sstream>
	11	+#include <type_traits>
	12	+
	13	+// This is unreachable outside this file; you should not use Combiner directly
	14	+namespace {
	15	+
	16	+void logit(std::string output) {
	17	+ std::cout << output << std::endl;
	18	+}
	19	+
	20	+template <typename T>
	21	+std::string join(const T& v, std::string delim = ",") {
	22	+ std::ostringstream s;
	23	+ for (const auto& i : v) {
	24	+ if (&i != &v[0]) {
	25	+ s << delim;
	26	+ }
	27	+ s << i;
	28	+ }
	29	+ return s.str();
	30	+}
	31	+
	32	+
	33	+
	34	+
	35	+struct Combiner {
	36	+ int num;
	37	+ bool positional;
	38	+ bool required;
	39	+ bool defaulted;
	40	+
	41	+ /// Can be or-ed together
	42	+ Combiner operator \| (Combiner b) const {
	43	+ Combiner self;
	44	+ self.num = num + b.num;
	45	+ self.positional = positional \|\| b.positional;
	46	+ self.required = required \|\| b.required;
	47	+ self.defaulted = defaulted \|\| b.defaulted;
	48	+ return self;
	49	+ }
	50	+
	51	+ /// Call to give the number of arguments expected on cli
	52	+ Combiner operator() (int n) const {
	53	+ return Combiner{n, positional, required, defaulted};
	54	+ }
	55	+ Combiner operator, (Combiner b) const {
	56	+ return *this \| b;
	57	+ }
	58	+};
	59	+
	60	+
	61	+}
	62	+
	63	+namespace CLI {
	64	+
	65	+class BadNameString : public std::runtime_error {
	66	+public:
	67	+ BadNameString(std::string name) : runtime_error("Failed to parse: " + name) {};
	68	+};
	69	+
	70	+class CallForHelp : public std::runtime_error {
	71	+public:
	72	+ CallForHelp() : runtime_error("Help option passed") {};
	73	+};
	74	+
	75	+class ParseError : public std::runtime_error {
	76	+public:
	77	+ ParseError(std::string info="") : runtime_error(info) {};
	78	+};
	79	+
	80	+class OptionAlreadyAdded : public std::runtime_error {
	81	+public:
	82	+ OptionAlreadyAdded(std::string name) : runtime_error("Already added:" + name) {};
	83	+};
	84	+
	85	+
	86	+
	87	+const std::regex reg_split{R"regex((?:([a-zA-Z0-9]?)(?:,\|$)\|^)([a-zA-Z0-9][a-zA-Z0-9_\-]*)?)regex"};
	88	+const std::regex reg_short{R"regex(-([^-])(.*))regex"};
	89	+const std::regex reg_long{R"regex(--([^-^=][^=])=?(.))regex"};
	90	+
	91	+
	92	+std::tuple<std::string, std::string> split(std::string fullname) throw(BadNameString) {
	93	+
	94	+ std::smatch match;
	95	+ if (std::regex_match(fullname, match, reg_split)) {
	96	+ std::string sname = match[1];
	97	+ std::string lname = match[2];
	98	+ if(sname == "" and lname == "")
	99	+ throw BadNameString("EMPTY");
	100	+ return std::tuple<std::string, std::string>(sname, lname);
	101	+ } else throw BadNameString(fullname);
	102	+}
	103	+
	104	+const Combiner NOTHING {0,false,false,false};
	105	+const Combiner REQUIRED {0,false,true, false};
	106	+const Combiner DEFAULT {0,false,false,true};
	107	+const Combiner POSITIONAL{0,true, false,false};
	108	+const Combiner ARGS {1,false,false,false};
	109	+
	110	+typedef std::vector<std::vector<std::string>> results_t;
	111	+typedef std::function<bool(results_t)> callback_t;
	112	+
	113	+class Option {
	114	+public:
	115	+protected:
	116	+ // Config
	117	+ std::string sname;
	118	+ std::string lname;
	119	+ Combiner opts;
	120	+ std::string discription;
	121	+ callback_t callback;
	122	+
	123	+ // Results
	124	+ results_t results {};
	125	+
	126	+
	127	+public:
	128	+ Option(std::string name, std::string discription = "", Combiner opts=NOTHING, std::function<bool(results_t)> callback=[](results_t){return true;}) throw (BadNameString) :
	129	+ opts(opts), discription(discription), callback(callback){
	130	+ std::tie(sname, lname) = split(name);
	131	+ }
	132	+
	133	+ /// Process the callback
	134	+ bool run_callback() const {
	135	+ return callback(results);
	136	+ }
	137	+
	138	+ /// Indistinguishible options are equal
	139	+ bool operator== (const Option& other) const {
	140	+ if(sname=="" && other.sname=="")
	141	+ return lname==other.lname;
	142	+ else if(lname=="" && other.lname=="")
	143	+ return sname==other.sname;
	144	+ else
	145	+ return sname==other.sname \|\| lname==other.lname;
	146	+ }
	147	+
	148	+ std::string getName() const {
	149	+ if(sname=="")
	150	+ return "--" + lname;
	151	+ else if (lname=="")
	152	+ return "-" + sname;
	153	+ else
	154	+ return "-" + sname + ", --" + lname;
	155	+ }
	156	+
	157	+ bool check_sname(const std::string& name) const {
	158	+ return name == sname;
	159	+ }
	160	+
	161	+ bool check_lname(const std::string& name) const {
	162	+ return name == lname;
	163	+ }
	164	+
	165	+ std::string get_sname() const {
	166	+ return sname;
	167	+ }
	168	+
	169	+ std::string get_lname() const {
	170	+ return lname;
	171	+ }
	172	+
	173	+
	174	+ int get_num() const {
	175	+ return opts.num;
	176	+ }
	177	+
	178	+ void add_result(int r, std::string s) {
	179	+ results.at(r).push_back(s);
	180	+ }
	181	+ int get_new() {
	182	+ results.emplace_back();
	183	+ return results.size() - 1;
	184	+ }
	185	+ int count() {
	186	+ return results.size();
	187	+ }
	188	+
	189	+ std::string string() const {
	190	+ std::string val = "Option: " + getName() + "\n"
	191	+ + " " + discription + "\n"
	192	+ + " [";
	193	+ for(const auto& item : results) {
	194	+ if(&item!=&results[0])
	195	+ val+="],[";
	196	+ val += join(item);
	197	+ }
	198	+ val += "]";
	199	+ return val;
	200	+ }
	201	+
	202	+};
	203	+
	204	+/// Creates a command line program, with very few defaults.
	205	+/** To use, create a new Program() instance with argc, argv, and a help discription. The templated
	206	+* add_option methods make it easy to prepare options. Remember to call `.start` before starting your
	207	+* program, so that the options can be evaluated and the help option doesn't accidentally run your program. */
	208	+class App {
	209	+public:
	210	+
	211	+protected:
	212	+
	213	+ std::string desc;
	214	+ std::vector<Option> options;
	215	+ std::vector<std::string> missing_options;
	216	+ std::vector<std::string> positionals;
	217	+
	218	+public:
	219	+
	220	+
	221	+ /// Create a new program. Pass in the same arguments as main(), along with a help string.
	222	+ App(std::string discription)
	223	+ : desc(discription) {
	224	+ }
	225	+
	226	+ /// Add an option, will automatically understand the type for common types.
	227	+ /** To use, create a variable with the expected type, and pass it in after the name.
	228	+ * After start is called, you can use count to see if the value was passed, and
	229	+ * the value will be initialized properly.
	230	+ *
	231	+ * Program::REQUIRED, Program::DEFAULT, and Program::POSITIONAL are options, and can be `\|`
	232	+ * together. The positional options take an optional number of arguments.
	233	+ *
	234	+ * For example,
	235	+ *
	236	+ * std::string filename
	237	+ * program.add_option("filename", filename, "discription of filename");
	238	+ */
	239	+ void add_option(
	240	+ std::string name, ///< The name, long,short
	241	+ callback_t callback, ///< The callback
	242	+ std::string discription="", ///< Discription string
	243	+ Combiner opts=ARGS ///< The options (REQUIRED, DEFAULT, POSITIONAL, ARGS())
	244	+ ) {
	245	+
	246	+ Option myopt{name, discription, opts, callback};
	247	+ if(std::find(std::begin(options), std::end(options), myopt) == std::end(options))
	248	+ options.push_back(myopt);
	249	+ else
	250	+ throw OptionAlreadyAdded(myopt.getName());
	251	+
	252	+ }
	253	+
	254	+ /// Add option for string
	255	+ void add_option(
	256	+ std::string name, ///< The name, long,short
	257	+ std::string &variable, ///< The variable to set
	258	+ std::string discription="", ///< Discription string
	259	+ Combiner opts=ARGS ///< The options (REQUIRED, DEFAULT, POSITIONAL, ARGS())
	260	+ ) {
	261	+
	262	+ CLI::callback_t fun = [&variable](CLI::results_t res){
	263	+ if(res.size()!=1) {
	264	+ return false;
	265	+ }
	266	+ if(res[0].size()!=1) {
	267	+ return false;
	268	+ }
	269	+ variable = res[0][0];
	270	+ return true;
	271	+ };
	272	+
	273	+ add_option(name, fun, discription, opts);
	274	+ }
	275	+
	276	+
	277	+ /// Add option for flag
	278	+ void add_flag(
	279	+ std::string name, ///< The name, short,long
	280	+ std::string discription="" ///< Discription string
	281	+ ) {
	282	+
	283	+ CLI::callback_t fun = [](CLI::results_t res){
	284	+ return true;
	285	+ };
	286	+
	287	+ add_option(name, fun, discription, NOTHING);
	288	+ }
	289	+
	290	+ /// Add option for flag
	291	+ template<typename T>
	292	+ typename std::enable_if<std::is_integral<T>::value, void>::type
	293	+ add_flag(
	294	+ std::string name, ///< The name, short,long
	295	+ T &count, ///< A varaible holding the count
	296	+ std::string discription="" ///< Discription string
	297	+ ) {
	298	+
	299	+ count = 0;
	300	+ CLI::callback_t fun = [&count](CLI::results_t res){
	301	+ count = res.size();
	302	+ return true;
	303	+ };
	304	+
	305	+ add_option(name, fun, discription, NOTHING);
	306	+ }
	307	+
	308	+
	309	+ /// Parses the command line - throws errors
	310	+ void parse(int argc, char **argv) throw(CallForHelp, ParseError) {
	311	+ std::vector<std::string> args;
	312	+ for(int i=1; i<argc; i++)
	313	+ args.emplace_back(argv[i]);
	314	+ parse(args);
	315	+ }
	316	+
	317	+ void parse(std::vector<std::string> args) throw(CallForHelp, ParseError) {
	318	+ std::reverse(args.begin(), args.end());
	319	+
	320	+ bool positional_only = false;
	321	+
	322	+ while(args.size()>0) {
	323	+
	324	+ if(args.back() == "--") {
	325	+ args.pop_back();
	326	+ positional_only = true;
	327	+ } else if(positional_only \|\| (!_parse_long(args) && !_parse_short(args))) {
	328	+
	329	+ logit("Positional: "+args.back());
	330	+ positionals.push_back(args.back());
	331	+ args.pop_back();
	332	+ }
	333	+ }
	334	+
	335	+ for(Option& opt : options)
	336	+ if (opt.count() > 0) {
	337	+ logit(opt.string());
	338	+ if(!opt.run_callback())
	339	+ logit("Failed");
	340	+ }
	341	+
	342	+ //TODO: Check for false callbacks
	343	+ }
	344	+
	345	+ bool _parse_short(std::vector<std::string> &args) {
	346	+ std::string current = args.back();
	347	+ std::smatch match;
	348	+
	349	+ if(!std::regex_match(current, match, reg_short))
	350	+ return false;
	351	+
	352	+ args.pop_back();
	353	+ std::string name = match[1];
	354	+ std::string rest = match[2];
	355	+
	356	+ logit("Working on short:");
	357	+ logit(name);
	358	+ logit(rest);
	359	+
	360	+ auto op = std::find_if(std::begin(options), std::end(options), [name](const Option &v){return v.check_sname(name);});
	361	+
	362	+ if(op == std::end(options)) {
	363	+ missing_options.push_back("-" + op->get_sname());
	364	+ return true;
	365	+ }
	366	+
	367	+ int vnum = op->get_new();
	368	+ int num = op->get_num();
	369	+
	370	+
	371	+ if(rest != "" && num > 0) {
	372	+ num--;
	373	+ op->add_result(vnum, rest);
	374	+ rest = "";
	375	+ }
	376	+
	377	+ while(num>0) {
	378	+ num--;
	379	+ std::string current = args.back();
	380	+ logit("Adding: "+current);
	381	+ args.pop_back();
	382	+ op->add_result(vnum,current);
	383	+ if(args.size()==0)
	384	+ return true;
	385	+ }
	386	+
	387	+ if(rest != "") {
	388	+ rest = "-" + rest;
	389	+ args.push_back(rest);
	390	+ }
	391	+ return true;
	392	+ }
	393	+
	394	+ bool _parse_long(std::vector<std::string> &args) {
	395	+ std::string current = args.back();
	396	+ std::smatch match;
	397	+
	398	+ if(!std::regex_match(current, match, reg_long))
	399	+ return false;
	400	+
	401	+ args.pop_back();
	402	+ std::string name = match[1];
	403	+ std::string value = match[2];
	404	+
	405	+
	406	+ logit("Working on long:");
	407	+ logit(name);
	408	+ logit(value);
	409	+
	410	+ auto op = std::find_if(std::begin(options), std::end(options), [name](const Option &v){return v.check_lname(name);});
	411	+
	412	+ if(op == std::end(options)) {
	413	+ missing_options.push_back("--" + op->get_lname());
	414	+ return true;
	415	+ }
	416	+
	417	+
	418	+ int vnum = op->get_new();
	419	+ int num = op->get_num();
	420	+
	421	+
	422	+ if(value != "") {
	423	+ num--;
	424	+ op->add_result(vnum, value);
	425	+ }
	426	+
	427	+ while(num>0) {
	428	+ num--;
	429	+ std::string current = args.back();
	430	+ args.pop_back();
	431	+ op->add_result(vnum,current);
	432	+ if(args.size()==0)
	433	+ return true;
	434	+ }
	435	+ return true;
	436	+ }
	437	+
	438	+ /// This must be called after the options are in but before the rest of the program.
	439	+ /** Instead of throwing erros, causes the program to exit
	440	+ * if -h or an invalid option is passed. */
	441	+ void start(int argc, char** argv) {
	442	+ try {
	443	+ parse(argc, argv);
	444	+ } catch(const CallForHelp &e) {
	445	+ std::cout << help() << std::endl;
	446	+ exit(0);
	447	+ } catch(const ParseError &e) {
	448	+ std::cerr << "ERROR:" << std::endl;
	449	+ std::cerr << e.what() << std::endl;
	450	+ std::cerr << help() << std::endl;
	451	+ exit(1);
	452	+ }
	453	+
	454	+ }
	455	+
	456	+ /// Counts the number of times the given option was passed.
	457	+ int count(std::string name) const {
	458	+ return 0;
	459	+ }
	460	+
	461	+ std::string help() const {return "";}
	462	+
	463	+
	464	+};
	465	+}
...	...

Program.hpp 0 → 100644

View file @2db1513

	1	+++ a/Program.hpp
	1	+#pragma once
	2	+
	3	+#include <string>
	4	+
	5	+#include <boost/program_options.hpp>
	6	+
	7	+
	8	+// This is unreachable outside this file; you should not use Combiner directly
	9	+namespace {
	10	+
	11	+struct Combiner {
	12	+ int positional;
	13	+ bool required;
	14	+ bool defaulted;
	15	+
	16	+ /// Can be or-ed together
	17	+ Combiner operator \| (Combiner b) const {
	18	+ Combiner self;
	19	+ self.positional = positional + b.positional;
	20	+ self.required = required \|\| b.required;
	21	+ self.defaulted = defaulted \|\| b.defaulted;
	22	+ return self;
	23	+ }
	24	+
	25	+ /// Call to give the number of arguments expected on cli
	26	+ Combiner operator() (int n) const {
	27	+ return Combiner{n, required, defaulted};
	28	+ }
	29	+ Combiner operator, (Combiner b) const {
	30	+ return *this \| b;
	31	+ }
	32	+};
	33	+}
	34	+
	35	+
	36	+
	37	+/// Creates a command line program, with very few defaults.
	38	+/** To use, create a new Program() instance with argc, argv, and a help description. The templated
	39	+* add_option methods make it easy to prepare options. Remember to call `.start` before starting your
	40	+* program, so that the options can be evaluated and the help option doesn't accidentally run your program. */
	41	+class Program {
	42	+public:
	43	+ static constexpr Combiner REQUIRED{0,true,false};
	44	+ static constexpr Combiner DEFAULT{0,false,true};
	45	+ static constexpr Combiner POSITIONAL{1,false,false};
	46	+
	47	+protected:
	48	+ boost::program_options::options_description desc;
	49	+ boost::program_options::positional_options_description p;
	50	+ boost::program_options::variables_map vm;
	51	+
	52	+ int argc;
	53	+ char **argv;
	54	+
	55	+ /// Parses the command line (internal function)
	56	+ void parse() {
	57	+ try {
	58	+ boost::program_options::store(boost::program_options::command_line_parser(argc, argv)
	59	+ .options(desc).positional(p).run(), vm);
	60	+
	61	+ if(vm.count("help")){
	62	+ std::cout << desc;
	63	+ exit(0);
	64	+ }
	65	+
	66	+ boost::program_options::notify(vm);
	67	+ } catch(const boost::program_options::error& e) {
	68	+ std::cerr << "ERROR: " << e.what() << std::endl << std::endl;
	69	+ std::cerr << desc << std::endl;
	70	+ exit(1);
	71	+ }
	72	+ }
	73	+
	74	+
	75	+public:
	76	+
	77	+ /// Create a new program. Pass in the same arguments as main(), along with a help string.
	78	+ Program(int argc, char** argv, std::string discription)
	79	+ : argc(argc), argv(argv), desc(discription) {
	80	+ desc.add_options()
	81	+ ("help,h", "Display this help message");
	82	+ }
	83	+
	84	+ /// Allows you to manually add options in the boost style.
	85	+ /** Usually the specialized methods are easier, but this remains for people used to Boost and for
	86	+ * unusual situations. */
	87	+ boost::program_options::options_description_easy_init add_options() {
	88	+ return desc.add_options();
	89	+ }
	90	+
	91	+ /// Add an option, will automatically understand the type for common types.
	92	+ /** To use, create a variable with the expected type, and pass it in after the name.
	93	+ * After start is called, you can use count to see if the value was passed, and
	94	+ * the value will be initialized properly.
	95	+ *
	96	+ * Program::REQUIRED, Program::DEFAULT, and Program::POSITIONAL are options, and can be `\|`
	97	+ * together. The positional options take an optional number of arguments.
	98	+ *
	99	+ * For example,
	100	+ *
	101	+ * std::string filename
	102	+ * program.add_option("filename", filename, "description of filename");
	103	+ */
	104	+ template<typename T>
	105	+ void add_option(
	106	+ std::string name, ///< The name, long,short
	107	+ T &value, ///< The value
	108	+ std::string description, ///< Discription string
	109	+ Combiner options ///< The options (REQUIRED, DEFAULT, POSITIONAL)
	110	+ ) {
	111	+ auto po_value = boost::program_options::value<T>(&value);
	112	+ if(options.defaulted)
	113	+ po_value = po_value->default_value(value);
	114	+ if(options.required)
	115	+ po_value = po_value->required();
	116	+ desc.add_options()(name.c_str(),po_value,description.c_str());
	117	+ if(options.positional!=0)
	118	+ p.add(name.c_str(), options.positional);
	119	+ }
	120	+
	121	+ /// Adds a flag style option
	122	+ void add_option(std::string name, std::string description) {
	123	+ desc.add_options()(name.c_str(),description.c_str());
	124	+ }
	125	+
	126	+
	127	+ /// This must be called after the options are in but before the rest of the program.
	128	+ /** Calls the Boost boost::program_options initialization, causing the program to exit
	129	+ * if -h or an invalid option is passed. */
	130	+ void start() {
	131	+ parse();
	132	+ }
	133	+
	134	+ /// Counts the number of times the given option was passed.
	135	+ int count(std::string name) const {
	136	+ return vm.count(name.c_str());
	137	+ }
	138	+
	139	+
	140	+};
...	...

ProgramOP.hpp 0 → 100644

View file @2db1513

	1	+++ a/ProgramOP.hpp
	1	+#pragma once
	2	+
	3	+#include <string>
	4	+#include <functional>
	5	+#include <unordered_set>
	6	+#include <vector>
	7	+#include <iostream>
	8	+
	9	+#include "optionparser.h"
	10	+
	11	+// This is unreachable outside this file; you should not use Combiner directly
	12	+namespace {
	13	+
	14	+struct Combiner {
	15	+ int positional;
	16	+ bool required;
	17	+ bool defaulted;
	18	+
	19	+ /// Can be or-ed together
	20	+ Combiner operator \| (Combiner b) const {
	21	+ Combiner self;
	22	+ self.positional = positional + b.positional;
	23	+ self.required = required \|\| b.required;
	24	+ self.defaulted = defaulted \|\| b.defaulted;
	25	+ return self;
	26	+ }
	27	+
	28	+ /// Call to give the number of arguments expected on cli
	29	+ Combiner operator() (int n) const {
	30	+ return Combiner{n, required, defaulted};
	31	+ }
	32	+};
	33	+}
	34	+
	35	+/// Creates a command line program, with very few defaults.
	36	+/** To use, create a new Program() instance with argc, argv, and a help description. The templated
	37	+* add_option methods make it easy to prepare options. Remember to call `.start` before starting your
	38	+* program, so that the options can be evaluated and the help option doesn't accidentally run your program. */
	39	+class Program {
	40	+public:
	41	+ static constexpr Combiner REQUIRED{0,true,false};
	42	+ static constexpr Combiner DEFAULT{0,false,true};
	43	+ static constexpr Combiner POSITIONAL{1,false,false};
	44	+
	45	+protected:
	46	+ std::vector<option::Descriptor> usage;
	47	+ std::vector<std::function<bool(std::vector<std::string>)>> convert; /// Number is loc+2
	48	+ std::unordered_set<int> required;
	49	+ std::vector<int> counts;
	50	+ std::vector<std::string> random_name_store;
	51	+
	52	+ int argc;
	53	+ char **argv;
	54	+
	55	+ /// Parses the command line (internal function)
	56	+ void parse() {
	57	+ usage.push_back(option::Descriptor{0, 0, nullptr, nullptr, nullptr, nullptr});
	58	+
	59	+ option::Stats stats(usage.data(), argc, argv);
	60	+ std::vector<option::Option> options(stats.options_max);
	61	+ std::vector<option::Option> buffer(stats.buffer_max);
	62	+ option::Parser parse(usage.data(), argc, argv, options.data(), buffer.data());
	63	+
	64	+ if(parse.error()) {
	65	+ std::cerr << "ERROR. See usage:" << std::endl;
	66	+ option::printUsage(std::cerr, usage.data());
	67	+ exit(1);
	68	+ }
	69	+
	70	+
	71	+ if(options[1]){
	72	+ option::printUsage(std::cerr, usage.data());
	73	+ exit(0);
	74	+ }
	75	+
	76	+ bool found_unk = false;
	77	+ for (option::Option* opt = options[0]; opt; opt = opt->next()) {
	78	+ std::cout << "Unknown option: " << opt->name << "\n";
	79	+ found_unk = true;
	80	+ }
	81	+ if(found_unk)
	82	+ exit(2);
	83	+
	84	+ for(int i=2; i<convert.size()+2; i++) {
	85	+ counts.emplace_back(options[i].count());
	86	+ if(options[i]) {
	87	+ std::vector<std::string> opt_list;
	88	+ for(option::Option* opt = options[i]; opt; opt = opt->next())
	89	+ opt_list.emplace_back(opt->arg ? opt->arg : "");
	90	+ convert.at(i-2)(opt_list);
	91	+ }
	92	+ }
	93	+ }
	94	+
	95	+public:
	96	+
	97	+ /// Create a new program. Pass in the same arguments as main(), along with a help string.
	98	+ Program(int argc, char** argv, std::string description)
	99	+ : argc(argc), argv(argv) {
	100	+ random_name_store.emplace_back(description);
	101	+ usage.push_back(option::Descriptor{0, 0, "", "", option::Arg::None, random_name_store.back().c_str()});
	102	+ usage.push_back(option::Descriptor{1, 0, "h", "help", option::Arg::None, "Display usage and exit."});
	103	+ }
	104	+
	105	+
	106	+ /// Add an option, will automatically understand the type for common types.
	107	+ /** To use, create a variable with the expected type, and pass it in after the name.
	108	+ * After start is called, you can use count to see if the value was passed, and
	109	+ * the value will be initialized properly.
	110	+ *
	111	+ * Program::REQUIRED, Program::DEFAULT, and Program::POSITIONAL are options, and can be `\|`
	112	+ * together. The positional options take an optional number of arguments.
	113	+ *
	114	+ * For example,
	115	+ *
	116	+ * std::string filename
	117	+ * program.add_option("filename", filename, "description of filename");
	118	+ */
	119	+ template<typename T>
	120	+ void add_option(
	121	+ std::string name, ///< The name, long,short
	122	+ T &value, ///< The value
	123	+ std::string description, ///< Description string
	124	+ Combiner options ///< The options (REQUIRED, DEFAULT, POSITIONAL)
	125	+ ) {
	126	+
	127	+ int curr_num = convert.size();
	128	+
	129	+ if(options.required)
	130	+ required.emplace(curr_num);
	131	+
	132	+ random_name_store.emplace_back(name);
	133	+ random_name_store.emplace_back(description);
	134	+
	135	+ usage.push_back(option::Descriptor{(unsigned int) convert.size()+2, 0, "", random_name_store.at(random_name_store.size()-2).c_str(), option::Arg::Optional, random_name_store.back().c_str()});
	136	+ add_option_internal(value);
	137	+
	138	+ if(options.positional!=0)
	139	+ std::cout << "positional args not yet supported" << std::endl;
	140	+
	141	+
	142	+
	143	+ }
	144	+
	145	+ /// Adds a flag style option
	146	+ void add_flag(std::string name, std::string description, int& flag) {
	147	+ counts.emplace_back(0);
	148	+ random_name_store.emplace_back(name);
	149	+ random_name_store.emplace_back(description);
	150	+ usage.push_back(option::Descriptor{(unsigned int) convert.size()+2, 0, "", random_name_store.at(random_name_store.size()-2).c_str(), option::Arg::None, random_name_store.back().c_str()});
	151	+ convert.push_back([&flag](std::vector<std::string> v){flag = v.size(); return true;});
	152	+ }
	153	+
	154	+ void add_option_internal(int &val) {
	155	+ convert.push_back([&val](std::vector<std::string> v){val = std::stoi(v.at(0)); return v.size()==1;});
	156	+ }
	157	+
	158	+ void add_option_internal(std::string &val) {
	159	+ convert.push_back([&val](std::vector<std::string> v){val = v.at(0); return v.size()==1;});
	160	+ }
	161	+ /// This must be called after the options are in but before the rest of the program.
	162	+ /** Calls the Boost boost::program_options initialization, causing the program to exit
	163	+ * if -h or an invalid option is passed. */
	164	+ void start() {
	165	+ parse();
	166	+ }
	167	+
	168	+ /// Counts the number of times the given option was passed.
	169	+ int count(std::string name) const {
	170	+ return 0;
	171	+ }
	172	+
	173	+
	174	+};
...	...

try.cpp 0 → 100644

View file @2db1513

	1	+++ a/try.cpp
	1	+#include "CLI.hpp"
	2	+
	3	+
	4	+int main (int argc, char** argv) {
	5	+
	6	+ CLI::App app("K3Pi goofit fitter");
	7	+
	8	+ std::string file;
	9	+ app.add_option("f,file", file, "File name");
	10	+
	11	+ int count;
	12	+ app.add_flag<int>("c,count", count, "File name");
	13	+
	14	+ app.parse(argc, argv);
	15	+
	16	+ std::cout << "Working on file: " << file << std::endl;
	17	+ std::cout << "Working on count: " << count << std::endl;
	18	+
	19	+ return 0;
	20	+}
...	...

try1.cpp 0 → 100644

View file @2db1513

	1	+++ a/try1.cpp
	1	+#include "CLI.hpp"
	2	+
	3	+
	4	+int main (int argc, char** argv) {
	5	+
	6	+ std::vector<std::string> test_strings = {"a,boo", ",coo", "d,", "Q,this-is", "s", "single"};
	7	+
	8	+ for(std::string name : test_strings) {
	9	+ std::string one;
	10	+ std::string two;
	11	+
	12	+ std::tie(one, two) = CLI::split(name);
	13	+ std::cout << one << ", " << two << std::endl;
	14	+ }
	15	+
	16	+ std::vector<std::string> test_fails= {"a,,boo", "a,b,c", "ssd,sfd", "-a", "", ",", "one two"};
	17	+
	18	+ for(std::string name : test_fails) {
	19	+ std::string one;
	20	+ std::string two;
	21	+
	22	+ try {
	23	+ std::tie(one, two) = CLI::split(name);
	24	+ std::cout << "Failed to catch: " << name << std::endl;
	25	+ return 1;
	26	+ } catch (const CLI::BadNameString &e) {
	27	+ std::cout << "Hooray! Caught: " << name << std::endl;
	28	+ }
	29	+ }
	30	+
	31	+
	32	+}
...	...