adding font-converter
diff --git a/skia/dependencies/make_skia_alpine.sh b/skia/dependencies/make_skia_alpine.sh
new file mode 100755
index 0000000..7955142
--- /dev/null
+++ b/skia/dependencies/make_skia_alpine.sh
@@ -0,0 +1,49 @@
+#!/bin/sh
+
+set -e
+
+./get_skia.sh
+
+cd skia
+
+# build static for host
+gn gen out/static --type=static_library --args=" \
+ extra_cflags=[\"-fno-rtti\", \"-flto=full\", \"-DSK_DISABLE_SKPICTURE\", \"-DSK_DISABLE_TEXT\", \"-DRIVE_OPTIMIZED\", \"-DSK_DISABLE_LEGACY_SHADERCONTEXT\", \"-DSK_DISABLE_LOWP_RASTER_PIPELINE\", \"-DSK_FORCE_RASTER_PIPELINE_BLITTER\", \"-DSK_DISABLE_AAA\", \"-DSK_DISABLE_EFFECT_DESERIALIZATION\"] \
+
+ is_official_build=true \
+ skia_use_gl=true \
+ skia_use_zlib=true \
+ skia_enable_gpu=true \
+ skia_enable_fontmgr_empty=true \
+ skia_use_libpng_encode=true \
+ skia_use_libpng_decode=true \
+ skia_enable_skgpu_v1=true \
+
+ skia_use_dng_sdk=false \
+ skia_use_egl=false \
+ skia_use_expat=false \
+ skia_use_fontconfig=false \
+ skia_use_freetype=false \
+ skia_use_icu=false \
+ skia_use_libheif=false \
+ skia_use_system_libpng=false \
+ skia_use_libjpeg_turbo_encode=false \
+ skia_use_libjpeg_turbo_decode=false \
+ skia_use_libwebp_encode=false \
+ skia_use_libwebp_decode=false \
+ skia_use_lua=false \
+ skia_use_piex=false \
+ skia_use_vulkan=false \
+ skia_use_metal=false \
+ skia_use_angle=false \
+ skia_use_system_zlib=false \
+ skia_enable_spirv_validation=false \
+ skia_enable_pdf=false \
+ skia_enable_skottie=false \
+ skia_enable_tools=false \
+ skia_enable_skgpu_v2=false \
+ "
+ninja -C out/static
+du -hs out/static/libskia.a
+
+cd ..
\ No newline at end of file
diff --git a/skia/font_converter/build.sh b/skia/font_converter/build.sh
new file mode 100755
index 0000000..02e73c8
--- /dev/null
+++ b/skia/font_converter/build.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+
+cd build
+
+OPTION=$1
+
+if [ "$OPTION" = 'help' ]; then
+ echo build.sh - build debug library
+ echo build.sh clean - clean the build
+ echo build.sh release - build release library
+elif [ "$OPTION" = "clean" ]; then
+ echo Cleaning project ...
+ # TODO: fix premake5 clean to bubble the clean command to dependent projects
+ premake5 gmake && make clean
+elif [ "$OPTION" = "release" ]; then
+ premake5 gmake && make config=release -j7
+else
+ premake5 gmake && make -j7
+fi
diff --git a/skia/font_converter/build/macosx/bin/debug/font_converter b/skia/font_converter/build/macosx/bin/debug/font_converter
new file mode 100755
index 0000000..7e306c5
--- /dev/null
+++ b/skia/font_converter/build/macosx/bin/debug/font_converter
Binary files differ
diff --git a/skia/font_converter/build/premake5.lua b/skia/font_converter/build/premake5.lua
new file mode 100644
index 0000000..f5e14ce
--- /dev/null
+++ b/skia/font_converter/build/premake5.lua
@@ -0,0 +1,76 @@
+workspace "rive"
+configurations {"debug", "release"}
+
+project "font_converter"
+kind "ConsoleApp"
+language "C++"
+cppdialect "C++17"
+targetdir "%{cfg.system}/bin/%{cfg.buildcfg}"
+objdir "%{cfg.system}/obj/%{cfg.buildcfg}"
+includedirs {
+ "../include",
+ "../../../include",
+ "../../renderer/include",
+ "../../dependencies/skia",
+ -- "../../dependencies/skia/include/core",
+ -- "../../dependencies/skia/include/effects",
+ -- "../../dependencies/skia/include/gpu",
+ -- "../../dependencies/skia/include/config",
+ "/usr/local/include",
+ "/usr/include",
+}
+
+if os.host() == 'macosx' then
+ links {
+ "Cocoa.framework",
+ "CoreFoundation.framework",
+ "IOKit.framework",
+ "Security.framework",
+ "bz2",
+ "iconv",
+ "lzma",
+ "skia",
+ "z", -- lib av format
+ }
+else
+ links {
+ "m",
+ "skia",
+ "z",
+ "dl",
+ }
+end
+
+libdirs {
+ "../../dependencies/skia/out/static",
+ "/usr/local/lib",
+ "/usr/lib",
+}
+
+files {"../src/**.cpp", "../src/**.c"}
+
+buildoptions {"-Wall", "-fno-rtti"}
+
+filter "configurations:debug"
+defines {"DEBUG"}
+symbols "On"
+
+filter "configurations:release"
+defines {"RELEASE"}
+defines {"NDEBUG"}
+optimize "On"
+
+-- Clean Function --
+newaction {
+ trigger = "clean",
+ description = "clean the build",
+ execute = function()
+ print("clean the build...")
+ os.rmdir("./bin")
+ os.rmdir("./obj")
+ os.remove("Makefile")
+ -- no wildcards in os.remove, so use shell
+ os.execute("rm *.make")
+ print("build cleaned")
+ end
+}
diff --git a/skia/font_converter/include/args.hxx b/skia/font_converter/include/args.hxx
new file mode 100644
index 0000000..bbc521d
--- /dev/null
+++ b/skia/font_converter/include/args.hxx
@@ -0,0 +1,4260 @@
+/* Copyright (c) 2016-2017 Taylor C. Richberger <taywee@gmx.com> and Pavel
+ * Belikov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+/** \file args.hxx
+ * \brief this single-header lets you use all of the args functionality
+ *
+ * The important stuff is done inside the args namespace
+ */
+
+#ifndef ARGS_HXX
+#define ARGS_HXX
+
+#include <algorithm>
+#include <iterator>
+#include <exception>
+#include <functional>
+#include <sstream>
+#include <string>
+#include <tuple>
+#include <vector>
+#include <unordered_map>
+#include <unordered_set>
+#include <type_traits>
+
+#ifdef ARGS_TESTNAMESPACE
+namespace argstest
+{
+#else
+
+/** \namespace args
+ * \brief contains all the functionality of the args library
+ */
+namespace args
+{
+#endif
+ /** Getter to grab the value from the argument type.
+ *
+ * If the Get() function of the type returns a reference, so does this, and
+ * the value will be modifiable.
+ */
+ template <typename Option>
+ auto get(Option &option_) -> decltype(option_.Get())
+ {
+ return option_.Get();
+ }
+
+ /** (INTERNAL) Count UTF-8 glyphs
+ *
+ * This is not reliable, and will fail for combinatory glyphs, but it's
+ * good enough here for now.
+ *
+ * \param string The string to count glyphs from
+ * \return The UTF-8 glyphs in the string
+ */
+ inline std::string::size_type Glyphs(const std::string &string_)
+ {
+ std::string::size_type length = 0;
+ for (const char c: string_)
+ {
+ if ((c & 0xc0) != 0x80)
+ {
+ ++length;
+ }
+ }
+ return length;
+ }
+
+ /** (INTERNAL) Wrap a vector of words into a vector of lines
+ *
+ * Empty words are skipped. Word "\n" forces wrapping.
+ *
+ * \param begin The begin iterator
+ * \param end The end iterator
+ * \param width The width of the body
+ * \param firstlinewidth the width of the first line, defaults to the width of the body
+ * \param firstlineindent the indent of the first line, defaults to 0
+ * \return the vector of lines
+ */
+ template <typename It>
+ inline std::vector<std::string> Wrap(It begin,
+ It end,
+ const std::string::size_type width,
+ std::string::size_type firstlinewidth = 0,
+ std::string::size_type firstlineindent = 0)
+ {
+ std::vector<std::string> output;
+ std::string line(firstlineindent, ' ');
+ bool empty = true;
+
+ if (firstlinewidth == 0)
+ {
+ firstlinewidth = width;
+ }
+
+ auto currentwidth = firstlinewidth;
+
+ for (auto it = begin; it != end; ++it)
+ {
+ if (it->empty())
+ {
+ continue;
+ }
+
+ if (*it == "\n")
+ {
+ if (!empty)
+ {
+ output.push_back(line);
+ line.clear();
+ empty = true;
+ currentwidth = width;
+ }
+
+ continue;
+ }
+
+ auto itemsize = Glyphs(*it);
+ if ((line.length() + 1 + itemsize) > currentwidth)
+ {
+ if (!empty)
+ {
+ output.push_back(line);
+ line.clear();
+ empty = true;
+ currentwidth = width;
+ }
+ }
+
+ if (itemsize > 0)
+ {
+ if (!empty)
+ {
+ line += ' ';
+ }
+
+ line += *it;
+ empty = false;
+ }
+ }
+
+ if (!empty)
+ {
+ output.push_back(line);
+ }
+
+ return output;
+ }
+
+ namespace detail
+ {
+ template <typename T>
+ std::string Join(const T& array, const std::string &delimiter)
+ {
+ std::string res;
+ for (auto &element : array)
+ {
+ if (!res.empty())
+ {
+ res += delimiter;
+ }
+
+ res += element;
+ }
+
+ return res;
+ }
+ }
+
+ /** (INTERNAL) Wrap a string into a vector of lines
+ *
+ * This is quick and hacky, but works well enough. You can specify a
+ * different width for the first line
+ *
+ * \param width The width of the body
+ * \param firstlinewid the width of the first line, defaults to the width of the body
+ * \return the vector of lines
+ */
+ inline std::vector<std::string> Wrap(const std::string &in, const std::string::size_type width, std::string::size_type firstlinewidth = 0)
+ {
+ // Preserve existing line breaks
+ const auto newlineloc = in.find('\n');
+ if (newlineloc != in.npos)
+ {
+ auto first = Wrap(std::string(in, 0, newlineloc), width);
+ auto second = Wrap(std::string(in, newlineloc + 1), width);
+ first.insert(
+ std::end(first),
+ std::make_move_iterator(std::begin(second)),
+ std::make_move_iterator(std::end(second)));
+ return first;
+ }
+
+ std::istringstream stream(in);
+ std::string::size_type indent = 0;
+
+ for (char c : in)
+ {
+ if (!isspace(c))
+ {
+ break;
+ }
+ ++indent;
+ }
+
+ return Wrap(std::istream_iterator<std::string>(stream), std::istream_iterator<std::string>(),
+ width, firstlinewidth, indent);
+ }
+
+#ifdef ARGS_NOEXCEPT
+ /// Error class, for when ARGS_NOEXCEPT is defined
+ enum class Error
+ {
+ None,
+ Usage,
+ Parse,
+ Validation,
+ Required,
+ Map,
+ Extra,
+ Help,
+ Subparser,
+ Completion,
+ };
+#else
+ /** Base error class
+ */
+ class Error : public std::runtime_error
+ {
+ public:
+ Error(const std::string &problem) : std::runtime_error(problem) {}
+ virtual ~Error() {}
+ };
+
+ /** Errors that occur during usage
+ */
+ class UsageError : public Error
+ {
+ public:
+ UsageError(const std::string &problem) : Error(problem) {}
+ virtual ~UsageError() {}
+ };
+
+ /** Errors that occur during regular parsing
+ */
+ class ParseError : public Error
+ {
+ public:
+ ParseError(const std::string &problem) : Error(problem) {}
+ virtual ~ParseError() {}
+ };
+
+ /** Errors that are detected from group validation after parsing finishes
+ */
+ class ValidationError : public Error
+ {
+ public:
+ ValidationError(const std::string &problem) : Error(problem) {}
+ virtual ~ValidationError() {}
+ };
+
+ /** Errors that when a required flag is omitted
+ */
+ class RequiredError : public ValidationError
+ {
+ public:
+ RequiredError(const std::string &problem) : ValidationError(problem) {}
+ virtual ~RequiredError() {}
+ };
+
+ /** Errors in map lookups
+ */
+ class MapError : public ParseError
+ {
+ public:
+ MapError(const std::string &problem) : ParseError(problem) {}
+ virtual ~MapError() {}
+ };
+
+ /** Error that occurs when a singular flag is specified multiple times
+ */
+ class ExtraError : public ParseError
+ {
+ public:
+ ExtraError(const std::string &problem) : ParseError(problem) {}
+ virtual ~ExtraError() {}
+ };
+
+ /** An exception that indicates that the user has requested help
+ */
+ class Help : public Error
+ {
+ public:
+ Help(const std::string &flag) : Error(flag) {}
+ virtual ~Help() {}
+ };
+
+ /** (INTERNAL) An exception that emulates coroutine-like control flow for subparsers.
+ */
+ class SubparserError : public Error
+ {
+ public:
+ SubparserError() : Error("") {}
+ virtual ~SubparserError() {}
+ };
+
+ /** An exception that contains autocompletion reply
+ */
+ class Completion : public Error
+ {
+ public:
+ Completion(const std::string &flag) : Error(flag) {}
+ virtual ~Completion() {}
+ };
+#endif
+
+ /** A simple unified option type for unified initializer lists for the Matcher class.
+ */
+ struct EitherFlag
+ {
+ const bool isShort;
+ const char shortFlag;
+ const std::string longFlag;
+ EitherFlag(const std::string &flag) : isShort(false), shortFlag(), longFlag(flag) {}
+ EitherFlag(const char *flag) : isShort(false), shortFlag(), longFlag(flag) {}
+ EitherFlag(const char flag) : isShort(true), shortFlag(flag), longFlag() {}
+
+ /** Get just the long flags from an initializer list of EitherFlags
+ */
+ static std::unordered_set<std::string> GetLong(std::initializer_list<EitherFlag> flags)
+ {
+ std::unordered_set<std::string> longFlags;
+ for (const EitherFlag &flag: flags)
+ {
+ if (!flag.isShort)
+ {
+ longFlags.insert(flag.longFlag);
+ }
+ }
+ return longFlags;
+ }
+
+ /** Get just the short flags from an initializer list of EitherFlags
+ */
+ static std::unordered_set<char> GetShort(std::initializer_list<EitherFlag> flags)
+ {
+ std::unordered_set<char> shortFlags;
+ for (const EitherFlag &flag: flags)
+ {
+ if (flag.isShort)
+ {
+ shortFlags.insert(flag.shortFlag);
+ }
+ }
+ return shortFlags;
+ }
+
+ std::string str() const
+ {
+ return isShort ? std::string(1, shortFlag) : longFlag;
+ }
+
+ std::string str(const std::string &shortPrefix, const std::string &longPrefix) const
+ {
+ return isShort ? shortPrefix + std::string(1, shortFlag) : longPrefix + longFlag;
+ }
+ };
+
+
+
+ /** A class of "matchers", specifying short and flags that can possibly be
+ * matched.
+ *
+ * This is supposed to be constructed and then passed in, not used directly
+ * from user code.
+ */
+ class Matcher
+ {
+ private:
+ const std::unordered_set<char> shortFlags;
+ const std::unordered_set<std::string> longFlags;
+
+ public:
+ /** Specify short and long flags separately as iterators
+ *
+ * ex: `args::Matcher(shortFlags.begin(), shortFlags.end(), longFlags.begin(), longFlags.end())`
+ */
+ template <typename ShortIt, typename LongIt>
+ Matcher(ShortIt shortFlagsStart, ShortIt shortFlagsEnd, LongIt longFlagsStart, LongIt longFlagsEnd) :
+ shortFlags(shortFlagsStart, shortFlagsEnd),
+ longFlags(longFlagsStart, longFlagsEnd)
+ {
+ if (shortFlags.empty() && longFlags.empty())
+ {
+#ifndef ARGS_NOEXCEPT
+ throw UsageError("empty Matcher");
+#endif
+ }
+ }
+
+#ifdef ARGS_NOEXCEPT
+ /// Only for ARGS_NOEXCEPT
+ Error GetError() const noexcept
+ {
+ return shortFlags.empty() && longFlags.empty() ? Error::Usage : Error::None;
+ }
+#endif
+
+ /** Specify short and long flags separately as iterables
+ *
+ * ex: `args::Matcher(shortFlags, longFlags)`
+ */
+ template <typename Short, typename Long>
+ Matcher(Short &&shortIn, Long &&longIn) :
+ Matcher(std::begin(shortIn), std::end(shortIn), std::begin(longIn), std::end(longIn))
+ {}
+
+ /** Specify a mixed single initializer-list of both short and long flags
+ *
+ * This is the fancy one. It takes a single initializer list of
+ * any number of any mixed kinds of flags. Chars are
+ * automatically interpreted as short flags, and strings are
+ * automatically interpreted as long flags:
+ *
+ * args::Matcher{'a'}
+ * args::Matcher{"foo"}
+ * args::Matcher{'h', "help"}
+ * args::Matcher{"foo", 'f', 'F', "FoO"}
+ */
+ Matcher(std::initializer_list<EitherFlag> in) :
+ Matcher(EitherFlag::GetShort(in), EitherFlag::GetLong(in)) {}
+
+ Matcher(Matcher &&other) : shortFlags(std::move(other.shortFlags)), longFlags(std::move(other.longFlags))
+ {}
+
+ ~Matcher() {}
+
+ /** (INTERNAL) Check if there is a match of a short flag
+ */
+ bool Match(const char flag) const
+ {
+ return shortFlags.find(flag) != shortFlags.end();
+ }
+
+ /** (INTERNAL) Check if there is a match of a long flag
+ */
+ bool Match(const std::string &flag) const
+ {
+ return longFlags.find(flag) != longFlags.end();
+ }
+
+ /** (INTERNAL) Check if there is a match of a flag
+ */
+ bool Match(const EitherFlag &flag) const
+ {
+ return flag.isShort ? Match(flag.shortFlag) : Match(flag.longFlag);
+ }
+
+ /** (INTERNAL) Get all flag strings as a vector, with the prefixes embedded
+ */
+ std::vector<EitherFlag> GetFlagStrings() const
+ {
+ std::vector<EitherFlag> flagStrings;
+ flagStrings.reserve(shortFlags.size() + longFlags.size());
+ for (const char flag: shortFlags)
+ {
+ flagStrings.emplace_back(flag);
+ }
+ for (const std::string &flag: longFlags)
+ {
+ flagStrings.emplace_back(flag);
+ }
+ return flagStrings;
+ }
+
+ /** (INTERNAL) Get long flag if it exists or any short flag
+ */
+ EitherFlag GetLongOrAny() const
+ {
+ if (!longFlags.empty())
+ {
+ return *longFlags.begin();
+ }
+
+ if (!shortFlags.empty())
+ {
+ return *shortFlags.begin();
+ }
+
+ // should be unreachable
+ return ' ';
+ }
+
+ /** (INTERNAL) Get short flag if it exists or any long flag
+ */
+ EitherFlag GetShortOrAny() const
+ {
+ if (!shortFlags.empty())
+ {
+ return *shortFlags.begin();
+ }
+
+ if (!longFlags.empty())
+ {
+ return *longFlags.begin();
+ }
+
+ // should be unreachable
+ return ' ';
+ }
+ };
+
+ /** Attributes for flags.
+ */
+ enum class Options
+ {
+ /** Default options.
+ */
+ None = 0x0,
+
+ /** Flag can't be passed multiple times.
+ */
+ Single = 0x01,
+
+ /** Flag can't be omitted.
+ */
+ Required = 0x02,
+
+ /** Flag is excluded from usage line.
+ */
+ HiddenFromUsage = 0x04,
+
+ /** Flag is excluded from options help.
+ */
+ HiddenFromDescription = 0x08,
+
+ /** Flag is global and can be used in any subcommand.
+ */
+ Global = 0x10,
+
+ /** Flag stops a parser.
+ */
+ KickOut = 0x20,
+
+ /** Flag is excluded from auto completion.
+ */
+ HiddenFromCompletion = 0x40,
+
+ /** Flag is excluded from options help and usage line
+ */
+ Hidden = HiddenFromUsage | HiddenFromDescription | HiddenFromCompletion,
+ };
+
+ inline Options operator | (Options lhs, Options rhs)
+ {
+ return static_cast<Options>(static_cast<int>(lhs) | static_cast<int>(rhs));
+ }
+
+ inline Options operator & (Options lhs, Options rhs)
+ {
+ return static_cast<Options>(static_cast<int>(lhs) & static_cast<int>(rhs));
+ }
+
+ class FlagBase;
+ class PositionalBase;
+ class Command;
+ class ArgumentParser;
+
+ /** A simple structure of parameters for easy user-modifyable help menus
+ */
+ struct HelpParams
+ {
+ /** The width of the help menu
+ */
+ unsigned int width = 80;
+ /** The indent of the program line
+ */
+ unsigned int progindent = 2;
+ /** The indent of the program trailing lines for long parameters
+ */
+ unsigned int progtailindent = 4;
+ /** The indent of the description and epilogs
+ */
+ unsigned int descriptionindent = 4;
+ /** The indent of the flags
+ */
+ unsigned int flagindent = 6;
+ /** The indent of the flag descriptions
+ */
+ unsigned int helpindent = 40;
+ /** The additional indent each group adds
+ */
+ unsigned int eachgroupindent = 2;
+
+ /** The minimum gutter between each flag and its help
+ */
+ unsigned int gutter = 1;
+
+ /** Show the terminator when both options and positional parameters are present
+ */
+ bool showTerminator = true;
+
+ /** Show the {OPTIONS} on the prog line when this is true
+ */
+ bool showProglineOptions = true;
+
+ /** Show the positionals on the prog line when this is true
+ */
+ bool showProglinePositionals = true;
+
+ /** The prefix for short flags
+ */
+ std::string shortPrefix;
+
+ /** The prefix for long flags
+ */
+ std::string longPrefix;
+
+ /** The separator for short flags
+ */
+ std::string shortSeparator;
+
+ /** The separator for long flags
+ */
+ std::string longSeparator;
+
+ /** The program name for help generation
+ */
+ std::string programName;
+
+ /** Show command's flags
+ */
+ bool showCommandChildren = false;
+
+ /** Show command's descriptions and epilog
+ */
+ bool showCommandFullHelp = false;
+
+ /** The postfix for progline when showProglineOptions is true and command has any flags
+ */
+ std::string proglineOptions = "{OPTIONS}";
+
+ /** The prefix for progline when command has any subcommands
+ */
+ std::string proglineCommand = "COMMAND";
+
+ /** The prefix for progline value
+ */
+ std::string proglineValueOpen = " <";
+
+ /** The postfix for progline value
+ */
+ std::string proglineValueClose = ">";
+
+ /** The prefix for progline required argument
+ */
+ std::string proglineRequiredOpen = "";
+
+ /** The postfix for progline required argument
+ */
+ std::string proglineRequiredClose = "";
+
+ /** The prefix for progline non-required argument
+ */
+ std::string proglineNonrequiredOpen = "[";
+
+ /** The postfix for progline non-required argument
+ */
+ std::string proglineNonrequiredClose = "]";
+
+ /** Show flags in program line
+ */
+ bool proglineShowFlags = false;
+
+ /** Use short flags in program lines when possible
+ */
+ bool proglinePreferShortFlags = false;
+
+ /** Program line prefix
+ */
+ std::string usageString;
+
+ /** String shown in help before flags descriptions
+ */
+ std::string optionsString = "OPTIONS:";
+
+ /** Display value name after all the long and short flags
+ */
+ bool useValueNameOnce = false;
+
+ /** Show value name
+ */
+ bool showValueName = true;
+
+ /** Add newline before flag description
+ */
+ bool addNewlineBeforeDescription = false;
+
+ /** The prefix for option value
+ */
+ std::string valueOpen = "[";
+
+ /** The postfix for option value
+ */
+ std::string valueClose = "]";
+
+ /** Add choices to argument description
+ */
+ bool addChoices = false;
+
+ /** The prefix for choices
+ */
+ std::string choiceString = "\nOne of: ";
+
+ /** Add default values to argument description
+ */
+ bool addDefault = false;
+
+ /** The prefix for default values
+ */
+ std::string defaultString = "\nDefault: ";
+ };
+
+ /** A number of arguments which can be consumed by an option.
+ *
+ * Represents a closed interval [min, max].
+ */
+ struct Nargs
+ {
+ const size_t min;
+ const size_t max;
+
+ Nargs(size_t min_, size_t max_) : min{min_}, max{max_}
+ {
+#ifndef ARGS_NOEXCEPT
+ if (max < min)
+ {
+ throw UsageError("Nargs: max > min");
+ }
+#endif
+ }
+
+ Nargs(size_t num_) : min{num_}, max{num_}
+ {
+ }
+
+ friend bool operator == (const Nargs &lhs, const Nargs &rhs)
+ {
+ return lhs.min == rhs.min && lhs.max == rhs.max;
+ }
+
+ friend bool operator != (const Nargs &lhs, const Nargs &rhs)
+ {
+ return !(lhs == rhs);
+ }
+ };
+
+ /** Base class for all match types
+ */
+ class Base
+ {
+ private:
+ Options options = {};
+
+ protected:
+ bool matched = false;
+ const std::string help;
+#ifdef ARGS_NOEXCEPT
+ /// Only for ARGS_NOEXCEPT
+ mutable Error error = Error::None;
+ mutable std::string errorMsg;
+#endif
+
+ public:
+ Base(const std::string &help_, Options options_ = {}) : options(options_), help(help_) {}
+ virtual ~Base() {}
+
+ Options GetOptions() const noexcept
+ {
+ return options;
+ }
+
+ bool IsRequired() const noexcept
+ {
+ return (GetOptions() & Options::Required) != Options::None;
+ }
+
+ virtual bool Matched() const noexcept
+ {
+ return matched;
+ }
+
+ virtual void Validate(const std::string &, const std::string &) const
+ {
+ }
+
+ operator bool() const noexcept
+ {
+ return Matched();
+ }
+
+ virtual std::vector<std::tuple<std::string, std::string, unsigned>> GetDescription(const HelpParams &, const unsigned indentLevel) const
+ {
+ std::tuple<std::string, std::string, unsigned> description;
+ std::get<1>(description) = help;
+ std::get<2>(description) = indentLevel;
+ return { std::move(description) };
+ }
+
+ virtual std::vector<Command*> GetCommands()
+ {
+ return {};
+ }
+
+ virtual bool IsGroup() const
+ {
+ return false;
+ }
+
+ virtual FlagBase *Match(const EitherFlag &)
+ {
+ return nullptr;
+ }
+
+ virtual PositionalBase *GetNextPositional()
+ {
+ return nullptr;
+ }
+
+ virtual std::vector<FlagBase*> GetAllFlags()
+ {
+ return {};
+ }
+
+ virtual bool HasFlag() const
+ {
+ return false;
+ }
+
+ virtual bool HasPositional() const
+ {
+ return false;
+ }
+
+ virtual bool HasCommand() const
+ {
+ return false;
+ }
+
+ virtual std::vector<std::string> GetProgramLine(const HelpParams &) const
+ {
+ return {};
+ }
+
+ /// Sets a kick-out value for building subparsers
+ void KickOut(bool kickout_) noexcept
+ {
+ if (kickout_)
+ {
+ options = options | Options::KickOut;
+ }
+ else
+ {
+ options = static_cast<Options>(static_cast<int>(options) & ~static_cast<int>(Options::KickOut));
+ }
+ }
+
+ /// Gets the kick-out value for building subparsers
+ bool KickOut() const noexcept
+ {
+ return (options & Options::KickOut) != Options::None;
+ }
+
+ virtual void Reset() noexcept
+ {
+ matched = false;
+#ifdef ARGS_NOEXCEPT
+ error = Error::None;
+ errorMsg.clear();
+#endif
+ }
+
+#ifdef ARGS_NOEXCEPT
+ /// Only for ARGS_NOEXCEPT
+ virtual Error GetError() const
+ {
+ return error;
+ }
+
+ /// Only for ARGS_NOEXCEPT
+ std::string GetErrorMsg() const
+ {
+ return errorMsg;
+ }
+#endif
+ };
+
+ /** Base class for all match types that have a name
+ */
+ class NamedBase : public Base
+ {
+ protected:
+ const std::string name;
+ bool kickout = false;
+ std::string defaultString;
+ bool defaultStringManual = false;
+ std::vector<std::string> choicesStrings;
+ bool choicesStringManual = false;
+
+ virtual std::string GetDefaultString(const HelpParams&) const { return {}; }
+
+ virtual std::vector<std::string> GetChoicesStrings(const HelpParams&) const { return {}; }
+
+ virtual std::string GetNameString(const HelpParams&) const { return Name(); }
+
+ void AddDescriptionPostfix(std::string &dest, const bool isManual, const std::string &manual, bool isGenerated, const std::string &generated, const std::string &str) const
+ {
+ if (isManual && !manual.empty())
+ {
+ dest += str;
+ dest += manual;
+ }
+ else if (!isManual && isGenerated && !generated.empty())
+ {
+ dest += str;
+ dest += generated;
+ }
+ }
+
+ public:
+ NamedBase(const std::string &name_, const std::string &help_, Options options_ = {}) : Base(help_, options_), name(name_) {}
+ virtual ~NamedBase() {}
+
+ /** Sets default value string that will be added to argument description.
+ * Use empty string to disable it for this argument.
+ */
+ void HelpDefault(const std::string &str)
+ {
+ defaultStringManual = true;
+ defaultString = str;
+ }
+
+ /** Gets default value string that will be added to argument description.
+ */
+ std::string HelpDefault(const HelpParams ¶ms) const
+ {
+ return defaultStringManual ? defaultString : GetDefaultString(params);
+ }
+
+ /** Sets choices strings that will be added to argument description.
+ * Use empty vector to disable it for this argument.
+ */
+ void HelpChoices(const std::vector<std::string> &array)
+ {
+ choicesStringManual = true;
+ choicesStrings = array;
+ }
+
+ /** Gets choices strings that will be added to argument description.
+ */
+ std::vector<std::string> HelpChoices(const HelpParams ¶ms) const
+ {
+ return choicesStringManual ? choicesStrings : GetChoicesStrings(params);
+ }
+
+ virtual std::vector<std::tuple<std::string, std::string, unsigned>> GetDescription(const HelpParams ¶ms, const unsigned indentLevel) const override
+ {
+ std::tuple<std::string, std::string, unsigned> description;
+ std::get<0>(description) = GetNameString(params);
+ std::get<1>(description) = help;
+ std::get<2>(description) = indentLevel;
+
+ AddDescriptionPostfix(std::get<1>(description), choicesStringManual, detail::Join(choicesStrings, ", "), params.addChoices, detail::Join(GetChoicesStrings(params), ", "), params.choiceString);
+ AddDescriptionPostfix(std::get<1>(description), defaultStringManual, defaultString, params.addDefault, GetDefaultString(params), params.defaultString);
+
+ return { std::move(description) };
+ }
+
+ virtual std::string Name() const
+ {
+ return name;
+ }
+ };
+
+ namespace detail
+ {
+ template <typename T, typename = int>
+ struct IsConvertableToString : std::false_type {};
+
+ template <typename T>
+ struct IsConvertableToString<T, decltype(std::declval<std::ostringstream&>() << std::declval<T>(), int())> : std::true_type {};
+
+ template <typename T>
+ typename std::enable_if<IsConvertableToString<T>::value, std::string>::type
+ ToString(const T &value)
+ {
+ std::ostringstream s;
+ s << value;
+ return s.str();
+ }
+
+ template <typename T>
+ typename std::enable_if<!IsConvertableToString<T>::value, std::string>::type
+ ToString(const T &)
+ {
+ return {};
+ }
+
+ template <typename T>
+ std::vector<std::string> MapKeysToStrings(const T &map)
+ {
+ std::vector<std::string> res;
+ using K = typename std::decay<decltype(std::begin(map)->first)>::type;
+ if (IsConvertableToString<K>::value)
+ {
+ for (const auto &p : map)
+ {
+ res.push_back(detail::ToString(p.first));
+ }
+
+ std::sort(res.begin(), res.end());
+ }
+ return res;
+ }
+ }
+
+ /** Base class for all flag options
+ */
+ class FlagBase : public NamedBase
+ {
+ protected:
+ const Matcher matcher;
+
+ virtual std::string GetNameString(const HelpParams ¶ms) const override
+ {
+ const std::string postfix = !params.showValueName || NumberOfArguments() == 0 ? std::string() : Name();
+ std::string flags;
+ const auto flagStrings = matcher.GetFlagStrings();
+ const bool useValueNameOnce = flagStrings.size() == 1 ? false : params.useValueNameOnce;
+ for (auto it = flagStrings.begin(); it != flagStrings.end(); ++it)
+ {
+ auto &flag = *it;
+ if (it != flagStrings.begin())
+ {
+ flags += ", ";
+ }
+
+ flags += flag.isShort ? params.shortPrefix : params.longPrefix;
+ flags += flag.str();
+
+ if (!postfix.empty() && (!useValueNameOnce || it + 1 == flagStrings.end()))
+ {
+ flags += flag.isShort ? params.shortSeparator : params.longSeparator;
+ flags += params.valueOpen + postfix + params.valueClose;
+ }
+ }
+
+ return flags;
+ }
+
+ public:
+ FlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, const bool extraError_ = false) : NamedBase(name_, help_, extraError_ ? Options::Single : Options()), matcher(std::move(matcher_)) {}
+
+ FlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_) : NamedBase(name_, help_, options_), matcher(std::move(matcher_)) {}
+
+ virtual ~FlagBase() {}
+
+ virtual FlagBase *Match(const EitherFlag &flag) override
+ {
+ if (matcher.Match(flag))
+ {
+ if ((GetOptions() & Options::Single) != Options::None && matched)
+ {
+ std::ostringstream problem;
+ problem << "Flag '" << flag.str() << "' was passed multiple times, but is only allowed to be passed once";
+#ifdef ARGS_NOEXCEPT
+ error = Error::Extra;
+ errorMsg = problem.str();
+#else
+ throw ExtraError(problem.str());
+#endif
+ }
+ matched = true;
+ return this;
+ }
+ return nullptr;
+ }
+
+ virtual std::vector<FlagBase*> GetAllFlags() override
+ {
+ return { this };
+ }
+
+ const Matcher &GetMatcher() const
+ {
+ return matcher;
+ }
+
+ virtual void Validate(const std::string &shortPrefix, const std::string &longPrefix) const override
+ {
+ if (!Matched() && IsRequired())
+ {
+ std::ostringstream problem;
+ problem << "Flag '" << matcher.GetLongOrAny().str(shortPrefix, longPrefix) << "' is required";
+#ifdef ARGS_NOEXCEPT
+ error = Error::Required;
+ errorMsg = problem.str();
+#else
+ throw RequiredError(problem.str());
+#endif
+ }
+ }
+
+ virtual std::vector<std::string> GetProgramLine(const HelpParams ¶ms) const override
+ {
+ if (!params.proglineShowFlags)
+ {
+ return {};
+ }
+
+ const std::string postfix = NumberOfArguments() == 0 ? std::string() : Name();
+ const EitherFlag flag = params.proglinePreferShortFlags ? matcher.GetShortOrAny() : matcher.GetLongOrAny();
+ std::string res = flag.str(params.shortPrefix, params.longPrefix);
+ if (!postfix.empty())
+ {
+ res += params.proglineValueOpen + postfix + params.proglineValueClose;
+ }
+
+ return { IsRequired() ? params.proglineRequiredOpen + res + params.proglineRequiredClose
+ : params.proglineNonrequiredOpen + res + params.proglineNonrequiredClose };
+ }
+
+ virtual bool HasFlag() const override
+ {
+ return true;
+ }
+
+#ifdef ARGS_NOEXCEPT
+ /// Only for ARGS_NOEXCEPT
+ virtual Error GetError() const override
+ {
+ const auto nargs = NumberOfArguments();
+ if (nargs.min > nargs.max)
+ {
+ return Error::Usage;
+ }
+
+ const auto matcherError = matcher.GetError();
+ if (matcherError != Error::None)
+ {
+ return matcherError;
+ }
+
+ return error;
+ }
+#endif
+
+ /** Defines how many values can be consumed by this option.
+ *
+ * \return closed interval [min, max]
+ */
+ virtual Nargs NumberOfArguments() const noexcept = 0;
+
+ /** Parse values of this option.
+ *
+ * \param value Vector of values. It's size must be in NumberOfArguments() interval.
+ */
+ virtual void ParseValue(const std::vector<std::string> &value) = 0;
+ };
+
+ /** Base class for value-accepting flag options
+ */
+ class ValueFlagBase : public FlagBase
+ {
+ public:
+ ValueFlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, const bool extraError_ = false) : FlagBase(name_, help_, std::move(matcher_), extraError_) {}
+ ValueFlagBase(const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_) : FlagBase(name_, help_, std::move(matcher_), options_) {}
+ virtual ~ValueFlagBase() {}
+
+ virtual Nargs NumberOfArguments() const noexcept override
+ {
+ return 1;
+ }
+ };
+
+ class CompletionFlag : public ValueFlagBase
+ {
+ public:
+ std::vector<std::string> reply;
+ size_t cword = 0;
+ std::string syntax;
+
+ template <typename GroupClass>
+ CompletionFlag(GroupClass &group_, Matcher &&matcher_): ValueFlagBase("completion", "completion flag", std::move(matcher_), Options::Hidden)
+ {
+ group_.AddCompletion(*this);
+ }
+
+ virtual ~CompletionFlag() {}
+
+ virtual Nargs NumberOfArguments() const noexcept override
+ {
+ return 2;
+ }
+
+ virtual void ParseValue(const std::vector<std::string> &value_) override
+ {
+ syntax = value_.at(0);
+ std::istringstream(value_.at(1)) >> cword;
+ }
+
+ /** Get the completion reply
+ */
+ std::string Get() noexcept
+ {
+ return detail::Join(reply, "\n");
+ }
+
+ virtual void Reset() noexcept override
+ {
+ ValueFlagBase::Reset();
+ cword = 0;
+ syntax.clear();
+ reply.clear();
+ }
+ };
+
+
+ /** Base class for positional options
+ */
+ class PositionalBase : public NamedBase
+ {
+ protected:
+ bool ready;
+
+ public:
+ PositionalBase(const std::string &name_, const std::string &help_, Options options_ = {}) : NamedBase(name_, help_, options_), ready(true) {}
+ virtual ~PositionalBase() {}
+
+ bool Ready()
+ {
+ return ready;
+ }
+
+ virtual void ParseValue(const std::string &value_) = 0;
+
+ virtual void Reset() noexcept override
+ {
+ matched = false;
+ ready = true;
+#ifdef ARGS_NOEXCEPT
+ error = Error::None;
+ errorMsg.clear();
+#endif
+ }
+
+ virtual PositionalBase *GetNextPositional() override
+ {
+ return Ready() ? this : nullptr;
+ }
+
+ virtual bool HasPositional() const override
+ {
+ return true;
+ }
+
+ virtual std::vector<std::string> GetProgramLine(const HelpParams ¶ms) const override
+ {
+ return { IsRequired() ? params.proglineRequiredOpen + Name() + params.proglineRequiredClose
+ : params.proglineNonrequiredOpen + Name() + params.proglineNonrequiredClose };
+ }
+
+ virtual void Validate(const std::string &, const std::string &) const override
+ {
+ if (IsRequired() && !Matched())
+ {
+ std::ostringstream problem;
+ problem << "Option '" << Name() << "' is required";
+#ifdef ARGS_NOEXCEPT
+ error = Error::Required;
+ errorMsg = problem.str();
+#else
+ throw RequiredError(problem.str());
+#endif
+ }
+ }
+ };
+
+ /** Class for all kinds of validating groups, including ArgumentParser
+ */
+ class Group : public Base
+ {
+ private:
+ std::vector<Base*> children;
+ std::function<bool(const Group &)> validator;
+
+ public:
+ /** Default validators
+ */
+ struct Validators
+ {
+ static bool Xor(const Group &group)
+ {
+ return group.MatchedChildren() == 1;
+ }
+
+ static bool AtLeastOne(const Group &group)
+ {
+ return group.MatchedChildren() >= 1;
+ }
+
+ static bool AtMostOne(const Group &group)
+ {
+ return group.MatchedChildren() <= 1;
+ }
+
+ static bool All(const Group &group)
+ {
+ return group.Children().size() == group.MatchedChildren();
+ }
+
+ static bool AllOrNone(const Group &group)
+ {
+ return (All(group) || None(group));
+ }
+
+ static bool AllChildGroups(const Group &group)
+ {
+ return std::none_of(std::begin(group.Children()), std::end(group.Children()), [](const Base* child) -> bool {
+ return child->IsGroup() && !child->Matched();
+ });
+ }
+
+ static bool DontCare(const Group &)
+ {
+ return true;
+ }
+
+ static bool CareTooMuch(const Group &)
+ {
+ return false;
+ }
+
+ static bool None(const Group &group)
+ {
+ return group.MatchedChildren() == 0;
+ }
+ };
+ /// If help is empty, this group will not be printed in help output
+ Group(const std::string &help_ = std::string(), const std::function<bool(const Group &)> &validator_ = Validators::DontCare, Options options_ = {}) : Base(help_, options_), validator(validator_) {}
+ /// If help is empty, this group will not be printed in help output
+ Group(Group &group_, const std::string &help_ = std::string(), const std::function<bool(const Group &)> &validator_ = Validators::DontCare, Options options_ = {}) : Base(help_, options_), validator(validator_)
+ {
+ group_.Add(*this);
+ }
+ virtual ~Group() {}
+
+ /** Append a child to this Group.
+ */
+ void Add(Base &child)
+ {
+ children.emplace_back(&child);
+ }
+
+ /** Get all this group's children
+ */
+ const std::vector<Base *> &Children() const
+ {
+ return children;
+ }
+
+ /** Return the first FlagBase that matches flag, or nullptr
+ *
+ * \param flag The flag with prefixes stripped
+ * \return the first matching FlagBase pointer, or nullptr if there is no match
+ */
+ virtual FlagBase *Match(const EitherFlag &flag) override
+ {
+ for (Base *child: Children())
+ {
+ if (FlagBase *match = child->Match(flag))
+ {
+ return match;
+ }
+ }
+ return nullptr;
+ }
+
+ virtual std::vector<FlagBase*> GetAllFlags() override
+ {
+ std::vector<FlagBase*> res;
+ for (Base *child: Children())
+ {
+ auto childRes = child->GetAllFlags();
+ res.insert(res.end(), childRes.begin(), childRes.end());
+ }
+ return res;
+ }
+
+ virtual void Validate(const std::string &shortPrefix, const std::string &longPrefix) const override
+ {
+ for (Base *child: Children())
+ {
+ child->Validate(shortPrefix, longPrefix);
+ }
+ }
+
+ /** Get the next ready positional, or nullptr if there is none
+ *
+ * \return the first ready PositionalBase pointer, or nullptr if there is no match
+ */
+ virtual PositionalBase *GetNextPositional() override
+ {
+ for (Base *child: Children())
+ {
+ if (auto next = child->GetNextPositional())
+ {
+ return next;
+ }
+ }
+ return nullptr;
+ }
+
+ /** Get whether this has any FlagBase children
+ *
+ * \return Whether or not there are any FlagBase children
+ */
+ virtual bool HasFlag() const override
+ {
+ return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasFlag(); });
+ }
+
+ /** Get whether this has any PositionalBase children
+ *
+ * \return Whether or not there are any PositionalBase children
+ */
+ virtual bool HasPositional() const override
+ {
+ return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasPositional(); });
+ }
+
+ /** Get whether this has any Command children
+ *
+ * \return Whether or not there are any Command children
+ */
+ virtual bool HasCommand() const override
+ {
+ return std::any_of(Children().begin(), Children().end(), [](Base *child) { return child->HasCommand(); });
+ }
+
+ /** Count the number of matched children this group has
+ */
+ std::vector<Base *>::size_type MatchedChildren() const
+ {
+ return std::count_if(std::begin(Children()), std::end(Children()), [](const Base *child){return child->Matched();});
+ }
+
+ /** Whether or not this group matches validation
+ */
+ virtual bool Matched() const noexcept override
+ {
+ return validator(*this);
+ }
+
+ /** Get validation
+ */
+ bool Get() const
+ {
+ return Matched();
+ }
+
+ /** Get all the child descriptions for help generation
+ */
+ virtual std::vector<std::tuple<std::string, std::string, unsigned>> GetDescription(const HelpParams ¶ms, const unsigned int indent) const override
+ {
+ std::vector<std::tuple<std::string, std::string, unsigned int>> descriptions;
+
+ // Push that group description on the back if not empty
+ unsigned addindent = 0;
+ if (!help.empty())
+ {
+ descriptions.emplace_back(help, "", indent);
+ addindent = 1;
+ }
+
+ for (Base *child: Children())
+ {
+ if ((child->GetOptions() & Options::HiddenFromDescription) != Options::None)
+ {
+ continue;
+ }
+
+ auto groupDescriptions = child->GetDescription(params, indent + addindent);
+ descriptions.insert(
+ std::end(descriptions),
+ std::make_move_iterator(std::begin(groupDescriptions)),
+ std::make_move_iterator(std::end(groupDescriptions)));
+ }
+ return descriptions;
+ }
+
+ /** Get the names of positional parameters
+ */
+ virtual std::vector<std::string> GetProgramLine(const HelpParams ¶ms) const override
+ {
+ std::vector <std::string> names;
+ for (Base *child: Children())
+ {
+ if ((child->GetOptions() & Options::HiddenFromUsage) != Options::None)
+ {
+ continue;
+ }
+
+ auto groupNames = child->GetProgramLine(params);
+ names.insert(
+ std::end(names),
+ std::make_move_iterator(std::begin(groupNames)),
+ std::make_move_iterator(std::end(groupNames)));
+ }
+ return names;
+ }
+
+ virtual std::vector<Command*> GetCommands() override
+ {
+ std::vector<Command*> res;
+ for (const auto &child : Children())
+ {
+ auto subparsers = child->GetCommands();
+ res.insert(std::end(res), std::begin(subparsers), std::end(subparsers));
+ }
+ return res;
+ }
+
+ virtual bool IsGroup() const override
+ {
+ return true;
+ }
+
+ virtual void Reset() noexcept override
+ {
+ Base::Reset();
+
+ for (auto &child: Children())
+ {
+ child->Reset();
+ }
+#ifdef ARGS_NOEXCEPT
+ error = Error::None;
+ errorMsg.clear();
+#endif
+ }
+
+#ifdef ARGS_NOEXCEPT
+ /// Only for ARGS_NOEXCEPT
+ virtual Error GetError() const override
+ {
+ if (error != Error::None)
+ {
+ return error;
+ }
+
+ auto it = std::find_if(Children().begin(), Children().end(), [](const Base *child){return child->GetError() != Error::None;});
+ if (it == Children().end())
+ {
+ return Error::None;
+ } else
+ {
+ return (*it)->GetError();
+ }
+ }
+#endif
+
+ };
+
+ /** Class for using global options in ArgumentParser.
+ */
+ class GlobalOptions : public Group
+ {
+ public:
+ GlobalOptions(Group &base, Base &options_) : Group(base, {}, Group::Validators::DontCare, Options::Global)
+ {
+ Add(options_);
+ }
+ };
+
+ /** Utility class for building subparsers with coroutines/callbacks.
+ *
+ * Brief example:
+ * \code
+ * Command command(argumentParser, "command", "my command", [](args::Subparser &s)
+ * {
+ * // your command flags/positionals
+ * s.Parse(); //required
+ * //your command code
+ * });
+ * \endcode
+ *
+ * For ARGS_NOEXCEPT mode don't forget to check `s.GetError()` after `s.Parse()`
+ * and return if it isn't equals to args::Error::None.
+ *
+ * \sa Command
+ */
+ class Subparser : public Group
+ {
+ private:
+ std::vector<std::string> args;
+ std::vector<std::string> kicked;
+ ArgumentParser *parser = nullptr;
+ const HelpParams &helpParams;
+ const Command &command;
+ bool isParsed = false;
+
+ public:
+ Subparser(std::vector<std::string> args_, ArgumentParser &parser_, const Command &command_, const HelpParams &helpParams_)
+ : args(std::move(args_)), parser(&parser_), helpParams(helpParams_), command(command_)
+ {
+ }
+
+ Subparser(const Command &command_, const HelpParams &helpParams_) : helpParams(helpParams_), command(command_)
+ {
+ }
+
+ Subparser(const Subparser&) = delete;
+ Subparser(Subparser&&) = delete;
+ Subparser &operator = (const Subparser&) = delete;
+ Subparser &operator = (Subparser&&) = delete;
+
+ const Command &GetCommand()
+ {
+ return command;
+ }
+
+ /** (INTERNAL) Determines whether Parse was called or not.
+ */
+ bool IsParsed() const
+ {
+ return isParsed;
+ }
+
+ /** Continue parsing arguments for new command.
+ */
+ void Parse();
+
+ /** Returns a vector of kicked out arguments.
+ *
+ * \sa Base::KickOut
+ */
+ const std::vector<std::string> &KickedOut() const noexcept
+ {
+ return kicked;
+ }
+ };
+
+ /** Main class for building subparsers.
+ *
+ * /sa Subparser
+ */
+ class Command : public Group
+ {
+ private:
+ friend class Subparser;
+
+ std::string name;
+ std::string help;
+ std::string description;
+ std::string epilog;
+ std::string proglinePostfix;
+
+ std::function<void(Subparser&)> parserCoroutine;
+ bool commandIsRequired = true;
+ Command *selectedCommand = nullptr;
+
+ mutable std::vector<std::tuple<std::string, std::string, unsigned>> subparserDescription;
+ mutable std::vector<std::string> subparserProgramLine;
+ mutable bool subparserHasFlag = false;
+ mutable bool subparserHasPositional = false;
+ mutable bool subparserHasCommand = false;
+#ifdef ARGS_NOEXCEPT
+ mutable Error subparserError = Error::None;
+#endif
+ mutable Subparser *subparser = nullptr;
+
+ protected:
+
+ class RaiiSubparser
+ {
+ public:
+ RaiiSubparser(ArgumentParser &parser_, std::vector<std::string> args_);
+ RaiiSubparser(const Command &command_, const HelpParams ¶ms_);
+
+ ~RaiiSubparser()
+ {
+ command.subparser = oldSubparser;
+ }
+
+ Subparser &Parser()
+ {
+ return parser;
+ }
+
+ private:
+ const Command &command;
+ Subparser parser;
+ Subparser *oldSubparser;
+ };
+
+ Command() = default;
+
+ std::function<void(Subparser&)> &GetCoroutine()
+ {
+ return selectedCommand != nullptr ? selectedCommand->GetCoroutine() : parserCoroutine;
+ }
+
+ Command &SelectedCommand()
+ {
+ Command *res = this;
+ while (res->selectedCommand != nullptr)
+ {
+ res = res->selectedCommand;
+ }
+
+ return *res;
+ }
+
+ const Command &SelectedCommand() const
+ {
+ const Command *res = this;
+ while (res->selectedCommand != nullptr)
+ {
+ res = res->selectedCommand;
+ }
+
+ return *res;
+ }
+
+ void UpdateSubparserHelp(const HelpParams ¶ms) const
+ {
+ if (parserCoroutine)
+ {
+ RaiiSubparser coro(*this, params);
+#ifndef ARGS_NOEXCEPT
+ try
+ {
+ parserCoroutine(coro.Parser());
+ }
+ catch (args::SubparserError&)
+ {
+ }
+#else
+ parserCoroutine(coro.Parser());
+#endif
+ }
+ }
+
+ public:
+ Command(Group &base_, std::string name_, std::string help_, std::function<void(Subparser&)> coroutine_ = {})
+ : name(std::move(name_)), help(std::move(help_)), parserCoroutine(std::move(coroutine_))
+ {
+ base_.Add(*this);
+ }
+
+ /** The description that appears on the prog line after options
+ */
+ const std::string &ProglinePostfix() const
+ { return proglinePostfix; }
+
+ /** The description that appears on the prog line after options
+ */
+ void ProglinePostfix(const std::string &proglinePostfix_)
+ { this->proglinePostfix = proglinePostfix_; }
+
+ /** The description that appears above options
+ */
+ const std::string &Description() const
+ { return description; }
+ /** The description that appears above options
+ */
+
+ void Description(const std::string &description_)
+ { this->description = description_; }
+
+ /** The description that appears below options
+ */
+ const std::string &Epilog() const
+ { return epilog; }
+
+ /** The description that appears below options
+ */
+ void Epilog(const std::string &epilog_)
+ { this->epilog = epilog_; }
+
+ /** The name of command
+ */
+ const std::string &Name() const
+ { return name; }
+
+ /** The description of command
+ */
+ const std::string &Help() const
+ { return help; }
+
+ /** If value is true, parser will fail if no command was parsed.
+ *
+ * Default: true.
+ */
+ void RequireCommand(bool value)
+ { commandIsRequired = value; }
+
+ virtual bool IsGroup() const override
+ { return false; }
+
+ virtual bool Matched() const noexcept override
+ { return Base::Matched(); }
+
+ operator bool() const noexcept
+ { return Matched(); }
+
+ void Match() noexcept
+ { matched = true; }
+
+ void SelectCommand(Command *c) noexcept
+ {
+ selectedCommand = c;
+
+ if (c != nullptr)
+ {
+ c->Match();
+ }
+ }
+
+ virtual FlagBase *Match(const EitherFlag &flag) override
+ {
+ if (selectedCommand != nullptr)
+ {
+ if (auto *res = selectedCommand->Match(flag))
+ {
+ return res;
+ }
+
+ for (auto *child: Children())
+ {
+ if ((child->GetOptions() & Options::Global) != Options::None)
+ {
+ if (auto *res = child->Match(flag))
+ {
+ return res;
+ }
+ }
+ }
+
+ return nullptr;
+ }
+
+ if (subparser != nullptr)
+ {
+ return subparser->Match(flag);
+ }
+
+ return Matched() ? Group::Match(flag) : nullptr;
+ }
+
+ virtual std::vector<FlagBase*> GetAllFlags() override
+ {
+ std::vector<FlagBase*> res;
+
+ if (!Matched())
+ {
+ return res;
+ }
+
+ for (auto *child: Children())
+ {
+ if (selectedCommand == nullptr || (child->GetOptions() & Options::Global) != Options::None)
+ {
+ auto childFlags = child->GetAllFlags();
+ res.insert(res.end(), childFlags.begin(), childFlags.end());
+ }
+ }
+
+ if (selectedCommand != nullptr)
+ {
+ auto childFlags = selectedCommand->GetAllFlags();
+ res.insert(res.end(), childFlags.begin(), childFlags.end());
+ }
+
+ if (subparser != nullptr)
+ {
+ auto childFlags = subparser->GetAllFlags();
+ res.insert(res.end(), childFlags.begin(), childFlags.end());
+ }
+
+ return res;
+ }
+
+ virtual PositionalBase *GetNextPositional() override
+ {
+ if (selectedCommand != nullptr)
+ {
+ if (auto *res = selectedCommand->GetNextPositional())
+ {
+ return res;
+ }
+
+ for (auto *child: Children())
+ {
+ if ((child->GetOptions() & Options::Global) != Options::None)
+ {
+ if (auto *res = child->GetNextPositional())
+ {
+ return res;
+ }
+ }
+ }
+
+ return nullptr;
+ }
+
+ if (subparser != nullptr)
+ {
+ return subparser->GetNextPositional();
+ }
+
+ return Matched() ? Group::GetNextPositional() : nullptr;
+ }
+
+ virtual bool HasFlag() const override
+ {
+ return subparserHasFlag || Group::HasFlag();
+ }
+
+ virtual bool HasPositional() const override
+ {
+ return subparserHasPositional || Group::HasPositional();
+ }
+
+ virtual bool HasCommand() const override
+ {
+ return true;
+ }
+
+ std::vector<std::string> GetCommandProgramLine(const HelpParams ¶ms) const
+ {
+ UpdateSubparserHelp(params);
+
+ auto res = Group::GetProgramLine(params);
+ res.insert(res.end(), subparserProgramLine.begin(), subparserProgramLine.end());
+
+ if (!params.proglineCommand.empty() && (Group::HasCommand() || subparserHasCommand))
+ {
+ res.insert(res.begin(), commandIsRequired ? params.proglineCommand : "[" + params.proglineCommand + "]");
+ }
+
+ if (!Name().empty())
+ {
+ res.insert(res.begin(), Name());
+ }
+
+ if ((subparserHasFlag || Group::HasFlag()) && params.showProglineOptions && !params.proglineShowFlags)
+ {
+ res.push_back(params.proglineOptions);
+ }
+
+ if (!ProglinePostfix().empty())
+ {
+ std::string line;
+ for (char c : ProglinePostfix())
+ {
+ if (isspace(c))
+ {
+ if (!line.empty())
+ {
+ res.push_back(line);
+ line.clear();
+ }
+
+ if (c == '\n')
+ {
+ res.push_back("\n");
+ }
+ }
+ else
+ {
+ line += c;
+ }
+ }
+
+ if (!line.empty())
+ {
+ res.push_back(line);
+ }
+ }
+
+ return res;
+ }
+
+ virtual std::vector<std::string> GetProgramLine(const HelpParams ¶ms) const override
+ {
+ if (!Matched())
+ {
+ return {};
+ }
+
+ return GetCommandProgramLine(params);
+ }
+
+ virtual std::vector<Command*> GetCommands() override
+ {
+ if (selectedCommand != nullptr)
+ {
+ return selectedCommand->GetCommands();
+ }
+
+ if (Matched())
+ {
+ return Group::GetCommands();
+ }
+
+ return { this };
+ }
+
+ virtual std::vector<std::tuple<std::string, std::string, unsigned>> GetDescription(const HelpParams ¶ms, const unsigned int indent) const override
+ {
+ std::vector<std::tuple<std::string, std::string, unsigned>> descriptions;
+ unsigned addindent = 0;
+
+ UpdateSubparserHelp(params);
+
+ if (!Matched())
+ {
+ if (params.showCommandFullHelp)
+ {
+ std::ostringstream s;
+ bool empty = true;
+ for (const auto &progline: GetCommandProgramLine(params))
+ {
+ if (!empty)
+ {
+ s << ' ';
+ }
+ else
+ {
+ empty = false;
+ }
+
+ s << progline;
+ }
+
+ descriptions.emplace_back(s.str(), "", indent);
+ }
+ else
+ {
+ descriptions.emplace_back(Name(), help, indent);
+ }
+
+ if (!params.showCommandChildren && !params.showCommandFullHelp)
+ {
+ return descriptions;
+ }
+
+ addindent = 1;
+ }
+
+ if (params.showCommandFullHelp && !Matched())
+ {
+ descriptions.emplace_back("", "", indent + addindent);
+ descriptions.emplace_back(Description().empty() ? Help() : Description(), "", indent + addindent);
+ descriptions.emplace_back("", "", indent + addindent);
+ }
+
+ for (Base *child: Children())
+ {
+ if ((child->GetOptions() & Options::HiddenFromDescription) != Options::None)
+ {
+ continue;
+ }
+
+ auto groupDescriptions = child->GetDescription(params, indent + addindent);
+ descriptions.insert(
+ std::end(descriptions),
+ std::make_move_iterator(std::begin(groupDescriptions)),
+ std::make_move_iterator(std::end(groupDescriptions)));
+ }
+
+ for (auto childDescription: subparserDescription)
+ {
+ std::get<2>(childDescription) += indent + addindent;
+ descriptions.push_back(std::move(childDescription));
+ }
+
+ if (params.showCommandFullHelp && !Matched())
+ {
+ descriptions.emplace_back("", "", indent + addindent);
+ if (!Epilog().empty())
+ {
+ descriptions.emplace_back(Epilog(), "", indent + addindent);
+ descriptions.emplace_back("", "", indent + addindent);
+ }
+ }
+
+ return descriptions;
+ }
+
+ virtual void Validate(const std::string &shortprefix, const std::string &longprefix) const override
+ {
+ if (!Matched())
+ {
+ return;
+ }
+
+ for (Base *child: Children())
+ {
+ if (child->IsGroup() && !child->Matched())
+ {
+ std::ostringstream problem;
+ problem << "Group validation failed somewhere!";
+#ifdef ARGS_NOEXCEPT
+ error = Error::Validation;
+ errorMsg = problem.str();
+#else
+ throw ValidationError(problem.str());
+#endif
+ }
+
+ child->Validate(shortprefix, longprefix);
+ }
+
+ if (subparser != nullptr)
+ {
+ subparser->Validate(shortprefix, longprefix);
+ }
+
+ if (selectedCommand == nullptr && commandIsRequired && (Group::HasCommand() || subparserHasCommand))
+ {
+ std::ostringstream problem;
+ problem << "Command is required";
+#ifdef ARGS_NOEXCEPT
+ error = Error::Validation;
+ errorMsg = problem.str();
+#else
+ throw ValidationError(problem.str());
+#endif
+ }
+ }
+
+ virtual void Reset() noexcept override
+ {
+ Group::Reset();
+ selectedCommand = nullptr;
+ subparserProgramLine.clear();
+ subparserDescription.clear();
+ subparserHasFlag = false;
+ subparserHasPositional = false;
+ subparserHasCommand = false;
+#ifdef ARGS_NOEXCEPT
+ subparserError = Error::None;
+#endif
+ }
+
+#ifdef ARGS_NOEXCEPT
+ /// Only for ARGS_NOEXCEPT
+ virtual Error GetError() const override
+ {
+ if (!Matched())
+ {
+ return Error::None;
+ }
+
+ if (error != Error::None)
+ {
+ return error;
+ }
+
+ if (subparserError != Error::None)
+ {
+ return subparserError;
+ }
+
+ return Group::GetError();
+ }
+#endif
+ };
+
+ /** The main user facing command line argument parser class
+ */
+ class ArgumentParser : public Command
+ {
+ friend class Subparser;
+
+ private:
+ std::string longprefix;
+ std::string shortprefix;
+
+ std::string longseparator;
+
+ std::string terminator;
+
+ bool allowJoinedShortValue = true;
+ bool allowJoinedLongValue = true;
+ bool allowSeparateShortValue = true;
+ bool allowSeparateLongValue = true;
+
+ CompletionFlag *completion = nullptr;
+ bool readCompletion = false;
+
+ protected:
+ enum class OptionType
+ {
+ LongFlag,
+ ShortFlag,
+ Positional
+ };
+
+ OptionType ParseOption(const std::string &s, bool allowEmpty = false)
+ {
+ if (s.find(longprefix) == 0 && (allowEmpty || s.length() > longprefix.length()))
+ {
+ return OptionType::LongFlag;
+ }
+
+ if (s.find(shortprefix) == 0 && (allowEmpty || s.length() > shortprefix.length()))
+ {
+ return OptionType::ShortFlag;
+ }
+
+ return OptionType::Positional;
+ }
+
+ template <typename It>
+ bool Complete(FlagBase &flag, It it, It end)
+ {
+ auto nextIt = it;
+ if (!readCompletion || (++nextIt != end))
+ {
+ return false;
+ }
+
+ const auto &chunk = *it;
+ for (auto &choice : flag.HelpChoices(helpParams))
+ {
+ AddCompletionReply(chunk, choice);
+ }
+
+#ifndef ARGS_NOEXCEPT
+ throw Completion(completion->Get());
+#else
+ return true;
+#endif
+ }
+
+ /** (INTERNAL) Parse flag's values
+ *
+ * \param arg The string to display in error message as a flag name
+ * \param[in, out] it The iterator to first value. It will point to the last value
+ * \param end The end iterator
+ * \param joinedArg Joined value (e.g. bar in --foo=bar)
+ * \param canDiscardJoined If true joined value can be parsed as flag not as a value (as in -abcd)
+ * \param[out] values The vector to store parsed arg's values
+ */
+ template <typename It>
+ std::string ParseArgsValues(FlagBase &flag, const std::string &arg, It &it, It end,
+ const bool allowSeparate, const bool allowJoined,
+ const bool hasJoined, const std::string &joinedArg,
+ const bool canDiscardJoined, std::vector<std::string> &values)
+ {
+ values.clear();
+
+ Nargs nargs = flag.NumberOfArguments();
+
+ if (hasJoined && !allowJoined && nargs.min != 0)
+ {
+ return "Flag '" + arg + "' was passed a joined argument, but these are disallowed";
+ }
+
+ if (hasJoined)
+ {
+ if (!canDiscardJoined || nargs.max != 0)
+ {
+ values.push_back(joinedArg);
+ }
+ } else if (!allowSeparate)
+ {
+ if (nargs.min != 0)
+ {
+ return "Flag '" + arg + "' was passed a separate argument, but these are disallowed";
+ }
+ } else
+ {
+ auto valueIt = it;
+ ++valueIt;
+
+ while (valueIt != end &&
+ values.size() < nargs.max &&
+ (nargs.min == nargs.max || ParseOption(*valueIt) == OptionType::Positional))
+ {
+ if (Complete(flag, valueIt, end))
+ {
+ it = end;
+ return "";
+ }
+
+ values.push_back(*valueIt);
+ ++it;
+ ++valueIt;
+ }
+ }
+
+ if (values.size() > nargs.max)
+ {
+ return "Passed an argument into a non-argument flag: " + arg;
+ } else if (values.size() < nargs.min)
+ {
+ if (nargs.min == 1 && nargs.max == 1)
+ {
+ return "Flag '" + arg + "' requires an argument but received none";
+ } else if (nargs.min == 1)
+ {
+ return "Flag '" + arg + "' requires at least one argument but received none";
+ } else if (nargs.min != nargs.max)
+ {
+ return "Flag '" + arg + "' requires at least " + std::to_string(nargs.min) +
+ " arguments but received " + std::to_string(values.size());
+ } else
+ {
+ return "Flag '" + arg + "' requires " + std::to_string(nargs.min) +
+ " arguments but received " + std::to_string(values.size());
+ }
+ }
+
+ return {};
+ }
+
+ template <typename It>
+ bool ParseLong(It &it, It end)
+ {
+ const auto &chunk = *it;
+ const auto argchunk = chunk.substr(longprefix.size());
+ // Try to separate it, in case of a separator:
+ const auto separator = longseparator.empty() ? argchunk.npos : argchunk.find(longseparator);
+ // If the separator is in the argument, separate it.
+ const auto arg = (separator != argchunk.npos ?
+ std::string(argchunk, 0, separator)
+ : argchunk);
+ const auto joined = (separator != argchunk.npos ?
+ argchunk.substr(separator + longseparator.size())
+ : std::string());
+
+ if (auto flag = Match(arg))
+ {
+ std::vector<std::string> values;
+ const std::string errorMessage = ParseArgsValues(*flag, arg, it, end, allowSeparateLongValue, allowJoinedLongValue,
+ separator != argchunk.npos, joined, false, values);
+ if (!errorMessage.empty())
+ {
+#ifndef ARGS_NOEXCEPT
+ throw ParseError(errorMessage);
+#else
+ error = Error::Parse;
+ errorMsg = errorMessage;
+ return false;
+#endif
+ }
+
+ if (!readCompletion)
+ {
+ flag->ParseValue(values);
+ }
+
+ if (flag->KickOut())
+ {
+ ++it;
+ return false;
+ }
+ } else
+ {
+ const std::string errorMessage("Flag could not be matched: " + arg);
+#ifndef ARGS_NOEXCEPT
+ throw ParseError(errorMessage);
+#else
+ error = Error::Parse;
+ errorMsg = errorMessage;
+ return false;
+#endif
+ }
+
+ return true;
+ }
+
+ template <typename It>
+ bool ParseShort(It &it, It end)
+ {
+ const auto &chunk = *it;
+ const auto argchunk = chunk.substr(shortprefix.size());
+ for (auto argit = std::begin(argchunk); argit != std::end(argchunk); ++argit)
+ {
+ const auto arg = *argit;
+
+ if (auto flag = Match(arg))
+ {
+ const std::string value(argit + 1, std::end(argchunk));
+ std::vector<std::string> values;
+ const std::string errorMessage = ParseArgsValues(*flag, std::string(1, arg), it, end,
+ allowSeparateShortValue, allowJoinedShortValue,
+ !value.empty(), value, !value.empty(), values);
+
+ if (!errorMessage.empty())
+ {
+#ifndef ARGS_NOEXCEPT
+ throw ParseError(errorMessage);
+#else
+ error = Error::Parse;
+ errorMsg = errorMessage;
+ return false;
+#endif
+ }
+
+ if (!readCompletion)
+ {
+ flag->ParseValue(values);
+ }
+
+ if (flag->KickOut())
+ {
+ ++it;
+ return false;
+ }
+
+ if (!values.empty())
+ {
+ break;
+ }
+ } else
+ {
+ const std::string errorMessage("Flag could not be matched: '" + std::string(1, arg) + "'");
+#ifndef ARGS_NOEXCEPT
+ throw ParseError(errorMessage);
+#else
+ error = Error::Parse;
+ errorMsg = errorMessage;
+ return false;
+#endif
+ }
+ }
+
+ return true;
+ }
+
+ bool AddCompletionReply(const std::string &cur, const std::string &choice)
+ {
+ if (cur.empty() || choice.find(cur) == 0)
+ {
+ if (completion->syntax == "bash" && ParseOption(choice) == OptionType::LongFlag && choice.find(longseparator) != std::string::npos)
+ {
+ completion->reply.push_back(choice.substr(choice.find(longseparator) + 1));
+ } else
+ {
+ completion->reply.push_back(choice);
+ }
+ return true;
+ }
+
+ return false;
+ }
+
+ template <typename It>
+ bool Complete(It it, It end)
+ {
+ auto nextIt = it;
+ if (!readCompletion || (++nextIt != end))
+ {
+ return false;
+ }
+
+ const auto &chunk = *it;
+ auto pos = GetNextPositional();
+ std::vector<Command *> commands = GetCommands();
+ const auto optionType = ParseOption(chunk, true);
+
+ if (!commands.empty() && (chunk.empty() || optionType == OptionType::Positional))
+ {
+ for (auto &cmd : commands)
+ {
+ if ((cmd->GetOptions() & Options::HiddenFromCompletion) == Options::None)
+ {
+ AddCompletionReply(chunk, cmd->Name());
+ }
+ }
+ } else
+ {
+ bool hasPositionalCompletion = true;
+
+ if (!commands.empty())
+ {
+ for (auto &cmd : commands)
+ {
+ if ((cmd->GetOptions() & Options::HiddenFromCompletion) == Options::None)
+ {
+ AddCompletionReply(chunk, cmd->Name());
+ }
+ }
+ } else if (pos)
+ {
+ if ((pos->GetOptions() & Options::HiddenFromCompletion) == Options::None)
+ {
+ auto choices = pos->HelpChoices(helpParams);
+ hasPositionalCompletion = !choices.empty() || optionType != OptionType::Positional;
+ for (auto &choice : choices)
+ {
+ AddCompletionReply(chunk, choice);
+ }
+ }
+ }
+
+ if (hasPositionalCompletion)
+ {
+ auto flags = GetAllFlags();
+ for (auto flag : flags)
+ {
+ if ((flag->GetOptions() & Options::HiddenFromCompletion) != Options::None)
+ {
+ continue;
+ }
+
+ auto &matcher = flag->GetMatcher();
+ if (!AddCompletionReply(chunk, matcher.GetShortOrAny().str(shortprefix, longprefix)))
+ {
+ for (auto &flagName : matcher.GetFlagStrings())
+ {
+ if (AddCompletionReply(chunk, flagName.str(shortprefix, longprefix)))
+ {
+ break;
+ }
+ }
+ }
+ }
+
+ if (optionType == OptionType::LongFlag && allowJoinedLongValue)
+ {
+ const auto separator = longseparator.empty() ? chunk.npos : chunk.find(longseparator);
+ if (separator != chunk.npos)
+ {
+ std::string arg(chunk, 0, separator);
+ if (auto flag = this->Match(arg.substr(longprefix.size())))
+ {
+ for (auto &choice : flag->HelpChoices(helpParams))
+ {
+ AddCompletionReply(chunk, arg + longseparator + choice);
+ }
+ }
+ }
+ } else if (optionType == OptionType::ShortFlag && allowJoinedShortValue)
+ {
+ if (chunk.size() > shortprefix.size() + 1)
+ {
+ auto arg = chunk.at(shortprefix.size());
+ //TODO: support -abcVALUE where a and b take no value
+ if (auto flag = this->Match(arg))
+ {
+ for (auto &choice : flag->HelpChoices(helpParams))
+ {
+ AddCompletionReply(chunk, shortprefix + arg + choice);
+ }
+ }
+ }
+ }
+ }
+ }
+
+#ifndef ARGS_NOEXCEPT
+ throw Completion(completion->Get());
+#else
+ return true;
+#endif
+ }
+
+ template <typename It>
+ It Parse(It begin, It end)
+ {
+ bool terminated = false;
+ std::vector<Command *> commands = GetCommands();
+
+ // Check all arg chunks
+ for (auto it = begin; it != end; ++it)
+ {
+ if (Complete(it, end))
+ {
+ return end;
+ }
+
+ const auto &chunk = *it;
+
+ if (!terminated && chunk == terminator)
+ {
+ terminated = true;
+ } else if (!terminated && ParseOption(chunk) == OptionType::LongFlag)
+ {
+ if (!ParseLong(it, end))
+ {
+ return it;
+ }
+ } else if (!terminated && ParseOption(chunk) == OptionType::ShortFlag)
+ {
+ if (!ParseShort(it, end))
+ {
+ return it;
+ }
+ } else if (!terminated && !commands.empty())
+ {
+ auto itCommand = std::find_if(commands.begin(), commands.end(), [&chunk](Command *c) { return c->Name() == chunk; });
+ if (itCommand == commands.end())
+ {
+ const std::string errorMessage("Unknown command: " + chunk);
+#ifndef ARGS_NOEXCEPT
+ throw ParseError(errorMessage);
+#else
+ error = Error::Parse;
+ errorMsg = errorMessage;
+ return it;
+#endif
+ }
+
+ SelectCommand(*itCommand);
+
+ if (const auto &coroutine = GetCoroutine())
+ {
+ ++it;
+ RaiiSubparser coro(*this, std::vector<std::string>(it, end));
+ coroutine(coro.Parser());
+#ifdef ARGS_NOEXCEPT
+ error = GetError();
+ if (error != Error::None)
+ {
+ return end;
+ }
+
+ if (!coro.Parser().IsParsed())
+ {
+ error = Error::Usage;
+ return end;
+ }
+#else
+ if (!coro.Parser().IsParsed())
+ {
+ throw UsageError("Subparser::Parse was not called");
+ }
+#endif
+
+ break;
+ }
+
+ commands = GetCommands();
+ } else
+ {
+ auto pos = GetNextPositional();
+ if (pos)
+ {
+ pos->ParseValue(chunk);
+
+ if (pos->KickOut())
+ {
+ return ++it;
+ }
+ } else
+ {
+ const std::string errorMessage("Passed in argument, but no positional arguments were ready to receive it: " + chunk);
+#ifndef ARGS_NOEXCEPT
+ throw ParseError(errorMessage);
+#else
+ error = Error::Parse;
+ errorMsg = errorMessage;
+ return it;
+#endif
+ }
+ }
+
+ if (!readCompletion && completion != nullptr && completion->Matched())
+ {
+#ifdef ARGS_NOEXCEPT
+ error = Error::Completion;
+#endif
+ readCompletion = true;
+ ++it;
+ size_t argsLeft = std::distance(it, end);
+ if (completion->cword == 0 || argsLeft <= 1 || completion->cword >= argsLeft)
+ {
+#ifndef ARGS_NOEXCEPT
+ throw Completion("");
+#endif
+ }
+
+ std::vector<std::string> curArgs(++it, end);
+ curArgs.resize(completion->cword);
+
+ if (completion->syntax == "bash")
+ {
+ // bash tokenizes --flag=value as --flag=value
+ for (size_t idx = 0; idx < curArgs.size(); )
+ {
+ if (idx > 0 && curArgs[idx] == "=")
+ {
+ curArgs[idx - 1] += "=";
+ if (idx + 1 < curArgs.size())
+ {
+ curArgs[idx - 1] += curArgs[idx + 1];
+ curArgs.erase(curArgs.begin() + idx, curArgs.begin() + idx + 2);
+ } else
+ {
+ curArgs.erase(curArgs.begin() + idx);
+ }
+ } else
+ {
+ ++idx;
+ }
+ }
+
+ }
+#ifndef ARGS_NOEXCEPT
+ try
+ {
+ Parse(curArgs.begin(), curArgs.end());
+ throw Completion("");
+ }
+ catch (Completion &)
+ {
+ throw;
+ }
+ catch (args::Error&)
+ {
+ throw Completion("");
+ }
+#else
+ return Parse(curArgs.begin(), curArgs.end());
+#endif
+ }
+ }
+
+ Validate(shortprefix, longprefix);
+ return end;
+ }
+
+ public:
+ HelpParams helpParams;
+
+ ArgumentParser(const std::string &description_, const std::string &epilog_ = std::string())
+ {
+ Description(description_);
+ Epilog(epilog_);
+ LongPrefix("--");
+ ShortPrefix("-");
+ LongSeparator("=");
+ Terminator("--");
+ SetArgumentSeparations(true, true, true, true);
+ matched = true;
+ }
+
+ void AddCompletion(CompletionFlag &completionFlag)
+ {
+ completion = &completionFlag;
+ Add(completionFlag);
+ }
+
+ /** The program name for help generation
+ */
+ const std::string &Prog() const
+ { return helpParams.programName; }
+ /** The program name for help generation
+ */
+ void Prog(const std::string &prog_)
+ { this->helpParams.programName = prog_; }
+
+ /** The prefix for long flags
+ */
+ const std::string &LongPrefix() const
+ { return longprefix; }
+ /** The prefix for long flags
+ */
+ void LongPrefix(const std::string &longprefix_)
+ {
+ this->longprefix = longprefix_;
+ this->helpParams.longPrefix = longprefix_;
+ }
+
+ /** The prefix for short flags
+ */
+ const std::string &ShortPrefix() const
+ { return shortprefix; }
+ /** The prefix for short flags
+ */
+ void ShortPrefix(const std::string &shortprefix_)
+ {
+ this->shortprefix = shortprefix_;
+ this->helpParams.shortPrefix = shortprefix_;
+ }
+
+ /** The separator for long flags
+ */
+ const std::string &LongSeparator() const
+ { return longseparator; }
+ /** The separator for long flags
+ */
+ void LongSeparator(const std::string &longseparator_)
+ {
+ if (longseparator_.empty())
+ {
+ const std::string errorMessage("longseparator can not be set to empty");
+#ifdef ARGS_NOEXCEPT
+ error = Error::Usage;
+ errorMsg = errorMessage;
+#else
+ throw UsageError(errorMessage);
+#endif
+ } else
+ {
+ this->longseparator = longseparator_;
+ this->helpParams.longSeparator = allowJoinedLongValue ? longseparator_ : " ";
+ }
+ }
+
+ /** The terminator that forcibly separates flags from positionals
+ */
+ const std::string &Terminator() const
+ { return terminator; }
+ /** The terminator that forcibly separates flags from positionals
+ */
+ void Terminator(const std::string &terminator_)
+ { this->terminator = terminator_; }
+
+ /** Get the current argument separation parameters.
+ *
+ * See SetArgumentSeparations for details on what each one means.
+ */
+ void GetArgumentSeparations(
+ bool &allowJoinedShortValue_,
+ bool &allowJoinedLongValue_,
+ bool &allowSeparateShortValue_,
+ bool &allowSeparateLongValue_) const
+ {
+ allowJoinedShortValue_ = this->allowJoinedShortValue;
+ allowJoinedLongValue_ = this->allowJoinedLongValue;
+ allowSeparateShortValue_ = this->allowSeparateShortValue;
+ allowSeparateLongValue_ = this->allowSeparateLongValue;
+ }
+
+ /** Change allowed option separation.
+ *
+ * \param allowJoinedShortValue_ Allow a short flag that accepts an argument to be passed its argument immediately next to it (ie. in the same argv field)
+ * \param allowJoinedLongValue_ Allow a long flag that accepts an argument to be passed its argument separated by the longseparator (ie. in the same argv field)
+ * \param allowSeparateShortValue_ Allow a short flag that accepts an argument to be passed its argument separated by whitespace (ie. in the next argv field)
+ * \param allowSeparateLongValue_ Allow a long flag that accepts an argument to be passed its argument separated by whitespace (ie. in the next argv field)
+ */
+ void SetArgumentSeparations(
+ const bool allowJoinedShortValue_,
+ const bool allowJoinedLongValue_,
+ const bool allowSeparateShortValue_,
+ const bool allowSeparateLongValue_)
+ {
+ this->allowJoinedShortValue = allowJoinedShortValue_;
+ this->allowJoinedLongValue = allowJoinedLongValue_;
+ this->allowSeparateShortValue = allowSeparateShortValue_;
+ this->allowSeparateLongValue = allowSeparateLongValue_;
+
+ this->helpParams.longSeparator = allowJoinedLongValue ? longseparator : " ";
+ this->helpParams.shortSeparator = allowJoinedShortValue ? "" : " ";
+ }
+
+ /** Pass the help menu into an ostream
+ */
+ void Help(std::ostream &help_) const
+ {
+ auto &command = SelectedCommand();
+ const auto &commandDescription = command.Description().empty() ? command.Help() : command.Description();
+ const auto description_text = Wrap(commandDescription, helpParams.width - helpParams.descriptionindent);
+ const auto epilog_text = Wrap(command.Epilog(), helpParams.width - helpParams.descriptionindent);
+
+ const bool hasoptions = command.HasFlag();
+ const bool hasarguments = command.HasPositional();
+
+ std::vector<std::string> prognameline;
+ prognameline.push_back(helpParams.usageString);
+ prognameline.push_back(Prog());
+ auto commandProgLine = command.GetProgramLine(helpParams);
+ prognameline.insert(prognameline.end(), commandProgLine.begin(), commandProgLine.end());
+
+ const auto proglines = Wrap(prognameline.begin(), prognameline.end(),
+ helpParams.width - (helpParams.progindent + helpParams.progtailindent),
+ helpParams.width - helpParams.progindent);
+ auto progit = std::begin(proglines);
+ if (progit != std::end(proglines))
+ {
+ help_ << std::string(helpParams.progindent, ' ') << *progit << '\n';
+ ++progit;
+ }
+ for (; progit != std::end(proglines); ++progit)
+ {
+ help_ << std::string(helpParams.progtailindent, ' ') << *progit << '\n';
+ }
+
+ help_ << '\n';
+
+ if (!description_text.empty())
+ {
+ for (const auto &line: description_text)
+ {
+ help_ << std::string(helpParams.descriptionindent, ' ') << line << "\n";
+ }
+ help_ << "\n";
+ }
+
+ bool lastDescriptionIsNewline = false;
+
+ if (!helpParams.optionsString.empty())
+ {
+ help_ << std::string(helpParams.progindent, ' ') << helpParams.optionsString << "\n\n";
+ }
+
+ for (const auto &desc: command.GetDescription(helpParams, 0))
+ {
+ lastDescriptionIsNewline = std::get<0>(desc).empty() && std::get<1>(desc).empty();
+ const auto groupindent = std::get<2>(desc) * helpParams.eachgroupindent;
+ const auto flags = Wrap(std::get<0>(desc), helpParams.width - (helpParams.flagindent + helpParams.helpindent + helpParams.gutter));
+ const auto info = Wrap(std::get<1>(desc), helpParams.width - (helpParams.helpindent + groupindent));
+
+ std::string::size_type flagssize = 0;
+ for (auto flagsit = std::begin(flags); flagsit != std::end(flags); ++flagsit)
+ {
+ if (flagsit != std::begin(flags))
+ {
+ help_ << '\n';
+ }
+ help_ << std::string(groupindent + helpParams.flagindent, ' ') << *flagsit;
+ flagssize = Glyphs(*flagsit);
+ }
+
+ auto infoit = std::begin(info);
+ // groupindent is on both sides of this inequality, and therefore can be removed
+ if ((helpParams.flagindent + flagssize + helpParams.gutter) > helpParams.helpindent || infoit == std::end(info) || helpParams.addNewlineBeforeDescription)
+ {
+ help_ << '\n';
+ } else
+ {
+ // groupindent is on both sides of the minus sign, and therefore doesn't actually need to be in here
+ help_ << std::string(helpParams.helpindent - (helpParams.flagindent + flagssize), ' ') << *infoit << '\n';
+ ++infoit;
+ }
+ for (; infoit != std::end(info); ++infoit)
+ {
+ help_ << std::string(groupindent + helpParams.helpindent, ' ') << *infoit << '\n';
+ }
+ }
+ if (hasoptions && hasarguments && helpParams.showTerminator)
+ {
+ lastDescriptionIsNewline = false;
+ for (const auto &item: Wrap(std::string("\"") + terminator + "\" can be used to terminate flag options and force all following arguments to be treated as positional options", helpParams.width - helpParams.flagindent))
+ {
+ help_ << std::string(helpParams.flagindent, ' ') << item << '\n';
+ }
+ }
+
+ if (!lastDescriptionIsNewline)
+ {
+ help_ << "\n";
+ }
+
+ for (const auto &line: epilog_text)
+ {
+ help_ << std::string(helpParams.descriptionindent, ' ') << line << "\n";
+ }
+ }
+
+ /** Generate a help menu as a string.
+ *
+ * \return the help text as a single string
+ */
+ std::string Help() const
+ {
+ std::ostringstream help_;
+ Help(help_);
+ return help_.str();
+ }
+
+ virtual void Reset() noexcept override
+ {
+ Command::Reset();
+ matched = true;
+ readCompletion = false;
+ }
+
+ /** Parse all arguments.
+ *
+ * \param begin an iterator to the beginning of the argument list
+ * \param end an iterator to the past-the-end element of the argument list
+ * \return the iterator after the last parsed value. Only useful for kick-out
+ */
+ template <typename It>
+ It ParseArgs(It begin, It end)
+ {
+ // Reset all Matched statuses and errors
+ Reset();
+#ifdef ARGS_NOEXCEPT
+ error = GetError();
+ if (error != Error::None)
+ {
+ return end;
+ }
+#endif
+ return Parse(begin, end);
+ }
+
+ /** Parse all arguments.
+ *
+ * \param args an iterable of the arguments
+ * \return the iterator after the last parsed value. Only useful for kick-out
+ */
+ template <typename T>
+ auto ParseArgs(const T &args) -> decltype(std::begin(args))
+ {
+ return ParseArgs(std::begin(args), std::end(args));
+ }
+
+ /** Convenience function to parse the CLI from argc and argv
+ *
+ * Just assigns the program name and vectorizes arguments for passing into ParseArgs()
+ *
+ * \return whether or not all arguments were parsed. This works for detecting kick-out, but is generally useless as it can't do anything with it.
+ */
+ bool ParseCLI(const int argc, const char * const * argv)
+ {
+ if (Prog().empty())
+ {
+ Prog(argv[0]);
+ }
+ const std::vector<std::string> args(argv + 1, argv + argc);
+ return ParseArgs(args) == std::end(args);
+ }
+
+ template <typename T>
+ bool ParseCLI(const T &args)
+ {
+ return ParseArgs(args) == std::end(args);
+ }
+ };
+
+ inline Command::RaiiSubparser::RaiiSubparser(ArgumentParser &parser_, std::vector<std::string> args_)
+ : command(parser_.SelectedCommand()), parser(std::move(args_), parser_, command, parser_.helpParams), oldSubparser(command.subparser)
+ {
+ command.subparser = &parser;
+ }
+
+ inline Command::RaiiSubparser::RaiiSubparser(const Command &command_, const HelpParams ¶ms_): command(command_), parser(command, params_), oldSubparser(command.subparser)
+ {
+ command.subparser = &parser;
+ }
+
+ inline void Subparser::Parse()
+ {
+ isParsed = true;
+ Reset();
+ command.subparserDescription = GetDescription(helpParams, 0);
+ command.subparserHasFlag = HasFlag();
+ command.subparserHasPositional = HasPositional();
+ command.subparserHasCommand = HasCommand();
+ command.subparserProgramLine = GetProgramLine(helpParams);
+ if (parser == nullptr)
+ {
+#ifndef ARGS_NOEXCEPT
+ throw args::SubparserError();
+#else
+ error = Error::Subparser;
+ return;
+#endif
+ }
+
+ auto it = parser->Parse(args.begin(), args.end());
+ command.Validate(parser->ShortPrefix(), parser->LongPrefix());
+ kicked.assign(it, args.end());
+
+#ifdef ARGS_NOEXCEPT
+ command.subparserError = GetError();
+#endif
+ }
+
+ inline std::ostream &operator<<(std::ostream &os, const ArgumentParser &parser)
+ {
+ parser.Help(os);
+ return os;
+ }
+
+ /** Boolean argument matcher
+ */
+ class Flag : public FlagBase
+ {
+ public:
+ Flag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_): FlagBase(name_, help_, std::move(matcher_), options_)
+ {
+ group_.Add(*this);
+ }
+
+ Flag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const bool extraError_ = false): Flag(group_, name_, help_, std::move(matcher_), extraError_ ? Options::Single : Options::None)
+ {
+ }
+
+ virtual ~Flag() {}
+
+ /** Get whether this was matched
+ */
+ bool Get() const
+ {
+ return Matched();
+ }
+
+ virtual Nargs NumberOfArguments() const noexcept override
+ {
+ return 0;
+ }
+
+ virtual void ParseValue(const std::vector<std::string>&) override
+ {
+ }
+ };
+
+ /** Help flag class
+ *
+ * Works like a regular flag, but throws an instance of Help when it is matched
+ */
+ class HelpFlag : public Flag
+ {
+ public:
+ HelpFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_ = {}): Flag(group_, name_, help_, std::move(matcher_), options_) {}
+
+ virtual ~HelpFlag() {}
+
+ virtual void ParseValue(const std::vector<std::string> &)
+ {
+#ifdef ARGS_NOEXCEPT
+ error = Error::Help;
+ errorMsg = Name();
+#else
+ throw Help(Name());
+#endif
+ }
+
+ /** Get whether this was matched
+ */
+ bool Get() const noexcept
+ {
+ return Matched();
+ }
+ };
+
+ /** A flag class that simply counts the number of times it's matched
+ */
+ class CounterFlag : public Flag
+ {
+ private:
+ const int startcount;
+ int count;
+
+ public:
+ CounterFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const int startcount_ = 0, Options options_ = {}):
+ Flag(group_, name_, help_, std::move(matcher_), options_), startcount(startcount_), count(startcount_) {}
+
+ virtual ~CounterFlag() {}
+
+ virtual FlagBase *Match(const EitherFlag &arg) override
+ {
+ auto me = FlagBase::Match(arg);
+ if (me)
+ {
+ ++count;
+ }
+ return me;
+ }
+
+ /** Get the count
+ */
+ int &Get() noexcept
+ {
+ return count;
+ }
+
+ virtual void Reset() noexcept override
+ {
+ FlagBase::Reset();
+ count = startcount;
+ }
+ };
+
+ /** A flag class that calls a function when it's matched
+ */
+ class ActionFlag : public FlagBase
+ {
+ private:
+ std::function<void(const std::vector<std::string> &)> action;
+ Nargs nargs;
+
+ public:
+ ActionFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Nargs nargs_, std::function<void(const std::vector<std::string> &)> action_, Options options_ = {}):
+ FlagBase(name_, help_, std::move(matcher_), options_), action(std::move(action_)), nargs(nargs_)
+ {
+ group_.Add(*this);
+ }
+
+ ActionFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, std::function<void(const std::string &)> action_, Options options_ = {}):
+ FlagBase(name_, help_, std::move(matcher_), options_), nargs(1)
+ {
+ group_.Add(*this);
+ action = [action_](const std::vector<std::string> &a) { return action_(a.at(0)); };
+ }
+
+ ActionFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, std::function<void()> action_, Options options_ = {}):
+ FlagBase(name_, help_, std::move(matcher_), options_), nargs(0)
+ {
+ group_.Add(*this);
+ action = [action_](const std::vector<std::string> &) { return action_(); };
+ }
+
+ virtual Nargs NumberOfArguments() const noexcept override
+ { return nargs; }
+
+ virtual void ParseValue(const std::vector<std::string> &value) override
+ { action(value); }
+ };
+
+ /** A default Reader class for argument classes
+ *
+ * If destination type is assignable to std::string it uses an assignment to std::string.
+ * Otherwise ValueReader simply uses a std::istringstream to read into the destination type, and
+ * raises a ParseError if there are any characters left.
+ */
+ struct ValueReader
+ {
+ template <typename T>
+ typename std::enable_if<!std::is_assignable<T, std::string>::value, bool>::type
+ operator ()(const std::string &name, const std::string &value, T &destination)
+ {
+ std::istringstream ss(value);
+ ss >> destination >> std::ws;
+
+ if (ss.rdbuf()->in_avail() > 0)
+ {
+#ifdef ARGS_NOEXCEPT
+ (void)name;
+ return false;
+#else
+ std::ostringstream problem;
+ problem << "Argument '" << name << "' received invalid value type '" << value << "'";
+ throw ParseError(problem.str());
+#endif
+ }
+ return true;
+ }
+
+ template <typename T>
+ typename std::enable_if<std::is_assignable<T, std::string>::value, bool>::type
+ operator()(const std::string &, const std::string &value, T &destination)
+ {
+ destination = value;
+ return true;
+ }
+ };
+
+ /** An argument-accepting flag class
+ *
+ * \tparam T the type to extract the argument as
+ * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+ */
+ template <
+ typename T,
+ typename Reader = ValueReader>
+ class ValueFlag : public ValueFlagBase
+ {
+ protected:
+ T value;
+ T defaultValue;
+
+ virtual std::string GetDefaultString(const HelpParams&) const override
+ {
+ return detail::ToString(defaultValue);
+ }
+
+ private:
+ Reader reader;
+
+ public:
+
+ ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_, Options options_): ValueFlagBase(name_, help_, std::move(matcher_), options_), value(defaultValue_), defaultValue(defaultValue_)
+ {
+ group_.Add(*this);
+ }
+
+ ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_ = T(), const bool extraError_ = false): ValueFlag(group_, name_, help_, std::move(matcher_), defaultValue_, extraError_ ? Options::Single : Options::None)
+ {
+ }
+
+ ValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_): ValueFlag(group_, name_, help_, std::move(matcher_), T(), options_)
+ {
+ }
+
+ virtual ~ValueFlag() {}
+
+ virtual void ParseValue(const std::vector<std::string> &values_) override
+ {
+ const std::string &value_ = values_.at(0);
+
+#ifdef ARGS_NOEXCEPT
+ if (!reader(name, value_, this->value))
+ {
+ error = Error::Parse;
+ }
+#else
+ reader(name, value_, this->value);
+#endif
+ }
+
+ virtual void Reset() noexcept override
+ {
+ ValueFlagBase::Reset();
+ value = defaultValue;
+ }
+
+ /** Get the value
+ */
+ T &Get() noexcept
+ {
+ return value;
+ }
+
+ /** Get the default value
+ */
+ const T &GetDefault() noexcept
+ {
+ return defaultValue;
+ }
+ };
+
+ /** An optional argument-accepting flag class
+ *
+ * \tparam T the type to extract the argument as
+ * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+ */
+ template <
+ typename T,
+ typename Reader = ValueReader>
+ class ImplicitValueFlag : public ValueFlag<T, Reader>
+ {
+ protected:
+ T implicitValue;
+
+ public:
+
+ ImplicitValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &implicitValue_, const T &defaultValue_ = T(), Options options_ = {})
+ : ValueFlag<T, Reader>(group_, name_, help_, std::move(matcher_), defaultValue_, options_), implicitValue(implicitValue_)
+ {
+ }
+
+ ImplicitValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const T &defaultValue_ = T(), Options options_ = {})
+ : ValueFlag<T, Reader>(group_, name_, help_, std::move(matcher_), defaultValue_, options_), implicitValue(defaultValue_)
+ {
+ }
+
+ ImplicitValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Options options_)
+ : ValueFlag<T, Reader>(group_, name_, help_, std::move(matcher_), {}, options_), implicitValue()
+ {
+ }
+
+ virtual ~ImplicitValueFlag() {}
+
+ virtual Nargs NumberOfArguments() const noexcept override
+ {
+ return {0, 1};
+ }
+
+ virtual void ParseValue(const std::vector<std::string> &value_) override
+ {
+ if (value_.empty())
+ {
+ this->value = implicitValue;
+ } else
+ {
+ ValueFlag<T, Reader>::ParseValue(value_);
+ }
+ }
+ };
+
+ /** A variadic arguments accepting flag class
+ *
+ * \tparam T the type to extract the argument as
+ * \tparam List the list type that houses the values
+ * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+ */
+ template <
+ typename T,
+ template <typename...> class List = std::vector,
+ typename Reader = ValueReader>
+ class NargsValueFlag : public FlagBase
+ {
+ protected:
+
+ List<T> values;
+ const List<T> defaultValues;
+ Nargs nargs;
+ Reader reader;
+
+ public:
+
+ typedef List<T> Container;
+ typedef T value_type;
+ typedef typename Container::allocator_type allocator_type;
+ typedef typename Container::pointer pointer;
+ typedef typename Container::const_pointer const_pointer;
+ typedef T& reference;
+ typedef const T& const_reference;
+ typedef typename Container::size_type size_type;
+ typedef typename Container::difference_type difference_type;
+ typedef typename Container::iterator iterator;
+ typedef typename Container::const_iterator const_iterator;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ NargsValueFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, Nargs nargs_, const List<T> &defaultValues_ = {}, Options options_ = {})
+ : FlagBase(name_, help_, std::move(matcher_), options_), values(defaultValues_), defaultValues(defaultValues_),nargs(nargs_)
+ {
+ group_.Add(*this);
+ }
+
+ virtual ~NargsValueFlag() {}
+
+ virtual Nargs NumberOfArguments() const noexcept override
+ {
+ return nargs;
+ }
+
+ virtual void ParseValue(const std::vector<std::string> &values_) override
+ {
+ values.clear();
+
+ for (const std::string &value : values_)
+ {
+ T v;
+#ifdef ARGS_NOEXCEPT
+ if (!reader(name, value, v))
+ {
+ error = Error::Parse;
+ }
+#else
+ reader(name, value, v);
+#endif
+ values.insert(std::end(values), v);
+ }
+ }
+
+ List<T> &Get() noexcept
+ {
+ return values;
+ }
+
+ iterator begin() noexcept
+ {
+ return values.begin();
+ }
+
+ const_iterator begin() const noexcept
+ {
+ return values.begin();
+ }
+
+ const_iterator cbegin() const noexcept
+ {
+ return values.cbegin();
+ }
+
+ iterator end() noexcept
+ {
+ return values.end();
+ }
+
+ const_iterator end() const noexcept
+ {
+ return values.end();
+ }
+
+ const_iterator cend() const noexcept
+ {
+ return values.cend();
+ }
+
+ virtual void Reset() noexcept override
+ {
+ FlagBase::Reset();
+ values = defaultValues;
+ }
+
+ virtual FlagBase *Match(const EitherFlag &arg) override
+ {
+ const bool wasMatched = Matched();
+ auto me = FlagBase::Match(arg);
+ if (me && !wasMatched)
+ {
+ values.clear();
+ }
+ return me;
+ }
+ };
+
+ /** An argument-accepting flag class that pushes the found values into a list
+ *
+ * \tparam T the type to extract the argument as
+ * \tparam List the list type that houses the values
+ * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+ */
+ template <
+ typename T,
+ template <typename...> class List = std::vector,
+ typename Reader = ValueReader>
+ class ValueFlagList : public ValueFlagBase
+ {
+ private:
+ using Container = List<T>;
+ Container values;
+ const Container defaultValues;
+ Reader reader;
+
+ public:
+
+ typedef T value_type;
+ typedef typename Container::allocator_type allocator_type;
+ typedef typename Container::pointer pointer;
+ typedef typename Container::const_pointer const_pointer;
+ typedef T& reference;
+ typedef const T& const_reference;
+ typedef typename Container::size_type size_type;
+ typedef typename Container::difference_type difference_type;
+ typedef typename Container::iterator iterator;
+ typedef typename Container::const_iterator const_iterator;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ ValueFlagList(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Container &defaultValues_ = Container(), Options options_ = {}):
+ ValueFlagBase(name_, help_, std::move(matcher_), options_), values(defaultValues_), defaultValues(defaultValues_)
+ {
+ group_.Add(*this);
+ }
+
+ virtual ~ValueFlagList() {}
+
+ virtual void ParseValue(const std::vector<std::string> &values_) override
+ {
+ const std::string &value_ = values_.at(0);
+
+ T v;
+#ifdef ARGS_NOEXCEPT
+ if (!reader(name, value_, v))
+ {
+ error = Error::Parse;
+ }
+#else
+ reader(name, value_, v);
+#endif
+ values.insert(std::end(values), v);
+ }
+
+ /** Get the values
+ */
+ Container &Get() noexcept
+ {
+ return values;
+ }
+
+ virtual std::string Name() const override
+ {
+ return name + std::string("...");
+ }
+
+ virtual void Reset() noexcept override
+ {
+ ValueFlagBase::Reset();
+ values = defaultValues;
+ }
+
+ virtual FlagBase *Match(const EitherFlag &arg) override
+ {
+ const bool wasMatched = Matched();
+ auto me = FlagBase::Match(arg);
+ if (me && !wasMatched)
+ {
+ values.clear();
+ }
+ return me;
+ }
+
+ iterator begin() noexcept
+ {
+ return values.begin();
+ }
+
+ const_iterator begin() const noexcept
+ {
+ return values.begin();
+ }
+
+ const_iterator cbegin() const noexcept
+ {
+ return values.cbegin();
+ }
+
+ iterator end() noexcept
+ {
+ return values.end();
+ }
+
+ const_iterator end() const noexcept
+ {
+ return values.end();
+ }
+
+ const_iterator cend() const noexcept
+ {
+ return values.cend();
+ }
+ };
+
+ /** A mapping value flag class
+ *
+ * \tparam K the type to extract the argument as
+ * \tparam T the type to store the result as
+ * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+ * \tparam Map The Map type. Should operate like std::map or std::unordered_map
+ */
+ template <
+ typename K,
+ typename T,
+ typename Reader = ValueReader,
+ template <typename...> class Map = std::unordered_map>
+ class MapFlag : public ValueFlagBase
+ {
+ private:
+ const Map<K, T> map;
+ T value;
+ const T defaultValue;
+ Reader reader;
+
+ protected:
+ virtual std::vector<std::string> GetChoicesStrings(const HelpParams &) const override
+ {
+ return detail::MapKeysToStrings(map);
+ }
+
+ public:
+
+ MapFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Map<K, T> &map_, const T &defaultValue_, Options options_): ValueFlagBase(name_, help_, std::move(matcher_), options_), map(map_), value(defaultValue_), defaultValue(defaultValue_)
+ {
+ group_.Add(*this);
+ }
+
+ MapFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Map<K, T> &map_, const T &defaultValue_ = T(), const bool extraError_ = false): MapFlag(group_, name_, help_, std::move(matcher_), map_, defaultValue_, extraError_ ? Options::Single : Options::None)
+ {
+ }
+
+ MapFlag(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Map<K, T> &map_, Options options_): MapFlag(group_, name_, help_, std::move(matcher_), map_, T(), options_)
+ {
+ }
+
+ virtual ~MapFlag() {}
+
+ virtual void ParseValue(const std::vector<std::string> &values_) override
+ {
+ const std::string &value_ = values_.at(0);
+
+ K key;
+#ifdef ARGS_NOEXCEPT
+ if (!reader(name, value_, key))
+ {
+ error = Error::Parse;
+ }
+#else
+ reader(name, value_, key);
+#endif
+ auto it = map.find(key);
+ if (it == std::end(map))
+ {
+ std::ostringstream problem;
+ problem << "Could not find key '" << key << "' in map for arg '" << name << "'";
+#ifdef ARGS_NOEXCEPT
+ error = Error::Map;
+ errorMsg = problem.str();
+#else
+ throw MapError(problem.str());
+#endif
+ } else
+ {
+ this->value = it->second;
+ }
+ }
+
+ /** Get the value
+ */
+ T &Get() noexcept
+ {
+ return value;
+ }
+
+ virtual void Reset() noexcept override
+ {
+ ValueFlagBase::Reset();
+ value = defaultValue;
+ }
+ };
+
+ /** A mapping value flag list class
+ *
+ * \tparam K the type to extract the argument as
+ * \tparam T the type to store the result as
+ * \tparam List the list type that houses the values
+ * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+ * \tparam Map The Map type. Should operate like std::map or std::unordered_map
+ */
+ template <
+ typename K,
+ typename T,
+ template <typename...> class List = std::vector,
+ typename Reader = ValueReader,
+ template <typename...> class Map = std::unordered_map>
+ class MapFlagList : public ValueFlagBase
+ {
+ private:
+ using Container = List<T>;
+ const Map<K, T> map;
+ Container values;
+ const Container defaultValues;
+ Reader reader;
+
+ protected:
+ virtual std::vector<std::string> GetChoicesStrings(const HelpParams &) const override
+ {
+ return detail::MapKeysToStrings(map);
+ }
+
+ public:
+ typedef T value_type;
+ typedef typename Container::allocator_type allocator_type;
+ typedef typename Container::pointer pointer;
+ typedef typename Container::const_pointer const_pointer;
+ typedef T& reference;
+ typedef const T& const_reference;
+ typedef typename Container::size_type size_type;
+ typedef typename Container::difference_type difference_type;
+ typedef typename Container::iterator iterator;
+ typedef typename Container::const_iterator const_iterator;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ MapFlagList(Group &group_, const std::string &name_, const std::string &help_, Matcher &&matcher_, const Map<K, T> &map_, const Container &defaultValues_ = Container()): ValueFlagBase(name_, help_, std::move(matcher_)), map(map_), values(defaultValues_), defaultValues(defaultValues_)
+ {
+ group_.Add(*this);
+ }
+
+ virtual ~MapFlagList() {}
+
+ virtual void ParseValue(const std::vector<std::string> &values_) override
+ {
+ const std::string &value = values_.at(0);
+
+ K key;
+#ifdef ARGS_NOEXCEPT
+ if (!reader(name, value, key))
+ {
+ error = Error::Parse;
+ }
+#else
+ reader(name, value, key);
+#endif
+ auto it = map.find(key);
+ if (it == std::end(map))
+ {
+ std::ostringstream problem;
+ problem << "Could not find key '" << key << "' in map for arg '" << name << "'";
+#ifdef ARGS_NOEXCEPT
+ error = Error::Map;
+ errorMsg = problem.str();
+#else
+ throw MapError(problem.str());
+#endif
+ } else
+ {
+ this->values.emplace_back(it->second);
+ }
+ }
+
+ /** Get the value
+ */
+ Container &Get() noexcept
+ {
+ return values;
+ }
+
+ virtual std::string Name() const override
+ {
+ return name + std::string("...");
+ }
+
+ virtual void Reset() noexcept override
+ {
+ ValueFlagBase::Reset();
+ values = defaultValues;
+ }
+
+ virtual FlagBase *Match(const EitherFlag &arg) override
+ {
+ const bool wasMatched = Matched();
+ auto me = FlagBase::Match(arg);
+ if (me && !wasMatched)
+ {
+ values.clear();
+ }
+ return me;
+ }
+
+ iterator begin() noexcept
+ {
+ return values.begin();
+ }
+
+ const_iterator begin() const noexcept
+ {
+ return values.begin();
+ }
+
+ const_iterator cbegin() const noexcept
+ {
+ return values.cbegin();
+ }
+
+ iterator end() noexcept
+ {
+ return values.end();
+ }
+
+ const_iterator end() const noexcept
+ {
+ return values.end();
+ }
+
+ const_iterator cend() const noexcept
+ {
+ return values.cend();
+ }
+ };
+
+ /** A positional argument class
+ *
+ * \tparam T the type to extract the argument as
+ * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+ */
+ template <
+ typename T,
+ typename Reader = ValueReader>
+ class Positional : public PositionalBase
+ {
+ private:
+ T value;
+ const T defaultValue;
+ Reader reader;
+ public:
+ Positional(Group &group_, const std::string &name_, const std::string &help_, const T &defaultValue_ = T(), Options options_ = {}): PositionalBase(name_, help_, options_), value(defaultValue_), defaultValue(defaultValue_)
+ {
+ group_.Add(*this);
+ }
+
+ Positional(Group &group_, const std::string &name_, const std::string &help_, Options options_): Positional(group_, name_, help_, T(), options_)
+ {
+ }
+
+ virtual ~Positional() {}
+
+ virtual void ParseValue(const std::string &value_) override
+ {
+#ifdef ARGS_NOEXCEPT
+ if (!reader(name, value_, this->value))
+ {
+ error = Error::Parse;
+ }
+#else
+ reader(name, value_, this->value);
+#endif
+ ready = false;
+ matched = true;
+ }
+
+ /** Get the value
+ */
+ T &Get() noexcept
+ {
+ return value;
+ }
+
+ virtual void Reset() noexcept override
+ {
+ PositionalBase::Reset();
+ value = defaultValue;
+ }
+ };
+
+ /** A positional argument class that pushes the found values into a list
+ *
+ * \tparam T the type to extract the argument as
+ * \tparam List the list type that houses the values
+ * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+ */
+ template <
+ typename T,
+ template <typename...> class List = std::vector,
+ typename Reader = ValueReader>
+ class PositionalList : public PositionalBase
+ {
+ private:
+ using Container = List<T>;
+ Container values;
+ const Container defaultValues;
+ Reader reader;
+
+ public:
+ typedef T value_type;
+ typedef typename Container::allocator_type allocator_type;
+ typedef typename Container::pointer pointer;
+ typedef typename Container::const_pointer const_pointer;
+ typedef T& reference;
+ typedef const T& const_reference;
+ typedef typename Container::size_type size_type;
+ typedef typename Container::difference_type difference_type;
+ typedef typename Container::iterator iterator;
+ typedef typename Container::const_iterator const_iterator;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ PositionalList(Group &group_, const std::string &name_, const std::string &help_, const Container &defaultValues_ = Container(), Options options_ = {}): PositionalBase(name_, help_, options_), values(defaultValues_), defaultValues(defaultValues_)
+ {
+ group_.Add(*this);
+ }
+
+ PositionalList(Group &group_, const std::string &name_, const std::string &help_, Options options_): PositionalList(group_, name_, help_, {}, options_)
+ {
+ }
+
+ virtual ~PositionalList() {}
+
+ virtual void ParseValue(const std::string &value_) override
+ {
+ T v;
+#ifdef ARGS_NOEXCEPT
+ if (!reader(name, value_, v))
+ {
+ error = Error::Parse;
+ }
+#else
+ reader(name, value_, v);
+#endif
+ values.insert(std::end(values), v);
+ matched = true;
+ }
+
+ virtual std::string Name() const override
+ {
+ return name + std::string("...");
+ }
+
+ /** Get the values
+ */
+ Container &Get() noexcept
+ {
+ return values;
+ }
+
+ virtual void Reset() noexcept override
+ {
+ PositionalBase::Reset();
+ values = defaultValues;
+ }
+
+ virtual PositionalBase *GetNextPositional() override
+ {
+ const bool wasMatched = Matched();
+ auto me = PositionalBase::GetNextPositional();
+ if (me && !wasMatched)
+ {
+ values.clear();
+ }
+ return me;
+ }
+
+ iterator begin() noexcept
+ {
+ return values.begin();
+ }
+
+ const_iterator begin() const noexcept
+ {
+ return values.begin();
+ }
+
+ const_iterator cbegin() const noexcept
+ {
+ return values.cbegin();
+ }
+
+ iterator end() noexcept
+ {
+ return values.end();
+ }
+
+ const_iterator end() const noexcept
+ {
+ return values.end();
+ }
+
+ const_iterator cend() const noexcept
+ {
+ return values.cend();
+ }
+ };
+
+ /** A positional argument mapping class
+ *
+ * \tparam K the type to extract the argument as
+ * \tparam T the type to store the result as
+ * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+ * \tparam Map The Map type. Should operate like std::map or std::unordered_map
+ */
+ template <
+ typename K,
+ typename T,
+ typename Reader = ValueReader,
+ template <typename...> class Map = std::unordered_map>
+ class MapPositional : public PositionalBase
+ {
+ private:
+ const Map<K, T> map;
+ T value;
+ const T defaultValue;
+ Reader reader;
+
+ protected:
+ virtual std::vector<std::string> GetChoicesStrings(const HelpParams &) const override
+ {
+ return detail::MapKeysToStrings(map);
+ }
+
+ public:
+
+ MapPositional(Group &group_, const std::string &name_, const std::string &help_, const Map<K, T> &map_, const T &defaultValue_ = T(), Options options_ = {}):
+ PositionalBase(name_, help_, options_), map(map_), value(defaultValue_), defaultValue(defaultValue_)
+ {
+ group_.Add(*this);
+ }
+
+ virtual ~MapPositional() {}
+
+ virtual void ParseValue(const std::string &value_) override
+ {
+ K key;
+#ifdef ARGS_NOEXCEPT
+ if (!reader(name, value_, key))
+ {
+ error = Error::Parse;
+ }
+#else
+ reader(name, value_, key);
+#endif
+ auto it = map.find(key);
+ if (it == std::end(map))
+ {
+ std::ostringstream problem;
+ problem << "Could not find key '" << key << "' in map for arg '" << name << "'";
+#ifdef ARGS_NOEXCEPT
+ error = Error::Map;
+ errorMsg = problem.str();
+#else
+ throw MapError(problem.str());
+#endif
+ } else
+ {
+ this->value = it->second;
+ ready = false;
+ matched = true;
+ }
+ }
+
+ /** Get the value
+ */
+ T &Get() noexcept
+ {
+ return value;
+ }
+
+ virtual void Reset() noexcept override
+ {
+ PositionalBase::Reset();
+ value = defaultValue;
+ }
+ };
+
+ /** A positional argument mapping list class
+ *
+ * \tparam K the type to extract the argument as
+ * \tparam T the type to store the result as
+ * \tparam List the list type that houses the values
+ * \tparam Reader The functor type used to read the argument, taking the name, value, and destination reference with operator(), and returning a bool (if ARGS_NOEXCEPT is defined)
+ * \tparam Map The Map type. Should operate like std::map or std::unordered_map
+ */
+ template <
+ typename K,
+ typename T,
+ template <typename...> class List = std::vector,
+ typename Reader = ValueReader,
+ template <typename...> class Map = std::unordered_map>
+ class MapPositionalList : public PositionalBase
+ {
+ private:
+ using Container = List<T>;
+
+ const Map<K, T> map;
+ Container values;
+ const Container defaultValues;
+ Reader reader;
+
+ protected:
+ virtual std::vector<std::string> GetChoicesStrings(const HelpParams &) const override
+ {
+ return detail::MapKeysToStrings(map);
+ }
+
+ public:
+ typedef T value_type;
+ typedef typename Container::allocator_type allocator_type;
+ typedef typename Container::pointer pointer;
+ typedef typename Container::const_pointer const_pointer;
+ typedef T& reference;
+ typedef const T& const_reference;
+ typedef typename Container::size_type size_type;
+ typedef typename Container::difference_type difference_type;
+ typedef typename Container::iterator iterator;
+ typedef typename Container::const_iterator const_iterator;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ MapPositionalList(Group &group_, const std::string &name_, const std::string &help_, const Map<K, T> &map_, const Container &defaultValues_ = Container(), Options options_ = {}):
+ PositionalBase(name_, help_, options_), map(map_), values(defaultValues_), defaultValues(defaultValues_)
+ {
+ group_.Add(*this);
+ }
+
+ virtual ~MapPositionalList() {}
+
+ virtual void ParseValue(const std::string &value_) override
+ {
+ K key;
+#ifdef ARGS_NOEXCEPT
+ if (!reader(name, value_, key))
+ {
+ error = Error::Parse;
+ }
+#else
+ reader(name, value_, key);
+#endif
+ auto it = map.find(key);
+ if (it == std::end(map))
+ {
+ std::ostringstream problem;
+ problem << "Could not find key '" << key << "' in map for arg '" << name << "'";
+#ifdef ARGS_NOEXCEPT
+ error = Error::Map;
+ errorMsg = problem.str();
+#else
+ throw MapError(problem.str());
+#endif
+ } else
+ {
+ this->values.emplace_back(it->second);
+ matched = true;
+ }
+ }
+
+ /** Get the value
+ */
+ Container &Get() noexcept
+ {
+ return values;
+ }
+
+ virtual std::string Name() const override
+ {
+ return name + std::string("...");
+ }
+
+ virtual void Reset() noexcept override
+ {
+ PositionalBase::Reset();
+ values = defaultValues;
+ }
+
+ virtual PositionalBase *GetNextPositional() override
+ {
+ const bool wasMatched = Matched();
+ auto me = PositionalBase::GetNextPositional();
+ if (me && !wasMatched)
+ {
+ values.clear();
+ }
+ return me;
+ }
+
+ iterator begin() noexcept
+ {
+ return values.begin();
+ }
+
+ const_iterator begin() const noexcept
+ {
+ return values.begin();
+ }
+
+ const_iterator cbegin() const noexcept
+ {
+ return values.cbegin();
+ }
+
+ iterator end() noexcept
+ {
+ return values.end();
+ }
+
+ const_iterator end() const noexcept
+ {
+ return values.end();
+ }
+
+ const_iterator cend() const noexcept
+ {
+ return values.cend();
+ }
+ };
+}
+
+#endif
diff --git a/skia/font_converter/include/util.hpp b/skia/font_converter/include/util.hpp
new file mode 100644
index 0000000..80cad97
--- /dev/null
+++ b/skia/font_converter/include/util.hpp
@@ -0,0 +1,6 @@
+#ifndef UTIL_HPP
+#define UTIL_HPP
+
+int nextMultipleOf(float number, int multiple_of);
+
+#endif
\ No newline at end of file
diff --git a/skia/font_converter/include/util.hxx b/skia/font_converter/include/util.hxx
new file mode 100644
index 0000000..d1c86e8
--- /dev/null
+++ b/skia/font_converter/include/util.hxx
@@ -0,0 +1,48 @@
+#ifndef UTIL_HXX
+#define UTIL_HXX
+
+#include <string>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <stdexcept>
+#include <memory>
+
+template <typename... Args>
+std::string string_format(const std::string& format, Args... args)
+{
+ int size = snprintf(nullptr, 0, format.c_str(), args...) +
+ 1; // Extra space for '\0'
+ if (size <= 0)
+ {
+ throw std::runtime_error("Error during formatting.");
+ }
+ std::unique_ptr<char[]> buf(new char[size]);
+ snprintf(buf.get(), size, format.c_str(), args...);
+ return std::string(buf.get(),
+ buf.get() + size - 1); // We don't want the '\0' inside
+}
+
+// QUESTION: inline looks fun. so this copy pastes the code around i guess, but
+// its considered faster than referencing code?
+inline bool file_exists(const std::string& name)
+{
+ // https://stackoverflow.com/questions/12774207/fastest-way-to-check-if-a-file-exist-using-standard-c-c11-c
+ struct stat buffer;
+ return (stat(name.c_str(), &buffer) == 0);
+}
+
+inline int valueOrDefault(int value, int default_value)
+{
+ return value <= 0 ? default_value : value;
+}
+
+inline void scale(int* value, int targetValue, int* otherValue)
+{
+ if (*value != targetValue)
+ {
+ *otherValue = *otherValue * targetValue / *value;
+ *value = targetValue;
+ }
+}
+
+#endif
\ No newline at end of file
diff --git a/skia/font_converter/run.sh b/skia/font_converter/run.sh
new file mode 100755
index 0000000..3e0c5e3
--- /dev/null
+++ b/skia/font_converter/run.sh
@@ -0,0 +1 @@
+./build/macosx/bin/debug/font_converter
\ No newline at end of file
diff --git a/skia/font_converter/src/font.cpp b/skia/font_converter/src/font.cpp
new file mode 100644
index 0000000..0fe5480
--- /dev/null
+++ b/skia/font_converter/src/font.cpp
@@ -0,0 +1,530 @@
+#include "font.h"
+#include "include/core/SkFont.h"
+
+uint16_t RiveFont::charToGlyph(SkUnichar u) const {
+ for (size_t i = 0; i < fCMap.size(); ++i) {
+ if (fCMap[i].fChar == u) {
+ return fCMap[i].fGlyph;
+ }
+ }
+ return 0;
+}
+
+float RiveFont::advance(uint16_t glyph) const {
+ assert(glyph < fGlyphs.size());
+ return fGlyphs[glyph].fAdvance;
+}
+
+const SkPath* RiveFont::path(uint16_t glyph) const {
+ assert(glyph < fGlyphs.size());
+ const SkPath& p = fGlyphs[glyph].fPath;
+ return p.isEmpty() ? nullptr : &p;
+}
+
+#define kSignature 0x23581321
+#define kVersion 1
+
+constexpr uint32_t Tag(unsigned a, unsigned b, unsigned c, unsigned d) {
+ assert((a & 0xFF) == a);
+ assert((b & 0xFF) == b);
+ assert((c & 0xFF) == c);
+ assert((d & 0xFF) == d);
+ return (a << 24) | (b << 16) | (c << 8) | d;
+}
+
+static inline void tag_to_str(uint32_t tag, char str[5]) {
+ str[0] = (tag >> 24) & 0xFF;
+ str[1] = (tag >> 16) & 0xFF;
+ str[2] = (tag >> 8) & 0xFF;
+ str[3] = (tag >> 0) & 0xFF;
+ str[4] = 0;
+}
+
+constexpr uint32_t kOffsets_TableTag = Tag('p', 'o', 'f', 'f');
+constexpr uint32_t kPaths_TableTag = Tag('p', 'a', 't', 'h');
+constexpr uint32_t kCMap_TableTag = Tag('c', 'm', 'a', 'p');
+constexpr uint32_t kInfo_TableTag = Tag('i', 'n', 'f', 'o');
+constexpr uint32_t kAdvances_TableTag = Tag('h', 'a', 'd', 'v');
+
+struct TableDir {
+ uint32_t tag;
+ uint32_t offset;
+ uint32_t length;
+};
+
+struct FontHead {
+ uint32_t signature;
+ uint32_t version;
+ uint32_t tableCount;
+ // TableDir[dirCount]
+
+ const TableDir* dir() const {
+ return (const TableDir*)(this + 1);
+ }
+
+ const void* findTable(uint32_t tag) const {
+ auto dir = this->dir();
+ for (unsigned i = 0; i < this->tableCount; ++i) {
+ if (dir[i].tag == tag) {
+ return (char*)this + dir[i].offset;
+ }
+ }
+ return nullptr;
+ }
+};
+
+struct InfoTable {
+ uint16_t glyphCount;
+ uint16_t upem;
+};
+
+struct GlyphOffsetTable {
+ // uint32_t offsets[glyphCount+1]; // relative to the glyphdata table
+};
+
+struct GlyphRec {
+ // uint16_t verbCount;
+ // uint16_t pointCount; // if verbCount > 0
+ // uint8_t verbs; // Move, Line, Quad, Cubic, Close
+ // pad16[]
+ // uint16_t x,y x,y x,y
+};
+
+void RiveFont::load(sk_sp<SkTypeface> tf, const std::string& str) {
+ this->clear();
+
+ SkFont font(std::move(tf), 1.0f);
+
+ size_t len = str.size();
+ uint16_t glyphIDs[len];
+ int glyphCount = font.textToGlyphs(str.data(), len, SkTextEncoding::kUTF8,
+ glyphIDs, len);
+ assert(glyphCount == (int)len);
+
+ struct Rec {
+ uint16_t charCode;
+ uint16_t srcGlyph;
+ uint16_t dstGlyph;
+ };
+ std::vector<Rec> rec;
+ uint16_t newGlyphID = 1;
+ for (size_t i = 0; i < len; ++i) {
+ uint16_t code = str[i];
+ auto iter = std::find_if(rec.begin(), rec.end(), [code](const auto& r) {
+ return r.charCode == code;
+ });
+ if (iter == rec.end()) {
+ rec.push_back({code, glyphIDs[i], glyphIDs[i] == 0 ? glyphIDs[i] : newGlyphID++});
+ }
+ }
+
+ std::sort(rec.begin(), rec.end(), [](const Rec& a, const Rec& b) {
+ return a.charCode < b.charCode;
+ });
+ for (const auto& r : rec) {
+ printf("'%c' %d -> %d\n", r.charCode, r.srcGlyph, r.dstGlyph);
+ fCMap.push_back({r.charCode, r.dstGlyph});
+ }
+
+ std::sort(rec.begin(), rec.end(), [](const Rec& a, const Rec& b) {
+ return a.dstGlyph < b.dstGlyph;
+ });
+
+ font.setLinearMetrics(true);
+ auto append_glyph = [&](uint16_t srcGlyph) {
+ float width;
+ font.getWidths(&srcGlyph, 1, &width);
+ SkPath path;
+ font.getPath(srcGlyph, &path); // returns false if glyph is bitmap
+
+ fGlyphs.push_back({std::move(path), width});
+ };
+
+ append_glyph(0); // missing glyph
+ assert(newGlyphID == rec.size() + 1);
+ for (size_t i = 0; i < rec.size(); ++i) {
+ const auto& r = rec[i];
+ assert(r.dstGlyph == i + 1);
+ assert(r.srcGlyph != 0);
+ append_glyph(r.srcGlyph);
+ }
+}
+
+struct ByteBuilder {
+ std::vector<uint8_t> bytes;
+
+ uint32_t length() const { return bytes.size(); }
+
+ uint8_t add8(size_t x) {
+ assert((x & 0xFF) == x);
+ uint8_t b = (uint8_t)x;
+ bytes.push_back(b);
+ return b;
+ }
+ int16_t addS16(ssize_t x) {
+ int16_t s = (int16_t)x;
+ assert(s == x);
+ this->add(&s, 2);
+ return s;
+ }
+ uint16_t addU16(size_t x) {
+ assert((x & 0xFFFF) == x);
+ uint16_t u = (uint16_t)x;
+ this->add(&u, 2);
+ return u;
+ }
+ uint32_t addU32(size_t x) {
+ assert((x & 0xFFFFFFFF) == x);
+ uint32_t u = (uint32_t)x;
+ this->add(&u, 4);
+ return u;
+ }
+
+ void add(const void* src, size_t n) {
+ size_t size = bytes.size();
+ bytes.resize(size + n);
+ memcpy(bytes.data() + size, src, n);
+ }
+ template <typename T> void add(const std::vector<T>& v) {
+ this->add(v.data(), v.size() * sizeof(T));
+ }
+ void add(const ByteBuilder& bb) {
+ this->add(bb.bytes.data(), bb.bytes.size());
+ }
+ void add(sk_sp<SkData> data) {
+ this->add(data->data(), data->size());
+ }
+
+ void padTo16() {
+ if (bytes.size() & 1) {
+ this->add8(0);
+ }
+ }
+ void padTo32() {
+ while (bytes.size() & 3) {
+ this->add8(0);
+ }
+ }
+
+ void set32(size_t offset, uint32_t value) {
+ assert(offset + 4 <= bytes.size());
+ assert((offset & 3) == 0);
+ memcpy(bytes.data() + offset, &value, 4);
+ }
+
+ sk_sp<SkData> detach() {
+ auto data = SkData::MakeWithCopy(bytes.data(), bytes.size());
+ bytes.clear();
+ return data;
+ }
+};
+
+void encode_path(ByteBuilder* bb, const SkPath& path, float scale) {
+ std::vector<uint8_t> varray;
+ std::vector<uint16_t> parray;
+
+ auto add_point = [&](SkPoint p) {
+ parray.push_back(SkScalarRoundToInt(p.fX * scale));
+ parray.push_back(SkScalarRoundToInt(p.fY * scale));
+ };
+
+ SkPath::RawIter iter(path);
+ for (;;) {
+ SkPoint pts[4];
+ auto verb = iter.next(pts);
+ if (verb == SkPath::kDone_Verb) {
+ break;
+ }
+ varray.push_back(verb);
+ switch ((SkPathVerb)verb) {
+ case SkPathVerb::kMove:
+ add_point(pts[0]);
+ break;
+ case SkPathVerb::kLine:
+ add_point(pts[1]);
+ break;
+ case SkPathVerb::kQuad:
+ add_point(pts[1]); add_point(pts[2]);
+ break;
+ case SkPathVerb::kCubic:
+ add_point(pts[1]); add_point(pts[2]); add_point(pts[3]);
+ break;
+ case SkPathVerb::kClose:
+ break;
+ default:
+ assert(false); // unsupported
+ }
+ }
+ assert((int)varray.size() == path.countVerbs());
+ assert((int)parray.size() == path.countPoints() * 2);
+
+ auto no_useful_verbs = [](const std::vector<uint8_t>& verbs) {
+ for (auto v : verbs) {
+ switch ((SkPathVerb)v) {
+ case SkPathVerb::kLine:
+ case SkPathVerb::kQuad:
+ case SkPathVerb::kCubic:
+ return false;
+ default:
+ break;
+ }
+ }
+ return true;
+ };
+ if (no_useful_verbs(varray)) {
+ return; // we signal empty paths with the offset table
+ }
+
+ bb->addU16(varray.size());
+ assert((parray.size() & 1) == 0);
+ bb->addU16(parray.size() / 2); // #points == 2 * #values
+
+ bb->add(varray);
+ bb->padTo16();
+ bb->add(parray);
+}
+
+sk_sp<SkData> RiveFont::encode() const {
+ sk_sp<SkData> infoD, cmapD, offsetsD, pathsD;
+ const int upem = 2048;
+ const float scale = upem;
+
+ struct DirRec {
+ uint32_t tag;
+ sk_sp<SkData> data;
+ };
+ std::vector<DirRec> dir;
+
+ {
+ InfoTable itable;
+ itable.glyphCount = fGlyphs.size();
+ itable.upem = upem;
+ dir.push_back({
+ kInfo_TableTag, SkData::MakeWithCopy(&itable, sizeof(itable))
+ });
+ }
+
+ {
+ ByteBuilder cmap;
+ // start with #pairs
+ cmap.addU16(fCMap.size());
+ for (const auto& cm : fCMap) {
+ cmap.addU16(cm.fChar);
+ cmap.addU16(cm.fGlyph);
+ }
+ dir.push_back({ kCMap_TableTag, cmap.detach() });
+ }
+
+ // todo: store offset[i] for glyph[i+1] since first offset is always 0
+ {
+ ByteBuilder paths, advances;
+ std::vector<uint32_t> offsets;
+ for (const auto& g : fGlyphs) {
+ offsets.push_back(paths.length());
+ encode_path(&paths, g.fPath, scale);
+ paths.padTo16();
+ advances.addU16(SkScalarRoundToInt(g.fAdvance * scale));
+ }
+ offsets.push_back(paths.length()); // store N+1 offsets
+
+ dir.push_back({
+ kOffsets_TableTag, SkData::MakeWithCopy(offsets.data(), offsets.size() * 4)
+ });
+ dir.push_back({ kPaths_TableTag, paths.detach() });
+ dir.push_back({ kAdvances_TableTag, advances.detach() });
+ }
+
+ std::sort(dir.begin(), dir.end(), [](const DirRec& a, const DirRec& b) {
+ return a.tag < b.tag;
+ });
+
+ ByteBuilder header;
+ header.addU32(kSignature);
+ header.addU32(kVersion);
+ header.addU32(dir.size());
+ for (auto& d : dir) {
+ header.addU32(d.tag);
+ header.addU32(0); // offset -- fill in later
+ header.addU32(d.data->size());
+ }
+
+ size_t offsetToDirEntry = sizeof(FontHead);
+ for (auto& d : dir) {
+ // +4 to skip the tag field of the dir entry
+ header.set32(offsetToDirEntry + 4, header.length());
+ offsetToDirEntry += sizeof(TableDir);
+
+ header.add(d.data);
+ header.padTo32();
+ }
+ return header.detach();
+}
+
+struct Reader {
+ const char* fStart;
+ const char* fCurr;
+ const char* fStop;
+
+ Reader(const void* data, size_t length) {
+ fStart = (const char*)data;
+ fCurr = fStart;
+ fStop = fStart + length;
+ }
+
+ bool isAvailable(size_t n) const { return fCurr + n <= fStop; }
+ size_t available() const { return fStop - fCurr; }
+
+ template <typename T> const T* skip(size_t size) {
+ assert(this->isAvailable(size));
+ const char* p = fCurr;
+ fCurr += size;
+ return reinterpret_cast<const T*>(p);
+ }
+
+ template <typename T> const T* skip() {
+ return this->skip<T>(sizeof(T));
+ }
+
+ void skip(size_t size) {
+ }
+
+ uint8_t u8() {
+ assert(this->isAvailable(1));
+ return *fCurr++;
+ }
+
+ int16_t s16() {
+ assert(this->isAvailable(2));
+ int16_t s;
+ memcpy(&s, fCurr, 2);
+ fCurr += 2;
+ return s;
+ }
+ uint16_t u16() {
+ assert(this->isAvailable(2));
+ uint16_t s;
+ memcpy(&s, fCurr, 2);
+ fCurr += 2;
+ return s;
+ }
+ uint32_t u32() {
+ assert(this->isAvailable(4));
+ uint32_t s;
+ memcpy(&s, fCurr, 4);
+ fCurr += 4;
+ return s;
+ }
+
+ void read(void* dst, size_t size) {
+ assert(this->isAvailable(size));
+ memcpy(dst, fCurr, size);
+ fCurr += size;
+ }
+
+ void skipPad16() {
+ size_t amount = fCurr - fStart;
+ if (amount & 1) {
+ assert(this->isAvailable(1));
+ fCurr += 1;
+ }
+ }
+};
+
+static int compute_point_count(const uint8_t verbs[], int verbCount) {
+ int count = 0;
+ for (int i = 0; i < verbCount; ++i) {
+ switch ((SkPathVerb)verbs[i]) {
+ case SkPathVerb::kMove: count += 1; break;
+ case SkPathVerb::kLine: count += 1; break;
+ case SkPathVerb::kQuad: count += 2; break;
+ case SkPathVerb::kCubic: count += 3; break;
+ case SkPathVerb::kClose: count += 0; break;
+ default:
+ assert(false);
+ return -1;
+ }
+ }
+ return count;
+}
+
+static SkPath decode_path(const void* data, size_t length, float scale) {
+ Reader reader(data, length);
+
+ const int verbCount = reader.u16();
+ assert(verbCount > 0);
+ const int pointCount = reader.u16();
+
+ auto verbs = reader.skip<uint8_t>(verbCount);
+ reader.skipPad16();
+ const int computedPointCount = compute_point_count(verbs, verbCount);
+ assert(pointCount == computedPointCount);
+
+ auto pts16 = reader.skip<int16_t>(pointCount * 2 * sizeof(int16_t));
+ assert(reader.available() == 0);
+
+ SkPoint pts[pointCount];
+ for (int i = 0; i < pointCount; ++i) {
+ pts[i] = { pts16[0] * scale, pts16[1] * scale };
+ pts16 += 2;
+ }
+
+ return SkPath::Make(pts, pointCount,
+ verbs, verbCount,
+ nullptr, 0,
+ SkPathFillType::kWinding);
+}
+
+bool RiveFont::decode(const void* data, size_t length) {
+ Reader reader(data, length);
+
+ auto font = reader.skip<FontHead>();
+ assert(font->signature == kSignature);
+ assert(font->version == kVersion);
+ assert(font->tableCount >= 0);
+
+ assert(reader.isAvailable(font->tableCount * sizeof(TableDir)));
+
+ if (true) {
+ auto dir = font->dir();
+ for (unsigned i = 0; i < font->tableCount; ++i) {
+ char str[5];
+ tag_to_str(dir[i].tag, str);
+ printf("[%d] {%0x08 %s %10d} %d %d\n", i, dir[i].tag, str, dir[i].tag,
+ dir[i].offset, dir[i].length);
+ }
+ }
+
+ auto info = (const InfoTable*)font->findTable(kInfo_TableTag);
+ auto cmap = (const uint16_t*)font->findTable(kCMap_TableTag);
+ auto paths = (const char*)font->findTable(kPaths_TableTag);
+ auto offsets = (const uint32_t*)font->findTable(kOffsets_TableTag);
+ auto advances = (const uint16_t*)font->findTable(kAdvances_TableTag);
+
+ const int glyphCount = info->glyphCount;
+
+ this->clear();
+
+ const int pairCount = *cmap++;
+ for (int i = 0; i < pairCount; ++i) {
+ uint16_t c = *cmap++;
+ uint16_t g = *cmap++;
+ assert(g < glyphCount);
+
+ fCMap.push_back({c, g});
+ }
+
+ const float scale = 1.0f / (float)info->upem;
+
+ for (int i = 0; i < glyphCount; ++i) {
+ float adv = advances[i] * scale;
+ uint32_t start = offsets[i];
+ uint32_t end = offsets[i+1];
+ assert(start <= end);
+
+ fGlyphs.push_back({
+ (start == end) ? SkPath() : decode_path(paths + start, end - start, scale),
+ adv
+ });
+ }
+ return true;
+}
diff --git a/skia/font_converter/src/font.h b/skia/font_converter/src/font.h
new file mode 100644
index 0000000..d5f109c
--- /dev/null
+++ b/skia/font_converter/src/font.h
@@ -0,0 +1,38 @@
+#ifndef RiveFont_DEFINED
+#define RiveFont_DEFINED
+
+#include "include/core/SkData.h"
+#include "include/core/SkPath.h"
+#include "include/core/SkTypeface.h"
+#include <vector>
+
+class RiveFont {
+ struct Pair {
+ uint16_t fChar;
+ uint16_t fGlyph;
+ };
+ std::vector<Pair> fCMap;
+
+ struct Glyph {
+ SkPath fPath;
+ float fAdvance;
+ };
+ std::vector<Glyph> fGlyphs;
+
+public:
+ uint16_t charToGlyph(SkUnichar) const;
+ float advance(uint16_t glyph) const;
+ const SkPath* path(uint16_t glyph) const;
+
+ void clear() {
+ fCMap.clear();
+ fGlyphs.clear();
+ }
+
+ void load(sk_sp<SkTypeface>, const std::string& chars);
+
+ sk_sp<SkData> encode() const;
+ bool decode(const void*, size_t);
+};
+
+#endif
diff --git a/skia/font_converter/src/font_arguments.hpp b/skia/font_converter/src/font_arguments.hpp
new file mode 100644
index 0000000..35ba1a9
--- /dev/null
+++ b/skia/font_converter/src/font_arguments.hpp
@@ -0,0 +1,87 @@
+#ifndef RECORDER_ARGUMENTS_HPP
+#define RECORDER_ARGUMENTS_HPP
+
+#include <iostream>
+#include <string>
+#include <unordered_map>
+
+#include "args.hxx"
+
+class FontArguments
+{
+
+public:
+ FontArguments(int argc, const char** argv)
+ {
+ // PARSE INPUT
+ m_Parser = new args::ArgumentParser(
+ "Record playback of a Rive file as a movie, gif, etc (eventually "
+ "should support image sequences saved in a zip/archive too).",
+ "Experimental....");
+ args::HelpFlag help(
+ *m_Parser, "help", "Display this help menu", {'h', "help"});
+ args::Group required(
+ *m_Parser, "required arguments:", args::Group::Validators::All);
+ args::Group optional(*m_Parser,
+ "optional arguments:",
+ args::Group::Validators::DontCare);
+
+ args::ValueFlag<std::string> source(
+ required, "path", "source filename", {'s', "source"});
+ args::ValueFlag<std::string> destination(
+ required, "path", "destination filename", {'d', "destination"});
+
+ args::CompletionFlag completion(*m_Parser, {"complete"});
+ try
+ {
+ m_Parser->ParseCLI(argc, argv);
+ }
+ catch (const std::invalid_argument e)
+ {
+ std::cout << e.what();
+ throw;
+ }
+ catch (const args::Completion& e)
+ {
+ std::cout << e.what();
+ throw;
+ }
+ catch (const args::Help&)
+ {
+ std::cout << m_Parser;
+ throw;
+ }
+ catch (const args::ParseError& e)
+ {
+ std::cerr << e.what() << std::endl;
+ std::cerr << m_Parser;
+ throw;
+ }
+ catch (args::ValidationError e)
+ {
+ std::cerr << e.what() << std::endl;
+ std::cerr << m_Parser;
+ throw;
+ }
+
+ m_Destination = args::get(destination);
+ m_Source = args::get(source);
+ }
+
+ ~FontArguments()
+ {
+ if (m_Parser != nullptr)
+ {
+ delete m_Parser;
+ }
+ }
+
+ const std::string& destination() const { return m_Destination; }
+ const std::string& source() const { return m_Source; }
+
+private:
+ args::ArgumentParser* m_Parser;
+ std::string m_Destination;
+ std::string m_Source;
+};
+#endif
\ No newline at end of file
diff --git a/skia/font_converter/src/main.cpp b/skia/font_converter/src/main.cpp
new file mode 100644
index 0000000..a50b0da
--- /dev/null
+++ b/skia/font_converter/src/main.cpp
@@ -0,0 +1,76 @@
+#ifdef TESTING
+#else
+
+#include "font.h"
+#include "font_arguments.hpp"
+
+void readFile(const char* path, uint8_t*& bytes, long& length)
+{
+ FILE* fp = fopen(path, "r");
+
+ if (fp == nullptr)
+ {
+ fclose(fp);
+ std::ostringstream errorStream;
+ errorStream << "Failed to open file " << path;
+ throw std::invalid_argument(errorStream.str());
+ }
+ fseek(fp, 0, SEEK_END);
+ length = ftell(fp);
+ fseek(fp, 0, SEEK_SET);
+
+ bytes = new uint8_t[length];
+
+ if (fread(bytes, 1, length, fp) != length)
+ {
+ fclose(fp);
+ delete[] bytes;
+ std::ostringstream errorStream;
+ errorStream << "Failed to read file into bytes array " << path;
+ throw std::invalid_argument(errorStream.str());
+ }
+
+ fclose(fp);
+}
+
+int main(int argc, const char* argv[])
+{
+ try
+ {
+ FontArguments args(argc, argv);
+ RiveFont* font = new RiveFont();
+
+ uint8_t* bytes;
+ long length = 0;
+ readFile(args.source().c_str(), bytes, length);
+ // font->decode(bytes, length);
+ // font->encode();
+
+ FILE* pFile;
+ pFile = fopen(args.destination().c_str(), "wb");
+ fwrite(bytes, sizeof(char), length, pFile);
+ fclose(pFile);
+
+ delete[] bytes;
+ }
+ catch (const args::Completion& e)
+ {
+ return 0;
+ }
+ catch (const args::Help&)
+ {
+ return 0;
+ }
+ catch (const args::ParseError& e)
+ {
+ return 1;
+ }
+ catch (args::ValidationError e)
+ {
+ return 1;
+ }
+
+ return 0;
+}
+
+#endif
