├── .clang-format
├── CMakeLists.txt
├── example
    ├── CMakeLists.txt
    └── exampleUsage.cpp
├── include
    └── autoArgParse
    │   ├── argHandlers.h
    │   ├── argParser.cpp
    │   ├── argParser.h
    │   ├── argParserBase.h
    │   ├── args.h
    │   ├── flags.h
    │   ├── indentedLine.h
    │   └── parseException.h
├── readme.md
└── src
    └── CMakeLists.txt


/.clang-format:
--------------------------------------------------------------------------------
1 | ---
2 | # We'll use defaults from the google style, but with 4 columns indentation.
3 | BasedOnStyle: google
4 | IndentWidth: 4
5 | ---
6 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | 
 2 | cmake_minimum_required (VERSION 3.6)
 3 | 
 4 | project (AutoArgParse
 5 |          VERSION 1.0.0
 6 |          LANGUAGES CXX)
 7 | 
 8 | add_subdirectory (src)
 9 | 
10 | if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
11 |     add_subdirectory (example)
12 | endif()
13 | 


--------------------------------------------------------------------------------
/example/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | 
2 | cmake_minimum_required (VERSION 3.6)
3 | set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Wextra -Wall")
4 | 
5 | add_executable (exampleUsage exampleUsage.cpp)
6 | target_link_libraries (exampleUsage PRIVATE autoArgParse)
7 | 


--------------------------------------------------------------------------------
/example/exampleUsage.cpp:
--------------------------------------------------------------------------------
 1 | #include <fstream>
 2 | #include <iostream>
 3 | #include "autoArgParse/argParser.h"
 4 | using namespace std;
 5 | using namespace AutoArgParse;
 6 | 
 7 | ArgParser argParser;
 8 | 
 9 | // Let's add an optional flag -p for power
