|
|
@@ -0,0 +1,4113 @@
|
|
|
+#pragma once
|
|
|
+
|
|
|
+// CLI11: Version 1.6.2
|
|
|
+// Originally designed by Henry Schreiner
|
|
|
+// https://github.com/CLIUtils/CLI11
|
|
|
+//
|
|
|
+// This is a standalone header file generated by MakeSingleHeader.py in CLI11/scripts
|
|
|
+// from: v1.6.2
|
|
|
+//
|
|
|
+// From LICENSE:
|
|
|
+//
|
|
|
+// CLI11 1.6 Copyright (c) 2017-2018 University of Cincinnati, developed by Henry
|
|
|
+// Schreiner under NSF AWARD 1414736. All rights reserved.
|
|
|
+//
|
|
|
+// Redistribution and use in source and binary forms of CLI11, with or without
|
|
|
+// modification, are permitted provided that the following conditions are met:
|
|
|
+//
|
|
|
+// 1. Redistributions of source code must retain the above copyright notice, this
|
|
|
+// list of conditions and the following disclaimer.
|
|
|
+// 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
|
+// this list of conditions and the following disclaimer in the documentation
|
|
|
+// and/or other materials provided with the distribution.
|
|
|
+// 3. Neither the name of the copyright holder nor the names of its contributors
|
|
|
+// may be used to endorse or promote products derived from this software without
|
|
|
+// specific prior written permission.
|
|
|
+//
|
|
|
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
|
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
|
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
|
|
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
|
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
|
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
|
+// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
+
|
|
|
+
|
|
|
+// Standard combined includes:
|
|
|
+
|
|
|
+#include <algorithm>
|
|
|
+#include <deque>
|
|
|
+#include <exception>
|
|
|
+#include <fstream>
|
|
|
+#include <functional>
|
|
|
+#include <iomanip>
|
|
|
+#include <iostream>
|
|
|
+#include <istream>
|
|
|
+#include <iterator>
|
|
|
+#include <locale>
|
|
|
+#include <map>
|
|
|
+#include <memory>
|
|
|
+#include <numeric>
|
|
|
+#include <set>
|
|
|
+#include <sstream>
|
|
|
+#include <stdexcept>
|
|
|
+#include <string>
|
|
|
+#include <sys/stat.h>
|
|
|
+#include <sys/types.h>
|
|
|
+#include <tuple>
|
|
|
+#include <type_traits>
|
|
|
+#include <utility>
|
|
|
+#include <vector>
|
|
|
+
|
|
|
+
|
|
|
+// Verbatim copy from CLI/Version.hpp:
|
|
|
+
|
|
|
+
|
|
|
+#define CLI11_VERSION_MAJOR 1
|
|
|
+#define CLI11_VERSION_MINOR 6
|
|
|
+#define CLI11_VERSION_PATCH 2
|
|
|
+#define CLI11_VERSION "1.6.2"
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+// Verbatim copy from CLI/Macros.hpp:
|
|
|
+
|
|
|
+
|
|
|
+// The following version macro is very similar to the one in PyBind11
|
|
|
+#if !(defined(_MSC_VER) && __cplusplus == 199711L) && !defined(__INTEL_COMPILER)
|
|
|
+#if __cplusplus >= 201402L
|
|
|
+#define CLI11_CPP14
|
|
|
+#if __cplusplus >= 201703L
|
|
|
+#define CLI11_CPP17
|
|
|
+#if __cplusplus > 201703L
|
|
|
+#define CLI11_CPP20
|
|
|
+#endif
|
|
|
+#endif
|
|
|
+#endif
|
|
|
+#elif defined(_MSC_VER) && __cplusplus == 199711L
|
|
|
+// MSVC sets _MSVC_LANG rather than __cplusplus (supposedly until the standard is fully implemented)
|
|
|
+// Unless you use the /Zc:__cplusplus flag on Visual Studio 2017 15.7 Preview 3 or newer
|
|
|
+#if _MSVC_LANG >= 201402L
|
|
|
+#define CLI11_CPP14
|
|
|
+#if _MSVC_LANG > 201402L && _MSC_VER >= 1910
|
|
|
+#define CLI11_CPP17
|
|
|
+#if __MSVC_LANG > 201703L && _MSC_VER >= 1910
|
|
|
+#define CLI11_CPP20
|
|
|
+#endif
|
|
|
+#endif
|
|
|
+#endif
|
|
|
+#endif
|
|
|
+
|
|
|
+#if defined(CLI11_CPP14)
|
|
|
+#define CLI11_DEPRECATED(reason) [[deprecated(reason)]]
|
|
|
+#elif defined(_MSC_VER)
|
|
|
+#define CLI11_DEPRECATED(reason) __declspec(deprecated(reason))
|
|
|
+#else
|
|
|
+#define CLI11_DEPRECATED(reason) __attribute__((deprecated(reason)))
|
|
|
+#endif
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+// Verbatim copy from CLI/Optional.hpp:
|
|
|
+
|
|
|
+#ifdef __has_include
|
|
|
+
|
|
|
+// You can explicitly enable or disable support
|
|
|
+// by defining these to 1 or 0.
|
|
|
+#if defined(CLI11_CPP17) && __has_include(<optional>) && \
|
|
|
+ !defined(CLI11_STD_OPTIONAL)
|
|
|
+#define CLI11_STD_OPTIONAL 1
|
|
|
+#endif
|
|
|
+
|
|
|
+#if defined(CLI11_CPP14) && __has_include(<experimental/optional>) && \
|
|
|
+ !defined(CLI11_EXPERIMENTAL_OPTIONAL) \
|
|
|
+ && (!defined(CLI11_STD_OPTIONAL) || CLI11_STD_OPTIONAL == 0)
|
|
|
+#define CLI11_EXPERIMENTAL_OPTIONAL 1
|
|
|
+#endif
|
|
|
+
|
|
|
+#if __has_include(<boost/optional.hpp>) && !defined(CLI11_BOOST_OPTIONAL)
|
|
|
+#include <boost/version.hpp>
|
|
|
+#if BOOST_VERSION >= 105800
|
|
|
+#define CLI11_BOOST_OPTIONAL 1
|
|
|
+#endif
|
|
|
+#endif
|
|
|
+
|
|
|
+#endif
|
|
|
+
|
|
|
+#if CLI11_STD_OPTIONAL
|
|
|
+#include <optional>
|
|
|
+#endif
|
|
|
+#if CLI11_EXPERIMENTAL_OPTIONAL
|
|
|
+#include <experimental/optional>
|
|
|
+#endif
|
|
|
+#if CLI11_BOOST_OPTIONAL
|
|
|
+#include <boost/optional.hpp>
|
|
|
+#endif
|
|
|
+
|
|
|
+
|
|
|
+// From CLI/Version.hpp:
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+// From CLI/Macros.hpp:
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+// From CLI/Optional.hpp:
|
|
|
+
|
|
|
+namespace CLI {
|
|
|
+
|
|
|
+#if CLI11_STD_OPTIONAL
|
|
|
+template <typename T> std::istream &operator>>(std::istream &in, std::optional<T> &val) {
|
|
|
+ T v;
|
|
|
+ in >> v;
|
|
|
+ val = v;
|
|
|
+ return in;
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+#if CLI11_EXPERIMENTAL_OPTIONAL
|
|
|
+template <typename T> std::istream &operator>>(std::istream &in, std::experimental::optional<T> &val) {
|
|
|
+ T v;
|
|
|
+ in >> v;
|
|
|
+ val = v;
|
|
|
+ return in;
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+#if CLI11_BOOST_OPTIONAL
|
|
|
+template <typename T> std::istream &operator>>(std::istream &in, boost::optional<T> &val) {
|
|
|
+ T v;
|
|
|
+ in >> v;
|
|
|
+ val = v;
|
|
|
+ return in;
|
|
|
+}
|
|
|
+#endif
|
|
|
+
|
|
|
+// Export the best optional to the CLI namespace
|
|
|
+#if CLI11_STD_OPTIONAL
|
|
|
+using std::optional;
|
|
|
+#elif CLI11_EXPERIMENTAL_OPTIONAL
|
|
|
+using std::experimental::optional;
|
|
|
+#elif CLI11_BOOST_OPTIONAL
|
|
|
+using boost::optional;
|
|
|
+#endif
|
|
|
+
|
|
|
+// This is true if any optional is found
|
|
|
+#if CLI11_STD_OPTIONAL || CLI11_EXPERIMENTAL_OPTIONAL || CLI11_BOOST_OPTIONAL
|
|
|
+#define CLI11_OPTIONAL 1
|
|
|
+#endif
|
|
|
+
|
|
|
+} // namespace CLI
|
|
|
+
|
|
|
+// From CLI/StringTools.hpp:
|
|
|
+
|
|
|
+namespace CLI {
|
|
|
+namespace detail {
|
|
|
+
|
|
|
+// Based on http://stackoverflow.com/questions/236129/split-a-string-in-c
|
|
|
+/// Split a string by a delim
|
|
|
+inline std::vector<std::string> split(const std::string &s, char delim) {
|
|
|
+ std::vector<std::string> elems;
|
|
|
+ // Check to see if empty string, give consistent result
|
|
|
+ if(s.empty())
|
|
|
+ elems.emplace_back("");
|
|
|
+ else {
|
|
|
+ std::stringstream ss;
|
|
|
+ ss.str(s);
|
|
|
+ std::string item;
|
|
|
+ while(std::getline(ss, item, delim)) {
|
|
|
+ elems.push_back(item);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return elems;
|
|
|
+}
|
|
|
+
|
|
|
+/// Simple function to join a string
|
|
|
+template <typename T> std::string join(const T &v, std::string delim = ",") {
|
|
|
+ std::ostringstream s;
|
|
|
+ size_t start = 0;
|
|
|
+ for(const auto &i : v) {
|
|
|
+ if(start++ > 0)
|
|
|
+ s << delim;
|
|
|
+ s << i;
|
|
|
+ }
|
|
|
+ return s.str();
|
|
|
+}
|
|
|
+
|
|
|
+/// Join a string in reverse order
|
|
|
+template <typename T> std::string rjoin(const T &v, std::string delim = ",") {
|
|
|
+ std::ostringstream s;
|
|
|
+ for(size_t start = 0; start < v.size(); start++) {
|
|
|
+ if(start > 0)
|
|
|
+ s << delim;
|
|
|
+ s << v[v.size() - start - 1];
|
|
|
+ }
|
|
|
+ return s.str();
|
|
|
+}
|
|
|
+
|
|
|
+// Based roughly on http://stackoverflow.com/questions/25829143/c-trim-whitespace-from-a-string
|
|
|
+
|
|
|
+/// Trim whitespace from left of string
|
|
|
+inline std::string <rim(std::string &str) {
|
|
|
+ auto it = std::find_if(str.begin(), str.end(), [](char ch) { return !std::isspace<char>(ch, std::locale()); });
|
|
|
+ str.erase(str.begin(), it);
|
|
|
+ return str;
|
|
|
+}
|
|
|
+
|
|
|
+/// Trim anything from left of string
|
|
|
+inline std::string <rim(std::string &str, const std::string &filter) {
|
|
|
+ auto it = std::find_if(str.begin(), str.end(), [&filter](char ch) { return filter.find(ch) == std::string::npos; });
|
|
|
+ str.erase(str.begin(), it);
|
|
|
+ return str;
|
|
|
+}
|
|
|
+
|
|
|
+/// Trim whitespace from right of string
|
|
|
+inline std::string &rtrim(std::string &str) {
|
|
|
+ auto it = std::find_if(str.rbegin(), str.rend(), [](char ch) { return !std::isspace<char>(ch, std::locale()); });
|
|
|
+ str.erase(it.base(), str.end());
|
|
|
+ return str;
|
|
|
+}
|
|
|
+
|
|
|
+/// Trim anything from right of string
|
|
|
+inline std::string &rtrim(std::string &str, const std::string &filter) {
|
|
|
+ auto it =
|
|
|
+ std::find_if(str.rbegin(), str.rend(), [&filter](char ch) { return filter.find(ch) == std::string::npos; });
|
|
|
+ str.erase(it.base(), str.end());
|
|
|
+ return str;
|
|
|
+}
|
|
|
+
|
|
|
+/// Trim whitespace from string
|
|
|
+inline std::string &trim(std::string &str) { return ltrim(rtrim(str)); }
|
|
|
+
|
|
|
+/// Trim anything from string
|
|
|
+inline std::string &trim(std::string &str, const std::string filter) { return ltrim(rtrim(str, filter), filter); }
|
|
|
+
|
|
|
+/// Make a copy of the string and then trim it
|
|
|
+inline std::string trim_copy(const std::string &str) {
|
|
|
+ std::string s = str;
|
|
|
+ return trim(s);
|
|
|
+}
|
|
|
+
|
|
|
+/// Make a copy of the string and then trim it, any filter string can be used (any char in string is filtered)
|
|
|
+inline std::string trim_copy(const std::string &str, const std::string &filter) {
|
|
|
+ std::string s = str;
|
|
|
+ return trim(s, filter);
|
|
|
+}
|
|
|
+/// Print a two part "help" string
|
|
|
+inline std::ostream &format_help(std::ostream &out, std::string name, std::string description, size_t wid) {
|
|
|
+ name = " " + name;
|
|
|
+ out << std::setw(static_cast<int>(wid)) << std::left << name;
|
|
|
+ if(!description.empty()) {
|
|
|
+ if(name.length() >= wid)
|
|
|
+ out << "\n" << std::setw(static_cast<int>(wid)) << "";
|
|
|
+ out << description;
|
|
|
+ }
|
|
|
+ out << "\n";
|
|
|
+ return out;
|
|
|
+}
|
|
|
+
|
|
|
+/// Verify the first character of an option
|
|
|
+template <typename T> bool valid_first_char(T c) { return std::isalpha(c, std::locale()) || c == '_'; }
|
|
|
+
|
|
|
+/// Verify following characters of an option
|
|
|
+template <typename T> bool valid_later_char(T c) {
|
|
|
+ return std::isalnum(c, std::locale()) || c == '_' || c == '.' || c == '-';
|
|
|
+}
|
|
|
+
|
|
|
+/// Verify an option name
|
|
|
+inline bool valid_name_string(const std::string &str) {
|
|
|
+ if(str.empty() || !valid_first_char(str[0]))
|
|
|
+ return false;
|
|
|
+ for(auto c : str.substr(1))
|
|
|
+ if(!valid_later_char(c))
|
|
|
+ return false;
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/// Return a lower case version of a string
|
|
|
+inline std::string to_lower(std::string str) {
|
|
|
+ std::transform(std::begin(str), std::end(str), std::begin(str), [](const std::string::value_type &x) {
|
|
|
+ return std::tolower(x, std::locale());
|
|
|
+ });
|
|
|
+ return str;
|
|
|
+}
|
|
|
+
|
|
|
+/// Split a string '"one two" "three"' into 'one two', 'three'
|
|
|
+inline std::vector<std::string> split_up(std::string str) {
|
|
|
+
|
|
|
+ std::vector<char> delims = {'\'', '\"'};
|
|
|
+ auto find_ws = [](char ch) { return std::isspace<char>(ch, std::locale()); };
|
|
|
+ trim(str);
|
|
|
+
|
|
|
+ std::vector<std::string> output;
|
|
|
+
|
|
|
+ while(!str.empty()) {
|
|
|
+ if(str[0] == '\'') {
|
|
|
+ auto end = str.find('\'', 1);
|
|
|
+ if(end != std::string::npos) {
|
|
|
+ output.push_back(str.substr(1, end - 1));
|
|
|
+ str = str.substr(end + 1);
|
|
|
+ } else {
|
|
|
+ output.push_back(str.substr(1));
|
|
|
+ str = "";
|
|
|
+ }
|
|
|
+ } else if(str[0] == '\"') {
|
|
|
+ auto end = str.find('\"', 1);
|
|
|
+ if(end != std::string::npos) {
|
|
|
+ output.push_back(str.substr(1, end - 1));
|
|
|
+ str = str.substr(end + 1);
|
|
|
+ } else {
|
|
|
+ output.push_back(str.substr(1));
|
|
|
+ str = "";
|
|
|
+ }
|
|
|
+
|
|
|
+ } else {
|
|
|
+ auto it = std::find_if(std::begin(str), std::end(str), find_ws);
|
|
|
+ if(it != std::end(str)) {
|
|
|
+ std::string value = std::string(str.begin(), it);
|
|
|
+ output.push_back(value);
|
|
|
+ str = std::string(it, str.end());
|
|
|
+ } else {
|
|
|
+ output.push_back(str);
|
|
|
+ str = "";
|
|
|
+ }
|
|
|
+ }
|
|
|
+ trim(str);
|
|
|
+ }
|
|
|
+
|
|
|
+ return output;
|
|
|
+}
|
|
|
+
|
|
|
+/// Add a leader to the beginning of all new lines (nothing is added
|
|
|
+/// at the start of the first line). `"; "` would be for ini files
|
|
|
+///
|
|
|
+/// Can't use Regex, or this would be a subs.
|
|
|
+inline std::string fix_newlines(std::string leader, std::string input) {
|
|
|
+ std::string::size_type n = 0;
|
|
|
+ while(n != std::string::npos && n < input.size()) {
|
|
|
+ n = input.find('\n', n);
|
|
|
+ if(n != std::string::npos) {
|
|
|
+ input = input.substr(0, n + 1) + leader + input.substr(n + 1);
|
|
|
+ n += leader.size();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return input;
|
|
|
+}
|
|
|
+
|
|
|
+/// Find and replace a subtring with another substring
|
|
|
+inline std::string find_and_replace(std::string str, std::string from, std::string to) {
|
|
|
+
|
|
|
+ size_t start_pos = 0;
|
|
|
+
|
|
|
+ while((start_pos = str.find(from, start_pos)) != std::string::npos) {
|
|
|
+ str.replace(start_pos, from.length(), to);
|
|
|
+ start_pos += to.length();
|
|
|
+ }
|
|
|
+
|
|
|
+ return str;
|
|
|
+}
|
|
|
+
|
|
|
+} // namespace detail
|
|
|
+} // namespace CLI
|
|
|
+
|
|
|
+// From CLI/Error.hpp:
|
|
|
+
|
|
|
+namespace CLI {
|
|
|
+
|
|
|
+// Use one of these on all error classes.
|
|
|
+// These are temporary and are undef'd at the end of this file.
|
|
|
+#define CLI11_ERROR_DEF(parent, name) \
|
|
|
+ protected: \
|
|
|
+ name(std::string name, std::string msg, int exit_code) : parent(std::move(name), std::move(msg), exit_code) {} \
|
|
|
+ name(std::string name, std::string msg, ExitCodes exit_code) \
|
|
|
+ : parent(std::move(name), std::move(msg), exit_code) {} \
|
|
|
+ \
|
|
|
+ public: \
|
|
|
+ name(std::string msg, ExitCodes exit_code) : parent(#name, std::move(msg), exit_code) {} \
|
|
|
+ name(std::string msg, int exit_code) : parent(#name, std::move(msg), exit_code) {}
|
|
|
+
|
|
|
+// This is added after the one above if a class is used directly and builds its own message
|
|
|
+#define CLI11_ERROR_SIMPLE(name) \
|
|
|
+ explicit name(std::string msg) : name(#name, msg, ExitCodes::name) {}
|
|
|
+
|
|
|
+/// These codes are part of every error in CLI. They can be obtained from e using e.exit_code or as a quick shortcut,
|
|
|
+/// int values from e.get_error_code().
|
|
|
+enum class ExitCodes {
|
|
|
+ Success = 0,
|
|
|
+ IncorrectConstruction = 100,
|
|
|
+ BadNameString,
|
|
|
+ OptionAlreadyAdded,
|
|
|
+ FileError,
|
|
|
+ ConversionError,
|
|
|
+ ValidationError,
|
|
|
+ RequiredError,
|
|
|
+ RequiresError,
|
|
|
+ ExcludesError,
|
|
|
+ ExtrasError,
|
|
|
+ ConfigError,
|
|
|
+ InvalidError,
|
|
|
+ HorribleError,
|
|
|
+ OptionNotFound,
|
|
|
+ ArgumentMismatch,
|
|
|
+ BaseClass = 127
|
|
|
+};
|
|
|
+
|
|
|
+// Error definitions
|
|
|
+
|
|
|
+/// @defgroup error_group Errors
|
|
|
+/// @brief Errors thrown by CLI11
|
|
|
+///
|
|
|
+/// These are the errors that can be thrown. Some of them, like CLI::Success, are not really errors.
|
|
|
+/// @{
|
|
|
+
|
|
|
+/// All errors derive from this one
|
|
|
+class Error : public std::runtime_error {
|
|
|
+ int exit_code;
|
|
|
+ std::string name{"Error"};
|
|
|
+
|
|
|
+ public:
|
|
|
+ int get_exit_code() const { return exit_code; }
|
|
|
+
|
|
|
+ std::string get_name() const { return name; }
|
|
|
+
|
|
|
+ Error(std::string name, std::string msg, int exit_code = static_cast<int>(ExitCodes::BaseClass))
|
|
|
+ : runtime_error(msg), exit_code(exit_code), name(std::move(name)) {}
|
|
|
+
|
|
|
+ Error(std::string name, std::string msg, ExitCodes exit_code) : Error(name, msg, static_cast<int>(exit_code)) {}
|
|
|
+};
|
|
|
+
|
|
|
+// Note: Using Error::Error constructors does not work on GCC 4.7
|
|
|
+
|
|
|
+/// Construction errors (not in parsing)
|
|
|
+class ConstructionError : public Error {
|
|
|
+ CLI11_ERROR_DEF(Error, ConstructionError)
|
|
|
+};
|
|
|
+
|
|
|
+/// Thrown when an option is set to conflicting values (non-vector and multi args, for example)
|
|
|
+class IncorrectConstruction : public ConstructionError {
|
|
|
+ CLI11_ERROR_DEF(ConstructionError, IncorrectConstruction)
|
|
|
+ CLI11_ERROR_SIMPLE(IncorrectConstruction)
|
|
|
+ static IncorrectConstruction PositionalFlag(std::string name) {
|
|
|
+ return IncorrectConstruction(name + ": Flags cannot be positional");
|
|
|
+ }
|
|
|
+ static IncorrectConstruction Set0Opt(std::string name) {
|
|
|
+ return IncorrectConstruction(name + ": Cannot set 0 expected, use a flag instead");
|
|
|
+ }
|
|
|
+ static IncorrectConstruction SetFlag(std::string name) {
|
|
|
+ return IncorrectConstruction(name + ": Cannot set an expected number for flags");
|
|
|
+ }
|
|
|
+ static IncorrectConstruction ChangeNotVector(std::string name) {
|
|
|
+ return IncorrectConstruction(name + ": You can only change the expected arguments for vectors");
|
|
|
+ }
|
|
|
+ static IncorrectConstruction AfterMultiOpt(std::string name) {
|
|
|
+ return IncorrectConstruction(
|
|
|
+ name + ": You can't change expected arguments after you've changed the multi option policy!");
|
|
|
+ }
|
|
|
+ static IncorrectConstruction MissingOption(std::string name) {
|
|
|
+ return IncorrectConstruction("Option " + name + " is not defined");
|
|
|
+ }
|
|
|
+ static IncorrectConstruction MultiOptionPolicy(std::string name) {
|
|
|
+ return IncorrectConstruction(name + ": multi_option_policy only works for flags and exact value options");
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/// Thrown on construction of a bad name
|
|
|
+class BadNameString : public ConstructionError {
|
|
|
+ CLI11_ERROR_DEF(ConstructionError, BadNameString)
|
|
|
+ CLI11_ERROR_SIMPLE(BadNameString)
|
|
|
+ static BadNameString OneCharName(std::string name) { return BadNameString("Invalid one char name: " + name); }
|
|
|
+ static BadNameString BadLongName(std::string name) { return BadNameString("Bad long name: " + name); }
|
|
|
+ static BadNameString DashesOnly(std::string name) {
|
|
|
+ return BadNameString("Must have a name, not just dashes: " + name);
|
|
|
+ }
|
|
|
+ static BadNameString MultiPositionalNames(std::string name) {
|
|
|
+ return BadNameString("Only one positional name allowed, remove: " + name);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/// Thrown when an option already exists
|
|
|
+class OptionAlreadyAdded : public ConstructionError {
|
|
|
+ CLI11_ERROR_DEF(ConstructionError, OptionAlreadyAdded)
|
|
|
+ explicit OptionAlreadyAdded(std::string name)
|
|
|
+ : OptionAlreadyAdded(name + " is already added", ExitCodes::OptionAlreadyAdded) {}
|
|
|
+ static OptionAlreadyAdded Requires(std::string name, std::string other) {
|
|
|
+ return OptionAlreadyAdded(name + " requires " + other, ExitCodes::OptionAlreadyAdded);
|
|
|
+ }
|
|
|
+ static OptionAlreadyAdded Excludes(std::string name, std::string other) {
|
|
|
+ return OptionAlreadyAdded(name + " excludes " + other, ExitCodes::OptionAlreadyAdded);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+// Parsing errors
|
|
|
+
|
|
|
+/// Anything that can error in Parse
|
|
|
+class ParseError : public Error {
|
|
|
+ CLI11_ERROR_DEF(Error, ParseError)
|
|
|
+};
|
|
|
+
|
|
|
+// Not really "errors"
|
|
|
+
|
|
|
+/// This is a successful completion on parsing, supposed to exit
|
|
|
+class Success : public ParseError {
|
|
|
+ CLI11_ERROR_DEF(ParseError, Success)
|
|
|
+ Success() : Success("Successfully completed, should be caught and quit", ExitCodes::Success) {}
|
|
|
+};
|
|
|
+
|
|
|
+/// -h or --help on command line
|
|
|
+class CallForHelp : public ParseError {
|
|
|
+ CLI11_ERROR_DEF(ParseError, CallForHelp)
|
|
|
+ CallForHelp() : CallForHelp("This should be caught in your main function, see examples", ExitCodes::Success) {}
|
|
|
+};
|
|
|
+
|
|
|
+/// Usually somethign like --help-all on command line
|
|
|
+class CallForAllHelp : public ParseError {
|
|
|
+ CLI11_ERROR_DEF(ParseError, CallForAllHelp)
|
|
|
+ CallForAllHelp()
|
|
|
+ : CallForAllHelp("This should be caught in your main function, see examples", ExitCodes::Success) {}
|
|
|
+};
|
|
|
+
|
|
|
+/// Does not output a diagnostic in CLI11_PARSE, but allows to return from main() with a specific error code.
|
|
|
+class RuntimeError : public ParseError {
|
|
|
+ CLI11_ERROR_DEF(ParseError, RuntimeError)
|
|
|
+ explicit RuntimeError(int exit_code = 1) : RuntimeError("Runtime error", exit_code) {}
|
|
|
+};
|
|
|
+
|
|
|
+/// Thrown when parsing an INI file and it is missing
|
|
|
+class FileError : public ParseError {
|
|
|
+ CLI11_ERROR_DEF(ParseError, FileError)
|
|
|
+ CLI11_ERROR_SIMPLE(FileError)
|
|
|
+ static FileError Missing(std::string name) { return FileError(name + " was not readable (missing?)"); }
|
|
|
+};
|
|
|
+
|
|
|
+/// Thrown when conversion call back fails, such as when an int fails to coerce to a string
|
|
|
+class ConversionError : public ParseError {
|
|
|
+ CLI11_ERROR_DEF(ParseError, ConversionError)
|
|
|
+ CLI11_ERROR_SIMPLE(ConversionError)
|
|
|
+ ConversionError(std::string member, std::string name)
|
|
|
+ : ConversionError("The value " + member + " is not an allowed value for " + name) {}
|
|
|
+ ConversionError(std::string name, std::vector<std::string> results)
|
|
|
+ : ConversionError("Could not convert: " + name + " = " + detail::join(results)) {}
|
|
|
+ static ConversionError TooManyInputsFlag(std::string name) {
|
|
|
+ return ConversionError(name + ": too many inputs for a flag");
|
|
|
+ }
|
|
|
+ static ConversionError TrueFalse(std::string name) {
|
|
|
+ return ConversionError(name + ": Should be true/false or a number");
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/// Thrown when validation of results fails
|
|
|
+class ValidationError : public ParseError {
|
|
|
+ CLI11_ERROR_DEF(ParseError, ValidationError)
|
|
|
+ CLI11_ERROR_SIMPLE(ValidationError)
|
|
|
+ explicit ValidationError(std::string name, std::string msg) : ValidationError(name + ": " + msg) {}
|
|
|
+};
|
|
|
+
|
|
|
+/// Thrown when a required option is missing
|
|
|
+class RequiredError : public ParseError {
|
|
|
+ CLI11_ERROR_DEF(ParseError, RequiredError)
|
|
|
+ explicit RequiredError(std::string name) : RequiredError(name + " is required", ExitCodes::RequiredError) {}
|
|
|
+ static RequiredError Subcommand(size_t min_subcom) {
|
|
|
+ if(min_subcom == 1)
|
|
|
+ return RequiredError("A subcommand");
|
|
|
+ else
|
|
|
+ return RequiredError("Requires at least " + std::to_string(min_subcom) + " subcommands",
|
|
|
+ ExitCodes::RequiredError);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/// Thrown when the wrong number of arguments has been received
|
|
|
+class ArgumentMismatch : public ParseError {
|
|
|
+ CLI11_ERROR_DEF(ParseError, ArgumentMismatch)
|
|
|
+ CLI11_ERROR_SIMPLE(ArgumentMismatch)
|
|
|
+ ArgumentMismatch(std::string name, int expected, size_t recieved)
|
|
|
+ : ArgumentMismatch(expected > 0 ? ("Expected exactly " + std::to_string(expected) + " arguments to " + name +
|
|
|
+ ", got " + std::to_string(recieved))
|
|
|
+ : ("Expected at least " + std::to_string(-expected) + " arguments to " + name +
|
|
|
+ ", got " + std::to_string(recieved)),
|
|
|
+ ExitCodes::ArgumentMismatch) {}
|
|
|
+
|
|
|
+ static ArgumentMismatch AtLeast(std::string name, int num) {
|
|
|
+ return ArgumentMismatch(name + ": At least " + std::to_string(num) + " required");
|
|
|
+ }
|
|
|
+ static ArgumentMismatch TypedAtLeast(std::string name, int num, std::string type) {
|
|
|
+ return ArgumentMismatch(name + ": " + std::to_string(num) + " required " + type + " missing");
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/// Thrown when a requires option is missing
|
|
|
+class RequiresError : public ParseError {
|
|
|
+ CLI11_ERROR_DEF(ParseError, RequiresError)
|
|
|
+ RequiresError(std::string curname, std::string subname)
|
|
|
+ : RequiresError(curname + " requires " + subname, ExitCodes::RequiresError) {}
|
|
|
+};
|
|
|
+
|
|
|
+/// Thrown when an excludes option is present
|
|
|
+class ExcludesError : public ParseError {
|
|
|
+ CLI11_ERROR_DEF(ParseError, ExcludesError)
|
|
|
+ ExcludesError(std::string curname, std::string subname)
|
|
|
+ : ExcludesError(curname + " excludes " + subname, ExitCodes::ExcludesError) {}
|
|
|
+};
|
|
|
+
|
|
|
+/// Thrown when too many positionals or options are found
|
|
|
+class ExtrasError : public ParseError {
|
|
|
+ CLI11_ERROR_DEF(ParseError, ExtrasError)
|
|
|
+ explicit ExtrasError(std::vector<std::string> args)
|
|
|
+ : ExtrasError((args.size() > 1 ? "The following arguments were not expected: "
|
|
|
+ : "The following argument was not expected: ") +
|
|
|
+ detail::rjoin(args, " "),
|
|
|
+ ExitCodes::ExtrasError) {}
|
|
|
+};
|
|
|
+
|
|
|
+/// Thrown when extra values are found in an INI file
|
|
|
+class ConfigError : public ParseError {
|
|
|
+ CLI11_ERROR_DEF(ParseError, ConfigError)
|
|
|
+ CLI11_ERROR_SIMPLE(ConfigError)
|
|
|
+ static ConfigError Extras(std::string item) { return ConfigError("INI was not able to parse " + item); }
|
|
|
+ static ConfigError NotConfigurable(std::string item) {
|
|
|
+ return ConfigError(item + ": This option is not allowed in a configuration file");
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/// Thrown when validation fails before parsing
|
|
|
+class InvalidError : public ParseError {
|
|
|
+ CLI11_ERROR_DEF(ParseError, InvalidError)
|
|
|
+ explicit InvalidError(std::string name)
|
|
|
+ : InvalidError(name + ": Too many positional arguments with unlimited expected args", ExitCodes::InvalidError) {
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/// This is just a safety check to verify selection and parsing match - you should not ever see it
|
|
|
+/// Strings are directly added to this error, but again, it should never be seen.
|
|
|
+class HorribleError : public ParseError {
|
|
|
+ CLI11_ERROR_DEF(ParseError, HorribleError)
|
|
|
+ CLI11_ERROR_SIMPLE(HorribleError)
|
|
|
+};
|
|
|
+
|
|
|
+// After parsing
|
|
|
+
|
|
|
+/// Thrown when counting a non-existent option
|
|
|
+class OptionNotFound : public Error {
|
|
|
+ CLI11_ERROR_DEF(Error, OptionNotFound)
|
|
|
+ explicit OptionNotFound(std::string name) : OptionNotFound(name + " not found", ExitCodes::OptionNotFound) {}
|
|
|
+};
|
|
|
+
|
|
|
+#undef CLI11_ERROR_DEF
|
|
|
+#undef CLI11_ERROR_SIMPLE
|
|
|
+
|
|
|
+/// @}
|
|
|
+
|
|
|
+} // namespace CLI
|
|
|
+
|
|
|
+// From CLI/TypeTools.hpp:
|
|
|
+
|
|
|
+namespace CLI {
|
|
|
+
|
|
|
+// Type tools
|
|
|
+
|
|
|
+/// A copy of enable_if_t from C++14, compatible with C++11.
|
|
|
+///
|
|
|
+/// We could check to see if C++14 is being used, but it does not hurt to redefine this
|
|
|
+/// (even Google does this: https://github.com/google/skia/blob/master/include/private/SkTLogic.h)
|
|
|
+/// It is not in the std namespace anyway, so no harm done.
|
|
|
+
|
|
|
+template <bool B, class T = void> using enable_if_t = typename std::enable_if<B, T>::type;
|
|
|
+
|
|
|
+/// Check to see if something is a vector (fail check by default)
|
|
|
+template <typename T> struct is_vector { static const bool value = false; };
|
|
|
+
|
|
|
+/// Check to see if something is a vector (true if actually a vector)
|
|
|
+template <class T, class A> struct is_vector<std::vector<T, A>> { static bool const value = true; };
|
|
|
+
|
|
|
+/// Check to see if something is bool (fail check by default)
|
|
|
+template <typename T> struct is_bool { static const bool value = false; };
|
|
|
+
|
|
|
+/// Check to see if something is bool (true if actually a bool)
|
|
|
+template <> struct is_bool<bool> { static bool const value = true; };
|
|
|
+
|
|
|
+namespace detail {
|
|
|
+// Based generally on https://rmf.io/cxx11/almost-static-if
|
|
|
+/// Simple empty scoped class
|
|
|
+enum class enabler {};
|
|
|
+
|
|
|
+/// An instance to use in EnableIf
|
|
|
+constexpr enabler dummy = {};
|
|
|
+
|
|
|
+// Type name print
|
|
|
+
|
|
|
+/// Was going to be based on
|
|
|
+/// http://stackoverflow.com/questions/1055452/c-get-name-of-type-in-template
|
|
|
+/// But this is cleaner and works better in this case
|
|
|
+
|
|
|
+template <typename T,
|
|
|
+ enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, detail::enabler> = detail::dummy>
|
|
|
+constexpr const char *type_name() {
|
|
|
+ return "INT";
|
|
|
+}
|
|
|
+
|
|
|
+template <typename T,
|
|
|
+ enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, detail::enabler> = detail::dummy>
|
|
|
+constexpr const char *type_name() {
|
|
|
+ return "UINT";
|
|
|
+}
|
|
|
+
|
|
|
+template <typename T, enable_if_t<std::is_floating_point<T>::value, detail::enabler> = detail::dummy>
|
|
|
+constexpr const char *type_name() {
|
|
|
+ return "FLOAT";
|
|
|
+}
|
|
|
+
|
|
|
+/// This one should not be used, since vector types print the internal type
|
|
|
+template <typename T, enable_if_t<is_vector<T>::value, detail::enabler> = detail::dummy>
|
|
|
+constexpr const char *type_name() {
|
|
|
+ return "VECTOR";
|
|
|
+}
|
|
|
+
|
|
|
+template <typename T,
|
|
|
+ enable_if_t<!std::is_floating_point<T>::value && !std::is_integral<T>::value && !is_vector<T>::value,
|
|
|
+ detail::enabler> = detail::dummy>
|
|
|
+constexpr const char *type_name() {
|
|
|
+ return "TEXT";
|
|
|
+}
|
|
|
+
|
|
|
+// Lexical cast
|
|
|
+
|
|
|
+/// Signed integers / enums
|
|
|
+template <typename T,
|
|
|
+ enable_if_t<(std::is_integral<T>::value && std::is_signed<T>::value), detail::enabler> = detail::dummy>
|
|
|
+bool lexical_cast(std::string input, T &output) {
|
|
|
+ try {
|
|
|
+ size_t n = 0;
|
|
|
+ long long output_ll = std::stoll(input, &n, 0);
|
|
|
+ output = static_cast<T>(output_ll);
|
|
|
+ return n == input.size() && static_cast<long long>(output) == output_ll;
|
|
|
+ } catch(const std::invalid_argument &) {
|
|
|
+ return false;
|
|
|
+ } catch(const std::out_of_range &) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/// Unsigned integers
|
|
|
+template <typename T,
|
|
|
+ enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, detail::enabler> = detail::dummy>
|
|
|
+bool lexical_cast(std::string input, T &output) {
|
|
|
+ if(!input.empty() && input.front() == '-')
|
|
|
+ return false; // std::stoull happily converts negative values to junk without any errors.
|
|
|
+
|
|
|
+ try {
|
|
|
+ size_t n = 0;
|
|
|
+ unsigned long long output_ll = std::stoull(input, &n, 0);
|
|
|
+ output = static_cast<T>(output_ll);
|
|
|
+ return n == input.size() && static_cast<unsigned long long>(output) == output_ll;
|
|
|
+ } catch(const std::invalid_argument &) {
|
|
|
+ return false;
|
|
|
+ } catch(const std::out_of_range &) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/// Floats
|
|
|
+template <typename T, enable_if_t<std::is_floating_point<T>::value, detail::enabler> = detail::dummy>
|
|
|
+bool lexical_cast(std::string input, T &output) {
|
|
|
+ try {
|
|
|
+ size_t n = 0;
|
|
|
+ output = static_cast<T>(std::stold(input, &n));
|
|
|
+ return n == input.size();
|
|
|
+ } catch(const std::invalid_argument &) {
|
|
|
+ return false;
|
|
|
+ } catch(const std::out_of_range &) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/// String and similar
|
|
|
+template <typename T,
|
|
|
+ enable_if_t<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
|
|
|
+ std::is_assignable<T &, std::string>::value,
|
|
|
+ detail::enabler> = detail::dummy>
|
|
|
+bool lexical_cast(std::string input, T &output) {
|
|
|
+ output = input;
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/// Non-string parsable
|
|
|
+template <typename T,
|
|
|
+ enable_if_t<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
|
|
|
+ !std::is_assignable<T &, std::string>::value,
|
|
|
+ detail::enabler> = detail::dummy>
|
|
|
+bool lexical_cast(std::string input, T &output) {
|
|
|
+ std::istringstream is;
|
|
|
+
|
|
|
+ is.str(input);
|
|
|
+ is >> output;
|
|
|
+ return !is.fail() && !is.rdbuf()->in_avail();
|
|
|
+}
|
|
|
+
|
|
|
+} // namespace detail
|
|
|
+} // namespace CLI
|
|
|
+
|
|
|
+// From CLI/Split.hpp:
|
|
|
+
|
|
|
+namespace CLI {
|
|
|
+namespace detail {
|
|
|
+
|
|
|
+// Returns false if not a short option. Otherwise, sets opt name and rest and returns true
|
|
|
+inline bool split_short(const std::string ¤t, std::string &name, std::string &rest) {
|
|
|
+ if(current.size() > 1 && current[0] == '-' && valid_first_char(current[1])) {
|
|
|
+ name = current.substr(1, 1);
|
|
|
+ rest = current.substr(2);
|
|
|
+ return true;
|
|
|
+ } else
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+// Returns false if not a long option. Otherwise, sets opt name and other side of = and returns true
|
|
|
+inline bool split_long(const std::string ¤t, std::string &name, std::string &value) {
|
|
|
+ if(current.size() > 2 && current.substr(0, 2) == "--" && valid_first_char(current[2])) {
|
|
|
+ auto loc = current.find("=");
|
|
|
+ if(loc != std::string::npos) {
|
|
|
+ name = current.substr(2, loc - 2);
|
|
|
+ value = current.substr(loc + 1);
|
|
|
+ } else {
|
|
|
+ name = current.substr(2);
|
|
|
+ value = "";
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ } else
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+// Splits a string into multiple long and short names
|
|
|
+inline std::vector<std::string> split_names(std::string current) {
|
|
|
+ std::vector<std::string> output;
|
|
|
+ size_t val;
|
|
|
+ while((val = current.find(",")) != std::string::npos) {
|
|
|
+ output.push_back(trim_copy(current.substr(0, val)));
|
|
|
+ current = current.substr(val + 1);
|
|
|
+ }
|
|
|
+ output.push_back(trim_copy(current));
|
|
|
+ return output;
|
|
|
+}
|
|
|
+
|
|
|
+/// Get a vector of short names, one of long names, and a single name
|
|
|
+inline std::tuple<std::vector<std::string>, std::vector<std::string>, std::string>
|
|
|
+get_names(const std::vector<std::string> &input) {
|
|
|
+
|
|
|
+ std::vector<std::string> short_names;
|
|
|
+ std::vector<std::string> long_names;
|
|
|
+ std::string pos_name;
|
|
|
+
|
|
|
+ for(std::string name : input) {
|
|
|
+ if(name.length() == 0)
|
|
|
+ continue;
|
|
|
+ else if(name.length() > 1 && name[0] == '-' && name[1] != '-') {
|
|
|
+ if(name.length() == 2 && valid_first_char(name[1]))
|
|
|
+ short_names.emplace_back(1, name[1]);
|
|
|
+ else
|
|
|
+ throw BadNameString::OneCharName(name);
|
|
|
+ } else if(name.length() > 2 && name.substr(0, 2) == "--") {
|
|
|
+ name = name.substr(2);
|
|
|
+ if(valid_name_string(name))
|
|
|
+ long_names.push_back(name);
|
|
|
+ else
|
|
|
+ throw BadNameString::BadLongName(name);
|
|
|
+ } else if(name == "-" || name == "--") {
|
|
|
+ throw BadNameString::DashesOnly(name);
|
|
|
+ } else {
|
|
|
+ if(pos_name.length() > 0)
|
|
|
+ throw BadNameString::MultiPositionalNames(name);
|
|
|
+ pos_name = name;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return std::tuple<std::vector<std::string>, std::vector<std::string>, std::string>(
|
|
|
+ short_names, long_names, pos_name);
|
|
|
+}
|
|
|
+
|
|
|
+} // namespace detail
|
|
|
+} // namespace CLI
|
|
|
+
|
|
|
+// From CLI/ConfigFwd.hpp:
|
|
|
+
|
|
|
+namespace CLI {
|
|
|
+
|
|
|
+class App;
|
|
|
+
|
|
|
+namespace detail {
|
|
|
+
|
|
|
+/// Comma separated join, adds quotes if needed
|
|
|
+inline std::string ini_join(std::vector<std::string> args) {
|
|
|
+ std::ostringstream s;
|
|
|
+ size_t start = 0;
|
|
|
+ for(const auto &arg : args) {
|
|
|
+ if(start++ > 0)
|
|
|
+ s << " ";
|
|
|
+
|
|
|
+ auto it = std::find_if(arg.begin(), arg.end(), [](char ch) { return std::isspace<char>(ch, std::locale()); });
|
|
|
+ if(it == arg.end())
|
|
|
+ s << arg;
|
|
|
+ else if(arg.find(R"(")") == std::string::npos)
|
|
|
+ s << R"(")" << arg << R"(")";
|
|
|
+ else
|
|
|
+ s << R"(')" << arg << R"(')";
|
|
|
+ }
|
|
|
+
|
|
|
+ return s.str();
|
|
|
+}
|
|
|
+
|
|
|
+} // namespace detail
|
|
|
+
|
|
|
+/// Holds values to load into Options
|
|
|
+struct ConfigItem {
|
|
|
+ /// This is the list of parents
|
|
|
+ std::vector<std::string> parents;
|
|
|
+
|
|
|
+ /// This is the name
|
|
|
+ std::string name;
|
|
|
+
|
|
|
+ /// Listing of inputs
|
|
|
+ std::vector<std::string> inputs;
|
|
|
+
|
|
|
+ /// The list of parents and name joined by "."
|
|
|
+ std::string fullname() const {
|
|
|
+ std::vector<std::string> tmp = parents;
|
|
|
+ tmp.emplace_back(name);
|
|
|
+ return detail::join(tmp, ".");
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/// This class provides a converter for configuration files.
|
|
|
+class Config {
|
|
|
+ protected:
|
|
|
+ std::vector<ConfigItem> items;
|
|
|
+
|
|
|
+ public:
|
|
|
+ /// Convert an app into a configuration
|
|
|
+ virtual std::string to_config(const App *, bool, bool, std::string) const = 0;
|
|
|
+
|
|
|
+ /// Convert a configuration into an app
|
|
|
+ virtual std::vector<ConfigItem> from_config(std::istream &) const = 0;
|
|
|
+
|
|
|
+ /// Convert a flag to a bool
|
|
|
+ virtual std::vector<std::string> to_flag(const ConfigItem &item) const {
|
|
|
+ if(item.inputs.size() == 1) {
|
|
|
+ std::string val = item.inputs.at(0);
|
|
|
+ val = detail::to_lower(val);
|
|
|
+
|
|
|
+ if(val == "true" || val == "on" || val == "yes") {
|
|
|
+ return std::vector<std::string>(1);
|
|
|
+ } else if(val == "false" || val == "off" || val == "no") {
|
|
|
+ return std::vector<std::string>();
|
|
|
+ } else {
|
|
|
+ try {
|
|
|
+ size_t ui = std::stoul(val);
|
|
|
+ return std::vector<std::string>(ui);
|
|
|
+ } catch(const std::invalid_argument &) {
|
|
|
+ throw ConversionError::TrueFalse(item.fullname());
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ throw ConversionError::TooManyInputsFlag(item.fullname());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Parse a config file, throw an error (ParseError:ConfigParseError or FileError) on failure
|
|
|
+ std::vector<ConfigItem> from_file(const std::string &name) {
|
|
|
+ std::ifstream input{name};
|
|
|
+ if(!input.good())
|
|
|
+ throw FileError::Missing(name);
|
|
|
+
|
|
|
+ return from_config(input);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// virtual destructor
|
|
|
+ virtual ~Config() = default;
|
|
|
+};
|
|
|
+
|
|
|
+/// This converter works with INI files
|
|
|
+class ConfigINI : public Config {
|
|
|
+ public:
|
|
|
+ std::string to_config(const App *, bool default_also, bool write_description, std::string prefix) const override;
|
|
|
+
|
|
|
+ std::vector<ConfigItem> from_config(std::istream &input) const override {
|
|
|
+ std::string line;
|
|
|
+ std::string section = "default";
|
|
|
+
|
|
|
+ std::vector<ConfigItem> output;
|
|
|
+
|
|
|
+ while(getline(input, line)) {
|
|
|
+ std::vector<std::string> items_buffer;
|
|
|
+
|
|
|
+ detail::trim(line);
|
|
|
+ size_t len = line.length();
|
|
|
+ if(len > 1 && line[0] == '[' && line[len - 1] == ']') {
|
|
|
+ section = line.substr(1, len - 2);
|
|
|
+ } else if(len > 0 && line[0] != ';') {
|
|
|
+ output.emplace_back();
|
|
|
+ ConfigItem &out = output.back();
|
|
|
+
|
|
|
+ // Find = in string, split and recombine
|
|
|
+ auto pos = line.find('=');
|
|
|
+ if(pos != std::string::npos) {
|
|
|
+ out.name = detail::trim_copy(line.substr(0, pos));
|
|
|
+ std::string item = detail::trim_copy(line.substr(pos + 1));
|
|
|
+ items_buffer = detail::split_up(item);
|
|
|
+ } else {
|
|
|
+ out.name = detail::trim_copy(line);
|
|
|
+ items_buffer = {"ON"};
|
|
|
+ }
|
|
|
+
|
|
|
+ if(detail::to_lower(section) != "default") {
|
|
|
+ out.parents = {section};
|
|
|
+ }
|
|
|
+
|
|
|
+ if(out.name.find('.') != std::string::npos) {
|
|
|
+ std::vector<std::string> plist = detail::split(out.name, '.');
|
|
|
+ out.name = plist.back();
|
|
|
+ plist.pop_back();
|
|
|
+ out.parents.insert(out.parents.end(), plist.begin(), plist.end());
|
|
|
+ }
|
|
|
+
|
|
|
+ out.inputs.insert(std::end(out.inputs), std::begin(items_buffer), std::end(items_buffer));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return output;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+} // namespace CLI
|
|
|
+
|
|
|
+// From CLI/Validators.hpp:
|
|
|
+
|
|
|
+namespace CLI {
|
|
|
+
|
|
|
+/// @defgroup validator_group Validators
|
|
|
+
|
|
|
+/// @brief Some validators that are provided
|
|
|
+///
|
|
|
+/// These are simple `std::string(const std::string&)` validators that are useful. They return
|
|
|
+/// a string if the validation fails. A custom struct is provided, as well, with the same user
|
|
|
+/// semantics, but with the ability to provide a new type name.
|
|
|
+/// @{
|
|
|
+
|
|
|
+///
|
|
|
+struct Validator {
|
|
|
+ /// This is the type name, if empty the type name will not be changed
|
|
|
+ std::string tname;
|
|
|
+
|
|
|
+ /// This it the base function that is to be called.
|
|
|
+ /// Returns a string error message if validation fails.
|
|
|
+ std::function<std::string(const std::string &)> func;
|
|
|
+
|
|
|
+ /// This is the required operator for a validator - provided to help
|
|
|
+ /// users (CLI11 uses the member `func` directly)
|
|
|
+ std::string operator()(const std::string &str) const { return func(str); };
|
|
|
+
|
|
|
+ /// Combining validators is a new validator
|
|
|
+ Validator operator&(const Validator &other) const {
|
|
|
+ Validator newval;
|
|
|
+ newval.tname = (tname == other.tname ? tname : "");
|
|
|
+
|
|
|
+ // Give references (will make a copy in lambda function)
|
|
|
+ const std::function<std::string(const std::string &filename)> &f1 = func;
|
|
|
+ const std::function<std::string(const std::string &filename)> &f2 = other.func;
|
|
|
+
|
|
|
+ newval.func = [f1, f2](const std::string &filename) {
|
|
|
+ std::string s1 = f1(filename);
|
|
|
+ std::string s2 = f2(filename);
|
|
|
+ if(!s1.empty() && !s2.empty())
|
|
|
+ return s1 + " & " + s2;
|
|
|
+ else
|
|
|
+ return s1 + s2;
|
|
|
+ };
|
|
|
+ return newval;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Combining validators is a new validator
|
|
|
+ Validator operator|(const Validator &other) const {
|
|
|
+ Validator newval;
|
|
|
+ newval.tname = (tname == other.tname ? tname : "");
|
|
|
+
|
|
|
+ // Give references (will make a copy in lambda function)
|
|
|
+ const std::function<std::string(const std::string &filename)> &f1 = func;
|
|
|
+ const std::function<std::string(const std::string &filename)> &f2 = other.func;
|
|
|
+
|
|
|
+ newval.func = [f1, f2](const std::string &filename) {
|
|
|
+ std::string s1 = f1(filename);
|
|
|
+ std::string s2 = f2(filename);
|
|
|
+ if(s1.empty() || s2.empty())
|
|
|
+ return std::string();
|
|
|
+ else
|
|
|
+ return s1 + " & " + s2;
|
|
|
+ };
|
|
|
+ return newval;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+// The implementation of the built in validators is using the Validator class;
|
|
|
+// the user is only expected to use the const (static) versions (since there's no setup).
|
|
|
+// Therefore, this is in detail.
|
|
|
+namespace detail {
|
|
|
+
|
|
|
+/// Check for an existing file (returns error message if check fails)
|
|
|
+struct ExistingFileValidator : public Validator {
|
|
|
+ ExistingFileValidator() {
|
|
|
+ tname = "FILE";
|
|
|
+ func = [](const std::string &filename) {
|
|
|
+ struct stat buffer;
|
|
|
+ bool exist = stat(filename.c_str(), &buffer) == 0;
|
|
|
+ bool is_dir = (buffer.st_mode & S_IFDIR) != 0;
|
|
|
+ if(!exist) {
|
|
|
+ return "File does not exist: " + filename;
|
|
|
+ } else if(is_dir) {
|
|
|
+ return "File is actually a directory: " + filename;
|
|
|
+ }
|
|
|
+ return std::string();
|
|
|
+ };
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/// Check for an existing directory (returns error message if check fails)
|
|
|
+struct ExistingDirectoryValidator : public Validator {
|
|
|
+ ExistingDirectoryValidator() {
|
|
|
+ tname = "DIR";
|
|
|
+ func = [](const std::string &filename) {
|
|
|
+ struct stat buffer;
|
|
|
+ bool exist = stat(filename.c_str(), &buffer) == 0;
|
|
|
+ bool is_dir = (buffer.st_mode & S_IFDIR) != 0;
|
|
|
+ if(!exist) {
|
|
|
+ return "Directory does not exist: " + filename;
|
|
|
+ } else if(!is_dir) {
|
|
|
+ return "Directory is actually a file: " + filename;
|
|
|
+ }
|
|
|
+ return std::string();
|
|
|
+ };
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/// Check for an existing path
|
|
|
+struct ExistingPathValidator : public Validator {
|
|
|
+ ExistingPathValidator() {
|
|
|
+ tname = "PATH";
|
|
|
+ func = [](const std::string &filename) {
|
|
|
+ struct stat buffer;
|
|
|
+ bool const exist = stat(filename.c_str(), &buffer) == 0;
|
|
|
+ if(!exist) {
|
|
|
+ return "Path does not exist: " + filename;
|
|
|
+ }
|
|
|
+ return std::string();
|
|
|
+ };
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/// Check for an non-existing path
|
|
|
+struct NonexistentPathValidator : public Validator {
|
|
|
+ NonexistentPathValidator() {
|
|
|
+ tname = "PATH";
|
|
|
+ func = [](const std::string &filename) {
|
|
|
+ struct stat buffer;
|
|
|
+ bool exist = stat(filename.c_str(), &buffer) == 0;
|
|
|
+ if(exist) {
|
|
|
+ return "Path already exists: " + filename;
|
|
|
+ }
|
|
|
+ return std::string();
|
|
|
+ };
|
|
|
+ }
|
|
|
+};
|
|
|
+} // namespace detail
|
|
|
+
|
|
|
+// Static is not needed here, because global const implies static.
|
|
|
+
|
|
|
+/// Check for existing file (returns error message if check fails)
|
|
|
+const detail::ExistingFileValidator ExistingFile;
|
|
|
+
|
|
|
+/// Check for an existing directory (returns error message if check fails)
|
|
|
+const detail::ExistingDirectoryValidator ExistingDirectory;
|
|
|
+
|
|
|
+/// Check for an existing path
|
|
|
+const detail::ExistingPathValidator ExistingPath;
|
|
|
+
|
|
|
+/// Check for an non-existing path
|
|
|
+const detail::NonexistentPathValidator NonexistentPath;
|
|
|
+
|
|
|
+/// Produce a range (factory). Min and max are inclusive.
|
|
|
+struct Range : public Validator {
|
|
|
+ /// This produces a range with min and max inclusive.
|
|
|
+ ///
|
|
|
+ /// Note that the constructor is templated, but the struct is not, so C++17 is not
|
|
|
+ /// needed to provide nice syntax for Range(a,b).
|
|
|
+ template <typename T> Range(T min, T max) {
|
|
|
+ std::stringstream out;
|
|
|
+ out << detail::type_name<T>() << " in [" << min << " - " << max << "]";
|
|
|
+
|
|
|
+ tname = out.str();
|
|
|
+ func = [min, max](std::string input) {
|
|
|
+ T val;
|
|
|
+ detail::lexical_cast(input, val);
|
|
|
+ if(val < min || val > max)
|
|
|
+ return "Value " + input + " not in range " + std::to_string(min) + " to " + std::to_string(max);
|
|
|
+
|
|
|
+ return std::string();
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Range of one value is 0 to value
|
|
|
+ template <typename T> explicit Range(T max) : Range(static_cast<T>(0), max) {}
|
|
|
+};
|
|
|
+
|
|
|
+/// @}
|
|
|
+
|
|
|
+} // namespace CLI
|
|
|
+
|
|
|
+// From CLI/FormatterFwd.hpp:
|
|
|
+
|
|
|
+namespace CLI {
|
|
|
+
|
|
|
+class Option;
|
|
|
+class App;
|
|
|
+
|
|
|
+/// This enum signifies the type of help requested
|
|
|
+///
|
|
|
+/// This is passed in by App; all user classes must accept this as
|
|
|
+/// the second argument.
|
|
|
+
|
|
|
+enum class AppFormatMode {
|
|
|
+ Normal, //< The normal, detailed help
|
|
|
+ All, //< A fully expanded help
|
|
|
+ Sub, //< Used when printed as part of expanded subcommand
|
|
|
+};
|
|
|
+
|
|
|
+/// This is the minimum requirements to run a formatter.
|
|
|
+///
|
|
|
+/// A user can subclass this is if they do not care at all
|
|
|
+/// about the structure in CLI::Formatter.
|
|
|
+class FormatterBase {
|
|
|
+ protected:
|
|
|
+ /// @name Options
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// The width of the first column
|
|
|
+ size_t column_width_{30};
|
|
|
+
|
|
|
+ /// @brief The required help printout labels (user changeable)
|
|
|
+ /// Values are Needs, Excludes, etc.
|
|
|
+ std::map<std::string, std::string> labels_;
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Basic
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ public:
|
|
|
+ FormatterBase() = default;
|
|
|
+ FormatterBase(const FormatterBase &) = default;
|
|
|
+ FormatterBase(FormatterBase &&) = default;
|
|
|
+ virtual ~FormatterBase() = default;
|
|
|
+
|
|
|
+ /// This is the key method that puts together help
|
|
|
+ virtual std::string make_help(const App *, std::string, AppFormatMode) const = 0;
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Setters
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Set the "REQUIRED" label
|
|
|
+ void label(std::string key, std::string val) { labels_[key] = val; }
|
|
|
+
|
|
|
+ /// Set the column width
|
|
|
+ void column_width(size_t val) { column_width_ = val; }
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Getters
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Get the current value of a name (REQUIRED, etc.)
|
|
|
+ std::string get_label(std::string key) const {
|
|
|
+ if(labels_.find(key) == labels_.end())
|
|
|
+ return key;
|
|
|
+ else
|
|
|
+ return labels_.at(key);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Get the current column width
|
|
|
+ size_t get_column_width() const { return column_width_; }
|
|
|
+
|
|
|
+ ///@}
|
|
|
+};
|
|
|
+
|
|
|
+/// This is a specialty override for lambda functions
|
|
|
+class FormatterLambda final : public FormatterBase {
|
|
|
+ using funct_t = std::function<std::string(const App *, std::string, AppFormatMode)>;
|
|
|
+
|
|
|
+ /// The lambda to hold and run
|
|
|
+ funct_t lambda_;
|
|
|
+
|
|
|
+ public:
|
|
|
+ /// Create a FormatterLambda with a lambda function
|
|
|
+ explicit FormatterLambda(funct_t funct) : lambda_(std::move(funct)) {}
|
|
|
+
|
|
|
+ /// This will simply call the lambda function
|
|
|
+ std::string make_help(const App *app, std::string name, AppFormatMode mode) const override {
|
|
|
+ return lambda_(app, name, mode);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/// This is the default Formatter for CLI11. It pretty prints help output, and is broken into quite a few
|
|
|
+/// overridable methods, to be highly customizable with minimal effort.
|
|
|
+class Formatter : public FormatterBase {
|
|
|
+ public:
|
|
|
+ Formatter() = default;
|
|
|
+ Formatter(const Formatter &) = default;
|
|
|
+ Formatter(Formatter &&) = default;
|
|
|
+
|
|
|
+ /// @name Overridables
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// This prints out a group of options with title
|
|
|
+ ///
|
|
|
+ virtual std::string make_group(std::string group, bool is_positional, std::vector<const Option *> opts) const;
|
|
|
+
|
|
|
+ /// This prints out just the positionals "group"
|
|
|
+ virtual std::string make_positionals(const App *app) const;
|
|
|
+
|
|
|
+ /// This prints out all the groups of options
|
|
|
+ std::string make_groups(const App *app, AppFormatMode mode) const;
|
|
|
+
|
|
|
+ /// This prints out all the subcommands
|
|
|
+ virtual std::string make_subcommands(const App *app, AppFormatMode mode) const;
|
|
|
+
|
|
|
+ /// This prints out a subcommand
|
|
|
+ virtual std::string make_subcommand(const App *sub) const;
|
|
|
+
|
|
|
+ /// This prints out a subcommand in help-all
|
|
|
+ virtual std::string make_expanded(const App *sub) const;
|
|
|
+
|
|
|
+ /// This prints out all the groups of options
|
|
|
+ virtual std::string make_footer(const App *app) const;
|
|
|
+
|
|
|
+ /// This displays the description line
|
|
|
+ virtual std::string make_description(const App *app) const;
|
|
|
+
|
|
|
+ /// This displays the usage line
|
|
|
+ virtual std::string make_usage(const App *app, std::string name) const;
|
|
|
+
|
|
|
+ /// This puts everything together
|
|
|
+ std::string make_help(const App *, std::string, AppFormatMode) const override;
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Options
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// This prints out an option help line, either positional or optional form
|
|
|
+ virtual std::string make_option(const Option *opt, bool is_positional) const {
|
|
|
+ std::stringstream out;
|
|
|
+ detail::format_help(
|
|
|
+ out, make_option_name(opt, is_positional) + make_option_opts(opt), make_option_desc(opt), column_width_);
|
|
|
+ return out.str();
|
|
|
+ }
|
|
|
+
|
|
|
+ /// @brief This is the name part of an option, Default: left column
|
|
|
+ virtual std::string make_option_name(const Option *, bool) const;
|
|
|
+
|
|
|
+ /// @brief This is the options part of the name, Default: combined into left column
|
|
|
+ virtual std::string make_option_opts(const Option *) const;
|
|
|
+
|
|
|
+ /// @brief This is the description. Default: Right column, on new line if left column too large
|
|
|
+ virtual std::string make_option_desc(const Option *) const;
|
|
|
+
|
|
|
+ /// @brief This is used to print the name on the USAGE line
|
|
|
+ virtual std::string make_option_usage(const Option *opt) const;
|
|
|
+
|
|
|
+ ///@}
|
|
|
+};
|
|
|
+
|
|
|
+} // namespace CLI
|
|
|
+
|
|
|
+// From CLI/Option.hpp:
|
|
|
+
|
|
|
+namespace CLI {
|
|
|
+
|
|
|
+using results_t = std::vector<std::string>;
|
|
|
+using callback_t = std::function<bool(results_t)>;
|
|
|
+
|
|
|
+class Option;
|
|
|
+class App;
|
|
|
+
|
|
|
+using Option_p = std::unique_ptr<Option>;
|
|
|
+
|
|
|
+enum class MultiOptionPolicy { Throw, TakeLast, TakeFirst, Join };
|
|
|
+
|
|
|
+/// This is the CRTP base class for Option and OptionDefaults. It was designed this way
|
|
|
+/// to share parts of the class; an OptionDefaults can copy to an Option.
|
|
|
+template <typename CRTP> class OptionBase {
|
|
|
+ friend App;
|
|
|
+
|
|
|
+ protected:
|
|
|
+ /// The group membership
|
|
|
+ std::string group_ = std::string("Options");
|
|
|
+
|
|
|
+ /// True if this is a required option
|
|
|
+ bool required_{false};
|
|
|
+
|
|
|
+ /// Ignore the case when matching (option, not value)
|
|
|
+ bool ignore_case_{false};
|
|
|
+
|
|
|
+ /// Allow this option to be given in a configuration file
|
|
|
+ bool configurable_{true};
|
|
|
+
|
|
|
+ /// Policy for multiple arguments when `expected_ == 1` (can be set on bool flags, too)
|
|
|
+ MultiOptionPolicy multi_option_policy_{MultiOptionPolicy::Throw};
|
|
|
+
|
|
|
+ /// Copy the contents to another similar class (one based on OptionBase)
|
|
|
+ template <typename T> void copy_to(T *other) const {
|
|
|
+ other->group(group_);
|
|
|
+ other->required(required_);
|
|
|
+ other->ignore_case(ignore_case_);
|
|
|
+ other->configurable(configurable_);
|
|
|
+ other->multi_option_policy(multi_option_policy_);
|
|
|
+ }
|
|
|
+
|
|
|
+ public:
|
|
|
+ // setters
|
|
|
+
|
|
|
+ /// Changes the group membership
|
|
|
+ CRTP *group(std::string name) {
|
|
|
+ group_ = name;
|
|
|
+ return static_cast<CRTP *>(this);
|
|
|
+ ;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Set the option as required
|
|
|
+ CRTP *required(bool value = true) {
|
|
|
+ required_ = value;
|
|
|
+ return static_cast<CRTP *>(this);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Support Plumbum term
|
|
|
+ CRTP *mandatory(bool value = true) { return required(value); }
|
|
|
+
|
|
|
+ // Getters
|
|
|
+
|
|
|
+ /// Get the group of this option
|
|
|
+ const std::string &get_group() const { return group_; }
|
|
|
+
|
|
|
+ /// True if this is a required option
|
|
|
+ bool get_required() const { return required_; }
|
|
|
+
|
|
|
+ /// The status of ignore case
|
|
|
+ bool get_ignore_case() const { return ignore_case_; }
|
|
|
+
|
|
|
+ /// The status of configurable
|
|
|
+ bool get_configurable() const { return configurable_; }
|
|
|
+
|
|
|
+ /// The status of the multi option policy
|
|
|
+ MultiOptionPolicy get_multi_option_policy() const { return multi_option_policy_; }
|
|
|
+
|
|
|
+ // Shortcuts for multi option policy
|
|
|
+
|
|
|
+ /// Set the multi option policy to take last
|
|
|
+ CRTP *take_last() {
|
|
|
+ auto self = static_cast<CRTP *>(this);
|
|
|
+ self->multi_option_policy(MultiOptionPolicy::TakeLast);
|
|
|
+ return self;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Set the multi option policy to take last
|
|
|
+ CRTP *take_first() {
|
|
|
+ auto self = static_cast<CRTP *>(this);
|
|
|
+ self->multi_option_policy(MultiOptionPolicy::TakeFirst);
|
|
|
+ return self;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Set the multi option policy to take last
|
|
|
+ CRTP *join() {
|
|
|
+ auto self = static_cast<CRTP *>(this);
|
|
|
+ self->multi_option_policy(MultiOptionPolicy::Join);
|
|
|
+ return self;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Allow in a configuration file
|
|
|
+ CRTP *configurable(bool value = true) {
|
|
|
+ configurable_ = value;
|
|
|
+ return static_cast<CRTP *>(this);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+/// This is a version of OptionBase that only supports setting values,
|
|
|
+/// for defaults. It is stored as the default option in an App.
|
|
|
+class OptionDefaults : public OptionBase<OptionDefaults> {
|
|
|
+ public:
|
|
|
+ OptionDefaults() = default;
|
|
|
+
|
|
|
+ // Methods here need a different implementation if they are Option vs. OptionDefault
|
|
|
+
|
|
|
+ /// Take the last argument if given multiple times
|
|
|
+ OptionDefaults *multi_option_policy(MultiOptionPolicy value = MultiOptionPolicy::Throw) {
|
|
|
+ multi_option_policy_ = value;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Ignore the case of the option name
|
|
|
+ OptionDefaults *ignore_case(bool value = true) {
|
|
|
+ ignore_case_ = value;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+class Option : public OptionBase<Option> {
|
|
|
+ friend App;
|
|
|
+
|
|
|
+ protected:
|
|
|
+ /// @name Names
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// A list of the short names (`-a`) without the leading dashes
|
|
|
+ std::vector<std::string> snames_;
|
|
|
+
|
|
|
+ /// A list of the long names (`--a`) without the leading dashes
|
|
|
+ std::vector<std::string> lnames_;
|
|
|
+
|
|
|
+ /// A positional name
|
|
|
+ std::string pname_;
|
|
|
+
|
|
|
+ /// If given, check the environment for this option
|
|
|
+ std::string envname_;
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Help
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// The description for help strings
|
|
|
+ std::string description_;
|
|
|
+
|
|
|
+ /// A human readable default value, usually only set if default is true in creation
|
|
|
+ std::string defaultval_;
|
|
|
+
|
|
|
+ /// A human readable type value, set when App creates this
|
|
|
+ ///
|
|
|
+ /// This is a lambda function so "types" can be dynamic, such as when a set prints its contents.
|
|
|
+ std::function<std::string()> type_name_{[]() { return std::string(); }};
|
|
|
+
|
|
|
+ /// True if this option has a default
|
|
|
+ bool default_{false};
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Configuration
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// The number of arguments that make up one option. -1=unlimited (vector-like), 0=flag, 1=normal option,
|
|
|
+ /// 2=complex/pair, etc. Set only when the option is created; this is intrinsic to the type. Eventually, -2 may mean
|
|
|
+ /// vector of pairs.
|
|
|
+ int type_size_{1};
|
|
|
+
|
|
|
+ /// The number of expected values, type_size_ must be < 0. Ignored for flag. N < 0 means at least -N values.
|
|
|
+ int expected_{1};
|
|
|
+
|
|
|
+ /// A list of validators to run on each value parsed
|
|
|
+ std::vector<std::function<std::string(std::string &)>> validators_;
|
|
|
+
|
|
|
+ /// A list of options that are required with this option
|
|
|
+ std::set<Option *> needs_;
|
|
|
+
|
|
|
+ /// A list of options that are excluded with this option
|
|
|
+ std::set<Option *> excludes_;
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Other
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Remember the parent app
|
|
|
+ App *parent_;
|
|
|
+
|
|
|
+ /// Options store a callback to do all the work
|
|
|
+ callback_t callback_;
|
|
|
+
|
|
|
+ /// Options can short-circuit for help options or similar (called before parsing is validated)
|
|
|
+ bool short_circuit_{false};
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Parsing results
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Results of parsing
|
|
|
+ results_t results_;
|
|
|
+
|
|
|
+ /// Whether the callback has run (needed for INI parsing)
|
|
|
+ bool callback_run_{false};
|
|
|
+
|
|
|
+ ///@}
|
|
|
+
|
|
|
+ /// Making an option by hand is not defined, it must be made by the App class
|
|
|
+ Option(
|
|
|
+ std::string name, std::string description, std::function<bool(results_t)> callback, bool defaulted, App *parent)
|
|
|
+ : description_(std::move(description)), default_(defaulted), parent_(parent),
|
|
|
+ callback_(callback ? std::move(callback) : [](results_t) { return true; }) {
|
|
|
+ std::tie(snames_, lnames_, pname_) = detail::get_names(detail::split_names(name));
|
|
|
+ }
|
|
|
+
|
|
|
+ public:
|
|
|
+ /// @name Basic
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Count the total number of times an option was passed
|
|
|
+ size_t count() const { return results_.size(); }
|
|
|
+
|
|
|
+ /// True if the option was not passed
|
|
|
+ size_t empty() const { return results_.empty(); }
|
|
|
+
|
|
|
+ /// This class is true if option is passed.
|
|
|
+ operator bool() const { return !empty(); }
|
|
|
+
|
|
|
+ /// Clear the parsed results (mostly for testing)
|
|
|
+ void clear() { results_.clear(); }
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Setting options
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Set the number of expected arguments (Flags don't use this)
|
|
|
+ Option *expected(int value) {
|
|
|
+ // Break if this is a flag
|
|
|
+ if(type_size_ == 0)
|
|
|
+ throw IncorrectConstruction::SetFlag(get_name(true, true));
|
|
|
+
|
|
|
+ // Setting 0 is not allowed
|
|
|
+ else if(value == 0)
|
|
|
+ throw IncorrectConstruction::Set0Opt(get_name());
|
|
|
+
|
|
|
+ // No change is okay, quit now
|
|
|
+ else if(expected_ == value)
|
|
|
+ return this;
|
|
|
+
|
|
|
+ // Type must be a vector
|
|
|
+ else if(type_size_ >= 0)
|
|
|
+ throw IncorrectConstruction::ChangeNotVector(get_name());
|
|
|
+
|
|
|
+ // TODO: Can support multioption for non-1 values (except for join)
|
|
|
+ else if(value != 1 && multi_option_policy_ != MultiOptionPolicy::Throw)
|
|
|
+ throw IncorrectConstruction::AfterMultiOpt(get_name());
|
|
|
+
|
|
|
+ expected_ = value;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Adds a validator with a built in type name
|
|
|
+ Option *check(const Validator &validator) {
|
|
|
+ validators_.emplace_back(validator.func);
|
|
|
+ if(!validator.tname.empty())
|
|
|
+ type_name(validator.tname);
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Adds a validator. Takes a const string& and returns an error message (empty if conversion/check is okay).
|
|
|
+ Option *check(std::function<std::string(const std::string &)> validator) {
|
|
|
+ validators_.emplace_back(validator);
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Adds a validator-like function that can change result
|
|
|
+ Option *transform(std::function<std::string(std::string)> func) {
|
|
|
+ validators_.emplace_back([func](std::string &inout) {
|
|
|
+ try {
|
|
|
+ inout = func(inout);
|
|
|
+ } catch(const ValidationError &e) {
|
|
|
+ return std::string(e.what());
|
|
|
+ }
|
|
|
+ return std::string();
|
|
|
+ });
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Adds a user supplied function to run on each item passed in (communicate though lambda capture)
|
|
|
+ Option *each(std::function<void(std::string)> func) {
|
|
|
+ validators_.emplace_back([func](std::string &inout) {
|
|
|
+ func(inout);
|
|
|
+ return std::string();
|
|
|
+ });
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Sets required options
|
|
|
+ Option *needs(Option *opt) {
|
|
|
+ auto tup = needs_.insert(opt);
|
|
|
+ if(!tup.second)
|
|
|
+ throw OptionAlreadyAdded::Requires(get_name(), opt->get_name());
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Can find a string if needed
|
|
|
+ template <typename T = App> Option *needs(std::string opt_name) {
|
|
|
+ for(const Option_p &opt : dynamic_cast<T *>(parent_)->options_)
|
|
|
+ if(opt.get() != this && opt->check_name(opt_name))
|
|
|
+ return needs(opt.get());
|
|
|
+ throw IncorrectConstruction::MissingOption(opt_name);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Any number supported, any mix of string and Opt
|
|
|
+ template <typename A, typename B, typename... ARG> Option *needs(A opt, B opt1, ARG... args) {
|
|
|
+ needs(opt);
|
|
|
+ return needs(opt1, args...);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Remove needs link from an option. Returns true if the option really was in the needs list.
|
|
|
+ bool remove_needs(Option *opt) {
|
|
|
+ auto iterator = std::find(std::begin(needs_), std::end(needs_), opt);
|
|
|
+
|
|
|
+ if(iterator != std::end(needs_)) {
|
|
|
+ needs_.erase(iterator);
|
|
|
+ return true;
|
|
|
+ } else {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Sets excluded options
|
|
|
+ Option *excludes(Option *opt) {
|
|
|
+ excludes_.insert(opt);
|
|
|
+
|
|
|
+ // Help text should be symmetric - excluding a should exclude b
|
|
|
+ opt->excludes_.insert(this);
|
|
|
+
|
|
|
+ // Ignoring the insert return value, excluding twice is now allowed.
|
|
|
+ // (Mostly to allow both directions to be excluded by user, even though the library does it for you.)
|
|
|
+
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Can find a string if needed
|
|
|
+ template <typename T = App> Option *excludes(std::string opt_name) {
|
|
|
+ for(const Option_p &opt : dynamic_cast<T *>(parent_)->options_)
|
|
|
+ if(opt.get() != this && opt->check_name(opt_name))
|
|
|
+ return excludes(opt.get());
|
|
|
+ throw IncorrectConstruction::MissingOption(opt_name);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Any number supported, any mix of string and Opt
|
|
|
+ template <typename A, typename B, typename... ARG> Option *excludes(A opt, B opt1, ARG... args) {
|
|
|
+ excludes(opt);
|
|
|
+ return excludes(opt1, args...);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Remove needs link from an option. Returns true if the option really was in the needs list.
|
|
|
+ bool remove_excludes(Option *opt) {
|
|
|
+ auto iterator = std::find(std::begin(excludes_), std::end(excludes_), opt);
|
|
|
+
|
|
|
+ if(iterator != std::end(excludes_)) {
|
|
|
+ excludes_.erase(iterator);
|
|
|
+ return true;
|
|
|
+ } else {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Sets environment variable to read if no option given
|
|
|
+ Option *envname(std::string name) {
|
|
|
+ envname_ = name;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Ignore case
|
|
|
+ ///
|
|
|
+ /// The template hides the fact that we don't have the definition of App yet.
|
|
|
+ /// You are never expected to add an argument to the template here.
|
|
|
+ template <typename T = App> Option *ignore_case(bool value = true) {
|
|
|
+ ignore_case_ = value;
|
|
|
+ auto *parent = dynamic_cast<T *>(parent_);
|
|
|
+
|
|
|
+ for(const Option_p &opt : parent->options_)
|
|
|
+ if(opt.get() != this && *opt == *this)
|
|
|
+ throw OptionAlreadyAdded(opt->get_name(true, true));
|
|
|
+
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Take the last argument if given multiple times (or another policy)
|
|
|
+ Option *multi_option_policy(MultiOptionPolicy value = MultiOptionPolicy::Throw) {
|
|
|
+
|
|
|
+ if(get_items_expected() < 0)
|
|
|
+ throw IncorrectConstruction::MultiOptionPolicy(get_name());
|
|
|
+ multi_option_policy_ = value;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Options with a short circuit set will run this function before parsing is finished.
|
|
|
+ ///
|
|
|
+ /// This is set on help functions, for example, to escape the normal validation.
|
|
|
+ Option *short_circuit(bool value = true) {
|
|
|
+ short_circuit_ = value;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Accessors
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// The number of arguments the option expects
|
|
|
+ int get_type_size() const { return type_size_; }
|
|
|
+
|
|
|
+ /// The environment variable associated to this value
|
|
|
+ std::string get_envname() const { return envname_; }
|
|
|
+
|
|
|
+ /// The set of options needed
|
|
|
+ std::set<Option *> get_needs() const { return needs_; }
|
|
|
+
|
|
|
+ /// The set of options excluded
|
|
|
+ std::set<Option *> get_excludes() const { return excludes_; }
|
|
|
+
|
|
|
+ /// The default value (for help printing)
|
|
|
+ std::string get_defaultval() const { return defaultval_; }
|
|
|
+
|
|
|
+ /// See if this is supposed to short circuit (skip validation, INI, etc) (Used for help flags)
|
|
|
+ bool get_short_circuit() const { return short_circuit_; }
|
|
|
+
|
|
|
+ /// Get the callback function
|
|
|
+ callback_t get_callback() const { return callback_; }
|
|
|
+
|
|
|
+ /// Get the long names
|
|
|
+ const std::vector<std::string> get_lnames() const { return lnames_; }
|
|
|
+
|
|
|
+ /// Get the short names
|
|
|
+ const std::vector<std::string> get_snames() const { return snames_; }
|
|
|
+
|
|
|
+ /// The number of times the option expects to be included
|
|
|
+ int get_expected() const { return expected_; }
|
|
|
+
|
|
|
+ /// \brief The total number of expected values (including the type)
|
|
|
+ /// This is positive if exactly this number is expected, and negitive for at least N values
|
|
|
+ ///
|
|
|
+ /// v = fabs(size_type*expected)
|
|
|
+ /// !MultiOptionPolicy::Throw
|
|
|
+ /// | Expected < 0 | Expected == 0 | Expected > 0
|
|
|
+ /// Size < 0 | -v | 0 | -v
|
|
|
+ /// Size == 0 | 0 | 0 | 0
|
|
|
+ /// Size > 0 | -v | 0 | -v // Expected must be 1
|
|
|
+ ///
|
|
|
+ /// MultiOptionPolicy::Throw
|
|
|
+ /// | Expected < 0 | Expected == 0 | Expected > 0
|
|
|
+ /// Size < 0 | -v | 0 | v
|
|
|
+ /// Size == 0 | 0 | 0 | 0
|
|
|
+ /// Size > 0 | v | 0 | v // Expected must be 1
|
|
|
+ ///
|
|
|
+ int get_items_expected() const {
|
|
|
+ return std::abs(type_size_ * expected_) *
|
|
|
+ ((multi_option_policy_ != MultiOptionPolicy::Throw || (expected_ < 0 && type_size_ < 0) ? -1 : 1));
|
|
|
+ }
|
|
|
+
|
|
|
+ /// True if this has a default value
|
|
|
+ int get_default() const { return default_; }
|
|
|
+
|
|
|
+ /// True if the argument can be given directly
|
|
|
+ bool get_positional() const { return pname_.length() > 0; }
|
|
|
+
|
|
|
+ /// True if option has at least one non-positional name
|
|
|
+ bool nonpositional() const { return (snames_.size() + lnames_.size()) > 0; }
|
|
|
+
|
|
|
+ /// True if option has description
|
|
|
+ bool has_description() const { return description_.length() > 0; }
|
|
|
+
|
|
|
+ /// Get the description
|
|
|
+ const std::string &get_description() const { return description_; }
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Help tools
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// \brief Gets a comma seperated list of names.
|
|
|
+ /// Will include / prefer the positional name if positional is true.
|
|
|
+ /// If all_options is false, pick just the most descriptive name to show.
|
|
|
+ /// Use `get_name(true)` to get the positional name (replaces `get_pname`)
|
|
|
+ std::string get_name(bool positional = false, //<[input] Show the positional name
|
|
|
+ bool all_options = false //<[input] Show every option
|
|
|
+ ) const {
|
|
|
+
|
|
|
+ if(all_options) {
|
|
|
+
|
|
|
+ std::vector<std::string> name_list;
|
|
|
+
|
|
|
+ /// The all list wil never include a positional unless asked or that's the only name.
|
|
|
+ if((positional && pname_.length()) || (snames_.empty() && lnames_.empty()))
|
|
|
+ name_list.push_back(pname_);
|
|
|
+
|
|
|
+ for(const std::string &sname : snames_)
|
|
|
+ name_list.push_back("-" + sname);
|
|
|
+
|
|
|
+ for(const std::string &lname : lnames_)
|
|
|
+ name_list.push_back("--" + lname);
|
|
|
+
|
|
|
+ return detail::join(name_list);
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ // This returns the positional name no matter what
|
|
|
+ if(positional)
|
|
|
+ return pname_;
|
|
|
+
|
|
|
+ // Prefer long name
|
|
|
+ else if(!lnames_.empty())
|
|
|
+ return std::string("--") + lnames_[0];
|
|
|
+
|
|
|
+ // Or short name if no long name
|
|
|
+ else if(!snames_.empty())
|
|
|
+ return std::string("-") + snames_[0];
|
|
|
+
|
|
|
+ // If positional is the only name, it's okay to use that
|
|
|
+ else
|
|
|
+ return pname_;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Parser tools
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Process the callback
|
|
|
+ void run_callback() {
|
|
|
+
|
|
|
+ // Run the validators (can change the string)
|
|
|
+ if(!validators_.empty()) {
|
|
|
+ for(std::string &result : results_)
|
|
|
+ for(const std::function<std::string(std::string &)> &vali : validators_) {
|
|
|
+ std::string err_msg = vali(result);
|
|
|
+ if(!err_msg.empty())
|
|
|
+ throw ValidationError(get_name(), err_msg);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ bool local_result;
|
|
|
+
|
|
|
+ // Num items expected or length of vector, always at least 1
|
|
|
+ // Only valid for a trimming policy
|
|
|
+ int trim_size =
|
|
|
+ std::min<int>(std::max<int>(std::abs(get_items_expected()), 1), static_cast<int>(results_.size()));
|
|
|
+
|
|
|
+ // Operation depends on the policy setting
|
|
|
+ if(multi_option_policy_ == MultiOptionPolicy::TakeLast) {
|
|
|
+ // Allow multi-option sizes (including 0)
|
|
|
+ results_t partial_result{results_.end() - trim_size, results_.end()};
|
|
|
+ local_result = !callback_(partial_result);
|
|
|
+
|
|
|
+ } else if(multi_option_policy_ == MultiOptionPolicy::TakeFirst) {
|
|
|
+ results_t partial_result{results_.begin(), results_.begin() + trim_size};
|
|
|
+ local_result = !callback_(partial_result);
|
|
|
+
|
|
|
+ } else if(multi_option_policy_ == MultiOptionPolicy::Join) {
|
|
|
+ results_t partial_result = {detail::join(results_, "\n")};
|
|
|
+ local_result = !callback_(partial_result);
|
|
|
+
|
|
|
+ } else {
|
|
|
+ // Exact number required
|
|
|
+ if(get_items_expected() > 0) {
|
|
|
+ if(results_.size() != static_cast<size_t>(get_items_expected()))
|
|
|
+ throw ArgumentMismatch(get_name(), get_items_expected(), results_.size());
|
|
|
+ // Variable length list
|
|
|
+ } else if(get_items_expected() < 0) {
|
|
|
+ // Require that this be a multiple of expected size and at least as many as expected
|
|
|
+ if(results_.size() < static_cast<size_t>(-get_items_expected()) ||
|
|
|
+ results_.size() % static_cast<size_t>(std::abs(get_type_size())) != 0)
|
|
|
+ throw ArgumentMismatch(get_name(), get_items_expected(), results_.size());
|
|
|
+ }
|
|
|
+ local_result = !callback_(results_);
|
|
|
+ }
|
|
|
+
|
|
|
+ if(local_result)
|
|
|
+ throw ConversionError(get_name(), results_);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// If options share any of the same names, they are equal (not counting positional)
|
|
|
+ bool operator==(const Option &other) const {
|
|
|
+ for(const std::string &sname : snames_)
|
|
|
+ if(other.check_sname(sname))
|
|
|
+ return true;
|
|
|
+ for(const std::string &lname : lnames_)
|
|
|
+ if(other.check_lname(lname))
|
|
|
+ return true;
|
|
|
+ // We need to do the inverse, just in case we are ignore_case
|
|
|
+ for(const std::string &sname : other.snames_)
|
|
|
+ if(check_sname(sname))
|
|
|
+ return true;
|
|
|
+ for(const std::string &lname : other.lnames_)
|
|
|
+ if(check_lname(lname))
|
|
|
+ return true;
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Check a name. Requires "-" or "--" for short / long, supports positional name
|
|
|
+ bool check_name(std::string name) const {
|
|
|
+
|
|
|
+ if(name.length() > 2 && name.substr(0, 2) == "--")
|
|
|
+ return check_lname(name.substr(2));
|
|
|
+ else if(name.length() > 1 && name.substr(0, 1) == "-")
|
|
|
+ return check_sname(name.substr(1));
|
|
|
+ else {
|
|
|
+ std::string local_pname = pname_;
|
|
|
+ if(ignore_case_) {
|
|
|
+ local_pname = detail::to_lower(local_pname);
|
|
|
+ name = detail::to_lower(name);
|
|
|
+ }
|
|
|
+ return name == local_pname;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Requires "-" to be removed from string
|
|
|
+ bool check_sname(std::string name) const {
|
|
|
+ if(ignore_case_) {
|
|
|
+ name = detail::to_lower(name);
|
|
|
+ return std::find_if(std::begin(snames_), std::end(snames_), [&name](std::string local_sname) {
|
|
|
+ return detail::to_lower(local_sname) == name;
|
|
|
+ }) != std::end(snames_);
|
|
|
+ } else
|
|
|
+ return std::find(std::begin(snames_), std::end(snames_), name) != std::end(snames_);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Requires "--" to be removed from string
|
|
|
+ bool check_lname(std::string name) const {
|
|
|
+ if(ignore_case_) {
|
|
|
+ name = detail::to_lower(name);
|
|
|
+ return std::find_if(std::begin(lnames_), std::end(lnames_), [&name](std::string local_sname) {
|
|
|
+ return detail::to_lower(local_sname) == name;
|
|
|
+ }) != std::end(lnames_);
|
|
|
+ } else
|
|
|
+ return std::find(std::begin(lnames_), std::end(lnames_), name) != std::end(lnames_);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Puts a result at the end
|
|
|
+ Option *add_result(std::string s) {
|
|
|
+ results_.push_back(s);
|
|
|
+ callback_run_ = false;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Set the results vector all at once
|
|
|
+ Option *set_results(std::vector<std::string> results) {
|
|
|
+ results_ = results;
|
|
|
+ callback_run_ = false;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Get a copy of the results
|
|
|
+ std::vector<std::string> results() const { return results_; }
|
|
|
+
|
|
|
+ /// See if the callback has been run already
|
|
|
+ bool get_callback_run() const { return callback_run_; }
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Custom options
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Set the type function to run when displayed on this option
|
|
|
+ Option *type_name_fn(std::function<std::string()> typefun) {
|
|
|
+ type_name_ = typefun;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Set a custom option typestring
|
|
|
+ Option *type_name(std::string typeval) {
|
|
|
+ type_name_fn([typeval]() { return typeval; });
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Provided for backward compatibility \deprecated
|
|
|
+ CLI11_DEPRECATED("Please use type_name instead")
|
|
|
+ Option *set_type_name(std::string typeval) { return type_name(typeval); }
|
|
|
+
|
|
|
+ /// Set a custom option size
|
|
|
+ Option *type_size(int type_size) {
|
|
|
+ type_size_ = type_size;
|
|
|
+ if(type_size_ == 0)
|
|
|
+ required_ = false;
|
|
|
+ if(type_size < 0)
|
|
|
+ expected_ = -1;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Set the default value string representation
|
|
|
+ Option *default_str(std::string val) {
|
|
|
+ defaultval_ = val;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Set the default value string representation and evaluate
|
|
|
+ Option *default_val(std::string val) {
|
|
|
+ default_str(val);
|
|
|
+ auto old_results = results_;
|
|
|
+ results_ = {val};
|
|
|
+ run_callback();
|
|
|
+ results_ = std::move(old_results);
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Get the typename for this option
|
|
|
+ std::string get_type_name() const { return type_name_(); }
|
|
|
+};
|
|
|
+
|
|
|
+} // namespace CLI
|
|
|
+
|
|
|
+// From CLI/App.hpp:
|
|
|
+
|
|
|
+namespace CLI {
|
|
|
+
|
|
|
+#ifndef CLI11_PARSE
|
|
|
+#define CLI11_PARSE(app, argc, argv) \
|
|
|
+ try { \
|
|
|
+ (app).parse((argc), (argv)); \
|
|
|
+ } catch(const CLI::ParseError &e) { \
|
|
|
+ return (app).exit(e); \
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+namespace detail {
|
|
|
+enum class Classifer { NONE, POSITIONAL_MARK, SHORT, LONG, SUBCOMMAND };
|
|
|
+struct AppFriend;
|
|
|
+} // namespace detail
|
|
|
+
|
|
|
+namespace FailureMessage {
|
|
|
+std::string simple(const App *app, const Error &e);
|
|
|
+std::string help(const App *app, const Error &e);
|
|
|
+} // namespace FailureMessage
|
|
|
+
|
|
|
+class App;
|
|
|
+
|
|
|
+using App_p = std::unique_ptr<App>;
|
|
|
+
|
|
|
+/// Creates a command line program, with very few defaults.
|
|
|
+/** To use, create a new `Program()` instance with `argc`, `argv`, and a help description. The templated
|
|
|
+ * add_option methods make it easy to prepare options. Remember to call `.start` before starting your
|
|
|
+ * program, so that the options can be evaluated and the help option doesn't accidentally run your program. */
|
|
|
+class App {
|
|
|
+ friend Option;
|
|
|
+ friend detail::AppFriend;
|
|
|
+
|
|
|
+ protected:
|
|
|
+ // This library follows the Google style guide for member names ending in underscores
|
|
|
+
|
|
|
+ /// @name Basics
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Subcommand name or program name (from parser if name is empty)
|
|
|
+ std::string name_;
|
|
|
+
|
|
|
+ /// Description of the current program/subcommand
|
|
|
+ std::string description_;
|
|
|
+
|
|
|
+ /// If true, allow extra arguments (ie, don't throw an error). INHERITABLE
|
|
|
+ bool allow_extras_{false};
|
|
|
+
|
|
|
+ /// If true, allow extra arguments in the ini file (ie, don't throw an error). INHERITABLE
|
|
|
+ bool allow_config_extras_{false};
|
|
|
+
|
|
|
+ /// If true, return immediately on an unrecognised option (implies allow_extras) INHERITABLE
|
|
|
+ bool prefix_command_{false};
|
|
|
+
|
|
|
+ /// This is a function that runs when complete. Great for subcommands. Can throw.
|
|
|
+ std::function<void()> callback_;
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Options
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// The default values for options, customizable and changeable INHERITABLE
|
|
|
+ OptionDefaults option_defaults_;
|
|
|
+
|
|
|
+ /// The list of options, stored locally
|
|
|
+ std::vector<Option_p> options_;
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Help
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Footer to put after all options in the help output INHERITABLE
|
|
|
+ std::string footer_;
|
|
|
+
|
|
|
+ /// A pointer to the help flag if there is one INHERITABLE
|
|
|
+ Option *help_ptr_{nullptr};
|
|
|
+
|
|
|
+ /// A pointer to the help all flag if there is one INHERITABLE
|
|
|
+ Option *help_all_ptr_{nullptr};
|
|
|
+
|
|
|
+ /// This is the formatter for help printing. Default provided. INHERITABLE (same pointer)
|
|
|
+ std::shared_ptr<FormatterBase> formatter_{new Formatter()};
|
|
|
+
|
|
|
+ /// The error message printing function INHERITABLE
|
|
|
+ std::function<std::string(const App *, const Error &e)> failure_message_ = FailureMessage::simple;
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Parsing
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ using missing_t = std::vector<std::pair<detail::Classifer, std::string>>;
|
|
|
+
|
|
|
+ /// Pair of classifier, string for missing options. (extra detail is removed on returning from parse)
|
|
|
+ ///
|
|
|
+ /// This is faster and cleaner than storing just a list of strings and reparsing. This may contain the -- separator.
|
|
|
+ missing_t missing_;
|
|
|
+
|
|
|
+ /// This is a list of pointers to options with the original parse order
|
|
|
+ std::vector<Option *> parse_order_;
|
|
|
+
|
|
|
+ /// This is a list of the subcommands collected, in order
|
|
|
+ std::vector<App *> parsed_subcommands_;
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Subcommands
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Storage for subcommand list
|
|
|
+ std::vector<App_p> subcommands_;
|
|
|
+
|
|
|
+ /// If true, the program name is not case sensitive INHERITABLE
|
|
|
+ bool ignore_case_{false};
|
|
|
+
|
|
|
+ /// Allow subcommand fallthrough, so that parent commands can collect commands after subcommand. INHERITABLE
|
|
|
+ bool fallthrough_{false};
|
|
|
+
|
|
|
+ /// A pointer to the parent if this is a subcommand
|
|
|
+ App *parent_{nullptr};
|
|
|
+
|
|
|
+ /// True if this command/subcommand was parsed
|
|
|
+ bool parsed_{false};
|
|
|
+
|
|
|
+ /// Minimum required subcommands (not inheritable!)
|
|
|
+ size_t require_subcommand_min_ = 0;
|
|
|
+
|
|
|
+ /// Max number of subcommands allowed (parsing stops after this number). 0 is unlimited INHERITABLE
|
|
|
+ size_t require_subcommand_max_ = 0;
|
|
|
+
|
|
|
+ /// The group membership INHERITABLE
|
|
|
+ std::string group_{"Subcommands"};
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Config
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// The name of the connected config file
|
|
|
+ std::string config_name_;
|
|
|
+
|
|
|
+ /// True if ini is required (throws if not present), if false simply keep going.
|
|
|
+ bool config_required_{false};
|
|
|
+
|
|
|
+ /// Pointer to the config option
|
|
|
+ Option *config_ptr_{nullptr};
|
|
|
+
|
|
|
+ /// This is the formatter for help printing. Default provided. INHERITABLE (same pointer)
|
|
|
+ std::shared_ptr<Config> config_formatter_{new ConfigINI()};
|
|
|
+
|
|
|
+ ///@}
|
|
|
+
|
|
|
+ /// Special private constructor for subcommand
|
|
|
+ App(std::string description_, std::string name, App *parent)
|
|
|
+ : name_(std::move(name)), description_(std::move(description_)), parent_(parent) {
|
|
|
+ // Inherit if not from a nullptr
|
|
|
+ if(parent_ != nullptr) {
|
|
|
+ if(parent_->help_ptr_ != nullptr)
|
|
|
+ set_help_flag(parent_->help_ptr_->get_name(false, true), parent_->help_ptr_->get_description());
|
|
|
+ if(parent_->help_all_ptr_ != nullptr)
|
|
|
+ set_help_all_flag(parent_->help_all_ptr_->get_name(false, true),
|
|
|
+ parent_->help_all_ptr_->get_description());
|
|
|
+
|
|
|
+ /// OptionDefaults
|
|
|
+ option_defaults_ = parent_->option_defaults_;
|
|
|
+
|
|
|
+ // INHERITABLE
|
|
|
+ failure_message_ = parent_->failure_message_;
|
|
|
+ allow_extras_ = parent_->allow_extras_;
|
|
|
+ allow_config_extras_ = parent_->allow_config_extras_;
|
|
|
+ prefix_command_ = parent_->prefix_command_;
|
|
|
+ ignore_case_ = parent_->ignore_case_;
|
|
|
+ fallthrough_ = parent_->fallthrough_;
|
|
|
+ group_ = parent_->group_;
|
|
|
+ footer_ = parent_->footer_;
|
|
|
+ formatter_ = parent_->formatter_;
|
|
|
+ config_formatter_ = parent_->config_formatter_;
|
|
|
+ require_subcommand_max_ = parent_->require_subcommand_max_;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public:
|
|
|
+ /// @name Basic
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Create a new program. Pass in the same arguments as main(), along with a help string.
|
|
|
+ explicit App(std::string description_ = "", std::string name = "") : App(description_, name, nullptr) {
|
|
|
+ set_help_flag("-h,--help", "Print this help message and exit");
|
|
|
+ }
|
|
|
+
|
|
|
+ /// virtual destructor
|
|
|
+ virtual ~App() = default;
|
|
|
+
|
|
|
+ /// Set a callback for the end of parsing.
|
|
|
+ ///
|
|
|
+ /// Due to a bug in c++11,
|
|
|
+ /// it is not possible to overload on std::function (fixed in c++14
|
|
|
+ /// and backported to c++11 on newer compilers). Use capture by reference
|
|
|
+ /// to get a pointer to App if needed.
|
|
|
+ App *callback(std::function<void()> callback) {
|
|
|
+ callback_ = callback;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Set a name for the app (empty will use parser to set the name)
|
|
|
+ App *name(std::string name = "") {
|
|
|
+ name_ = name;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Remove the error when extras are left over on the command line.
|
|
|
+ App *allow_extras(bool allow = true) {
|
|
|
+ allow_extras_ = allow;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Remove the error when extras are left over on the command line.
|
|
|
+ /// Will also call App::allow_extras().
|
|
|
+ App *allow_config_extras(bool allow = true) {
|
|
|
+ allow_extras(allow);
|
|
|
+ allow_config_extras_ = allow;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Do not parse anything after the first unrecognised option and return
|
|
|
+ App *prefix_command(bool allow = true) {
|
|
|
+ prefix_command_ = allow;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Ignore case. Subcommand inherit value.
|
|
|
+ App *ignore_case(bool value = true) {
|
|
|
+ ignore_case_ = value;
|
|
|
+ if(parent_ != nullptr) {
|
|
|
+ for(const auto &subc : parent_->subcommands_) {
|
|
|
+ if(subc.get() != this && (this->check_name(subc->name_) || subc->check_name(this->name_)))
|
|
|
+ throw OptionAlreadyAdded(subc->name_);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Set the help formatter
|
|
|
+ App *formatter(std::shared_ptr<FormatterBase> fmt) {
|
|
|
+ formatter_ = fmt;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Set the help formatter
|
|
|
+ App *formatter_fn(std::function<std::string(const App *, std::string, AppFormatMode)> fmt) {
|
|
|
+ formatter_ = std::make_shared<FormatterLambda>(fmt);
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Set the config formatter
|
|
|
+ App *config_formatter(std::shared_ptr<Config> fmt) {
|
|
|
+ config_formatter_ = fmt;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Check to see if this subcommand was parsed, true only if received on command line.
|
|
|
+ bool parsed() const { return parsed_; }
|
|
|
+
|
|
|
+ /// Get the OptionDefault object, to set option defaults
|
|
|
+ OptionDefaults *option_defaults() { return &option_defaults_; }
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Adding options
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Add an option, will automatically understand the type for common types.
|
|
|
+ ///
|
|
|
+ /// To use, create a variable with the expected type, and pass it in after the name.
|
|
|
+ /// After start is called, you can use count to see if the value was passed, and
|
|
|
+ /// the value will be initialized properly. Numbers, vectors, and strings are supported.
|
|
|
+ ///
|
|
|
+ /// ->required(), ->default, and the validators are options,
|
|
|
+ /// The positional options take an optional number of arguments.
|
|
|
+ ///
|
|
|
+ /// For example,
|
|
|
+ ///
|
|
|
+ /// std::string filename;
|
|
|
+ /// program.add_option("filename", filename, "description of filename");
|
|
|
+ ///
|
|
|
+ Option *add_option(std::string name, callback_t callback, std::string description = "", bool defaulted = false) {
|
|
|
+ Option myopt{name, description, callback, defaulted, this};
|
|
|
+
|
|
|
+ if(std::find_if(std::begin(options_), std::end(options_), [&myopt](const Option_p &v) {
|
|
|
+ return *v == myopt;
|
|
|
+ }) == std::end(options_)) {
|
|
|
+ options_.emplace_back();
|
|
|
+ Option_p &option = options_.back();
|
|
|
+ option.reset(new Option(name, description, callback, defaulted, this));
|
|
|
+ option_defaults_.copy_to(option.get());
|
|
|
+ return option.get();
|
|
|
+ } else
|
|
|
+ throw OptionAlreadyAdded(myopt.get_name());
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Add option for non-vectors (duplicate copy needed without defaulted to avoid `iostream << value`)
|
|
|
+ template <typename T, enable_if_t<!is_vector<T>::value, detail::enabler> = detail::dummy>
|
|
|
+ Option *add_option(std::string name,
|
|
|
+ T &variable, ///< The variable to set
|
|
|
+ std::string description = "") {
|
|
|
+
|
|
|
+ CLI::callback_t fun = [&variable](CLI::results_t res) { return detail::lexical_cast(res[0], variable); };
|
|
|
+
|
|
|
+ Option *opt = add_option(name, fun, description, false);
|
|
|
+ opt->type_name(detail::type_name<T>());
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Add option for non-vectors with a default print
|
|
|
+ template <typename T, enable_if_t<!is_vector<T>::value, detail::enabler> = detail::dummy>
|
|
|
+ Option *add_option(std::string name,
|
|
|
+ T &variable, ///< The variable to set
|
|
|
+ std::string description,
|
|
|
+ bool defaulted) {
|
|
|
+
|
|
|
+ CLI::callback_t fun = [&variable](CLI::results_t res) { return detail::lexical_cast(res[0], variable); };
|
|
|
+
|
|
|
+ Option *opt = add_option(name, fun, description, defaulted);
|
|
|
+ opt->type_name(detail::type_name<T>());
|
|
|
+ if(defaulted) {
|
|
|
+ std::stringstream out;
|
|
|
+ out << variable;
|
|
|
+ opt->default_str(out.str());
|
|
|
+ }
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Add option for vectors (no default)
|
|
|
+ template <typename T>
|
|
|
+ Option *add_option(std::string name,
|
|
|
+ std::vector<T> &variable, ///< The variable vector to set
|
|
|
+ std::string description = "") {
|
|
|
+
|
|
|
+ CLI::callback_t fun = [&variable](CLI::results_t res) {
|
|
|
+ bool retval = true;
|
|
|
+ variable.clear();
|
|
|
+ for(const auto &a : res) {
|
|
|
+ variable.emplace_back();
|
|
|
+ retval &= detail::lexical_cast(a, variable.back());
|
|
|
+ }
|
|
|
+ return (!variable.empty()) && retval;
|
|
|
+ };
|
|
|
+
|
|
|
+ Option *opt = add_option(name, fun, description, false);
|
|
|
+ opt->type_name(detail::type_name<T>())->type_size(-1);
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Add option for vectors
|
|
|
+ template <typename T>
|
|
|
+ Option *add_option(std::string name,
|
|
|
+ std::vector<T> &variable, ///< The variable vector to set
|
|
|
+ std::string description,
|
|
|
+ bool defaulted) {
|
|
|
+
|
|
|
+ CLI::callback_t fun = [&variable](CLI::results_t res) {
|
|
|
+ bool retval = true;
|
|
|
+ variable.clear();
|
|
|
+ for(const auto &a : res) {
|
|
|
+ variable.emplace_back();
|
|
|
+ retval &= detail::lexical_cast(a, variable.back());
|
|
|
+ }
|
|
|
+ return (!variable.empty()) && retval;
|
|
|
+ };
|
|
|
+
|
|
|
+ Option *opt = add_option(name, fun, description, defaulted);
|
|
|
+ opt->type_name(detail::type_name<T>())->type_size(-1);
|
|
|
+ if(defaulted)
|
|
|
+ opt->default_str("[" + detail::join(variable) + "]");
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Set a help flag, replace the existing one if present
|
|
|
+ Option *set_help_flag(std::string name = "", std::string description = "") {
|
|
|
+ if(help_ptr_ != nullptr) {
|
|
|
+ remove_option(help_ptr_);
|
|
|
+ help_ptr_ = nullptr;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Empty name will simply remove the help flag
|
|
|
+ if(!name.empty()) {
|
|
|
+ help_ptr_ = add_flag_function(name, [](size_t) -> void { throw CallForHelp(); }, description);
|
|
|
+ help_ptr_->short_circuit(true);
|
|
|
+ help_ptr_->configurable(false);
|
|
|
+ }
|
|
|
+
|
|
|
+ return help_ptr_;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Set a help all flag, replaced the existing one if present
|
|
|
+ Option *set_help_all_flag(std::string name = "", std::string description = "") {
|
|
|
+ if(help_all_ptr_ != nullptr) {
|
|
|
+ remove_option(help_all_ptr_);
|
|
|
+ help_all_ptr_ = nullptr;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Empty name will simply remove the help all flag
|
|
|
+ if(!name.empty()) {
|
|
|
+ help_all_ptr_ = add_flag_function(name, [](size_t) -> void { throw CallForAllHelp(); }, description);
|
|
|
+ help_all_ptr_->short_circuit(true);
|
|
|
+ help_all_ptr_->configurable(false);
|
|
|
+ }
|
|
|
+
|
|
|
+ return help_all_ptr_;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Add option for flag
|
|
|
+ Option *add_flag(std::string name, std::string description = "") {
|
|
|
+ CLI::callback_t fun = [](CLI::results_t) { return true; };
|
|
|
+
|
|
|
+ Option *opt = add_option(name, fun, description, false);
|
|
|
+ if(opt->get_positional())
|
|
|
+ throw IncorrectConstruction::PositionalFlag(name);
|
|
|
+ opt->type_size(0);
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Add option for flag integer
|
|
|
+ template <typename T,
|
|
|
+ enable_if_t<std::is_integral<T>::value && !is_bool<T>::value, detail::enabler> = detail::dummy>
|
|
|
+ Option *add_flag(std::string name,
|
|
|
+ T &count, ///< A variable holding the count
|
|
|
+ std::string description = "") {
|
|
|
+
|
|
|
+ count = 0;
|
|
|
+ CLI::callback_t fun = [&count](CLI::results_t res) {
|
|
|
+ count = static_cast<T>(res.size());
|
|
|
+ return true;
|
|
|
+ };
|
|
|
+
|
|
|
+ Option *opt = add_option(name, fun, description, false);
|
|
|
+ if(opt->get_positional())
|
|
|
+ throw IncorrectConstruction::PositionalFlag(name);
|
|
|
+ opt->type_size(0);
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Bool version - defaults to allowing multiple passings, but can be forced to one if
|
|
|
+ /// `multi_option_policy(CLI::MultiOptionPolicy::Throw)` is used.
|
|
|
+ template <typename T, enable_if_t<is_bool<T>::value, detail::enabler> = detail::dummy>
|
|
|
+ Option *add_flag(std::string name,
|
|
|
+ T &count, ///< A variable holding true if passed
|
|
|
+ std::string description = "") {
|
|
|
+
|
|
|
+ count = false;
|
|
|
+ CLI::callback_t fun = [&count](CLI::results_t res) {
|
|
|
+ count = true;
|
|
|
+ return res.size() == 1;
|
|
|
+ };
|
|
|
+
|
|
|
+ Option *opt = add_option(name, fun, description, false);
|
|
|
+ if(opt->get_positional())
|
|
|
+ throw IncorrectConstruction::PositionalFlag(name);
|
|
|
+ opt->type_size(0);
|
|
|
+ opt->multi_option_policy(CLI::MultiOptionPolicy::TakeLast);
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Add option for callback
|
|
|
+ Option *add_flag_function(std::string name,
|
|
|
+ std::function<void(size_t)> function, ///< A function to call, void(size_t)
|
|
|
+ std::string description = "") {
|
|
|
+
|
|
|
+ CLI::callback_t fun = [function](CLI::results_t res) {
|
|
|
+ auto count = static_cast<size_t>(res.size());
|
|
|
+ function(count);
|
|
|
+ return true;
|
|
|
+ };
|
|
|
+
|
|
|
+ Option *opt = add_option(name, fun, description, false);
|
|
|
+ if(opt->get_positional())
|
|
|
+ throw IncorrectConstruction::PositionalFlag(name);
|
|
|
+ opt->type_size(0);
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+#ifdef CLI11_CPP14
|
|
|
+ /// Add option for callback (C++14 or better only)
|
|
|
+ Option *add_flag(std::string name,
|
|
|
+ std::function<void(size_t)> function, ///< A function to call, void(size_t)
|
|
|
+ std::string description = "") {
|
|
|
+ return add_flag_function(name, function, description);
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+ /// Add set of options (No default, temp refernce, such as an inline set)
|
|
|
+ template <typename T>
|
|
|
+ Option *add_set(std::string name,
|
|
|
+ T &member, ///< The selected member of the set
|
|
|
+ const std::set<T> &&options, ///< The set of possibilities
|
|
|
+ std::string description = "") {
|
|
|
+
|
|
|
+ std::string simple_name = CLI::detail::split(name, ',').at(0);
|
|
|
+ CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
|
|
|
+ bool retval = detail::lexical_cast(res[0], member);
|
|
|
+ if(!retval)
|
|
|
+ throw ConversionError(res[0], simple_name);
|
|
|
+ return std::find(std::begin(options), std::end(options), member) != std::end(options);
|
|
|
+ };
|
|
|
+
|
|
|
+ Option *opt = add_option(name, fun, description, false);
|
|
|
+ std::string typeval = detail::type_name<T>();
|
|
|
+ typeval += " in {" + detail::join(options) + "}";
|
|
|
+ opt->type_name(typeval);
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Add set of options (No default, non-temp refernce, such as an existing set)
|
|
|
+ template <typename T>
|
|
|
+ Option *add_set(std::string name,
|
|
|
+ T &member, ///< The selected member of the set
|
|
|
+ const std::set<T> &options, ///< The set of possibilities
|
|
|
+ std::string description = "") {
|
|
|
+
|
|
|
+ std::string simple_name = CLI::detail::split(name, ',').at(0);
|
|
|
+ CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
|
|
|
+ bool retval = detail::lexical_cast(res[0], member);
|
|
|
+ if(!retval)
|
|
|
+ throw ConversionError(res[0], simple_name);
|
|
|
+ return std::find(std::begin(options), std::end(options), member) != std::end(options);
|
|
|
+ };
|
|
|
+
|
|
|
+ Option *opt = add_option(name, fun, description, false);
|
|
|
+ opt->type_name_fn(
|
|
|
+ [&options]() { return std::string(detail::type_name<T>()) + " in {" + detail::join(options) + "}"; });
|
|
|
+
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Add set of options (with default, R value, such as an inline set)
|
|
|
+ template <typename T>
|
|
|
+ Option *add_set(std::string name,
|
|
|
+ T &member, ///< The selected member of the set
|
|
|
+ const std::set<T> &&options, ///< The set of posibilities
|
|
|
+ std::string description,
|
|
|
+ bool defaulted) {
|
|
|
+
|
|
|
+ std::string simple_name = CLI::detail::split(name, ',').at(0);
|
|
|
+ CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
|
|
|
+ bool retval = detail::lexical_cast(res[0], member);
|
|
|
+ if(!retval)
|
|
|
+ throw ConversionError(res[0], simple_name);
|
|
|
+ return std::find(std::begin(options), std::end(options), member) != std::end(options);
|
|
|
+ };
|
|
|
+
|
|
|
+ Option *opt = add_option(name, fun, description, defaulted);
|
|
|
+ std::string typeval = detail::type_name<T>();
|
|
|
+ typeval += " in {" + detail::join(options) + "}";
|
|
|
+ opt->type_name(typeval);
|
|
|
+ if(defaulted) {
|
|
|
+ std::stringstream out;
|
|
|
+ out << member;
|
|
|
+ opt->default_str(out.str());
|
|
|
+ }
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Add set of options (with default, L value refernce, such as an existing set)
|
|
|
+ template <typename T>
|
|
|
+ Option *add_set(std::string name,
|
|
|
+ T &member, ///< The selected member of the set
|
|
|
+ const std::set<T> &options, ///< The set of posibilities
|
|
|
+ std::string description,
|
|
|
+ bool defaulted) {
|
|
|
+
|
|
|
+ std::string simple_name = CLI::detail::split(name, ',').at(0);
|
|
|
+ CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
|
|
|
+ bool retval = detail::lexical_cast(res[0], member);
|
|
|
+ if(!retval)
|
|
|
+ throw ConversionError(res[0], simple_name);
|
|
|
+ return std::find(std::begin(options), std::end(options), member) != std::end(options);
|
|
|
+ };
|
|
|
+
|
|
|
+ Option *opt = add_option(name, fun, description, defaulted);
|
|
|
+ opt->type_name_fn(
|
|
|
+ [&options]() { return std::string(detail::type_name<T>()) + " in {" + detail::join(options) + "}"; });
|
|
|
+ if(defaulted) {
|
|
|
+ std::stringstream out;
|
|
|
+ out << member;
|
|
|
+ opt->default_str(out.str());
|
|
|
+ }
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Add set of options, string only, ignore case (no default, R value)
|
|
|
+ Option *add_set_ignore_case(std::string name,
|
|
|
+ std::string &member, ///< The selected member of the set
|
|
|
+ const std::set<std::string> &&options, ///< The set of possibilities
|
|
|
+ std::string description = "") {
|
|
|
+
|
|
|
+ std::string simple_name = CLI::detail::split(name, ',').at(0);
|
|
|
+ CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
|
|
|
+ member = detail::to_lower(res[0]);
|
|
|
+ auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
|
|
|
+ return detail::to_lower(val) == member;
|
|
|
+ });
|
|
|
+ if(iter == std::end(options))
|
|
|
+ throw ConversionError(member, simple_name);
|
|
|
+ else {
|
|
|
+ member = *iter;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ Option *opt = add_option(name, fun, description, false);
|
|
|
+ std::string typeval = detail::type_name<std::string>();
|
|
|
+ typeval += " in {" + detail::join(options) + "}";
|
|
|
+ opt->type_name(typeval);
|
|
|
+
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Add set of options, string only, ignore case (no default, L value)
|
|
|
+ Option *add_set_ignore_case(std::string name,
|
|
|
+ std::string &member, ///< The selected member of the set
|
|
|
+ const std::set<std::string> &options, ///< The set of possibilities
|
|
|
+ std::string description = "") {
|
|
|
+
|
|
|
+ std::string simple_name = CLI::detail::split(name, ',').at(0);
|
|
|
+ CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
|
|
|
+ member = detail::to_lower(res[0]);
|
|
|
+ auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
|
|
|
+ return detail::to_lower(val) == member;
|
|
|
+ });
|
|
|
+ if(iter == std::end(options))
|
|
|
+ throw ConversionError(member, simple_name);
|
|
|
+ else {
|
|
|
+ member = *iter;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ Option *opt = add_option(name, fun, description, false);
|
|
|
+ opt->type_name_fn([&options]() {
|
|
|
+ return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
|
|
|
+ });
|
|
|
+
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Add set of options, string only, ignore case (default, R value)
|
|
|
+ Option *add_set_ignore_case(std::string name,
|
|
|
+ std::string &member, ///< The selected member of the set
|
|
|
+ const std::set<std::string> &&options, ///< The set of posibilities
|
|
|
+ std::string description,
|
|
|
+ bool defaulted) {
|
|
|
+
|
|
|
+ std::string simple_name = CLI::detail::split(name, ',').at(0);
|
|
|
+ CLI::callback_t fun = [&member, options, simple_name](CLI::results_t res) {
|
|
|
+ member = detail::to_lower(res[0]);
|
|
|
+ auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
|
|
|
+ return detail::to_lower(val) == member;
|
|
|
+ });
|
|
|
+ if(iter == std::end(options))
|
|
|
+ throw ConversionError(member, simple_name);
|
|
|
+ else {
|
|
|
+ member = *iter;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ Option *opt = add_option(name, fun, description, defaulted);
|
|
|
+ std::string typeval = detail::type_name<std::string>();
|
|
|
+ typeval += " in {" + detail::join(options) + "}";
|
|
|
+ opt->type_name(typeval);
|
|
|
+ if(defaulted) {
|
|
|
+ opt->default_str(member);
|
|
|
+ }
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Add set of options, string only, ignore case (default, L value)
|
|
|
+ Option *add_set_ignore_case(std::string name,
|
|
|
+ std::string &member, ///< The selected member of the set
|
|
|
+ const std::set<std::string> &options, ///< The set of posibilities
|
|
|
+ std::string description,
|
|
|
+ bool defaulted) {
|
|
|
+
|
|
|
+ std::string simple_name = CLI::detail::split(name, ',').at(0);
|
|
|
+ CLI::callback_t fun = [&member, &options, simple_name](CLI::results_t res) {
|
|
|
+ member = detail::to_lower(res[0]);
|
|
|
+ auto iter = std::find_if(std::begin(options), std::end(options), [&member](std::string val) {
|
|
|
+ return detail::to_lower(val) == member;
|
|
|
+ });
|
|
|
+ if(iter == std::end(options))
|
|
|
+ throw ConversionError(member, simple_name);
|
|
|
+ else {
|
|
|
+ member = *iter;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ Option *opt = add_option(name, fun, description, defaulted);
|
|
|
+ opt->type_name_fn([&options]() {
|
|
|
+ return std::string(detail::type_name<std::string>()) + " in {" + detail::join(options) + "}";
|
|
|
+ });
|
|
|
+ if(defaulted) {
|
|
|
+ opt->default_str(member);
|
|
|
+ }
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Add a complex number
|
|
|
+ template <typename T>
|
|
|
+ Option *add_complex(std::string name,
|
|
|
+ T &variable,
|
|
|
+ std::string description = "",
|
|
|
+ bool defaulted = false,
|
|
|
+ std::string label = "COMPLEX") {
|
|
|
+
|
|
|
+ std::string simple_name = CLI::detail::split(name, ',').at(0);
|
|
|
+ CLI::callback_t fun = [&variable, simple_name, label](results_t res) {
|
|
|
+ if(res[1].back() == 'i')
|
|
|
+ res[1].pop_back();
|
|
|
+ double x, y;
|
|
|
+ bool worked = detail::lexical_cast(res[0], x) && detail::lexical_cast(res[1], y);
|
|
|
+ if(worked)
|
|
|
+ variable = T(x, y);
|
|
|
+ return worked;
|
|
|
+ };
|
|
|
+
|
|
|
+ CLI::Option *opt = add_option(name, fun, description, defaulted);
|
|
|
+ opt->type_name(label)->type_size(2);
|
|
|
+ if(defaulted) {
|
|
|
+ std::stringstream out;
|
|
|
+ out << variable;
|
|
|
+ opt->default_str(out.str());
|
|
|
+ }
|
|
|
+ return opt;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Set a configuration ini file option, or clear it if no name passed
|
|
|
+ Option *set_config(std::string name = "",
|
|
|
+ std::string default_filename = "",
|
|
|
+ std::string help = "Read an ini file",
|
|
|
+ bool required = false) {
|
|
|
+
|
|
|
+ // Remove existing config if present
|
|
|
+ if(config_ptr_ != nullptr)
|
|
|
+ remove_option(config_ptr_);
|
|
|
+
|
|
|
+ // Only add config if option passed
|
|
|
+ if(!name.empty()) {
|
|
|
+ config_name_ = default_filename;
|
|
|
+ config_required_ = required;
|
|
|
+ config_ptr_ = add_option(name, config_name_, help, !default_filename.empty());
|
|
|
+ config_ptr_->configurable(false);
|
|
|
+ }
|
|
|
+
|
|
|
+ return config_ptr_;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Removes an option from the App. Takes an option pointer. Returns true if found and removed.
|
|
|
+ bool remove_option(Option *opt) {
|
|
|
+ // Make sure no links exist
|
|
|
+ for(Option_p &op : options_) {
|
|
|
+ op->remove_needs(opt);
|
|
|
+ op->remove_excludes(opt);
|
|
|
+ }
|
|
|
+
|
|
|
+ auto iterator =
|
|
|
+ std::find_if(std::begin(options_), std::end(options_), [opt](const Option_p &v) { return v.get() == opt; });
|
|
|
+ if(iterator != std::end(options_)) {
|
|
|
+ options_.erase(iterator);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Subcommmands
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Add a subcommand. Inherits INHERITABLE and OptionDefaults, and help flag
|
|
|
+ App *add_subcommand(std::string name, std::string description = "") {
|
|
|
+ subcommands_.emplace_back(new App(description, name, this));
|
|
|
+ for(const auto &subc : subcommands_)
|
|
|
+ if(subc.get() != subcommands_.back().get())
|
|
|
+ if(subc->check_name(subcommands_.back()->name_) || subcommands_.back()->check_name(subc->name_))
|
|
|
+ throw OptionAlreadyAdded(subc->name_);
|
|
|
+ return subcommands_.back().get();
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Check to see if a subcommand is part of this command (doesn't have to be in command line)
|
|
|
+ App *get_subcommand(App *subcom) const {
|
|
|
+ for(const App_p &subcomptr : subcommands_)
|
|
|
+ if(subcomptr.get() == subcom)
|
|
|
+ return subcom;
|
|
|
+ throw OptionNotFound(subcom->get_name());
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Check to see if a subcommand is part of this command (text version)
|
|
|
+ App *get_subcommand(std::string subcom) const {
|
|
|
+ for(const App_p &subcomptr : subcommands_)
|
|
|
+ if(subcomptr->check_name(subcom))
|
|
|
+ return subcomptr.get();
|
|
|
+ throw OptionNotFound(subcom);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Changes the group membership
|
|
|
+ App *group(std::string name) {
|
|
|
+ group_ = name;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// The argumentless form of require subcommand requires 1 or more subcommands
|
|
|
+ App *require_subcommand() {
|
|
|
+ require_subcommand_min_ = 1;
|
|
|
+ require_subcommand_max_ = 0;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Require a subcommand to be given (does not affect help call)
|
|
|
+ /// The number required can be given. Negative values indicate maximum
|
|
|
+ /// number allowed (0 for any number). Max number inheritable.
|
|
|
+ App *require_subcommand(int value) {
|
|
|
+ if(value < 0) {
|
|
|
+ require_subcommand_min_ = 0;
|
|
|
+ require_subcommand_max_ = static_cast<size_t>(-value);
|
|
|
+ } else {
|
|
|
+ require_subcommand_min_ = static_cast<size_t>(value);
|
|
|
+ require_subcommand_max_ = static_cast<size_t>(value);
|
|
|
+ }
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Explicitly control the number of subcommands required. Setting 0
|
|
|
+ /// for the max means unlimited number allowed. Max number inheritable.
|
|
|
+ App *require_subcommand(size_t min, size_t max) {
|
|
|
+ require_subcommand_min_ = min;
|
|
|
+ require_subcommand_max_ = max;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Stop subcommand fallthrough, so that parent commands cannot collect commands after subcommand.
|
|
|
+ /// Default from parent, usually set on parent.
|
|
|
+ App *fallthrough(bool value = true) {
|
|
|
+ fallthrough_ = value;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Check to see if this subcommand was parsed, true only if received on command line.
|
|
|
+ /// This allows the subcommand to be directly checked.
|
|
|
+ operator bool() const { return parsed_; }
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Extras for subclassing
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// This allows subclasses to inject code before callbacks but after parse.
|
|
|
+ ///
|
|
|
+ /// This does not run if any errors or help is thrown.
|
|
|
+ virtual void pre_callback() {}
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Parsing
|
|
|
+ ///@{
|
|
|
+ //
|
|
|
+ /// Reset the parsed data
|
|
|
+ void clear() {
|
|
|
+
|
|
|
+ parsed_ = false;
|
|
|
+ missing_.clear();
|
|
|
+ parsed_subcommands_.clear();
|
|
|
+
|
|
|
+ for(const Option_p &opt : options_) {
|
|
|
+ opt->clear();
|
|
|
+ }
|
|
|
+ for(const App_p &app : subcommands_) {
|
|
|
+ app->clear();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Parses the command line - throws errors
|
|
|
+ /// This must be called after the options are in but before the rest of the program.
|
|
|
+ void parse(int argc, const char *const *argv) {
|
|
|
+ // If the name is not set, read from command line
|
|
|
+ if(name_.empty())
|
|
|
+ name_ = argv[0];
|
|
|
+
|
|
|
+ std::vector<std::string> args;
|
|
|
+ for(int i = argc - 1; i > 0; i--)
|
|
|
+ args.emplace_back(argv[i]);
|
|
|
+ parse(args);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// The real work is done here. Expects a reversed vector.
|
|
|
+ /// Changes the vector to the remaining options.
|
|
|
+ void parse(std::vector<std::string> &args) {
|
|
|
+ // Clear if parsed
|
|
|
+ if(parsed_)
|
|
|
+ clear();
|
|
|
+
|
|
|
+ // Redundant (set by _parse on commands/subcommands)
|
|
|
+ // but placed here to make sure this is cleared when
|
|
|
+ // running parse after an error is thrown, even by _validate.
|
|
|
+ parsed_ = true;
|
|
|
+
|
|
|
+ _validate();
|
|
|
+ _parse(args);
|
|
|
+ run_callback();
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Provide a function to print a help message. The function gets access to the App pointer and error.
|
|
|
+ void failure_message(std::function<std::string(const App *, const Error &e)> function) {
|
|
|
+ failure_message_ = function;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Print a nice error message and return the exit code
|
|
|
+ int exit(const Error &e, std::ostream &out = std::cout, std::ostream &err = std::cerr) const {
|
|
|
+
|
|
|
+ /// Avoid printing anything if this is a CLI::RuntimeError
|
|
|
+ if(dynamic_cast<const CLI::RuntimeError *>(&e) != nullptr)
|
|
|
+ return e.get_exit_code();
|
|
|
+
|
|
|
+ if(dynamic_cast<const CLI::CallForHelp *>(&e) != nullptr) {
|
|
|
+ out << help();
|
|
|
+ return e.get_exit_code();
|
|
|
+ }
|
|
|
+
|
|
|
+ if(dynamic_cast<const CLI::CallForAllHelp *>(&e) != nullptr) {
|
|
|
+ out << help("", AppFormatMode::All);
|
|
|
+ return e.get_exit_code();
|
|
|
+ }
|
|
|
+
|
|
|
+ if(e.get_exit_code() != static_cast<int>(ExitCodes::Success)) {
|
|
|
+ if(failure_message_)
|
|
|
+ err << failure_message_(this, e) << std::flush;
|
|
|
+ }
|
|
|
+
|
|
|
+ return e.get_exit_code();
|
|
|
+ }
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Post parsing
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Counts the number of times the given option was passed.
|
|
|
+ size_t count(std::string name) const {
|
|
|
+ for(const Option_p &opt : options_) {
|
|
|
+ if(opt->check_name(name)) {
|
|
|
+ return opt->count();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ throw OptionNotFound(name);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Get a subcommand pointer list to the currently selected subcommands (after parsing by by default, in command
|
|
|
+ /// line order; use parsed = false to get the original definition list.)
|
|
|
+ std::vector<App *> get_subcommands() const { return parsed_subcommands_; }
|
|
|
+
|
|
|
+ /// Get a filtered subcommand pointer list from the original definition list. An empty function will provide all
|
|
|
+ /// subcommands (const)
|
|
|
+ std::vector<const App *> get_subcommands(const std::function<bool(const App *)> &filter) const {
|
|
|
+ std::vector<const App *> subcomms(subcommands_.size());
|
|
|
+ std::transform(std::begin(subcommands_), std::end(subcommands_), std::begin(subcomms), [](const App_p &v) {
|
|
|
+ return v.get();
|
|
|
+ });
|
|
|
+
|
|
|
+ if(filter) {
|
|
|
+ subcomms.erase(std::remove_if(std::begin(subcomms),
|
|
|
+ std::end(subcomms),
|
|
|
+ [&filter](const App *app) { return !filter(app); }),
|
|
|
+ std::end(subcomms));
|
|
|
+ }
|
|
|
+
|
|
|
+ return subcomms;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Get a filtered subcommand pointer list from the original definition list. An empty function will provide all
|
|
|
+ /// subcommands
|
|
|
+ std::vector<App *> get_subcommands(const std::function<bool(App *)> &filter) {
|
|
|
+ std::vector<App *> subcomms(subcommands_.size());
|
|
|
+ std::transform(std::begin(subcommands_), std::end(subcommands_), std::begin(subcomms), [](const App_p &v) {
|
|
|
+ return v.get();
|
|
|
+ });
|
|
|
+
|
|
|
+ if(filter) {
|
|
|
+ subcomms.erase(
|
|
|
+ std::remove_if(std::begin(subcomms), std::end(subcomms), [&filter](App *app) { return !filter(app); }),
|
|
|
+ std::end(subcomms));
|
|
|
+ }
|
|
|
+
|
|
|
+ return subcomms;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Check to see if given subcommand was selected
|
|
|
+ bool got_subcommand(App *subcom) const {
|
|
|
+ // get subcom needed to verify that this was a real subcommand
|
|
|
+ return get_subcommand(subcom)->parsed_;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Check with name instead of pointer to see if subcommand was selected
|
|
|
+ bool got_subcommand(std::string name) const { return get_subcommand(name)->parsed_; }
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Help
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Set footer.
|
|
|
+ App *footer(std::string footer) {
|
|
|
+ footer_ = footer;
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Produce a string that could be read in as a config of the current values of the App. Set default_also to include
|
|
|
+ /// default arguments. Prefix will add a string to the beginning of each option.
|
|
|
+ std::string config_to_str(bool default_also = false, bool write_description = false) const {
|
|
|
+ return config_formatter_->to_config(this, default_also, write_description, "");
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Makes a help message, using the currently configured formatter
|
|
|
+ /// Will only do one subcommand at a time
|
|
|
+ std::string help(std::string prev = "", AppFormatMode mode = AppFormatMode::Normal) const {
|
|
|
+ if(prev.empty())
|
|
|
+ prev = get_name();
|
|
|
+ else
|
|
|
+ prev += " " + get_name();
|
|
|
+
|
|
|
+ // Delegate to subcommand if needed
|
|
|
+ auto selected_subcommands = get_subcommands();
|
|
|
+ if(!selected_subcommands.empty())
|
|
|
+ return selected_subcommands.at(0)->help(prev, mode);
|
|
|
+ else
|
|
|
+ return formatter_->make_help(this, prev, mode);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Provided for backwards compatibility \deprecated
|
|
|
+ CLI11_DEPRECATED("Please use footer instead")
|
|
|
+ App *set_footer(std::string msg) { return footer(msg); }
|
|
|
+
|
|
|
+ /// Provided for backwards compatibility \deprecated
|
|
|
+ CLI11_DEPRECATED("Please use name instead")
|
|
|
+ App *set_name(std::string msg) { return name(msg); }
|
|
|
+
|
|
|
+ /// Provided for backwards compatibility \deprecated
|
|
|
+ CLI11_DEPRECATED("Please use callback instead")
|
|
|
+ App *set_callback(std::function<void()> fn) { return callback(fn); }
|
|
|
+
|
|
|
+ ///@}
|
|
|
+ /// @name Getters
|
|
|
+ ///@{
|
|
|
+
|
|
|
+ /// Access the formatter
|
|
|
+ std::shared_ptr<FormatterBase> get_formatter() const { return formatter_; }
|
|
|
+
|
|
|
+ /// Access the config formatter
|
|
|
+ std::shared_ptr<Config> get_config_formatter() const { return config_formatter_; }
|
|
|
+
|
|
|
+ /// Get the app or subcommand description
|
|
|
+ std::string get_description() const { return description_; }
|
|
|
+
|
|
|
+ /// Get the list of options (user facing function, so returns raw pointers), has optional filter function
|
|
|
+ std::vector<const Option *> get_options(const std::function<bool(const Option *)> filter = {}) const {
|
|
|
+ std::vector<const Option *> options(options_.size());
|
|
|
+ std::transform(std::begin(options_), std::end(options_), std::begin(options), [](const Option_p &val) {
|
|
|
+ return val.get();
|
|
|
+ });
|
|
|
+
|
|
|
+ if(filter) {
|
|
|
+ options.erase(std::remove_if(std::begin(options),
|
|
|
+ std::end(options),
|
|
|
+ [&filter](const Option *opt) { return !filter(opt); }),
|
|
|
+ std::end(options));
|
|
|
+ }
|
|
|
+
|
|
|
+ return options;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Get an option by name
|
|
|
+ const Option *get_option(std::string name) const {
|
|
|
+ for(const Option_p &opt : options_) {
|
|
|
+ if(opt->check_name(name)) {
|
|
|
+ return opt.get();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ throw OptionNotFound(name);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Get an option by name (non-const version)
|
|
|
+ Option *get_option(std::string name) {
|
|
|
+ for(Option_p &opt : options_) {
|
|
|
+ if(opt->check_name(name)) {
|
|
|
+ return opt.get();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ throw OptionNotFound(name);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Check the status of ignore_case
|
|
|
+ bool get_ignore_case() const { return ignore_case_; }
|
|
|
+
|
|
|
+ /// Check the status of fallthrough
|
|
|
+ bool get_fallthrough() const { return fallthrough_; }
|
|
|
+
|
|
|
+ /// Get the group of this subcommand
|
|
|
+ const std::string &get_group() const { return group_; }
|
|
|
+
|
|
|
+ /// Get footer.
|
|
|
+ std::string get_footer() const { return footer_; }
|
|
|
+
|
|
|
+ /// Get the required min subcommand value
|
|
|
+ size_t get_require_subcommand_min() const { return require_subcommand_min_; }
|
|
|
+
|
|
|
+ /// Get the required max subcommand value
|
|
|
+ size_t get_require_subcommand_max() const { return require_subcommand_max_; }
|
|
|
+
|
|
|
+ /// Get the prefix command status
|
|
|
+ bool get_prefix_command() const { return prefix_command_; }
|
|
|
+
|
|
|
+ /// Get the status of allow extras
|
|
|
+ bool get_allow_extras() const { return allow_extras_; }
|
|
|
+
|
|
|
+ /// Get the status of allow extras
|
|
|
+ bool get_allow_config_extras() const { return allow_config_extras_; }
|
|
|
+
|
|
|
+ /// Get a pointer to the help flag.
|
|
|
+ Option *get_help_ptr() { return help_ptr_; }
|
|
|
+
|
|
|
+ /// Get a pointer to the help flag. (const)
|
|
|
+ const Option *get_help_ptr() const { return help_ptr_; }
|
|
|
+
|
|
|
+ /// Get a pointer to the help all flag. (const)
|
|
|
+ const Option *get_help_all_ptr() const { return help_all_ptr_; }
|
|
|
+
|
|
|
+ /// Get a pointer to the config option.
|
|
|
+ Option *get_config_ptr() { return config_ptr_; }
|
|
|
+
|
|
|
+ /// Get a pointer to the config option. (const)
|
|
|
+ const Option *get_config_ptr() const { return config_ptr_; }
|
|
|
+
|
|
|
+ /// Get the parent of this subcommand (or nullptr if master app)
|
|
|
+ App *get_parent() { return parent_; }
|
|
|
+
|
|
|
+ /// Get the parent of this subcommand (or nullptr if master app) (const version)
|
|
|
+ const App *get_parent() const { return parent_; }
|
|
|
+
|
|
|
+ /// Get the name of the current app
|
|
|
+ std::string get_name() const { return name_; }
|
|
|
+
|
|
|
+ /// Check the name, case insensitive if set
|
|
|
+ bool check_name(std::string name_to_check) const {
|
|
|
+ std::string local_name = name_;
|
|
|
+ if(ignore_case_) {
|
|
|
+ local_name = detail::to_lower(name_);
|
|
|
+ name_to_check = detail::to_lower(name_to_check);
|
|
|
+ }
|
|
|
+
|
|
|
+ return local_name == name_to_check;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Get the groups available directly from this option (in order)
|
|
|
+ std::vector<std::string> get_groups() const {
|
|
|
+ std::vector<std::string> groups;
|
|
|
+
|
|
|
+ for(const Option_p &opt : options_) {
|
|
|
+ // Add group if it is not already in there
|
|
|
+ if(std::find(groups.begin(), groups.end(), opt->get_group()) == groups.end()) {
|
|
|
+ groups.push_back(opt->get_group());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return groups;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// This gets a vector of pointers with the original parse order
|
|
|
+ const std::vector<Option *> &parse_order() const { return parse_order_; }
|
|
|
+
|
|
|
+ /// This returns the missing options from the current subcommand
|
|
|
+ std::vector<std::string> remaining(bool recurse = false) const {
|
|
|
+ std::vector<std::string> miss_list;
|
|
|
+ for(const std::pair<detail::Classifer, std::string> &miss : missing_) {
|
|
|
+ miss_list.push_back(std::get<1>(miss));
|
|
|
+ }
|
|
|
+
|
|
|
+ // Recurse into subcommands
|
|
|
+ if(recurse) {
|
|
|
+ for(const App *sub : parsed_subcommands_) {
|
|
|
+ std::vector<std::string> output = sub->remaining(recurse);
|
|
|
+ std::copy(std::begin(output), std::end(output), std::back_inserter(miss_list));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return miss_list;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// This returns the number of remaining options, minus the -- seperator
|
|
|
+ size_t remaining_size(bool recurse = false) const {
|
|
|
+ auto count = static_cast<size_t>(std::count_if(
|
|
|
+ std::begin(missing_), std::end(missing_), [](const std::pair<detail::Classifer, std::string> &val) {
|
|
|
+ return val.first != detail::Classifer::POSITIONAL_MARK;
|
|
|
+ }));
|
|
|
+ if(recurse) {
|
|
|
+ for(const App_p &sub : subcommands_) {
|
|
|
+ count += sub->remaining_size(recurse);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return count;
|
|
|
+ }
|
|
|
+
|
|
|
+ ///@}
|
|
|
+
|
|
|
+ protected:
|
|
|
+ /// Check the options to make sure there are no conflicts.
|
|
|
+ ///
|
|
|
+ /// Currently checks to see if multiple positionals exist with -1 args
|
|
|
+ void _validate() const {
|
|
|
+ auto count = std::count_if(std::begin(options_), std::end(options_), [](const Option_p &opt) {
|
|
|
+ return opt->get_items_expected() < 0 && opt->get_positional();
|
|
|
+ });
|
|
|
+ if(count > 1)
|
|
|
+ throw InvalidError(name_);
|
|
|
+ for(const App_p &app : subcommands_)
|
|
|
+ app->_validate();
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Internal function to run (App) callback, top down
|
|
|
+ void run_callback() {
|
|
|
+ pre_callback();
|
|
|
+ if(callback_)
|
|
|
+ callback_();
|
|
|
+ for(App *subc : get_subcommands()) {
|
|
|
+ subc->run_callback();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Check to see if a subcommand is valid. Give up immediately if subcommand max has been reached.
|
|
|
+ bool _valid_subcommand(const std::string ¤t) const {
|
|
|
+ // Don't match if max has been reached - but still check parents
|
|
|
+ if(require_subcommand_max_ != 0 && parsed_subcommands_.size() >= require_subcommand_max_) {
|
|
|
+ return parent_ != nullptr && parent_->_valid_subcommand(current);
|
|
|
+ }
|
|
|
+
|
|
|
+ for(const App_p &com : subcommands_)
|
|
|
+ if(com->check_name(current) && !*com)
|
|
|
+ return true;
|
|
|
+
|
|
|
+ // Check parent if exists, else return false
|
|
|
+ return parent_ != nullptr && parent_->_valid_subcommand(current);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Selects a Classifier enum based on the type of the current argument
|
|
|
+ detail::Classifer _recognize(const std::string ¤t) const {
|
|
|
+ std::string dummy1, dummy2;
|
|
|
+
|
|
|
+ if(current == "--")
|
|
|
+ return detail::Classifer::POSITIONAL_MARK;
|
|
|
+ if(_valid_subcommand(current))
|
|
|
+ return detail::Classifer::SUBCOMMAND;
|
|
|
+ if(detail::split_long(current, dummy1, dummy2))
|
|
|
+ return detail::Classifer::LONG;
|
|
|
+ if(detail::split_short(current, dummy1, dummy2))
|
|
|
+ return detail::Classifer::SHORT;
|
|
|
+ return detail::Classifer::NONE;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Internal parse function
|
|
|
+ void _parse(std::vector<std::string> &args) {
|
|
|
+ parsed_ = true;
|
|
|
+ bool positional_only = false;
|
|
|
+
|
|
|
+ while(!args.empty()) {
|
|
|
+ _parse_single(args, positional_only);
|
|
|
+ }
|
|
|
+
|
|
|
+ for(const Option_p &opt : options_)
|
|
|
+ if(opt->get_short_circuit() && opt->count() > 0)
|
|
|
+ opt->run_callback();
|
|
|
+
|
|
|
+ // Process an INI file
|
|
|
+ if(config_ptr_ != nullptr) {
|
|
|
+ if(*config_ptr_) {
|
|
|
+ config_ptr_->run_callback();
|
|
|
+ config_required_ = true;
|
|
|
+ }
|
|
|
+ if(!config_name_.empty()) {
|
|
|
+ try {
|
|
|
+ std::vector<ConfigItem> values = config_formatter_->from_file(config_name_);
|
|
|
+ _parse_config(values);
|
|
|
+ } catch(const FileError &) {
|
|
|
+ if(config_required_)
|
|
|
+ throw;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Get envname options if not yet passed
|
|
|
+ for(const Option_p &opt : options_) {
|
|
|
+ if(opt->count() == 0 && !opt->envname_.empty()) {
|
|
|
+ char *buffer = nullptr;
|
|
|
+ std::string ename_string;
|
|
|
+
|
|
|
+#ifdef _MSC_VER
|
|
|
+ // Windows version
|
|
|
+ size_t sz = 0;
|
|
|
+ if(_dupenv_s(&buffer, &sz, opt->envname_.c_str()) == 0 && buffer != nullptr) {
|
|
|
+ ename_string = std::string(buffer);
|
|
|
+ free(buffer);
|
|
|
+ }
|
|
|
+#else
|
|
|
+ // This also works on Windows, but gives a warning
|
|
|
+ buffer = std::getenv(opt->envname_.c_str());
|
|
|
+ if(buffer != nullptr)
|
|
|
+ ename_string = std::string(buffer);
|
|
|
+#endif
|
|
|
+
|
|
|
+ if(!ename_string.empty()) {
|
|
|
+ opt->add_result(ename_string);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Process callbacks
|
|
|
+ for(const Option_p &opt : options_) {
|
|
|
+ if(opt->count() > 0 && !opt->get_callback_run()) {
|
|
|
+ opt->run_callback();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Verify required options
|
|
|
+ for(const Option_p &opt : options_) {
|
|
|
+ // Exit if a help flag was passed (requirements not required in that case)
|
|
|
+ if(_any_help_flag())
|
|
|
+ break;
|
|
|
+
|
|
|
+ // Required or partially filled
|
|
|
+ if(opt->get_required() || opt->count() != 0) {
|
|
|
+ // Make sure enough -N arguments parsed (+N is already handled in parsing function)
|
|
|
+ if(opt->get_items_expected() < 0 && opt->count() < static_cast<size_t>(-opt->get_items_expected()))
|
|
|
+ throw ArgumentMismatch::AtLeast(opt->get_name(), -opt->get_items_expected());
|
|
|
+
|
|
|
+ // Required but empty
|
|
|
+ if(opt->get_required() && opt->count() == 0)
|
|
|
+ throw RequiredError(opt->get_name());
|
|
|
+ }
|
|
|
+ // Requires
|
|
|
+ for(const Option *opt_req : opt->needs_)
|
|
|
+ if(opt->count() > 0 && opt_req->count() == 0)
|
|
|
+ throw RequiresError(opt->get_name(), opt_req->get_name());
|
|
|
+ // Excludes
|
|
|
+ for(const Option *opt_ex : opt->excludes_)
|
|
|
+ if(opt->count() > 0 && opt_ex->count() != 0)
|
|
|
+ throw ExcludesError(opt->get_name(), opt_ex->get_name());
|
|
|
+ }
|
|
|
+
|
|
|
+ auto selected_subcommands = get_subcommands();
|
|
|
+ if(require_subcommand_min_ > selected_subcommands.size())
|
|
|
+ throw RequiredError::Subcommand(require_subcommand_min_);
|
|
|
+
|
|
|
+ // Convert missing (pairs) to extras (string only)
|
|
|
+ if(!(allow_extras_ || prefix_command_)) {
|
|
|
+ size_t num_left_over = remaining_size();
|
|
|
+ if(num_left_over > 0) {
|
|
|
+ args = remaining(false);
|
|
|
+ throw ExtrasError(args);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if(parent_ == nullptr) {
|
|
|
+ args = remaining(false);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Return True if a help flag detected (checks all parents) (only run if help called before subcommand)
|
|
|
+ bool _any_help_flag() const {
|
|
|
+ bool result = false;
|
|
|
+ const Option *help_ptr = get_help_ptr();
|
|
|
+ const Option *help_all_ptr = get_help_all_ptr();
|
|
|
+ if(help_ptr != nullptr && help_ptr->count() > 0)
|
|
|
+ result = true;
|
|
|
+ if(help_all_ptr != nullptr && help_all_ptr->count() > 0)
|
|
|
+ result = true;
|
|
|
+ if(parent_ != nullptr)
|
|
|
+ return result || parent_->_any_help_flag();
|
|
|
+ else
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Parse one config param, return false if not found in any subcommand, remove if it is
|
|
|
+ ///
|
|
|
+ /// If this has more than one dot.separated.name, go into the subcommand matching it
|
|
|
+ /// Returns true if it managed to find the option, if false you'll need to remove the arg manually.
|
|
|
+ void _parse_config(std::vector<ConfigItem> &args) {
|
|
|
+ for(ConfigItem item : args) {
|
|
|
+ if(!_parse_single_config(item) && !allow_config_extras_)
|
|
|
+ throw ConfigError::Extras(item.fullname());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Fill in a single config option
|
|
|
+ bool _parse_single_config(const ConfigItem &item, size_t level = 0) {
|
|
|
+ if(level < item.parents.size()) {
|
|
|
+ App *subcom;
|
|
|
+ try {
|
|
|
+ subcom = get_subcommand(item.parents.at(level));
|
|
|
+ } catch(const OptionNotFound &) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ return subcom->_parse_single_config(item, level + 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ Option *op;
|
|
|
+ try {
|
|
|
+ op = get_option("--" + item.name);
|
|
|
+ } catch(const OptionNotFound &) {
|
|
|
+ // If the option was not present
|
|
|
+ if(get_allow_config_extras())
|
|
|
+ // Should we worry about classifying the extras properly?
|
|
|
+ missing_.emplace_back(detail::Classifer::NONE, item.fullname());
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(!op->get_configurable())
|
|
|
+ throw ConfigError::NotConfigurable(item.fullname());
|
|
|
+
|
|
|
+ if(op->empty()) {
|
|
|
+ // Flag parsing
|
|
|
+ if(op->get_type_size() == 0) {
|
|
|
+ op->set_results(config_formatter_->to_flag(item));
|
|
|
+ } else {
|
|
|
+ op->set_results(item.inputs);
|
|
|
+ op->run_callback();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Parse "one" argument (some may eat more than one), delegate to parent if fails, add to missing if missing from
|
|
|
+ /// master
|
|
|
+ void _parse_single(std::vector<std::string> &args, bool &positional_only) {
|
|
|
+
|
|
|
+ detail::Classifer classifer = positional_only ? detail::Classifer::NONE : _recognize(args.back());
|
|
|
+ switch(classifer) {
|
|
|
+ case detail::Classifer::POSITIONAL_MARK:
|
|
|
+ missing_.emplace_back(classifer, args.back());
|
|
|
+ args.pop_back();
|
|
|
+ positional_only = true;
|
|
|
+ break;
|
|
|
+ case detail::Classifer::SUBCOMMAND:
|
|
|
+ _parse_subcommand(args);
|
|
|
+ break;
|
|
|
+ case detail::Classifer::LONG:
|
|
|
+ // If already parsed a subcommand, don't accept options_
|
|
|
+ _parse_arg(args, true);
|
|
|
+ break;
|
|
|
+ case detail::Classifer::SHORT:
|
|
|
+ // If already parsed a subcommand, don't accept options_
|
|
|
+ _parse_arg(args, false);
|
|
|
+ break;
|
|
|
+ case detail::Classifer::NONE:
|
|
|
+ // Probably a positional or something for a parent (sub)command
|
|
|
+ _parse_positional(args);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Count the required remaining positional arguments
|
|
|
+ size_t _count_remaining_positionals(bool required = false) const {
|
|
|
+ size_t retval = 0;
|
|
|
+ for(const Option_p &opt : options_)
|
|
|
+ if(opt->get_positional() && (!required || opt->get_required()) && opt->get_items_expected() > 0 &&
|
|
|
+ static_cast<int>(opt->count()) < opt->get_items_expected())
|
|
|
+ retval = static_cast<size_t>(opt->get_items_expected()) - opt->count();
|
|
|
+
|
|
|
+ return retval;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Parse a positional, go up the tree to check
|
|
|
+ void _parse_positional(std::vector<std::string> &args) {
|
|
|
+
|
|
|
+ std::string positional = args.back();
|
|
|
+ for(const Option_p &opt : options_) {
|
|
|
+ // Eat options, one by one, until done
|
|
|
+ if(opt->get_positional() &&
|
|
|
+ (static_cast<int>(opt->count()) < opt->get_items_expected() || opt->get_items_expected() < 0)) {
|
|
|
+
|
|
|
+ opt->add_result(positional);
|
|
|
+ parse_order_.push_back(opt.get());
|
|
|
+ args.pop_back();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if(parent_ != nullptr && fallthrough_)
|
|
|
+ return parent_->_parse_positional(args);
|
|
|
+ else {
|
|
|
+ args.pop_back();
|
|
|
+ missing_.emplace_back(detail::Classifer::NONE, positional);
|
|
|
+
|
|
|
+ if(prefix_command_) {
|
|
|
+ while(!args.empty()) {
|
|
|
+ missing_.emplace_back(detail::Classifer::NONE, args.back());
|
|
|
+ args.pop_back();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Parse a subcommand, modify args and continue
|
|
|
+ ///
|
|
|
+ /// Unlike the others, this one will always allow fallthrough
|
|
|
+ void _parse_subcommand(std::vector<std::string> &args) {
|
|
|
+ if(_count_remaining_positionals(/* required */ true) > 0)
|
|
|
+ return _parse_positional(args);
|
|
|
+ for(const App_p &com : subcommands_) {
|
|
|
+ if(com->check_name(args.back())) {
|
|
|
+ args.pop_back();
|
|
|
+ if(std::find(std::begin(parsed_subcommands_), std::end(parsed_subcommands_), com.get()) ==
|
|
|
+ std::end(parsed_subcommands_))
|
|
|
+ parsed_subcommands_.push_back(com.get());
|
|
|
+ com->_parse(args);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if(parent_ != nullptr)
|
|
|
+ return parent_->_parse_subcommand(args);
|
|
|
+ else
|
|
|
+ throw HorribleError("Subcommand " + args.back() + " missing");
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Parse a short (false) or long (true) argument, must be at the top of the list
|
|
|
+ void _parse_arg(std::vector<std::string> &args, bool second_dash) {
|
|
|
+
|
|
|
+ detail::Classifer current_type = second_dash ? detail::Classifer::LONG : detail::Classifer::SHORT;
|
|
|
+
|
|
|
+ std::string current = args.back();
|
|
|
+
|
|
|
+ std::string name;
|
|
|
+ std::string value;
|
|
|
+ std::string rest;
|
|
|
+
|
|
|
+ if(second_dash) {
|
|
|
+ if(!detail::split_long(current, name, value))
|
|
|
+ throw HorribleError("Long parsed but missing (you should not see this):" + args.back());
|
|
|
+ } else {
|
|
|
+ if(!detail::split_short(current, name, rest))
|
|
|
+ throw HorribleError("Short parsed but missing! You should not see this");
|
|
|
+ }
|
|
|
+
|
|
|
+ auto op_ptr = std::find_if(std::begin(options_), std::end(options_), [name, second_dash](const Option_p &opt) {
|
|
|
+ return second_dash ? opt->check_lname(name) : opt->check_sname(name);
|
|
|
+ });
|
|
|
+
|
|
|
+ // Option not found
|
|
|
+ if(op_ptr == std::end(options_)) {
|
|
|
+ // If a subcommand, try the master command
|
|
|
+ if(parent_ != nullptr && fallthrough_)
|
|
|
+ return parent_->_parse_arg(args, second_dash);
|
|
|
+ // Otherwise, add to missing
|
|
|
+ else {
|
|
|
+ args.pop_back();
|
|
|
+ missing_.emplace_back(current_type, current);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ args.pop_back();
|
|
|
+
|
|
|
+ // Get a reference to the pointer to make syntax bearable
|
|
|
+ Option_p &op = *op_ptr;
|
|
|
+
|
|
|
+ int num = op->get_items_expected();
|
|
|
+
|
|
|
+ // Make sure we always eat the minimum for unlimited vectors
|
|
|
+ int collected = 0;
|
|
|
+
|
|
|
+ // --this=value
|
|
|
+ if(!value.empty()) {
|
|
|
+ // If exact number expected
|
|
|
+ if(num > 0)
|
|
|
+ num--;
|
|
|
+ op->add_result(value);
|
|
|
+ parse_order_.push_back(op.get());
|
|
|
+ collected += 1;
|
|
|
+ } else if(num == 0) {
|
|
|
+ op->add_result("");
|
|
|
+ parse_order_.push_back(op.get());
|
|
|
+ // -Trest
|
|
|
+ } else if(!rest.empty()) {
|
|
|
+ if(num > 0)
|
|
|
+ num--;
|
|
|
+ op->add_result(rest);
|
|
|
+ parse_order_.push_back(op.get());
|
|
|
+ rest = "";
|
|
|
+ collected += 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Unlimited vector parser
|
|
|
+ if(num < 0) {
|
|
|
+ while(!args.empty() && _recognize(args.back()) == detail::Classifer::NONE) {
|
|
|
+ if(collected >= -num) {
|
|
|
+ // We could break here for allow extras, but we don't
|
|
|
+
|
|
|
+ // If any positionals remain, don't keep eating
|
|
|
+ if(_count_remaining_positionals() > 0)
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ op->add_result(args.back());
|
|
|
+ parse_order_.push_back(op.get());
|
|
|
+ args.pop_back();
|
|
|
+ collected++;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Allow -- to end an unlimited list and "eat" it
|
|
|
+ if(!args.empty() && _recognize(args.back()) == detail::Classifer::POSITIONAL_MARK)
|
|
|
+ args.pop_back();
|
|
|
+
|
|
|
+ } else {
|
|
|
+ while(num > 0 && !args.empty()) {
|
|
|
+ num--;
|
|
|
+ std::string current_ = args.back();
|
|
|
+ args.pop_back();
|
|
|
+ op->add_result(current_);
|
|
|
+ parse_order_.push_back(op.get());
|
|
|
+ }
|
|
|
+
|
|
|
+ if(num > 0) {
|
|
|
+ throw ArgumentMismatch::TypedAtLeast(op->get_name(), num, op->get_type_name());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if(!rest.empty()) {
|
|
|
+ rest = "-" + rest;
|
|
|
+ args.push_back(rest);
|
|
|
+ }
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+namespace FailureMessage {
|
|
|
+
|
|
|
+/// Printout a clean, simple message on error (the default in CLI11 1.5+)
|
|
|
+inline std::string simple(const App *app, const Error &e) {
|
|
|
+ std::string header = std::string(e.what()) + "\n";
|
|
|
+ if(app->get_help_ptr() != nullptr)
|
|
|
+ header += "Run with " + app->get_help_ptr()->get_name() + " for more information.\n";
|
|
|
+ return header;
|
|
|
+}
|
|
|
+
|
|
|
+/// Printout the full help string on error (if this fn is set, the old default for CLI11)
|
|
|
+inline std::string help(const App *app, const Error &e) {
|
|
|
+ std::string header = std::string("ERROR: ") + e.get_name() + ": " + e.what() + "\n";
|
|
|
+ header += app->help();
|
|
|
+ return header;
|
|
|
+}
|
|
|
+
|
|
|
+} // namespace FailureMessage
|
|
|
+
|
|
|
+namespace detail {
|
|
|
+/// This class is simply to allow tests access to App's protected functions
|
|
|
+struct AppFriend {
|
|
|
+
|
|
|
+ /// Wrap _parse_short, perfectly forward arguments and return
|
|
|
+ template <typename... Args>
|
|
|
+ static auto parse_arg(App *app, Args &&... args) ->
|
|
|
+ typename std::result_of<decltype (&App::_parse_arg)(App, Args...)>::type {
|
|
|
+ return app->_parse_arg(std::forward<Args>(args)...);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// Wrap _parse_subcommand, perfectly forward arguments and return
|
|
|
+ template <typename... Args>
|
|
|
+ static auto parse_subcommand(App *app, Args &&... args) ->
|
|
|
+ typename std::result_of<decltype (&App::_parse_subcommand)(App, Args...)>::type {
|
|
|
+ return app->_parse_subcommand(std::forward<Args>(args)...);
|
|
|
+ }
|
|
|
+};
|
|
|
+} // namespace detail
|
|
|
+
|
|
|
+} // namespace CLI
|
|
|
+
|
|
|
+// From CLI/Config.hpp:
|
|
|
+
|
|
|
+namespace CLI {
|
|
|
+
|
|
|
+inline std::string
|
|
|
+ConfigINI::to_config(const App *app, bool default_also, bool write_description, std::string prefix) const {
|
|
|
+ std::stringstream out;
|
|
|
+ for(const Option *opt : app->get_options({})) {
|
|
|
+
|
|
|
+ // Only process option with a long-name and configurable
|
|
|
+ if(!opt->get_lnames().empty() && opt->get_configurable()) {
|
|
|
+ std::string name = prefix + opt->get_lnames()[0];
|
|
|
+ std::string value;
|
|
|
+
|
|
|
+ // Non-flags
|
|
|
+ if(opt->get_type_size() != 0) {
|
|
|
+
|
|
|
+ // If the option was found on command line
|
|
|
+ if(opt->count() > 0)
|
|
|
+ value = detail::ini_join(opt->results());
|
|
|
+
|
|
|
+ // If the option has a default and is requested by optional argument
|
|
|
+ else if(default_also && !opt->get_defaultval().empty())
|
|
|
+ value = opt->get_defaultval();
|
|
|
+ // Flag, one passed
|
|
|
+ } else if(opt->count() == 1) {
|
|
|
+ value = "true";
|
|
|
+
|
|
|
+ // Flag, multiple passed
|
|
|
+ } else if(opt->count() > 1) {
|
|
|
+ value = std::to_string(opt->count());
|
|
|
+
|
|
|
+ // Flag, not present
|
|
|
+ } else if(opt->count() == 0 && default_also) {
|
|
|
+ value = "false";
|
|
|
+ }
|
|
|
+
|
|
|
+ if(!value.empty()) {
|
|
|
+ if(write_description && opt->has_description()) {
|
|
|
+ if(static_cast<int>(out.tellp()) != 0) {
|
|
|
+ out << std::endl;
|
|
|
+ }
|
|
|
+ out << "; " << detail::fix_newlines("; ", opt->get_description()) << std::endl;
|
|
|
+ }
|
|
|
+ out << name << "=" << value << std::endl;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ for(const App *subcom : app->get_subcommands({}))
|
|
|
+ out << to_config(subcom, default_also, write_description, prefix + subcom->get_name() + ".");
|
|
|
+
|
|
|
+ return out.str();
|
|
|
+}
|
|
|
+
|
|
|
+} // namespace CLI
|
|
|
+
|
|
|
+// From CLI/Formatter.hpp:
|
|
|
+
|
|
|
+namespace CLI {
|
|
|
+
|
|
|
+inline std::string
|
|
|
+Formatter::make_group(std::string group, bool is_positional, std::vector<const Option *> opts) const {
|
|
|
+ std::stringstream out;
|
|
|
+
|
|
|
+ out << "\n" << group << ":\n";
|
|
|
+ for(const Option *opt : opts) {
|
|
|
+ out << make_option(opt, is_positional);
|
|
|
+ }
|
|
|
+
|
|
|
+ return out.str();
|
|
|
+}
|
|
|
+
|
|
|
+inline std::string Formatter::make_positionals(const App *app) const {
|
|
|
+ std::vector<const Option *> opts =
|
|
|
+ app->get_options([](const Option *opt) { return !opt->get_group().empty() && opt->get_positional(); });
|
|
|
+
|
|
|
+ if(opts.empty())
|
|
|
+ return std::string();
|
|
|
+ else
|
|
|
+ return make_group(get_label("Positionals"), true, opts);
|
|
|
+}
|
|
|
+
|
|
|
+inline std::string Formatter::make_groups(const App *app, AppFormatMode mode) const {
|
|
|
+ std::stringstream out;
|
|
|
+ std::vector<std::string> groups = app->get_groups();
|
|
|
+
|
|
|
+ // Options
|
|
|
+ for(const std::string &group : groups) {
|
|
|
+ std::vector<const Option *> opts = app->get_options([app, mode, &group](const Option *opt) {
|
|
|
+ return opt->get_group() == group // Must be in the right group
|
|
|
+ && opt->nonpositional() // Must not be a positional
|
|
|
+ && (mode != AppFormatMode::Sub // If mode is Sub, then
|
|
|
+ || (app->get_help_ptr() != opt // Ignore help pointer
|
|
|
+ && app->get_help_all_ptr() != opt)); // Ignore help all pointer
|
|
|
+ });
|
|
|
+ if(!group.empty() && !opts.empty()) {
|
|
|
+ out << make_group(group, false, opts);
|
|
|
+
|
|
|
+ if(group != groups.back())
|
|
|
+ out << "\n";
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return out.str();
|
|
|
+}
|
|
|
+
|
|
|
+inline std::string Formatter::make_description(const App *app) const {
|
|
|
+ std::string desc = app->get_description();
|
|
|
+
|
|
|
+ if(!desc.empty())
|
|
|
+ return desc + "\n";
|
|
|
+ else
|
|
|
+ return "";
|
|
|
+}
|
|
|
+
|
|
|
+inline std::string Formatter::make_usage(const App *app, std::string name) const {
|
|
|
+ std::stringstream out;
|
|
|
+
|
|
|
+ out << get_label("Usage") << ":" << (name.empty() ? "" : " ") << name;
|
|
|
+
|
|
|
+ std::vector<std::string> groups = app->get_groups();
|
|
|
+
|
|
|
+ // Print an Options badge if any options exist
|
|
|
+ std::vector<const Option *> non_pos_options =
|
|
|
+ app->get_options([](const Option *opt) { return opt->nonpositional(); });
|
|
|
+ if(!non_pos_options.empty())
|
|
|
+ out << " [" << get_label("OPTIONS") << "]";
|
|
|
+
|
|
|
+ // Positionals need to be listed here
|
|
|
+ std::vector<const Option *> positionals = app->get_options([](const Option *opt) { return opt->get_positional(); });
|
|
|
+
|
|
|
+ // Print out positionals if any are left
|
|
|
+ if(!positionals.empty()) {
|
|
|
+ // Convert to help names
|
|
|
+ std::vector<std::string> positional_names(positionals.size());
|
|
|
+ std::transform(positionals.begin(), positionals.end(), positional_names.begin(), [this](const Option *opt) {
|
|
|
+ return make_option_usage(opt);
|
|
|
+ });
|
|
|
+
|
|
|
+ out << " " << detail::join(positional_names, " ");
|
|
|
+ }
|
|
|
+
|
|
|
+ // Add a marker if subcommands are expected or optional
|
|
|
+ if(!app->get_subcommands({}).empty()) {
|
|
|
+ out << " " << (app->get_require_subcommand_min() == 0 ? "[" : "")
|
|
|
+ << get_label(app->get_require_subcommand_max() < 2 || app->get_require_subcommand_min() > 1 ? "SUBCOMMAND"
|
|
|
+ : "SUBCOMMANDS")
|
|
|
+ << (app->get_require_subcommand_min() == 0 ? "]" : "");
|
|
|
+ }
|
|
|
+
|
|
|
+ out << std::endl;
|
|
|
+
|
|
|
+ return out.str();
|
|
|
+}
|
|
|
+
|
|
|
+inline std::string Formatter::make_footer(const App *app) const {
|
|
|
+ std::string footer = app->get_footer();
|
|
|
+ if(!footer.empty())
|
|
|
+ return footer + "\n";
|
|
|
+ else
|
|
|
+ return "";
|
|
|
+}
|
|
|
+
|
|
|
+inline std::string Formatter::make_help(const App *app, std::string name, AppFormatMode mode) const {
|
|
|
+
|
|
|
+ // This immediatly forwards to the make_expanded method. This is done this way so that subcommands can
|
|
|
+ // have overridden formatters
|
|
|
+ if(mode == AppFormatMode::Sub)
|
|
|
+ return make_expanded(app);
|
|
|
+
|
|
|
+ std::stringstream out;
|
|
|
+
|
|
|
+ out << make_description(app);
|
|
|
+ out << make_usage(app, name);
|
|
|
+ out << make_positionals(app);
|
|
|
+ out << make_groups(app, mode);
|
|
|
+ out << make_subcommands(app, mode);
|
|
|
+ out << make_footer(app);
|
|
|
+
|
|
|
+ return out.str();
|
|
|
+}
|
|
|
+
|
|
|
+inline std::string Formatter::make_subcommands(const App *app, AppFormatMode mode) const {
|
|
|
+ std::stringstream out;
|
|
|
+
|
|
|
+ std::vector<const App *> subcommands = app->get_subcommands({});
|
|
|
+
|
|
|
+ // Make a list in definition order of the groups seen
|
|
|
+ std::vector<std::string> subcmd_groups_seen;
|
|
|
+ for(const App *com : subcommands) {
|
|
|
+ std::string group_key = com->get_group();
|
|
|
+ if(!group_key.empty() &&
|
|
|
+ std::find_if(subcmd_groups_seen.begin(), subcmd_groups_seen.end(), [&group_key](std::string a) {
|
|
|
+ return detail::to_lower(a) == detail::to_lower(group_key);
|
|
|
+ }) == subcmd_groups_seen.end())
|
|
|
+ subcmd_groups_seen.push_back(group_key);
|
|
|
+ }
|
|
|
+
|
|
|
+ // For each group, filter out and print subcommands
|
|
|
+ for(const std::string &group : subcmd_groups_seen) {
|
|
|
+ out << "\n" << group << ":\n";
|
|
|
+ std::vector<const App *> subcommands_group = app->get_subcommands(
|
|
|
+ [&group](const App *app) { return detail::to_lower(app->get_group()) == detail::to_lower(group); });
|
|
|
+ for(const App *new_com : subcommands_group) {
|
|
|
+ if(mode != AppFormatMode::All) {
|
|
|
+ out << make_subcommand(new_com);
|
|
|
+ } else {
|
|
|
+ out << new_com->help(new_com->get_name(), AppFormatMode::Sub);
|
|
|
+ out << "\n";
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return out.str();
|
|
|
+}
|
|
|
+
|
|
|
+inline std::string Formatter::make_subcommand(const App *sub) const {
|
|
|
+ std::stringstream out;
|
|
|
+ detail::format_help(out, sub->get_name(), sub->get_description(), column_width_);
|
|
|
+ return out.str();
|
|
|
+}
|
|
|
+
|
|
|
+inline std::string Formatter::make_expanded(const App *sub) const {
|
|
|
+ std::stringstream out;
|
|
|
+ out << sub->get_name() << "\n";
|
|
|
+
|
|
|
+ out << make_description(sub);
|
|
|
+ out << make_positionals(sub);
|
|
|
+ out << make_groups(sub, AppFormatMode::Sub);
|
|
|
+ out << make_subcommands(sub, AppFormatMode::Sub);
|
|
|
+
|
|
|
+ // Drop blank spaces
|
|
|
+ std::string tmp = detail::find_and_replace(out.str(), "\n\n", "\n");
|
|
|
+ tmp = tmp.substr(0, tmp.size() - 1); // Remove the final '\n'
|
|
|
+
|
|
|
+ // Indent all but the first line (the name)
|
|
|
+ return detail::find_and_replace(tmp, "\n", "\n ") + "\n";
|
|
|
+}
|
|
|
+
|
|
|
+inline std::string Formatter::make_option_name(const Option *opt, bool is_positional) const {
|
|
|
+ if(is_positional)
|
|
|
+ return opt->get_name(true, false);
|
|
|
+ else
|
|
|
+ return opt->get_name(false, true);
|
|
|
+}
|
|
|
+
|
|
|
+inline std::string Formatter::make_option_opts(const Option *opt) const {
|
|
|
+ std::stringstream out;
|
|
|
+
|
|
|
+ if(opt->get_type_size() != 0) {
|
|
|
+ if(!opt->get_type_name().empty())
|
|
|
+ out << " " << get_label(opt->get_type_name());
|
|
|
+ if(!opt->get_defaultval().empty())
|
|
|
+ out << "=" << opt->get_defaultval();
|
|
|
+ if(opt->get_expected() > 1)
|
|
|
+ out << " x " << opt->get_expected();
|
|
|
+ if(opt->get_expected() == -1)
|
|
|
+ out << " ...";
|
|
|
+ if(opt->get_required())
|
|
|
+ out << " " << get_label("REQUIRED");
|
|
|
+ }
|
|
|
+ if(!opt->get_envname().empty())
|
|
|
+ out << " (" << get_label("Env") << ":" << opt->get_envname() << ")";
|
|
|
+ if(!opt->get_needs().empty()) {
|
|
|
+ out << " " << get_label("Needs") << ":";
|
|
|
+ for(const Option *op : opt->get_needs())
|
|
|
+ out << " " << op->get_name();
|
|
|
+ }
|
|
|
+ if(!opt->get_excludes().empty()) {
|
|
|
+ out << " " << get_label("Excludes") << ":";
|
|
|
+ for(const Option *op : opt->get_excludes())
|
|
|
+ out << " " << op->get_name();
|
|
|
+ }
|
|
|
+ return out.str();
|
|
|
+}
|
|
|
+
|
|
|
+inline std::string Formatter::make_option_desc(const Option *opt) const { return opt->get_description(); }
|
|
|
+
|
|
|
+inline std::string Formatter::make_option_usage(const Option *opt) const {
|
|
|
+ // Note that these are positionals usages
|
|
|
+ std::stringstream out;
|
|
|
+ out << make_option_name(opt, true);
|
|
|
+
|
|
|
+ if(opt->get_expected() > 1)
|
|
|
+ out << "(" << std::to_string(opt->get_expected()) << "x)";
|
|
|
+ else if(opt->get_expected() < 0)
|
|
|
+ out << "...";
|
|
|
+
|
|
|
+ return opt->get_required() ? out.str() : "[" + out.str() + "]";
|
|
|
+}
|
|
|
+
|
|
|
+} // namespace CLI
|
|
|
+
|
Pär Winzell