10 | // also attach a trigger which prints a message if -p is detected
11 | auto& powerFlag = argParser.add<ComplexFlag>(
12 |     "-p", Policy::OPTIONAL, "Specify power output.",
13 |     [](const std::string&) { std::cout << "Triggered power flag\n"; });
14 | 
15 | // give -p a mandatory argument, an integer. Typesafe conversion will be used
16 | auto& powerArg = powerFlag.add<Arg<int>>(
17 |     "number_watts", Policy::MANDATORY,
18 |     "An integer representing the number of watts.",
19 |     chain(Converter<int>(), IntRange(0, 50, true, true)));
20 | 
21 | // Let's Add a mandatory flag speed
22 | auto& speedFlag = argParser.add<ComplexFlag>("--speed", Policy::MANDATORY,
23 |                                              "Specify the speed.");
24 | 
25 | auto& exclusiveSpeed = speedFlag.makeExclusiveGroup(Policy::MANDATORY);
26 | // Add three exclusive flags, fast, medium slow
27 | // no need to provide descriptions, these are self explanatory
28 | auto& slow = exclusiveSpeed.add<Flag>("slow", "");
29 | auto& medium = exclusiveSpeed.add<Flag>("medium", "");
30 | auto& fast = exclusiveSpeed.add<Flag>("fast", "");
31 | 
32 | // first demonstrating automatic parsing of file
33 | auto& file1Flag = argParser.add<ComplexFlag>("--file", Policy::OPTIONAL,
34 |                                              "Read the specified file.");
35 | auto& file1 = file1Flag.add<Arg<std::ifstream>>("file_path", Policy::MANDATORY,
36 |                                                 "Path to an existing file.");
37 | 
38 | // now with custm checkso
39 | auto& file2Flag =
40 |     argParser.add<ComplexFlag>("--file2", Policy::OPTIONAL,
41 |                                "Read the specified file with custom checking.");
42 | 
43 | auto& file2 = file2Flag.add<Arg<std::fstream>>(
44 |     "file_path", Policy::MANDATORY, "Path to an existing file.",
45 |     [](const std::string& arg) {
46 |         std::fstream stream;
47 |         stream.open(arg);
48 |         // custom checks, here we will just do good()
49 |         if (!stream.good()) {
50 |             throw ErrorMessage("custom checks of file failed.");
51 |         }
52 |         return stream;
53 |     });
54 | 
55 | int main(const int argc, const char** argv) {
56 |     argParser.validateArgs(argc, argv);
57 |     // the above will print an error and exit if not all arguments were
58 |     //     successfully parsed
59 |     // otherwise, testing flags is easy
60 | 
61 |     if (powerFlag) {
62 |         int power = powerArg.get();
63 |         // already converted to integer
64 |         cout << "Accepted power output of " << power << " W" << endl;
65 |     }
66 |     if (slow) {
67 |         cout << "Running slowly." << endl;
68 |     } else if (medium) {
69 |         cout << "Running normally." << endl;
70 |     } else if (fast) {
71 |         cout << "running fast." << endl;
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/include/autoArgParse/argHandlers.h:
--------------------------------------------------------------------------------
  1 | /**This file contains types required for handling arguments.  Including parsing
  2 |  strings into types and constraints on types.*/
  3 | 
  4 | #ifndef AUTOARGPARSE_ARGHANDLERS_H_
  5 | #define AUTOARGPARSE_ARGHANDLERS_H_
  6 | #include <fstream>
  7 | #include <sstream>
  8 | #include <string>
  9 | #include <tuple>
 10 | #include <utility>
 11 | namespace AutoArgParse {
 12 | struct ErrorMessage : public std::exception {
 13 |     const std::string message;
 14 |     ErrorMessage(const std::string& message) : message(message) {}
 15 | };
 16 | 
 17 | /** a fake converter object, should never be called, used only to assist with
 18 | meta programming. */
 19 | template <typename T>
 20 | struct FakeDoNothingConverter {
 21 |     template <typename... Args>
 22 |     T operator()(const Args&...) const {
 23 |         abort();
 24 |     }
 25 | };
 26 | 
 27 | /**
 28 |  * Default object for converting strings to types.  Defaults to using
 29 |  * `istringstream` and the `>>` operator. can be specialised to use custom
 30 |  * parser.
 31 |  */
 32 | template <typename T>
 33 | struct Converter {
 34 |     inline T operator()(const std::string& stringArgToParse) const {
 35 |         T value;
 36 |         std::istringstream is(stringArgToParse);
 37 |         bool success(is >> value);
 38 |         if (!success) {
 39 |             throw ErrorMessage(makeErrorMessage());
 40 |         }
 41 |         return value;
 42 |     }
 43 | 
 44 |     // allow custom error messages for integral, float and unsigned types
 45 |     static inline std::string makeErrorMessage() {
 46 |         std::ostringstream os;
 47 |         if (std::is_integral<T>::value) {
 48 |             os << "Could not interpret argument as integer";
 49 |         } else if (std::is_floating_point<T>::value) {
 50 |             os << "Could not interpret argument as number";
 51 |         } else {
 52 |             os << "Could not parse argument";
 53 |         }
 54 |         if (std::is_unsigned<T>::value) {
 55 |             os << " greater or equal to 0.";
 56 |         } else {
 57 |             os << ".";
 58 |         }
 59 |         return os.str();
 60 |     }
 61 | };
 62 | 
 63 | template <>
 64 | struct Converter<std::string> {
 65 |     inline std::string operator()(const std::string& stringArgToParse) const {
 66 |         return stringArgToParse;
 67 |     }
 68 | };
 69 | 
 70 | template <>
 71 | struct Converter<std::ifstream> {
 72 |     inline std::ifstream operator()(const std::string& stringArgToParse) const {
 73 |         std::ifstream inFile(stringArgToParse);
 74 |         if (!inFile.good()) {
 75 |             throw ErrorMessage("Could not open file " + stringArgToParse +
 76 |                                " for reading.");
 77 |         }
 78 |         return inFile;
 79 |     }
 80 | };
 81 | 
 82 | template <>
 83 | struct Converter<std::ofstream> {
 84 |     inline std::ofstream operator()(const std::string& stringArgToParse) const {
 85 |         std::ofstream outFile(stringArgToParse);
 86 |         if (!outFile.good()) {
 87 |             throw ErrorMessage("Could not open file " + stringArgToParse +
 88 |                                " for writing.");
 89 |         }
 90 |         return outFile;
 91 |     }
 92 | };
 93 | 
 94 | /*helper classes for the chain function, a function that composes multiple
 95 |  * functions together*/
 96 | namespace detail {
 97 | 
 98 | /** helper functions for ConverterChain class below */
 99 | template <typename Func1, typename Func2>
100 | class Composed {
101 |     Func1 func1;
102 |     Func2 func2;
103 | 
104 |    public:
105 |     Composed(Func1&& func1, Func2&& func2)
106 |         : func1(std::forward<Func1>(func1)),
107 |           func2(std::forward<Func2>(func2)) {}
108 |     template <typename T>
109 |     inline auto operator()(T&& arg)
110 |         -> decltype(func2(func1(std::forward<T>(arg)))) {
111 |         return func2(func1(std::forward<T>(arg)));
112 |     }
113 | };
114 | template <typename Func1, typename Func2>
115 | inline Composed<Func1, Func2> composed(Func1&& func1, Func2&& func2) {
116 |     return Composed<Func1, Func2>(std::forward<Func1>(func1),
117 |                                   std::forward<Func2>(func2));
118 | }
119 | 
120 | template <typename... Funcs>
121 | struct ChainType;
122 | 
123 | template <typename Func1, typename Func2>
124 | struct ChainType<Func1, Func2> {
125 |     typedef Composed<Func1, Func2> type;
126 | };
127 | 
128 | template <typename Func1, typename Func2, typename... Funcs>
129 | struct ChainType<Func1, Func2, Funcs...> {
130 |     typedef Composed<Func1, typename ChainType<Func2, Funcs...>::type> type;
131 | };
132 | }  // namespace detail
133 | 
134 | template <typename Func>
135 | inline auto chain(Func&& func) -> decltype(std::forward<Func>(func)) {
136 |     return std::forward<Func>(func);
137 | }
138 | 
139 | template <typename Func, typename... Funcs>
140 | inline typename detail::ChainType<Func, Funcs...>::type chain(
141 |     Func&& func, Funcs&&... funcs) {
142 |     return detail::composed(std::forward<Func>(func),
143 |                             chain(std::forward<Funcs>(funcs)...));
144 | }
145 | 
146 | /**
147 |  * Integer range constraint
148 |  */
149 | class IntRange {
150 |    public:
151 |     const int min, max;
152 |     const bool minInclusive, maxInclusive;
153 |     IntRange(int min, int max, bool minInclusive, bool maxInclusive)
154 |         : min(min),
155 |           max(max),
156 |           minInclusive(minInclusive),
157 |           maxInclusive(maxInclusive) {}
158 |     int operator()(int parsedValue) const {
159 |         int testMin = (minInclusive) ? min : min + 1;
160 |         int testMax = (maxInclusive) ? max : max - 1;
161 |         if (parsedValue < testMin || parsedValue > testMax) {
162 |             throw ErrorMessage(
163 |                 "Expected value to be between " + std::to_string(min) +
164 |                 ((minInclusive) ? "(inclusive)" : "(exclusive") + " and " +
165 |                 std::to_string(max) +
166 |                 ((maxInclusive) ? "(inclusive)" : "(exclusive)") + ".");
167 |         }
168 |         return parsedValue;
169 |     }
170 | };
171 | }  // namespace AutoArgParse
172 | 
173 | #endif /* AUTOARGPARSE_ARGHANDLERS_H_ */
174 | 


--------------------------------------------------------------------------------
/include/autoArgParse/argParser.cpp:
--------------------------------------------------------------------------------
  1 | #ifndef AUTOARGPARSE_ARGPARSER_CPP_
  2 | #define AUTOARGPARSE_ARGPARSER_CPP_
  3 | 
  4 | #include "argParser.h"
  5 | #include <stdexcept>
  6 | #include "parseException.h"
  7 | 
  8 | #if AUTOARGPARSE_HEADER_ONLY
  9 | #define AUTOARGPARSE_INLINE inline
 10 | #else
 11 | #define AUTOARGPARSE_INLINE /* NO-OP */
 12 | #endif
 13 | 
 14 | namespace AutoArgParse {
 15 | AUTOARGPARSE_INLINE void FlagStore::parse(ArgIter& first, ArgIter& last) {
 16 |     int numberParsedMandatoryFlags = 0;
 17 |     int numberParsedMandatoryArgs = 0;
 18 |     while (first != last) {
 19 |         Policy foundPolicy;
 20 |         if (tryParseFlag(first, last, foundPolicy)) {
 21 |             if (foundPolicy == Policy::MANDATORY) {
 22 |                 numberParsedMandatoryFlags++;
 23 |             }
 24 |         } else if (tryParseArg(first, last, foundPolicy)) {
 25 |             if (foundPolicy == Policy::MANDATORY) {
 26 |                 numberParsedMandatoryArgs++;
 27 |             }
 28 |         } else {
 29 |             break;
 30 |         }
 31 |     }
 32 |     if (numberParsedMandatoryFlags != _numberMandatoryFlags) {
 33 |         if (first == last) {
 34 |             throw MissingMandatoryFlagException(*this);
 35 |         } else {
 36 |             throw UnexpectedArgException(*first, *this);
 37 |         }
 38 |     }
 39 |     if (numberParsedMandatoryArgs != _numberMandatoryArgs) {
 40 |         if (first == last) {
 41 |             throw MissingMandatoryArgException(*this);
 42 |         } else {
 43 |             throw UnexpectedArgException(*first, *this);
 44 |         }
 45 |     }
 46 | }
 47 | 
 48 | AUTOARGPARSE_INLINE bool FlagStore::tryParseArg(ArgIter& first, ArgIter& last,
 49 |                                                 Policy& foundArgPolicy) {
 50 |     for (auto& argPtr : args) {
 51 |         if (argPtr->parsed()) {
 52 |             continue;
 53 |         }
 54 |         argPtr->parse(first, last);
 55 |         if (argPtr->parsed()) {
 56 |             foundArgPolicy = argPtr->policy;
 57 |             return true;
 58 |         }
 59 |     }
 60 |     return false;
 61 | }
 62 | 
 63 | AUTOARGPARSE_INLINE bool FlagStore::tryParseFlag(ArgIter& first, ArgIter& last,
 64 |                                                  Policy& foundFlagPolicy) {
 65 |     auto flagIter = flags.find(*first);
 66 |     if (flagIter != end(flags)) {
 67 |         if (flagIter->second->parsed()) {
 68 |             throw RepeatedFlagException(*first);
 69 |         }
 70 |         ++first;
 71 |         flagIter->second->parse(first, last);
 72 |         foundFlagPolicy = flagIter->second->policy;
 73 |         return true;
 74 |     } else {
 75 |         return false;
 76 |     }
 77 | }
 78 | 
 79 | typedef std::pair<const std::string, FlagPtr> FlagMapping;
 80 | 
 81 | AUTOARGPARSE_INLINE void FlagStore::printUsageSummary(std::ostream& os) const {
 82 |     for (auto& argPtr : args) {
 83 |         os << " ";
 84 |         if (argPtr->policy == Policy::OPTIONAL) {
 85 |             os << "[";
 86 |         }
 87 |         os << argPtr->name;
 88 |         if (argPtr->policy == Policy::OPTIONAL) {
 89 |             os << "]";
 90 |         }
 91 |     }
 92 |     for (const auto& flag : flagInsertionOrder) {
 93 |         auto& flagObj = flags.at(flag);
 94 |         os << " ";
 95 | 
 96 |         if (flagObj->policy == Policy::OPTIONAL) {
 97 |             os << "[";
 98 |         }
 99 |         if (!flagObj->isExclusiveGroup()) {
100 |             os << flag;
101 |         }
102 |         flagObj->printUsageSummary(os);
103 |         if (flagObj->policy == Policy::OPTIONAL) {
104 |             os << "]";
105 |         }
106 |     }
107 | }
108 | 
109 | AUTOARGPARSE_INLINE void printUsageHelp(
110 |     const std::deque<std::string>& flagInsertionOrder, const FlagMap& flags,
111 |     std::ostream& os, IndentedLine& lineIndent) {
112 |     for (const auto& flag : flagInsertionOrder) {
113 |         auto& flagObj = flags.at(flag);
114 |         if (flagObj->description.size() > 0) {
115 |             os << lineIndent;
116 |             os << flag;
117 |             flagObj->printUsageSummary(os);
118 |             os << lineIndent;
119 |             if (flagObj->policy == Policy::OPTIONAL) {
120 |                 os << "[optional] ";
121 |             }
122 |             os << flagObj->description;
123 |             flagObj->printUsageHelp(os, lineIndent);
124 |         } else if (flagObj->isExclusiveGroup()) {
125 |             flagObj->printUsageHelp(os, lineIndent);
126 |         }
127 |     }
128 | }
129 | 
130 | AUTOARGPARSE_INLINE void FlagStore::printUsageHelp(
131 |     std::ostream& os, IndentedLine& lineIndent) const {
132 |     lineIndent.indentLevel++;
133 |     for (auto& argPtr : args) {
134 |         if (argPtr->description.size() > 0) {
135 |             os << lineIndent;
136 |             os << argPtr->name;
137 |             if (argPtr->policy == Policy::OPTIONAL) {
138 |                 os << " [optional]";
139 |             }
140 |             std::cout << ": " << argPtr->description;
141 |         }
142 |     }
143 |     AutoArgParse::printUsageHelp(flagInsertionOrder, flags, os, lineIndent);
144 |     lineIndent.indentLevel--;
145 | }
146 | 
147 | AUTOARGPARSE_INLINE void PrintGroup::printUsageHelp(std::ostream& os) const {
148 |     IndentedLine lineIndent(0);
149 |     if (isDefaultGroup) {
150 |         argParser.printUsageHelp(os, lineIndent);
151 |         return;
152 |     }
153 |     for (size_t index : argsToPrint) {
154 |         auto& argPtr = argParser.getArgs()[index];
155 |         if (argPtr->description.size() > 0) {
156 |             os << lineIndent;
157 |             os << argPtr->name;
158 |             if (argPtr->policy == Policy::OPTIONAL) {
159 |                 os << " [optional]";
160 |             }
161 |             std::cout << ": " << argPtr->description;
162 |         }
163 |     }
164 |     AutoArgParse::printUsageHelp(flagsToPrint, argParser.store.flags, os,
165 |                                  lineIndent);
166 | }
167 | 
168 | AUTOARGPARSE_INLINE void ArgParser::printSuccessfullyParsed(
169 |     std::ostream& os, const char** argv,
170 |     const int numberSuccessfullyParsed) const {
171 |     for (int i = 0; i < numberSuccessfullyParsed; i++) {
172 |         os << " " << argv[i];
173 |     }
174 | }
175 | 
176 | AUTOARGPARSE_INLINE void ArgParser::validateArgs(const int argc,
177 |                                                  const char** argv,
178 |                                                  bool handleError) {
179 |     stringArgs.assign(argv + 1, argv + argc);
180 |     using std::begin;
181 | 
182 |     using std::end;
183 |     auto first = begin(stringArgs);
184 |     auto last = end(stringArgs);
185 |     try {
186 |         parse(first, last);
187 |         if (first != last) {
188 |             throw UnexpectedArgException(*first, this->getFlagStore());
189 |         }
190 |         numberArgsSuccessfullyParsed =
191 |             std::distance(begin(stringArgs), first) + 1;
192 |     } catch (ParseException& e) {
193 |         numberArgsSuccessfullyParsed =
194 |             std::distance(begin(stringArgs), first) + 1;
195 |         if (!handleError) {
196 |             throw;
197 |         }
198 |         std::cerr << "Error: " << e.what() << std::endl;
199 |         std::cerr << "Successfully parsed: ";
200 |         printSuccessfullyParsed(std::cerr, argv);
201 |         std::cerr << "\n\n";
202 |         printAllUsageInfo(std::cerr, argv[0]);
203 |         exit(1);
204 |     } catch (HelpFlagTriggeredException& e) {
205 |         if (first[-1] == std::string("--help")) {
206 |             printAllUsageInfo(std::cout, argv[0]);
207 |         }
208 |         exit(0);
209 |     }
210 | }
211 | 
212 | AUTOARGPARSE_INLINE void ArgParser::printAllUsageInfo(
213 |     std::ostream& os, const std::string& programName) {
214 |     if (helpFlag && firstTimePrinting) {
215 |         firstTimePrinting = false;
216 |         // help flag would have been the first thing added, move it to the end.
217 |         store.rotateLeft();
218 |     }
219 |     os << "Usage: " << programName;
220 |     printUsageSummary(os);
221 |     os << "\n\nArguments:\n";
222 |     if (printGroups.size() == 1) {
223 |         printGroups.at(0).printUsageHelp(os);
224 |         return;
225 |     }
226 |     os << "The options are divided into the following groups.  Use --help "
227 |           "group_name to detail the options under a particular group:\n";
228 |     bool first = true;
229 |     for (auto& pg : printGroups) {
230 |         if (first) {
231 |             first = false;
232 |             continue;
233 |         }
234 |         os << pg.getName() << "  -- " << pg.getDescription() << std::endl;
235 |     }
236 |     if (helpFlag) {
237 |         os << "--help prints this message.\n";
238 |     }
239 | }
240 | 
241 | AUTOARGPARSE_INLINE void throwFailedArgConversionException(
242 |     const std::string& name, const std::string& additionalExpl) {
243 |     throw FailedArgConversionException(name, additionalExpl);
244 | }
245 | 
246 | AUTOARGPARSE_INLINE void throwMoreThanOneExclusiveArgException(
247 |     const std::string& conflictingFlag1, const std::string& conflictingFlag2,
248 |     const std::deque<std::string>& exclusiveFlags) {
249 |     throw MoreThanOneExclusiveArgException(conflictingFlag1, conflictingFlag2,
250 |                                            exclusiveFlags);
251 | }
252 | 
253 | AUTOARGPARSE_INLINE void FlagStore::rotateLeft() {
254 |     if (flagInsertionOrder.empty()) {
255 |         return;
256 |     }
257 |     auto flag = std::move(flagInsertionOrder.front());
258 |     flagInsertionOrder.pop_front();
259 |     flagInsertionOrder.emplace_back(std::move(flag));
260 | }
261 | } /* namespace AutoArgParse */
262 | #endif /* AUTOARGPARSE_ARGPARSER_CPP_ */
263 | 


--------------------------------------------------------------------------------
/include/autoArgParse/argParser.h:
--------------------------------------------------------------------------------
  1 | #ifndef AUTOARGPARSE_ARGPARSER_H_
  2 | #define AUTOARGPARSE_ARGPARSER_H_
  3 | #include "argHandlers.h"
  4 | #include "argParserBase.h"
  5 | #include "args.h"
  6 | #include "flags.h"
  7 | #include "indentedLine.h"
  8 | 
  9 | namespace AutoArgParse {
 10 | class ArgParser;
 11 | class PrintGroup;
 12 | 
 13 | class PrintGroup {
 14 |     ArgParser& argParser;
 15 |     std::string name;
 16 |     std::string description;
 17 |     std::deque<std::string> flagsToPrint;
 18 |     std::vector<size_t> argsToPrint;
 19 |     bool isDefaultGroup;
 20 | 
 21 |    public:
 22 |     PrintGroup(ArgParser& argParser, const std::string& name,
 23 |                const std::string& description, bool isDefaultGroup = false)
 24 |         : argParser(argParser),
 25 |           name(name),
 26 |           description(description),
 27 |           isDefaultGroup(isDefaultGroup) {}
 28 |     inline bool active() const {
 29 |         return !argsToPrint.empty() || !flagsToPrint.empty();
 30 |     }
 31 |     inline const std::string& getName() const { return name; }
 32 | 
 33 |     inline const std::string& getDescription() const { return description; }
 34 |     template <template <class T> class FlagType,
 35 |               typename OnParseTriggerType =
 36 |                   DoNothingTrigger>  // bool means nothing here
 37 |     typename std::enable_if<
 38 |         std::is_base_of<FlagBase, FlagType<OnParseTriggerType>>::value,
 39 |         FlagType<OnParseTriggerType>&>::type
 40 |     add(const std::string& flag, const Policy policy,
 41 |         const std::string& description,
 42 |         OnParseTriggerType&& trigger = DoNothingTrigger());
 43 | 
 44 |     template <typename ArgType,
 45 |               typename ConverterFunc = Converter<typename ArgType::ValueType>,
 46 |               typename ArgValueType = typename ArgType::ValueType>
 47 |     typename std::enable_if<std::is_base_of<ArgBase, ArgType>::value,
 48 |                             Arg<ArgValueType, ConverterFunc>&>::type
 49 |     add(const std::string& name, const Policy policy,
 50 |         const std::string& description,
 51 |         ConverterFunc&& convert = Converter<ArgValueType>());
 52 | 
 53 |     void printUsageHelp(std::ostream& os) const;
 54 |     ExclusiveFlagGroup<DoNothingTrigger>& makeExclusiveGroup(Policy);
 55 | };
 56 | 
 57 | class ArgParser : public ComplexFlag<DoNothingTrigger> {
 58 |     struct HelpFlagTriggeredException {};
 59 |     struct HelpFlagTrigger {
 60 |         ArgParser& argParser;
 61 |         HelpFlagTrigger(ArgParser& argParser) : argParser(argParser) {}
 62 |         void operator()(const std::string&) {
 63 |             throw HelpFlagTriggeredException();
 64 |         }
 65 |     };
 66 | 
 67 |     friend PrintGroup;
 68 |     int numberArgsSuccessfullyParsed = 0;
 69 |     std::vector<std::string> stringArgs;
 70 |     std::deque<PrintGroup> printGroups;
 71 |     ComplexFlag<HelpFlagTrigger>* helpFlag = NULL;
 72 |     bool firstTimePrinting = true;
 73 | 
 74 |    public:
 75 |     ArgParser(bool addHelpFlag = true);
 76 | 
 77 |     inline int getNumberArgsSuccessfullyParsed() const {
 78 |         return numberArgsSuccessfullyParsed;
 79 |     }
 80 |     void printGroupHelp(std::string groupName);
 81 |     void validateArgs(const int argc, const char** argv,
 82 |                       bool handleError = true);
 83 | 
 84 |     void printSuccessfullyParsed(std::ostream& os, const char** argv,
 85 |                                  int numberParsed) const;
 86 | 
 87 |     inline void printSuccessfullyParsed(std::ostream& os,
 88 |                                         const char** argv) const {
 89 |         printSuccessfullyParsed(os, argv, getNumberArgsSuccessfullyParsed());
 90 |     }
 91 |     void printAllUsageInfo(std::ostream& os, const std::string& programName);
 92 | 
 93 |     template <template <class T> class FlagType,
 94 |               typename OnParseTriggerType =
 95 |                   DoNothingTrigger>  // bool means nothing here
 96 |     typename std::enable_if<
 97 |         std::is_base_of<FlagBase, FlagType<OnParseTriggerType>>::value,
 98 |         FlagType<OnParseTriggerType>&>::type
 99 |     add(const std::string& flag, const Policy policy,
100 |         const std::string& description,
101 |         OnParseTriggerType&& trigger = DoNothingTrigger()) {
102 |         return printGroups.at(0).add<FlagType>(
103 |             flag, policy, description,
104 |             std::forward<OnParseTriggerType>(trigger));
105 |     }
106 | 
107 |     template <typename ArgType,
108 |               typename ConverterFunc = Converter<typename ArgType::ValueType>,
109 |               typename ArgValueType = typename ArgType::ValueType>
110 |     typename std::enable_if<std::is_base_of<ArgBase, ArgType>::value,
111 |                             Arg<ArgValueType, ConverterFunc>&>::type
112 |     add(const std::string& name, const Policy policy,
113 |         const std::string& description,
114 |         ConverterFunc&& convert = Converter<ArgValueType>()) {
115 |         return printGroups.at(0).add<ArgType>(
116 |             name, policy, description, std::forward<ConverterFunc>(convert));
117 |     }
118 | 
119 |     inline PrintGroup& makePrintGroup(std::string name,
120 |                                       std::string description) {
121 |         printGroups.emplace_back(*this, name, std::move(description));
122 |         PrintGroup& pg = printGroups.back();
123 |         if (helpFlag) {
124 |             helpFlag->add<Flag>(
125 |                 name, Policy::OPTIONAL, "",
126 |                 [&pg](const std::string&) { pg.printUsageHelp(std::cout); });
127 |         }
128 |         return pg;
129 |     }
130 | };
131 | 
132 | template <template <class T> class FlagType, typename OnParseTriggerType>
133 | typename std::enable_if<
134 |     std::is_base_of<FlagBase, FlagType<OnParseTriggerType>>::value,
135 |     FlagType<OnParseTriggerType>&>::type
136 | PrintGroup::add(const std::string& flag, const Policy policy,
137 |                 const std::string& description, OnParseTriggerType&& trigger) {
138 |     if (!isDefaultGroup) {
139 |         flagsToPrint.emplace_back(flag);
140 |     }
141 |     return static_cast<ComplexFlag<DoNothingTrigger>&>(argParser).add<FlagType>(
142 |         flag, policy, description, std::forward<OnParseTriggerType>(trigger));
143 | }  // namespace AutoArgParse
144 | 
145 | template <typename ArgType, typename ConverterFunc, typename ArgValueType>
146 | typename std::enable_if<std::is_base_of<ArgBase, ArgType>::value,
147 |                         Arg<ArgValueType, ConverterFunc>&>::type
148 | PrintGroup::add(const std::string& name, const Policy policy,
149 |                 const std::string& description, ConverterFunc&& convert) {
150 |     if (!isDefaultGroup) {
151 |         argsToPrint.emplace_back(argParser.getArgs().size());
152 |     }
153 |     return static_cast<ComplexFlag<DoNothingTrigger>&>(argParser).add<ArgType>(
154 |         name, policy, description, std::forward<ConverterFunc>(convert));
155 | }
156 | 
157 | ExclusiveFlagGroup<DoNothingTrigger>& PrintGroup::makeExclusiveGroup(Policy p) {
158 |     return argParser.makeExclusiveGroup(p);
159 | }
160 | inline ArgParser::ArgParser(bool addHelpFlag)
161 |     : ComplexFlag(Policy::MANDATORY, "", DoNothingTrigger()),
162 |       printGroups({PrintGroup(*this, "default", "", true)}) {
163 |     if (addHelpFlag) {
164 |         helpFlag =
165 |             &add<ComplexFlag>("--help", Policy::OPTIONAL, "Print usage help.",
166 |                               HelpFlagTrigger(*this));
167 |     }
168 | }
169 | }  // namespace AutoArgParse
170 | 
171 | #if AUTOARGPARSE_HEADER_ONLY
172 | #include "argParser.cpp"
173 | #endif
174 | 
175 | #endif /* AUTOARGPARSE_ARGPARSER_H_ */
176 | 


--------------------------------------------------------------------------------
/include/autoArgParse/argParserBase.h:
--------------------------------------------------------------------------------
 1 | #ifndef AUTOARGPARSE_ARGPARSERBASE_H_
 2 | #define AUTOARGPARSE_ARGPARSERBASE_H_
 3 | #include <deque>
 4 | #include <iostream>
 5 | #include <memory>
 6 | #include <string>
 7 | #include <unordered_map>
 8 | #include <vector>
 9 | #include "indentedLine.h"
10 | namespace AutoArgParse {
11 | typedef std::vector<std::string>::iterator ArgIter;
12 | 
13 | enum Policy { MANDATORY, OPTIONAL };
14 | 
15 | // absolute base class for flags and args
16 | class ParseToken {
17 |    protected:
18 |     bool _parsed;
19 |     bool _available = true;
20 | 
21 |    public:
22 |     const Policy policy;  // optional or mandatory
23 |     const std::string
24 |         description;  // help info on this parse token (e.g. flag, arg,etc.)
25 | 
26 |     ParseToken(const Policy policy, const std::string& description)
27 |         : _parsed(false), policy(policy), description(description) {}
28 |     virtual ~ParseToken() = default;
29 | 
30 |     /**
31 |      * Return whether or not this parse token (arg/flag/etc.) was successfully
32 |      * parsed.
33 |      */
34 |     inline bool parsed() const { return _parsed; }
35 | 
36 |     inline operator bool() const { return parsed(); }
37 | 
38 |     inline bool available() { return _available; }
39 | };
40 | 
41 | /**Forward declaration of FlagStore such that it may be a friend */
42 | class FlagStore;
43 | class ArgBase : public ParseToken {
44 |     friend FlagStore;
45 | 
46 |    protected:
47 |     virtual void parse(ArgIter& first, ArgIter& last) = 0;
48 | 
49 |    public:
50 |     const std::string name;  // name/description of the arg, not the argitself
51 |     ArgBase(const std::string& name, const Policy policy,
52 |             const std::string& description)
53 |         : ParseToken(policy, description), name(name) {}
54 |     virtual ~ArgBase() = default;
55 | };
56 | 
57 | /**
58 |  * non templated base of flag.
59 |  */
60 | class FlagBase : public ParseToken {
61 |    public:
62 |     virtual void parse(ArgIter& first, ArgIter& last) = 0;
63 |     using ParseToken::ParseToken;
64 |     inline virtual void printUsageHelp(std::ostream&, IndentedLine&) const {}
65 |     inline virtual void printUsageSummary(std::ostream&) const {}
66 | 
67 |     inline void printUsageHelp(std::ostream& os) const {
68 |         IndentedLine lineIndent(0);
69 |         printUsageHelp(os, lineIndent);
70 |     }
71 |     typedef std::unique_ptr<FlagBase> FlagPtr;
72 |     typedef std::unordered_map<std::string, FlagPtr> FlagMap;
73 |     typedef std::vector<std::unique_ptr<ArgBase>> ArgVector;
74 |     virtual inline bool isExclusiveGroup() { return false; }
75 | 
76 |     virtual const std::deque<std::string>& getFlagInsertionOrder() const {
77 |         abort();
78 |     }
79 | };
80 | typedef std::unique_ptr<FlagBase> FlagPtr;
81 | typedef std::unordered_map<std::string, FlagPtr> FlagMap;
82 | typedef std::vector<std::unique_ptr<ArgBase>> ArgVector;
83 | }  // namespace AutoArgParse
84 | #endif /* AUTOARGPARSE_ARGPARSERBASE_H_ */
85 | 


--------------------------------------------------------------------------------
/include/autoArgParse/args.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef AUTOARGPARSE_ARGS_H_
 3 | #define AUTOARGPARSE_ARGS_H_
 4 | #include "argParserBase.h"
 5 | namespace AutoArgParse {
 6 | 
 7 | // forward decls of functions that throw exceptions, cannot include
 8 | // parseException.h in this file due to circular dependencies
 9 | void throwFailedArgConversionException(const std::string& name,
10 |                                        const std::string& additionalExpl);
11 | 
12 | template <typename T, typename ConverterFunc = FakeDoNothingConverter<T>>
13 | class Arg : public ArgBase {
14 |    public:
15 |     typedef T ValueType;
16 | 
17 |    private:
18 |     T parsedValue;
19 |     ConverterFunc convert;
20 | 
21 |    protected:
22 |     virtual inline void parse(ArgIter& first, ArgIter&) {
23 |         _parsed = false;
24 |         try {
25 |             parsedValue = std::move(convert(*first));
26 |             ++first;
27 |             _parsed = true;
28 |         } catch (ErrorMessage& e) {
29 |             if (this->policy == Policy::MANDATORY) {
30 |                 throwFailedArgConversionException(this->name, e.message);
31 |             } else {
32 |                 return;
33 |             }
34 |         }
35 |     }
36 | 
37 |    public:
38 |     Arg(const std::string& name, const Policy policy,
39 |         const std::string& description, ConverterFunc convert)
40 |         : ArgBase(name, policy, description), convert(std::move(convert)) {}
41 | 
42 |     T& get() { return parsedValue; }
43 | };
44 | }  // namespace AutoArgParse
45 | 
46 | #endif /* AUTOARGPARSE_ARGS_H_ */
47 | 


--------------------------------------------------------------------------------
/include/autoArgParse/flags.h:
--------------------------------------------------------------------------------
  1 | 
  2 | #ifndef AUTOARGPARSE_FLAGS_H_
  3 | #define AUTOARGPARSE_FLAGS_H_
  4 | #include <algorithm>
  5 | #include <cstring>
  6 | #include <deque>
  7 | #include <iostream>
  8 | #include <memory>
  9 | #include <stdexcept>
 10 | #include <string>
 11 | #include <unordered_map>
 12 | #include <utility>
 13 | #include <vector>
 14 | #include "argHandlers.h"
 15 | #include "argParserBase.h"
 16 | 
 17 | namespace AutoArgParse {
 18 | struct DoNothingTrigger {
 19 |     void operator()(const std::string&) {}
 20 | };
 21 | 
 22 | // some constants
 23 | static const char* alphanumericSymbols =
 24 |     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890";
 25 | static const size_t alphanumericSymbolsLength = strlen(alphanumericSymbols);
 26 | static const int RANDOM_STRING_LENGTH = 10;
 27 | inline std::string generateRandomString(size_t length) {
 28 |     auto generator = [&]() {
 29 |         return alphanumericSymbols[rand() % alphanumericSymbolsLength];
 30 |     };
 31 |     std::string result;
 32 |     result.reserve(length);
 33 |     std::generate_n(back_inserter(result), length, generator);
 34 |     return result;
 35 | }
 36 | static const std::string RANDOM_STRING =
 37 |     generateRandomString(RANDOM_STRING_LENGTH);
 38 | 
 39 | /**
 40 |  * Represents a simple flag, does not have any nested flags or arguments.
 41 |  */
 42 | template <typename OnParseTrigger>
 43 | class Flag : public FlagBase {
 44 |     OnParseTrigger parsedTrigger;
 45 | 
 46 |    protected:
 47 |     inline void triggerParseSuccess(const std::string& flag) {
 48 |         parsedTrigger(flag);
 49 |     }
 50 |     inline virtual void parse(ArgIter& first, ArgIter&) {
 51 |         _parsed = true;
 52 |         triggerParseSuccess(first[-1]);
 53 |         // we know that first always points to the element just after the most
 54 |         // recently parsed flag
 55 |     }
 56 | 
 57 |    public:
 58 |     Flag(const Policy policy, const std::string& description,
 59 |          OnParseTrigger&& trigger)
 60 |         : FlagBase(policy, description),
 61 |           parsedTrigger(std::forward<OnParseTrigger>(trigger)) {}
 62 |     virtual ~Flag() = default;
 63 | };
 64 | 
 65 | void printUsageHelp(const std::deque<std::string>& flagInsertionOrder,
 66 |                     const FlagMap& flags, std::ostream& os,
 67 |                     IndentedLine& lineIndent);
 68 | 
 69 | /**
 70 |  * A non templated object that can hold most of the data belonging to templated
 71 |  * class ComplexFlag and implement some of its functions.  The purpose of this
 72 |  * class is to allow non templated functions to be defined in the CPP file
 73 |  * rather than having to inline the code in this file.
 74 |  */
 75 | class FlagStore {
 76 |    public:
 77 |     FlagMap flags;
 78 |     std::deque<std::string> flagInsertionOrder;
 79 |     ArgVector args;
 80 |     int _numberMandatoryFlags = 0;
 81 |     int _numberOptionalFlags = 0;
 82 |     int _numberMandatoryArgs = 0;
 83 |     int _numberOptionalArgs = 0;
 84 | 
 85 |     bool tryParseArg(ArgIter& first, ArgIter& last, Policy& foundArgPolicy);
 86 |     bool tryParseFlag(ArgIter& first, ArgIter& last, Policy& foundFlagPolicy);
 87 | 
 88 |     void parse(ArgIter& first, ArgIter& last);
 89 |     void printUsageSummary(std::ostream& os) const;
 90 |     virtual void printUsageHelp(std::ostream& os,
 91 |                                 IndentedLine& lineIndent) const;
 92 |     void rotateLeft();
 93 | };
 94 | 
 95 | void throwMoreThanOneExclusiveArgException(
 96 |     const std::string& conflictingFlag1, const std::string& conflictingFlag2,
 97 |     const std::deque<std::string>& exclusiveFlags);
 98 | 
 99 | template <typename T>
100 | class ExclusiveFlagGroup;
101 | 
102 | template <typename OnParseTrigger>
103 | class ComplexFlag : public Flag<OnParseTrigger> {
104 |     friend class ExclusiveFlagGroup<OnParseTrigger>;
105 | 
106 |    protected:
107 |     FlagStore store;
108 | 
109 |     virtual void parse(ArgIter& first, ArgIter& last) {
110 |         int distance = (int)std::distance(first, last);
111 |         store.parse(first, last);
112 |         this->_parsed = true;
113 |         this->triggerParseSuccess(last[(0 - distance) - 1]);
114 |     }
115 | 
116 |     inline const FlagStore& getFlagStore() { return store; }
117 | 
118 |    public:
119 |     using Flag<OnParseTrigger>::Flag;
120 | 
121 |     inline const ArgVector& getArgs() const { return store.args; }
122 | 
123 |     const FlagMap& getFlagMap() const { return store.flags; }
124 |     const std::deque<std::string>& getFlagInsertionOrder() const {
125 |         return store.flagInsertionOrder;
126 |     }
127 | 
128 |     inline int numberMandatoryArgs() { return store._numberMandatoryArgs; }
129 | 
130 |     inline int numberOptionalArgs() { return store._numberOptionalArgs; }
131 | 
132 |     inline int numberMandatoryFlags() { return store._numberMandatoryFlags; }
133 | 
134 |     inline int numberOptionalFlags() { return store._numberOptionalFlags; }
135 | 
136 |     ExclusiveFlagGroup<OnParseTrigger>& makeExclusiveGroup(Policy);
137 |     template <template <class T> class FlagType,
138 |               typename OnParseTriggerType =
139 |                   DoNothingTrigger>  // bool means nothing here
140 |     typename std::enable_if<
141 |         std::is_base_of<FlagBase, FlagType<OnParseTriggerType>>::value,
142 |         FlagType<OnParseTriggerType>&>::type
143 |     add(const std::string& flag, const Policy policy,
144 |         const std::string& description,
145 |         OnParseTriggerType&& trigger = DoNothingTrigger()) {
146 |         auto added = store.flags.insert(std::make_pair(
147 |             flag, std::unique_ptr<FlagBase>(new FlagType<OnParseTriggerType>(
148 |                       policy, description,
149 |                       std::forward<OnParseTriggerType>(trigger)))));
150 |         if (added.first->second->policy == Policy::MANDATORY) {
151 |             ++store._numberMandatoryFlags;
152 |         } else {
153 |             ++store._numberOptionalFlags;
154 |         }
155 |         store.flagInsertionOrder.emplace_back(flag);
156 |         // get underlying raw pointer from unique pointer, used only for casting
157 |         // purposes
158 |         return *(static_cast<FlagType<OnParseTriggerType>*>(
159 |             added.first->second.get()));
160 |     }
161 | 
162 |     template <typename ArgType,
163 |               typename ConverterFunc = Converter<typename ArgType::ValueType>,
164 |               typename ArgValueType = typename ArgType::ValueType>
165 |     typename std::enable_if<std::is_base_of<ArgBase, ArgType>::value,
166 |                             Arg<ArgValueType, ConverterFunc>&>::type
167 |     add(const std::string& name, const Policy policy,
168 |         const std::string& description,
169 |         ConverterFunc&& convert = Converter<ArgValueType>()) {
170 |         store.args.emplace_back(
171 |             std::unique_ptr<Arg<ArgValueType, ConverterFunc>>(
172 |                 new Arg<ArgValueType, ConverterFunc>(
173 |                     name, policy, description,
174 |                     std::forward<ConverterFunc>(convert))));
175 |         if (store.args.back()->policy == Policy::MANDATORY) {
176 |             ++store._numberMandatoryArgs;
177 |         } else {
178 |             ++store._numberOptionalArgs;
179 |         }
180 |         return *(static_cast<Arg<ArgValueType, ConverterFunc>*>(
181 |             store.args.back().get()));
182 |     }
183 | 
184 |     inline void printUsageSummary(std::ostream& os) const {
185 |         store.printUsageSummary(os);
186 |     }
187 |     inline void printUsageHelp(std::ostream& os,
188 |                                IndentedLine& lineIndent) const {
189 |         store.printUsageHelp(os, lineIndent);
190 |     }
191 |     using Flag<OnParseTrigger>::printUsageHelp;
192 | };
193 | template <typename OnParseFunc>
194 | class ExclusiveFlagGroup : public FlagBase {
195 |     ComplexFlag<OnParseFunc>& parentFlag;
196 |     std::deque<std::string> flags;
197 |     const std::string* _parsedValue;
198 | 
199 |    public:
200 |     const std::string& parsedValue() { return *_parsedValue; }
201 |     ExclusiveFlagGroup(ComplexFlag<OnParseFunc>& parentFlag, Policy policy)
202 |         : FlagBase(policy, ""), parentFlag(parentFlag) {}
203 | 
204 |     inline virtual void parse(ArgIter&, ArgIter&) {
205 |         std::cerr << "This should never be called\n";
206 |         abort();
207 |     }
208 | 
209 |     inline virtual void printUsageHelp(std::ostream& os,
210 |                                        IndentedLine& lineIndent) const {
211 |         AutoArgParse::printUsageHelp(flags, parentFlag.getFlagMap(), os,
212 |                                      lineIndent);
213 |     }
214 |     inline virtual void printUsageSummary(std::ostream& os) const {
215 |         if (flags.empty()) {
216 |             return;
217 |         }
218 |         bool first = true;
219 |         for (const auto& flag : flags) {
220 |             auto& flagObj = parentFlag.getFlagMap().at(flag);
221 |             if (first) {
222 |                 first = false;
223 |             } else {
224 |                 os << "|";
225 |             }
226 |             os << flag;
227 |             flagObj->printUsageSummary(os);
228 |         }
229 |     };
230 | 
231 |     /**
232 |      * Wrapper around OnParseTriggers, insures exclusivity before  allowing a
233 |      * successful parse
234 |      */
235 |     template <typename OnParseTriggerType>
236 |     struct ExclusiveWrapper {
237 |         ExclusiveFlagGroup<OnParseFunc>* parentGroup;
238 |         OnParseTriggerType onParseSuccess;
239 |         ExclusiveWrapper(ExclusiveFlagGroup<OnParseFunc>* parentGroup,
240 |                          OnParseTriggerType&& onParseSuccess)
241 |             : parentGroup(parentGroup), onParseSuccess(onParseSuccess) {}
242 | 
243 |         void operator()(const std::string& flag) {
244 |             if (parentGroup->_parsed) {
245 |                 throwMoreThanOneExclusiveArgException(
246 |                     parentGroup->parsedValue(), flag, parentGroup->flags);
247 |             }
248 |             parentGroup->_parsed = true;
249 |             parentGroup->_available = false;
250 |             parentGroup->_parsedValue = &flag;
251 |             onParseSuccess(flag);
252 |         }
253 |     };
254 | 
255 |     template <template <class T> class FlagType,
256 |               typename OnParseTriggerType = DoNothingTrigger>
257 |     FlagType<ExclusiveWrapper<OnParseTriggerType>>& add(
258 |         const std::string& flag, const std::string& description,
259 |         OnParseTriggerType&& trigger = DoNothingTrigger()) {
260 |         typedef ExclusiveWrapper<OnParseTriggerType> ExclusiveEnforcer;
261 |         auto& flagObj = parentFlag.template add<FlagType>(
262 |             flag, policy, description,
263 |             ExclusiveEnforcer(this, std::forward<OnParseTriggerType>(trigger)));
264 |         flags.push_back(std::move(parentFlag.store.flagInsertionOrder.back()));
265 |         parentFlag.store.flagInsertionOrder.pop_back();
266 |         if (flags.size() > 1) {
267 |             if (policy == Policy::MANDATORY) {
268 |                 --parentFlag.store._numberMandatoryFlags;
269 |             } else {
270 |                 --parentFlag.store._numberOptionalFlags;
271 |             }
272 |         }
273 |         return flagObj;
274 |     }
275 |     virtual inline bool isExclusiveGroup() { return true; }
276 | 
277 |     virtual const std::deque<std::string>& getFlagInsertionOrder() const {
278 |         return flags;
279 |     }
280 | 
281 |     /**indevelopment
282 |         template <template <class T> class FlagType, typename... StringFlags>
283 |         auto with(StringFlags&&... flags)  -> decltype(){
284 |             return std::tie(add<FlagType>(flags,"")...);
285 |         }*/
286 | };
287 | 
288 | template <typename T>
289 | inline ExclusiveFlagGroup<T>& ComplexFlag<T>::makeExclusiveGroup(
290 |     Policy policy) {
291 |     std::string randomName = std::to_string(store.flags.size()) + RANDOM_STRING;
292 |     auto flagIter = store.flags.insert(std::make_pair(
293 |         randomName,
294 |         std::unique_ptr<FlagBase>(new ExclusiveFlagGroup<T>(*this, policy))));
295 |     store.flagInsertionOrder.push_back(randomName);
296 |     return *(static_cast<ExclusiveFlagGroup<T>*>(flagIter.first->second.get()));
297 | }
298 | }  // namespace AutoArgParse
299 | #endif /* AUTOARGPARSE_FLAGS_H_ */
300 | 


--------------------------------------------------------------------------------
/include/autoArgParse/indentedLine.h:
--------------------------------------------------------------------------------
 1 | #ifndef AUTOARGPARSE_INDENTEDLINE_H_
 2 | #define AUTOARGPARSE_INDENTEDLINE_H_
 3 | #include <iostream>
 4 | namespace AutoArgParse {
 5 | class IndentedLine {
 6 |    public:
 7 |     int indentLevel;
 8 |     IndentedLine(int level) : indentLevel(level) {}
 9 |     IndentedLine() : indentLevel(0) {}
10 | 
11 |     inline void forcePrintIndent(std::ostream& os) const {
12 |         for (int i = 0; i < indentLevel; i++) {
13 |             os << "    ";
14 |         }
15 |     }
16 | 
17 |     inline void forceSingleIndent(std::ostream& os) { os << "    "; }
18 |     friend inline std::ostream& operator<<(std::ostream& os,
19 |                                            const IndentedLine& indent) {
20 |         os << "\n";
21 |         indent.forcePrintIndent(os);
22 |         return os;
23 |     }
24 | };
25 | }  // namespace AutoArgParse
26 | #endif /* AUTOARGPARSE_INDENTEDLINE_H_ */
27 | 


--------------------------------------------------------------------------------
/include/autoArgParse/parseException.h:
--------------------------------------------------------------------------------
  1 | #ifndef AUTOARGPARSE_PARSEEXCEPTION_H_
  2 | #define AUTOARGPARSE_PARSEEXCEPTION_H_
  3 | #include <cassert>
  4 | #include <exception>
  5 | #include <iostream>
  6 | #include <sstream>
  7 | #include <string>
  8 | #include "argParser.h"
  9 | namespace AutoArgParse {
 10 | 
 11 | void printUnParsed(std::ostringstream& os,
 12 |                    const std::deque<std::string>& flagInsertionOrder,
 13 |                    const FlagMap& flags) {
 14 |     bool first = true;
 15 |     for (auto& flag : flagInsertionOrder) {
 16 |         auto& flagObj = flags.at(flag);
 17 |         if (flagObj->isExclusiveGroup()) {
 18 |             printUnParsed(os, flagObj->getFlagInsertionOrder(), flags);
 19 |             continue;
 20 |         }
 21 |         if (!flagObj->parsed() && flagObj->available()) {
 22 |             if (first) {
 23 |                 os << " ";
 24 |                 first = false;
 25 |             } else {
 26 |                 os << ", ";
 27 |             }
 28 |             if (flagObj->policy == Policy::OPTIONAL) {
 29 |                 os << "[";
 30 |             }
 31 |             os << flag;
 32 |             if (flagObj->policy == Policy::OPTIONAL) {
 33 |                 os << "]";
 34 |             }
 35 |         }
 36 |     }
 37 | }
 38 | 
 39 | void printUnParsed(std::ostringstream& os, const ArgVector& args) {
 40 |     for (auto& argPtr : args) {
 41 |         if (!argPtr->parsed()) {
 42 |             os << " ";
 43 |             if (argPtr->policy == Policy::OPTIONAL) {
 44 |                 os << "[";
 45 |             }
 46 |             os << argPtr->name;
 47 |             if (argPtr->policy == Policy::OPTIONAL) {
 48 |                 os << "]";
 49 |             }
 50 |         }
 51 |     }
 52 | }
 53 | 
 54 | enum ParseFailureReason {
 55 |     MISSING_MANDATORY_FLAG,
 56 |     REPEATED_FLAG,
 57 |     MISSING_MANDATORY_ARG,
 58 |     UNEXPECTED_ARG,
 59 |     MORE_THAN_ONE_EXCLUSIVE_ARG,
 60 |     FAILED_ARG_CONVERSION
 61 | };
 62 | 
 63 | class ParseException : public std::exception {
 64 |    public:
 65 |     const ParseFailureReason failureReason;
 66 |     const std::string errorMessage;
 67 | 
 68 |     ParseException(ParseFailureReason failureReason, std::string errorMessage)
 69 |         : failureReason(failureReason), errorMessage(errorMessage) {}
 70 | 
 71 |     virtual ~ParseException() = default;
 72 | 
 73 |     virtual const char* what() const noexcept { return errorMessage.c_str(); }
 74 | };
 75 | 
 76 | class MissingMandatoryArgException : public ParseException {
 77 |    public:
 78 |     const FlagStore& flagStore;
 79 | 
 80 |     MissingMandatoryArgException(const FlagStore& flagStore)
 81 |         : ParseException(MISSING_MANDATORY_ARG, makeErrorMessage(flagStore)),
 82 |           flagStore(flagStore) {}
 83 |     static std::string makeErrorMessage(const FlagStore& flagStore) {
 84 |         std::ostringstream os;
 85 |         os << "Missing mandatory argument(s).  Valid option(s) are: ";
 86 |         printUnParsed(os, flagStore.args);
 87 |         return os.str();
 88 |     }
 89 | };
 90 | 
 91 | class MissingMandatoryFlagException : public ParseException {
 92 |    public:
 93 |     const FlagStore& flagStore;
 94 | 
 95 |     MissingMandatoryFlagException(const FlagStore& flagStore)
 96 |         : ParseException(MISSING_MANDATORY_FLAG, makeErrorMessage(flagStore)),
 97 |           flagStore(flagStore) {}
 98 |     static std::string makeErrorMessage(const FlagStore& flagStore) {
 99 |         std::ostringstream os;
100 |         os << "Missing mandatory argument(s). valid option(s) are: ";
101 |         printUnParsed(os, flagStore.flagInsertionOrder, flagStore.flags);
102 |         return os.str();
103 |     }
104 | };
105 | 
106 | class RepeatedFlagException : public ParseException {
107 |    public:
108 |     const std::string repeatedFlag;
109 |     RepeatedFlagException(std::string repeatedFlag)
110 |         : ParseException(REPEATED_FLAG, makeErrorMessage(repeatedFlag)),
111 |           repeatedFlag(std::move(repeatedFlag)) {}
112 |     static std::string makeErrorMessage(const std::string& flag) {
113 |         return "Repeated flag: " + flag;
114 |     }
115 | };
116 | 
117 | class UnexpectedArgException : public ParseException {
118 |    public:
119 |     const std::string unexpectedArg;
120 |     const FlagStore& flagStore;
121 | 
122 |     UnexpectedArgException(std::string unexpectedArg,
123 |                            const FlagStore& flagStore)
124 |         : ParseException(UNEXPECTED_ARG,
125 |                          makeErrorMessage(unexpectedArg, flagStore)),
126 |           unexpectedArg(std::move(unexpectedArg)),
127 |           flagStore(flagStore) {}
128 |     static std::string makeErrorMessage(const std::string& unexpectedArg,
129 |                                         const FlagStore& flagStore) {
130 |         std::ostringstream os;
131 |         os << "Unexpected argument: " << unexpectedArg << std::endl;
132 |         os << "Valid option(s): ";
133 |         printUnParsed(os, flagStore.flagInsertionOrder, flagStore.flags);
134 |         printUnParsed(os, flagStore.args);
135 |         return os.str();
136 |     }
137 | };
138 | 
139 | class MoreThanOneExclusiveArgException : public ParseException {
140 |    public:
141 |     const std::string conflictingFlag1;
142 |     const std::string conflictingFlag2;
143 |     const std::deque<std::string>& exclusiveFlags;
144 | 
145 |     MoreThanOneExclusiveArgException(
146 |         const std::string& conflictingFlag1,
147 |         const std::string& conflictingFlag2,
148 |         const std::deque<std::string>& exclusiveFlags)
149 |         : ParseException(MORE_THAN_ONE_EXCLUSIVE_ARG,
150 |                          makeErrorMessage(conflictingFlag1, conflictingFlag2,
151 |                                           exclusiveFlags)),
152 |           conflictingFlag1(conflictingFlag1),
153 |           conflictingFlag2(conflictingFlag2),
154 |           exclusiveFlags(exclusiveFlags) {}
155 |     static std::string makeErrorMessage(
156 |         const std::string& conflictingFlag1,
157 |         const std::string& conflictingFlag2,
158 |         const std::deque<std::string>& exclusiveFlags) {
159 |         std::ostringstream os;
160 |         os << "Cannot use " << conflictingFlag1 << " in conjunction with "
161 |            << conflictingFlag2 << ".\nThe following flags are exclusive:\n";
162 |         bool first = true;
163 |         for (const auto& flag : exclusiveFlags) {
164 |             if (first) {
165 |                 first = false;
166 |             } else {
167 |                 os << "|";
168 |             }
169 |             os << flag;
170 |         }
171 |         os << "\n";
172 |         return os.str();
173 |     }
174 | };
175 | 
176 | class FailedArgConversionException : public ParseException {
177 |    public:
178 |     const std::string argName;
179 |     const std::string additionalExpl;
180 |     FailedArgConversionException(const std::string& argName,
181 |                                  const std::string& additionalExpl)
182 |         : ParseException(FAILED_ARG_CONVERSION,
183 |                          makeErrorMessage(argName, additionalExpl)),
184 |           argName(argName),
185 |           additionalExpl(additionalExpl) {}
186 |     static std::string makeErrorMessage(const std::string& argName,
187 |                                         const std::string& additionalExpl) {
188 |         return "Could not parse argument: " + argName + "\n" + additionalExpl +
189 |                "\n";
190 |     }
191 | };
192 | }  // namespace AutoArgParse
193 | #endif /* AUTOARGPARSE_PARSEEXCEPTION_H_ */
194 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
  1 | # Auto Arg Parse 
  2 | # Fast and easy C++ argument parser 
  3 | 
  4 | * Automatic validation of program arguments,
  5 | *  Automatic generation of usage instructions,
  6 | *  Type safe conversion from string input to desired type.
  7 | 
  8 | ## Features
  9 | *  Validation of mandatory and optional arguments,
 10 | *  Validation of mandatory and optional flags,
 11 | *  Arbitrary nesting, flags may themselves have mandatory and optional flags or arguments,
 12 | * Type safe, (built in and  user defined) conversions from string input to required type,
 13 | *  Add constraints to arguments,
 14 | *  Make a set of flags exclusive,
 15 | *  Automatically trigger code on successful parsing of a flag or argument,
 16 | 
 17 | 
 18 | ## Coming soon
 19 | 
 20 | *  Variable number of arguments,
 21 | *  More built in conversions (other number formats, file path->stream conversion, etc.)
 22 | 
 23 | 
 24 | # Example Usage
 25 | 
 26 | ## Setting up:
 27 | ### Code:
 28 | 
 29 | ```c++
 30 | #include <iostream>
 31 | #include "autoArgParse/argParser.h"
 32 | using namespace std;
 33 | using namespace AutoArgParse;
 34 | 
 35 | ArgParser argParser;
 36 | //declare flags and args here
 37 | 
 38 | int main(const int argc, const char** argv) {
 39 | //or here 
 40 | //then 
 41 |     argParser.validateArgs(argc, argv);
 42 | }
 43 | ```
 44 | 
 45 | ### Output:
 46 | If all flags and args are validated, proceed as normal, otherwise,an error is printed with the usage information (see below).
 47 | 
 48 | ## Mandatory flag
 49 | 
 50 | ### Code:
 51 | ```c++
 52 | // Let's Add a mandatory flag speed
 53 | auto& speedFlag = argParser.add<Flag>("--speed", Policy::MANDATORY,
 54 |                                              "Specify the speed limit.");
 55 | ```
 56 | ### Output:
 57 | 
 58 | ```
 59 | $./testProg 
 60 | Error: Missing mandatory argument(s). valid option(s) are:  --speed
 61 | Successfully parsed:  ./testProg
 62 | ...
 63 | ```
 64 | 
 65 | ## Optional flag 
 66 | ### Code:
 67 | ```c++
 68 | // Let's add an optional flag -p for power
 69 | auto& powerFlag =
 70 |     argParser.add<Flag>("-p", Policy::OPTIONAL, "Use power.");
 71 | ```
 72 | 
 73 | ### Output:
 74 | ```
 75 | $./testProg  -a
 76 | Error: Unexpected argument: -a
 77 | Valid option(s):  [-p]
 78 | ...
 79 | $./testProg 
 80 | okay, -p is optional
 81 | $./testProg  -p
 82 | Okay, -p is optional and has been used
 83 | ```
 84 | 
 85 | ## Trigger code when flag is detected:
 86 | ### Code:
 87 | ```c++
 88 | // Let's add an optional flag -p for power
 89 | //also attach a trigger which prints a message if -p is detected
 90 | auto& powerFlag = argParser.add<ComplexFlag>(
 91 |     "-p", Policy::OPTIONAL, "Specify power output.",
 92 |     [](const std::string&) { std::cout << "Triggered power flag\n"; });
 93 | ```
 94 | 
 95 | ### Output:
 96 | ```
 97 | $./testProg 
 98 | <no_output>
 99 | 
100 | $./testProg  -p
101 | Triggered power flag
102 | ```
103 | 
104 | 
105 | ## Nesting, flags may themselves take flags and arguments
106 | Give -p a mandatory integer argument, type safe conversion from string to int will automatically be used.
107 | 
108 | ### Code:
109 | ```c++
110 | // Let's add an optional flag -p for power.
111 | //This time, -p is of type ComplexFlag.
112 | //Allows nesting
113 | auto& powerFlag =
114 |     argParser.add<ComplexFlag>("-p", Policy::OPTIONAL, "Specify power output.");
115 | 
116 | // give -p a mandatory argument, an integer. Type safe conversion will be used
117 | auto& powerArg =
118 |     powerFlag.add<Arg<int>>("number_watts", Policy::MANDATORY,
119 |                             "An integer representing the number of watts.");
120 | 
121 | ```
122 | 
123 | ### Output:
124 | ```
125 | $./testProg -p 
126 | Error: Missing mandatory argument(s).  Valid option(s) are:  number_watts
127 | Successfully parsed:  ./testProg -p
128 | ...
129 | $./testProg -p fudge
130 | Error: Could not parse argument: number_watts
131 | Could not interpret "fudge" as an integer.
132 | ...
133 | ```
134 | 
135 | ## Add constraint to argument:
136 | Power must be in range 0-50 inclusive.
137 | 
138 | ## Code: modified from above
139 | ```c++
140 | 
141 | // Let's add an optional flag -p for power
142 | auto& powerFlag =
143 |     argParser.add<ComplexFlag>("-p", Policy::OPTIONAL, "Specify power output.");
144 | 
145 | // give -p a mandatory argument, an integer. Typesafe conversion will be used
146 | auto& powerArg = powerFlag.add<Arg<int>>(
147 |     "number_watts", Policy::MANDATORY,
148 |     "An integer representing the number of watts in the range 0..50.",
149 |     chain(Converter<int>(), IntRange(0, 50, true, true)));
150 | ```
151 | 
152 | ### Output:
153 | ```
154 | $./testProg -p 55 
155 | Error: Could not parse argument: number_watts
156 | Expected value to be between 0(inclusive) and 50(inclusive).
157 | ...
158 | ```
159 | 
160 | ## Exclusive flags:
161 | 
162 | ### Code:
163 | ```c++
164 | auto& speedFlag = argParser.add<ComplexFlag>("--speed", Policy::MANDATORY,
165 |                                              "Specify the speed.");
166 | 
167 | auto& exclusiveSpeed = speedFlag.makeExclusiveGroup(Policy::MANDATORY);
168 | // Add three exclusive flags, fast, medium slow
169 | // no need to provide descriptions, these are self explanatory
170 | auto& slow = exclusiveSpeed.add<Flag>("slow", "");
171 | auto& medium = exclusiveSpeed.add<Flag>("medium", "");
172 | auto& fast = exclusiveSpeed.add<Flag>("fast", "");
173 | ```
174 | 
175 | ### Output:
176 | ```
177 | $ ./testProg --speed 
178 | Error: Missing mandatory argument(s). valid option(s) are:  slow, medium, fast
179 | Successfully parsed:  ./testProg --speed
180 | ...
181 | $ ./testProg --speed fast slow
182 | Error: The following arguments are exclusive and may not be used in conjunction: fast|medium|slow
183 | Successfully parsed:  ./testProg --speed
184 | ...
185 | ```
186 | 
187 | ## Add user defined constraint to argument
188 | Here we put constraints on  a file path before converting to an `ifstream`.   Note however that this is only  for demonstration purposes.  This is already  automatically done for `ifstream` and  `ofstream`. 
189 | ### Code:
190 | ```
191 | 
192 | auto& fileFlag = argParser.add<ComplexFlag>("--file", Policy::OPTIONAL,
193 |                                             "Read the specified file.");
194 | //passing a lambda function which validates the argument.
195 | auto& file = fileFlag.add<Arg<std::ifstream>>(
196 |     "file_path", Policy::MANDATORY, "Path to an existing file.",
197 |     [](const std::string& arg) {
198 |         std::fstream stream;
199 |         stream.open(arg);
200 |         if (!stream.good()) {
201 |             throw ErrorMessage("File " + arg + " does not exist.");
202 |         }
203 |         return std::move(stream);
204 |     });
205 | 
206 | ```
207 | 
208 | ### Output:
209 | ```
210 | $ ./testProg  --file fudge_file 
211 | Error: Could not parse argument: file_path
212 | File fudge_file does not exist.
213 | 
214 | Successfully parsed:  ./testProg --file
215 | ...
216 | ```
217 | 
218 | ## Usage information:
219 | ### Code:
220 | If an error is reported, the usage information is printed out.  Otherwise, the information can be manually printed:
221 | ```c++
222 | int main(const int argc, const char** argv) {
223 |     argParser.printAllUsageInfo(cout, argv[0]);
224 | }
225 | ```
226 | 
227 | ### Output:
228 | Taken from code src/exampleUsage.cpp
229 | ```
230 | Usage: ./testProg [-p number_watts]  --speed slow|medium|fast  
231 | 
232 | Arguments:
233 |     -p number_watts
234 |     [optional] Specify power output.
235 |             number_watts: An integer representing the number of watts.
236 |         --speed slow|medium|fast 
237 |     Specify the speed.
238 |             
239 | ```
240 | 
241 | ## Testing flag status after validation:
242 | 
243 | *  Recommended, use code triggers where possible, they will be automatically run if a flag and all its sub flags are successfully parsed.  No need to list out long chains of if/else blocks.
244 | *  Attach code triggers to arg objects by chaining user defined constraints.  Constraints can act like code triggers as they run arbitrary code (see chaining and user defined constraints below).
245 | *  Alternatively, All flags and arguments are implicitly convertible to bool (true=parsed, false otherwise).  For example, you can test if an optional flag `"-p"` has been provided by querying its flag object `if (powerFlag)`.
246 | *  Retrieve the value given to an argument by calling the member function `arg.get()`.
247 | *  Retrieve the value used for an exclusive group by calling `exclusiveGroup.parsedValue()`.
248 | 
249 | ### Code:
250 | ```c++
251 | int main(const int argc, const char** argv) {
252 |     argParser.validateArgs(argc, argv);
253 |     // the above will print an error and exit if not all arguments were
254 |     //     successfully parsed
255 |     // otherwise, testing flags is easy
256 | 
257 | 
258 |     if (powerFlag) {
259 |         int power = powerArg.get();
260 |         // already converted to integer
261 |         cout << "Accepted power output of " << power << " W" << endl;
262 |     }
263 |     //either get the string flag itself using:
264 |     //exclusiveSpeed.parsedValue()
265 |     //or test each flag object individually 
266 |     if (slow) {
267 |         cout << "Running slowly." << endl;
268 |     } else if (medium) {
269 |         cout << "Running normally." << endl;
270 |     } else if (fast) {
271 |         cout << "running fast." << endl;
272 |     }
273 |     //also allowed to do
274 |     }
275 | 
276 | ```
277 | 
278 | 
279 | # Implementation FAQ:
280 | 
281 | 
282 | ## Is auto-arg-parse fast?
283 | The aim has been to make the validation of *correct* input fast.  Sometimes, this leads to slower error reporting on incorrect input. However, since finding an error usually leads to the program exiting, preference is given to speeding up the validating of valid input.  It is however still very doubtful that any speed differences will ever be noticed.
284 | 
285 | ## What is the scope/life time of an argument or flag?
286 | 
287 | *  As long as the `ArgParser` object is in scope, all flags and arguments shall remain constructed.  
288 | * You need not maintain a reference to a `flag`, `ComplexFlag` or  `Arg` object unless you wish to query its status. e.g. 
289 | *     Test if an optional flag has been used,
290 | *     Retrieve the value given as an argument.
291 | *  This is therefore legal and sometimes recommended. 
292 |     ```
293 |     auto& someArg = argParser.add<ComplexFlag>("--flag", Policy::OPTIONAL, "")
294 |     .add<Arg<int>>("someArg", Policy::MANDATORY, "");
295 |     ```
296 | * You should __never__ need to copy or copy-initialise a flag or argument object. Only maintain references where possible.  e.g. `auto& arg = ...` not `auto arg = ...`  
297 |     Since `someArg` is a mandatory argument on `--flag`, you can test if a value for `someArg` exists by testing, `if (someArg)`.  You need not test the flag itself, though that is of course up to you.
298 | 
299 | ## Are there restrictions on the type of an argument `arg<T>`?
300 | Here, `T` must be default constructible and movable.  It need not be copyable.  If you are getting an error due to a missing copy constructor, first check that you are not copy-initialising arguments (you should be doing `auto& arg = ...` not `auto arg = ...`).  If you are still getting an error, please report it as a bug.
301 | 
302 | ## How do I parse an argument of a type other than string or int:
303 | 
304 | So far, parsing args of type `Arg<int>` or `Arg<std::string>` require no further work, they will trigger built-in converters.
305 | 
306 | However, if you wish to parse an argument of an unsupported type, you have two options:
307 | 
308 | The simplest option is to provide a fourth argument to the add<Arg<NewType>>() method, an object (e.g. lambda) that implements:
309 | ```
310 | void operator()(const std::sotring& stringArgToParse, NewType& parsedValue);
311 | ```
312 | In this function:
313 | * `Newtype& parsedValue` has been default constructed and represents the parsed value.
314 | * `const std::string& stringToParse` is the string argument given at the command line.
315 | * You signal an error by calling `throw ErrorMessage("error here")`.  
316 | 
317 | Here is an example of parsing a  string file path into an fstream  object, reporting an error if the file does not exist:
318 | ```c++
319 | auto& file = argParser.add<Arg<std::fstream>>(
320 |     "file_path", Policy::MANDATORY, "Path to an existing file.",
321 |     [](const std::string& arg) {
322 |         std::fstream stream;
323 |         stream.open(arg);
324 |         if (!stream.good()) {
325 |             throw ErrorMessage("File " + arg + " does not exist.");
326 |         }
327 |         return stream;
328 |     });
329 | ```
330 | 
331 | Alternatively, you may provide a default converter for all instances of `Arg<NewType>` by specialising the Converter object within the AutoArgParse namespace.
332 | 
333 |  ```
334 | namespace AutoArgParse {
335 | template <> struct Converter<NewType> {
336 | 	inline void operator()(const std::string& stringToParse,
337 | 			NewType& parsedValue) {
338 | 		...
339 | 	}
340 | }
341 | }
342 | ```
343 | 
344 | ## How do I constrain the allowed values of an argument?
345 | 
346 | 
347 | User defined constraints are specified exactly in the same method as converters (see above).  You pass the value through if it is allowed or throw ErrorMessage if not.  This allows constraints to be tested before or after parsing the given string into the argument type, which ever is more efficient/convenient.  So far, the `IntRange` constraint has been provided as a built-in (see end of section on chaining), more are coming soon.
348 | 
349 | ## How do I add multiple constraints to an argument?
350 | 
351 | You may wish to apply multiple constraints to an argument, or perhaps apply a conversion followed by a constraint.  You can do this by calling the `Auto'ArgParse::chain(...)` function.  Below is an example where we use the built in conversion to int followed by a lambda function to verify that the int is within the correct range.
352 | 
353 | ```c++
354 | auto& intArg = argParser.add<Arg<int>>(
355 |     "some_int", Policy::MANDATORY, "description",
356 |     chain(Converter<int>(),
357 |     [](const std::string& arg, int& value) {
358 |         if (value < 0 || value > 50) {
359 |             throw ErrorMessage("Integer is out of range.");
360 |         }
361 |     }));
362 | ```
363 | 
364 | For convenience an IntRange constraint has already been added:
365 | 
366 | ```c++
367 | auto& intArg = argParser.add<Arg<int>>(
368 |     "some_int", Policy::MANDATORY, "description",
369 |     chain(Converter<int>(), IntRange(0,50,true,true)));
370 | ```
371 | 


--------------------------------------------------------------------------------
/src/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | 
 2 | cmake_minimum_required (VERSION 3.6)
 3 | 
 4 | # List of C++ features used.
 5 | # Should be `cxx_std_11`, but this style specification was introduced from `CMake` 3.8
 6 | set (CXX_FEATURES_USED cxx_auto_type
 7 |                        cxx_defaulted_functions
 8 |                        cxx_generalized_initializers
 9 |                        cxx_variadic_templates)
10 | 
11 | add_library (autoArgParse INTERFACE)
12 | target_include_directories (autoArgParse INTERFACE
13 |                             $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>
14 |                             $<INSTALL_INTERFACE:include>)
15 | target_compile_features (autoArgParse INTERFACE ${CXX_FEATURES_USED})
16 | target_compile_definitions (autoArgParse INTERFACE AUTOARGPARSE_HEADER_ONLY=1)
17 | 


--------------------------------------------------------------------------------