[ { "path": ".gitattributes", "content": "###############################################################################\n# Set default behavior to automatically normalize line endings.\n###############################################################################\n* text=auto\n\n###############################################################################\n# Set default behavior for command prompt diff.\n#\n# This is need for earlier builds of msysgit that does not have it on by\n# default for csharp files.\n# Note: This is only used by command line\n###############################################################################\n#*.cs diff=csharp\n\n###############################################################################\n# Set the merge driver for project and solution files\n#\n# Merging from the command prompt will add diff markers to the files if there\n# are conflicts (Merging from VS is not affected by the settings below, in VS\n# the diff markers are never inserted). Diff markers may cause the following \n# file extensions to fail to load in VS. An alternative would be to treat\n# these files as binary and thus will always conflict and require user\n# intervention with every merge. To do so, just uncomment the entries below\n###############################################################################\n#*.sln merge=binary\n#*.csproj merge=binary\n#*.vbproj merge=binary\n#*.vcxproj merge=binary\n#*.vcproj merge=binary\n#*.dbproj merge=binary\n#*.fsproj merge=binary\n#*.lsproj merge=binary\n#*.wixproj merge=binary\n#*.modelproj merge=binary\n#*.sqlproj merge=binary\n#*.wwaproj merge=binary\n\n###############################################################################\n# behavior for image files\n#\n# image files are treated as binary by default.\n###############################################################################\n#*.jpg binary\n#*.png binary\n#*.gif binary\n\n###############################################################################\n# diff behavior for common document formats\n# \n# Convert binary document formats to text before diffing them. This feature\n# is only available from the command line. Turn it on by uncommenting the \n# entries below.\n###############################################################################\n#*.doc diff=astextplain\n#*.DOC diff=astextplain\n#*.docx diff=astextplain\n#*.DOCX diff=astextplain\n#*.dot diff=astextplain\n#*.DOT diff=astextplain\n#*.pdf diff=astextplain\n#*.PDF diff=astextplain\n#*.rtf diff=astextplain\n#*.RTF diff=astextplain\n" }, { "path": ".gitignore", "content": "## Ignore Visual Studio temporary files, build results, and\n## files generated by popular Visual Studio add-ons.\n##\n## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore\n\n# User-specific files\n*.rsuser\n*.suo\n*.user\n*.userosscache\n*.sln.docstates\n\n# User-specific files (MonoDevelop/Xamarin Studio)\n*.userprefs\n\n# Mono auto generated files\nmono_crash.*\n\n# Build results\n[Dd]ebug/\n[Dd]ebugPublic/\n[Ww][Ii][Nn]32/\n[Aa][Rr][Mm]/\n[Aa][Rr][Mm]64/\nbld/\n[Bb]in/\n[Oo]bj/\n[Oo]ut/\n[Ll]og/\n[Ll]ogs/\n\n# Visual Studio 2015/2017 cache/options directory\n.vs/\n# Uncomment if you have tasks that create the project's static files in wwwroot\n#wwwroot/\n\n# Visual Studio 2017 auto generated files\nGenerated\\ Files/\n\n# MSTest test Results\n[Tt]est[Rr]esult*/\n[Bb]uild[Ll]og.*\n\n# NUnit\n*.VisualState.xml\nTestResult.xml\nnunit-*.xml\n\n# Build Results of an ATL Project\n[Dd]ebugPS/\n[Rr]eleasePS/\ndlldata.c\n\n# Benchmark Results\nBenchmarkDotNet.Artifacts/\n\n# .NET Core\nproject.lock.json\nproject.fragment.lock.json\nartifacts/\n\n# ASP.NET Scaffolding\nScaffoldingReadMe.txt\n\n# StyleCop\nStyleCopReport.xml\n\n# Files built by Visual Studio\n*_i.c\n*_p.c\n*.ilk\n*.meta\n*.obj\n*.iobj\n*.pch\n*.pdb\n*.ipdb\n*.pgc\n*.pgd\n*.rsp\n*.sbr\n*.tlb\n*.tli\n*.tlh\n*.tmp\n*.tmp_proj\n*_wpftmp.csproj\n*.log\n*.vspscc\n*.vssscc\n.builds\n*.pidb\n*.svclog\n*.scc\n\n# Chutzpah Test files\n_Chutzpah*\n\n# Visual C++ cache files\nipch/\n*.aps\n*.ncb\n*.opendb\n*.opensdf\n*.sdf\n*.cachefile\n*.VC.db\n*.VC.VC.opendb\n\n# Visual Studio profiler\n*.psess\n*.vsp\n*.vspx\n*.sap\n\n# Visual Studio Trace Files\n*.e2e\n\n# TFS 2012 Local Workspace\n$tf/\n\n# Guidance Automation Toolkit\n*.gpState\n\n# ReSharper is a .NET coding add-in\n_ReSharper*/\n*.[Rr]e[Ss]harper\n*.DotSettings.user\n\n# TeamCity is a build add-in\n_TeamCity*\n\n# DotCover is a Code Coverage Tool\n*.dotCover\n\n# AxoCover is a Code Coverage Tool\n.axoCover/*\n!.axoCover/settings.json\n\n# Coverlet is a free, cross platform Code Coverage Tool\ncoverage*.json\ncoverage*.xml\ncoverage*.info\n\n# Visual Studio code coverage results\n*.coverage\n*.coveragexml\n\n# NCrunch\n_NCrunch_*\n.*crunch*.local.xml\nnCrunchTemp_*\n\n# MightyMoose\n*.mm.*\nAutoTest.Net/\n\n# Web workbench (sass)\n.sass-cache/\n\n# Installshield output folder\n[Ee]xpress/\n\n# DocProject is a documentation generator add-in\nDocProject/buildhelp/\nDocProject/Help/*.HxT\nDocProject/Help/*.HxC\nDocProject/Help/*.hhc\nDocProject/Help/*.hhk\nDocProject/Help/*.hhp\nDocProject/Help/Html2\nDocProject/Help/html\n\n# Click-Once directory\npublish/\n\n# Publish Web Output\n*.[Pp]ublish.xml\n*.azurePubxml\n# Note: Comment the next line if you want to checkin your web deploy settings,\n# but database connection strings (with potential passwords) will be unencrypted\n*.pubxml\n*.publishproj\n\n# Microsoft Azure Web App publish settings. Comment the next line if you want to\n# checkin your Azure Web App publish settings, but sensitive information contained\n# in these scripts will be unencrypted\nPublishScripts/\n\n# NuGet Packages\n*.nupkg\n# NuGet Symbol Packages\n*.snupkg\n# The packages folder can be ignored because of Package Restore\n**/[Pp]ackages/*\n# except build/, which is used as an MSBuild target.\n!**/[Pp]ackages/build/\n# Uncomment if necessary however generally it will be regenerated when needed\n#!**/[Pp]ackages/repositories.config\n# NuGet v3's project.json files produces more ignorable files\n*.nuget.props\n*.nuget.targets\n\n# Microsoft Azure Build Output\ncsx/\n*.build.csdef\n\n# Microsoft Azure Emulator\necf/\nrcf/\n\n# Windows Store app package directories and files\nAppPackages/\nBundleArtifacts/\nPackage.StoreAssociation.xml\n_pkginfo.txt\n*.appx\n*.appxbundle\n*.appxupload\n\n# Visual Studio cache files\n# files ending in .cache can be ignored\n*.[Cc]ache\n# but keep track of directories ending in .cache\n!?*.[Cc]ache/\n\n# Others\nClientBin/\n~$*\n*~\n*.dbmdl\n*.dbproj.schemaview\n*.jfm\n*.pfx\n*.publishsettings\norleans.codegen.cs\n\n# Including strong name files can present a security risk\n# (https://github.com/github/gitignore/pull/2483#issue-259490424)\n#*.snk\n\n# Since there are multiple workflows, uncomment next line to ignore bower_components\n# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)\n#bower_components/\n\n# RIA/Silverlight projects\nGenerated_Code/\n\n# Backup & report files from converting an old project file\n# to a newer Visual Studio version. Backup files are not needed,\n# because we have git ;-)\n_UpgradeReport_Files/\nBackup*/\nUpgradeLog*.XML\nUpgradeLog*.htm\nServiceFabricBackup/\n*.rptproj.bak\n\n# SQL Server files\n*.mdf\n*.ldf\n*.ndf\n\n# Business Intelligence projects\n*.rdl.data\n*.bim.layout\n*.bim_*.settings\n*.rptproj.rsuser\n*- [Bb]ackup.rdl\n*- [Bb]ackup ([0-9]).rdl\n*- [Bb]ackup ([0-9][0-9]).rdl\n\n# Microsoft Fakes\nFakesAssemblies/\n\n# GhostDoc plugin setting file\n*.GhostDoc.xml\n\n# Node.js Tools for Visual Studio\n.ntvs_analysis.dat\nnode_modules/\n\n# Visual Studio 6 build log\n*.plg\n\n# Visual Studio 6 workspace options file\n*.opt\n\n# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)\n*.vbw\n\n# Visual Studio LightSwitch build output\n**/*.HTMLClient/GeneratedArtifacts\n**/*.DesktopClient/GeneratedArtifacts\n**/*.DesktopClient/ModelManifest.xml\n**/*.Server/GeneratedArtifacts\n**/*.Server/ModelManifest.xml\n_Pvt_Extensions\n\n# Paket dependency manager\n.paket/paket.exe\npaket-files/\n\n# FAKE - F# Make\n.fake/\n\n# CodeRush personal settings\n.cr/personal\n\n# Python Tools for Visual Studio (PTVS)\n__pycache__/\n*.pyc\n\n# Cake - Uncomment if you are using it\n# tools/**\n# !tools/packages.config\n\n# Tabs Studio\n*.tss\n\n# Telerik's JustMock configuration file\n*.jmconfig\n\n# BizTalk build output\n*.btp.cs\n*.btm.cs\n*.odx.cs\n*.xsd.cs\n\n# OpenCover UI analysis results\nOpenCover/\n\n# Azure Stream Analytics local run output\nASALocalRun/\n\n# MSBuild Binary and Structured Log\n*.binlog\n\n# NVidia Nsight GPU debugger configuration file\n*.nvuser\n\n# MFractors (Xamarin productivity tool) working folder\n.mfractor/\n\n# Local History for Visual Studio\n.localhistory/\n\n# BeatPulse healthcheck temp database\nhealthchecksdb\n\n# Backup folder for Package Reference Convert tool in Visual Studio 2017\nMigrationBackup/\n\n# Ionide (cross platform F# VS Code tools) working folder\n.ionide/\n\n# Fody - auto-generated XML schema\nFodyWeavers.xsd\n*.tlog\n*.txt\n*.recipe\n" }, { "path": ".gitmodules", "content": "[submodule \"win32errorcodes\"]\n\tpath = win32errorcodes\n\turl = https://github.com/p0dalirius/win32errorcodes\n" }, { "path": "CLI11.hpp", "content": "// CLI11: Version 2.3.2\n// Originally designed by Henry Schreiner\n// https://github.com/CLIUtils/CLI11\n//\n// This is a standalone header file generated by MakeSingleHeader.py in CLI11/scripts\n// from: v2.3.2\n//\n// CLI11 2.3.2 Copyright (c) 2017-2022 University of Cincinnati, developed by Henry\n// Schreiner under NSF AWARD 1414736. All rights reserved.\n//\n// Redistribution and use in source and binary forms of CLI11, with or without\n// modification, are permitted provided that the following conditions are met:\n//\n// 1. Redistributions of source code must retain the above copyright notice, this\n// list of conditions and the following disclaimer.\n// 2. Redistributions in binary form must reproduce the above copyright notice,\n// this list of conditions and the following disclaimer in the documentation\n// and/or other materials provided with the distribution.\n// 3. Neither the name of the copyright holder nor the names of its contributors\n// may be used to endorse or promote products derived from this software without\n// specific prior written permission.\n//\n// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\n// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR\n// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON\n// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n#pragma once\n\n// Standard combined includes:\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\n#define CLI11_VERSION_MAJOR 2\n#define CLI11_VERSION_MINOR 3\n#define CLI11_VERSION_PATCH 2\n#define CLI11_VERSION \"2.3.2\"\n\n\n\n\n// The following version macro is very similar to the one in pybind11\n#if !(defined(_MSC_VER) && __cplusplus == 199711L) && !defined(__INTEL_COMPILER)\n#if __cplusplus >= 201402L\n#define CLI11_CPP14\n#if __cplusplus >= 201703L\n#define CLI11_CPP17\n#if __cplusplus > 201703L\n#define CLI11_CPP20\n#endif\n#endif\n#endif\n#elif defined(_MSC_VER) && __cplusplus == 199711L\n// MSVC sets _MSVC_LANG rather than __cplusplus (supposedly until the standard is fully implemented)\n// Unless you use the /Zc:__cplusplus flag on Visual Studio 2017 15.7 Preview 3 or newer\n#if _MSVC_LANG >= 201402L\n#define CLI11_CPP14\n#if _MSVC_LANG > 201402L && _MSC_VER >= 1910\n#define CLI11_CPP17\n#if _MSVC_LANG > 201703L && _MSC_VER >= 1910\n#define CLI11_CPP20\n#endif\n#endif\n#endif\n#endif\n\n#if defined(CLI11_CPP14)\n#define CLI11_DEPRECATED(reason) [[deprecated(reason)]]\n#elif defined(_MSC_VER)\n#define CLI11_DEPRECATED(reason) __declspec(deprecated(reason))\n#else\n#define CLI11_DEPRECATED(reason) __attribute__((deprecated(reason)))\n#endif\n\n// GCC < 10 doesn't ignore this in unevaluated contexts\n#if !defined(CLI11_CPP17) || \\\n (defined(__GNUC__) && !defined(__llvm__) && !defined(__INTEL_COMPILER) && __GNUC__ < 10 && __GNUC__ > 4)\n#define CLI11_NODISCARD\n#else\n#define CLI11_NODISCARD [[nodiscard]]\n#endif\n\n/** detection of rtti */\n#ifndef CLI11_USE_STATIC_RTTI\n#if(defined(_HAS_STATIC_RTTI) && _HAS_STATIC_RTTI)\n#define CLI11_USE_STATIC_RTTI 1\n#elif defined(__cpp_rtti)\n#if(defined(_CPPRTTI) && _CPPRTTI == 0)\n#define CLI11_USE_STATIC_RTTI 1\n#else\n#define CLI11_USE_STATIC_RTTI 0\n#endif\n#elif(defined(__GCC_RTTI) && __GXX_RTTI)\n#define CLI11_USE_STATIC_RTTI 0\n#else\n#define CLI11_USE_STATIC_RTTI 1\n#endif\n#endif\n\n/** Inline macro **/\n#ifdef CLI11_COMPILE\n#define CLI11_INLINE\n#else\n#define CLI11_INLINE inline\n#endif\n\n\n\n// C standard library\n// Only needed for existence checking\n#if defined CLI11_CPP17 && defined __has_include && !defined CLI11_HAS_FILESYSTEM\n#if __has_include()\n// Filesystem cannot be used if targeting macOS < 10.15\n#if defined __MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500\n#define CLI11_HAS_FILESYSTEM 0\n#elif defined(__wasi__)\n// As of wasi-sdk-14, filesystem is not implemented\n#define CLI11_HAS_FILESYSTEM 0\n#else\n#include \n#if defined __cpp_lib_filesystem && __cpp_lib_filesystem >= 201703\n#if defined _GLIBCXX_RELEASE && _GLIBCXX_RELEASE >= 9\n#define CLI11_HAS_FILESYSTEM 1\n#elif defined(__GLIBCXX__)\n// if we are using gcc and Version <9 default to no filesystem\n#define CLI11_HAS_FILESYSTEM 0\n#else\n#define CLI11_HAS_FILESYSTEM 1\n#endif\n#else\n#define CLI11_HAS_FILESYSTEM 0\n#endif\n#endif\n#endif\n#endif\n\n#if defined CLI11_HAS_FILESYSTEM && CLI11_HAS_FILESYSTEM > 0\n#include // NOLINT(build/include)\n#else\n#include \n#include \n#endif\n\n\n\nnamespace CLI {\n\n\n/// Include the items in this namespace to get free conversion of enums to/from streams.\n/// (This is available inside CLI as well, so CLI11 will use this without a using statement).\nnamespace enums {\n\n/// output streaming for enumerations\ntemplate ::value>::type>\nstd::ostream &operator<<(std::ostream &in, const T &item) {\n // make sure this is out of the detail namespace otherwise it won't be found when needed\n return in << static_cast::type>(item);\n}\n\n} // namespace enums\n\n/// Export to CLI namespace\nusing enums::operator<<;\n\nnamespace detail {\n/// a constant defining an expected max vector size defined to be a big number that could be multiplied by 4 and not\n/// produce overflow for some expected uses\nconstexpr int expected_max_vector_size{1 << 29};\n// Based on http://stackoverflow.com/questions/236129/split-a-string-in-c\n/// Split a string by a delim\nCLI11_INLINE std::vector split(const std::string &s, char delim);\n\n/// Simple function to join a string\ntemplate std::string join(const T &v, std::string delim = \",\") {\n std::ostringstream s;\n auto beg = std::begin(v);\n auto end = std::end(v);\n if(beg != end)\n s << *beg++;\n while(beg != end) {\n s << delim << *beg++;\n }\n return s.str();\n}\n\n/// Simple function to join a string from processed elements\ntemplate ::value>::type>\nstd::string join(const T &v, Callable func, std::string delim = \",\") {\n std::ostringstream s;\n auto beg = std::begin(v);\n auto end = std::end(v);\n auto loc = s.tellp();\n while(beg != end) {\n auto nloc = s.tellp();\n if(nloc > loc) {\n s << delim;\n loc = nloc;\n }\n s << func(*beg++);\n }\n return s.str();\n}\n\n/// Join a string in reverse order\ntemplate std::string rjoin(const T &v, std::string delim = \",\") {\n std::ostringstream s;\n for(std::size_t start = 0; start < v.size(); start++) {\n if(start > 0)\n s << delim;\n s << v[v.size() - start - 1];\n }\n return s.str();\n}\n\n// Based roughly on http://stackoverflow.com/questions/25829143/c-trim-whitespace-from-a-string\n\n/// Trim whitespace from left of string\nCLI11_INLINE std::string <rim(std::string &str);\n\n/// Trim anything from left of string\nCLI11_INLINE std::string <rim(std::string &str, const std::string &filter);\n\n/// Trim whitespace from right of string\nCLI11_INLINE std::string &rtrim(std::string &str);\n\n/// Trim anything from right of string\nCLI11_INLINE std::string &rtrim(std::string &str, const std::string &filter);\n\n/// Trim whitespace from string\ninline std::string &trim(std::string &str) { return ltrim(rtrim(str)); }\n\n/// Trim anything from string\ninline std::string &trim(std::string &str, const std::string filter) { return ltrim(rtrim(str, filter), filter); }\n\n/// Make a copy of the string and then trim it\ninline std::string trim_copy(const std::string &str) {\n std::string s = str;\n return trim(s);\n}\n\n/// remove quotes at the front and back of a string either '\"' or '\\''\nCLI11_INLINE std::string &remove_quotes(std::string &str);\n\n/// Add a leader to the beginning of all new lines (nothing is added\n/// at the start of the first line). `\"; \"` would be for ini files\n///\n/// Can't use Regex, or this would be a subs.\nCLI11_INLINE std::string fix_newlines(const std::string &leader, std::string input);\n\n/// Make a copy of the string and then trim it, any filter string can be used (any char in string is filtered)\ninline std::string trim_copy(const std::string &str, const std::string &filter) {\n std::string s = str;\n return trim(s, filter);\n}\n/// Print a two part \"help\" string\nCLI11_INLINE std::ostream &\nformat_help(std::ostream &out, std::string name, const std::string &description, std::size_t wid);\n\n/// Print subcommand aliases\nCLI11_INLINE std::ostream &format_aliases(std::ostream &out, const std::vector &aliases, std::size_t wid);\n\n/// Verify the first character of an option\n/// - is a trigger character, ! has special meaning and new lines would just be annoying to deal with\ntemplate bool valid_first_char(T c) { return ((c != '-') && (c != '!') && (c != ' ') && c != '\\n'); }\n\n/// Verify following characters of an option\ntemplate bool valid_later_char(T c) {\n // = and : are value separators, { has special meaning for option defaults,\n // and \\n would just be annoying to deal with in many places allowing space here has too much potential for\n // inadvertent entry errors and bugs\n return ((c != '=') && (c != ':') && (c != '{') && (c != ' ') && c != '\\n');\n}\n\n/// Verify an option/subcommand name\nCLI11_INLINE bool valid_name_string(const std::string &str);\n\n/// Verify an app name\ninline bool valid_alias_name_string(const std::string &str) {\n static const std::string badChars(std::string(\"\\n\") + '\\0');\n return (str.find_first_of(badChars) == std::string::npos);\n}\n\n/// check if a string is a container segment separator (empty or \"%%\")\ninline bool is_separator(const std::string &str) {\n static const std::string sep(\"%%\");\n return (str.empty() || str == sep);\n}\n\n/// Verify that str consists of letters only\ninline bool isalpha(const std::string &str) {\n return std::all_of(str.begin(), str.end(), [](char c) { return std::isalpha(c, std::locale()); });\n}\n\n/// Return a lower case version of a string\ninline std::string to_lower(std::string str) {\n std::transform(std::begin(str), std::end(str), std::begin(str), [](const std::string::value_type &x) {\n return std::tolower(x, std::locale());\n });\n return str;\n}\n\n/// remove underscores from a string\ninline std::string remove_underscore(std::string str) {\n str.erase(std::remove(std::begin(str), std::end(str), '_'), std::end(str));\n return str;\n}\n\n/// Find and replace a substring with another substring\nCLI11_INLINE std::string find_and_replace(std::string str, std::string from, std::string to);\n\n/// check if the flag definitions has possible false flags\ninline bool has_default_flag_values(const std::string &flags) {\n return (flags.find_first_of(\"{!\") != std::string::npos);\n}\n\nCLI11_INLINE void remove_default_flag_values(std::string &flags);\n\n/// Check if a string is a member of a list of strings and optionally ignore case or ignore underscores\nCLI11_INLINE std::ptrdiff_t find_member(std::string name,\n const std::vector names,\n bool ignore_case = false,\n bool ignore_underscore = false);\n\n/// Find a trigger string and call a modify callable function that takes the current string and starting position of the\n/// trigger and returns the position in the string to search for the next trigger string\ntemplate inline std::string find_and_modify(std::string str, std::string trigger, Callable modify) {\n std::size_t start_pos = 0;\n while((start_pos = str.find(trigger, start_pos)) != std::string::npos) {\n start_pos = modify(str, start_pos);\n }\n return str;\n}\n\n/// Split a string '\"one two\" \"three\"' into 'one two', 'three'\n/// Quote characters can be ` ' or \"\nCLI11_INLINE std::vector split_up(std::string str, char delimiter = '\\0');\n\n/// This function detects an equal or colon followed by an escaped quote after an argument\n/// then modifies the string to replace the equality with a space. This is needed\n/// to allow the split up function to work properly and is intended to be used with the find_and_modify function\n/// the return value is the offset+1 which is required by the find_and_modify function.\nCLI11_INLINE std::size_t escape_detect(std::string &str, std::size_t offset);\n\n/// Add quotes if the string contains spaces\nCLI11_INLINE std::string &add_quotes_if_needed(std::string &str);\n\n} // namespace detail\n\n\n\n\nnamespace detail {\nCLI11_INLINE std::vector split(const std::string &s, char delim) {\n std::vector elems;\n // Check to see if empty string, give consistent result\n if(s.empty()) {\n elems.emplace_back();\n } else {\n std::stringstream ss;\n ss.str(s);\n std::string item;\n while(std::getline(ss, item, delim)) {\n elems.push_back(item);\n }\n }\n return elems;\n}\n\nCLI11_INLINE std::string <rim(std::string &str) {\n auto it = std::find_if(str.begin(), str.end(), [](char ch) { return !std::isspace(ch, std::locale()); });\n str.erase(str.begin(), it);\n return str;\n}\n\nCLI11_INLINE std::string <rim(std::string &str, const std::string &filter) {\n auto it = std::find_if(str.begin(), str.end(), [&filter](char ch) { return filter.find(ch) == std::string::npos; });\n str.erase(str.begin(), it);\n return str;\n}\n\nCLI11_INLINE std::string &rtrim(std::string &str) {\n auto it = std::find_if(str.rbegin(), str.rend(), [](char ch) { return !std::isspace(ch, std::locale()); });\n str.erase(it.base(), str.end());\n return str;\n}\n\nCLI11_INLINE std::string &rtrim(std::string &str, const std::string &filter) {\n auto it =\n std::find_if(str.rbegin(), str.rend(), [&filter](char ch) { return filter.find(ch) == std::string::npos; });\n str.erase(it.base(), str.end());\n return str;\n}\n\nCLI11_INLINE std::string &remove_quotes(std::string &str) {\n if(str.length() > 1 && (str.front() == '\"' || str.front() == '\\'')) {\n if(str.front() == str.back()) {\n str.pop_back();\n str.erase(str.begin(), str.begin() + 1);\n }\n }\n return str;\n}\n\nCLI11_INLINE std::string fix_newlines(const std::string &leader, std::string input) {\n std::string::size_type n = 0;\n while(n != std::string::npos && n < input.size()) {\n n = input.find('\\n', n);\n if(n != std::string::npos) {\n input = input.substr(0, n + 1) + leader + input.substr(n + 1);\n n += leader.size();\n }\n }\n return input;\n}\n\nCLI11_INLINE std::ostream &\nformat_help(std::ostream &out, std::string name, const std::string &description, std::size_t wid) {\n name = \" \" + name;\n out << std::setw(static_cast(wid)) << std::left << name;\n if(!description.empty()) {\n if(name.length() >= wid)\n out << \"\\n\" << std::setw(static_cast(wid)) << \"\";\n for(const char c : description) {\n out.put(c);\n if(c == '\\n') {\n out << std::setw(static_cast(wid)) << \"\";\n }\n }\n }\n out << \"\\n\";\n return out;\n}\n\nCLI11_INLINE std::ostream &format_aliases(std::ostream &out, const std::vector &aliases, std::size_t wid) {\n if(!aliases.empty()) {\n out << std::setw(static_cast(wid)) << \" aliases: \";\n bool front = true;\n for(const auto &alias : aliases) {\n if(!front) {\n out << \", \";\n } else {\n front = false;\n }\n out << detail::fix_newlines(\" \", alias);\n }\n out << \"\\n\";\n }\n return out;\n}\n\nCLI11_INLINE bool valid_name_string(const std::string &str) {\n if(str.empty() || !valid_first_char(str[0])) {\n return false;\n }\n auto e = str.end();\n for(auto c = str.begin() + 1; c != e; ++c)\n if(!valid_later_char(*c))\n return false;\n return true;\n}\n\nCLI11_INLINE std::string find_and_replace(std::string str, std::string from, std::string to) {\n\n std::size_t start_pos = 0;\n\n while((start_pos = str.find(from, start_pos)) != std::string::npos) {\n str.replace(start_pos, from.length(), to);\n start_pos += to.length();\n }\n\n return str;\n}\n\nCLI11_INLINE void remove_default_flag_values(std::string &flags) {\n auto loc = flags.find_first_of('{', 2);\n while(loc != std::string::npos) {\n auto finish = flags.find_first_of(\"},\", loc + 1);\n if((finish != std::string::npos) && (flags[finish] == '}')) {\n flags.erase(flags.begin() + static_cast(loc),\n flags.begin() + static_cast(finish) + 1);\n }\n loc = flags.find_first_of('{', loc + 1);\n }\n flags.erase(std::remove(flags.begin(), flags.end(), '!'), flags.end());\n}\n\nCLI11_INLINE std::ptrdiff_t\nfind_member(std::string name, const std::vector names, bool ignore_case, bool ignore_underscore) {\n auto it = std::end(names);\n if(ignore_case) {\n if(ignore_underscore) {\n name = detail::to_lower(detail::remove_underscore(name));\n it = std::find_if(std::begin(names), std::end(names), [&name](std::string local_name) {\n return detail::to_lower(detail::remove_underscore(local_name)) == name;\n });\n } else {\n name = detail::to_lower(name);\n it = std::find_if(std::begin(names), std::end(names), [&name](std::string local_name) {\n return detail::to_lower(local_name) == name;\n });\n }\n\n } else if(ignore_underscore) {\n name = detail::remove_underscore(name);\n it = std::find_if(std::begin(names), std::end(names), [&name](std::string local_name) {\n return detail::remove_underscore(local_name) == name;\n });\n } else {\n it = std::find(std::begin(names), std::end(names), name);\n }\n\n return (it != std::end(names)) ? (it - std::begin(names)) : (-1);\n}\n\nCLI11_INLINE std::vector split_up(std::string str, char delimiter) {\n\n const std::string delims(\"\\'\\\"`\");\n auto find_ws = [delimiter](char ch) {\n return (delimiter == '\\0') ? std::isspace(ch, std::locale()) : (ch == delimiter);\n };\n trim(str);\n\n std::vector output;\n bool embeddedQuote = false;\n char keyChar = ' ';\n while(!str.empty()) {\n if(delims.find_first_of(str[0]) != std::string::npos) {\n keyChar = str[0];\n auto end = str.find_first_of(keyChar, 1);\n while((end != std::string::npos) && (str[end - 1] == '\\\\')) { // deal with escaped quotes\n end = str.find_first_of(keyChar, end + 1);\n embeddedQuote = true;\n }\n if(end != std::string::npos) {\n output.push_back(str.substr(1, end - 1));\n if(end + 2 < str.size()) {\n str = str.substr(end + 2);\n } else {\n str.clear();\n }\n\n } else {\n output.push_back(str.substr(1));\n str = \"\";\n }\n } else {\n auto it = std::find_if(std::begin(str), std::end(str), find_ws);\n if(it != std::end(str)) {\n std::string value = std::string(str.begin(), it);\n output.push_back(value);\n str = std::string(it + 1, str.end());\n } else {\n output.push_back(str);\n str = \"\";\n }\n }\n // transform any embedded quotes into the regular character\n if(embeddedQuote) {\n output.back() = find_and_replace(output.back(), std::string(\"\\\\\") + keyChar, std::string(1, keyChar));\n embeddedQuote = false;\n }\n trim(str);\n }\n return output;\n}\n\nCLI11_INLINE std::size_t escape_detect(std::string &str, std::size_t offset) {\n auto next = str[offset + 1];\n if((next == '\\\"') || (next == '\\'') || (next == '`')) {\n auto astart = str.find_last_of(\"-/ \\\"\\'`\", offset - 1);\n if(astart != std::string::npos) {\n if(str[astart] == ((str[offset] == '=') ? '-' : '/'))\n str[offset] = ' '; // interpret this as a space so the split_up works properly\n }\n }\n return offset + 1;\n}\n\nCLI11_INLINE std::string &add_quotes_if_needed(std::string &str) {\n if((str.front() != '\"' && str.front() != '\\'') || str.front() != str.back()) {\n char quote = str.find('\"') < str.find('\\'') ? '\\'' : '\"';\n if(str.find(' ') != std::string::npos) {\n str.insert(0, 1, quote);\n str.append(1, quote);\n }\n }\n return str;\n}\n\n} // namespace detail\n\n\n\n// Use one of these on all error classes.\n// These are temporary and are undef'd at the end of this file.\n#define CLI11_ERROR_DEF(parent, name) \\\n protected: \\\n name(std::string ename, std::string msg, int exit_code) : parent(std::move(ename), std::move(msg), exit_code) {} \\\n name(std::string ename, std::string msg, ExitCodes exit_code) \\\n : parent(std::move(ename), std::move(msg), exit_code) {} \\\n \\\n public: \\\n name(std::string msg, ExitCodes exit_code) : parent(#name, std::move(msg), exit_code) {} \\\n name(std::string msg, int exit_code) : parent(#name, std::move(msg), exit_code) {}\n\n// This is added after the one above if a class is used directly and builds its own message\n#define CLI11_ERROR_SIMPLE(name) \\\n explicit name(std::string msg) : name(#name, msg, ExitCodes::name) {}\n\n/// These codes are part of every error in CLI. They can be obtained from e using e.exit_code or as a quick shortcut,\n/// int values from e.get_error_code().\nenum class ExitCodes {\n Success = 0,\n IncorrectConstruction = 100,\n BadNameString,\n OptionAlreadyAdded,\n FileError,\n ConversionError,\n ValidationError,\n RequiredError,\n RequiresError,\n ExcludesError,\n ExtrasError,\n ConfigError,\n InvalidError,\n HorribleError,\n OptionNotFound,\n ArgumentMismatch,\n BaseClass = 127\n};\n\n// Error definitions\n\n/// @defgroup error_group Errors\n/// @brief Errors thrown by CLI11\n///\n/// These are the errors that can be thrown. Some of them, like CLI::Success, are not really errors.\n/// @{\n\n/// All errors derive from this one\nclass Error : public std::runtime_error {\n int actual_exit_code;\n std::string error_name{\"Error\"};\n\n public:\n CLI11_NODISCARD int get_exit_code() const { return actual_exit_code; }\n\n CLI11_NODISCARD std::string get_name() const { return error_name; }\n\n Error(std::string name, std::string msg, int exit_code = static_cast(ExitCodes::BaseClass))\n : runtime_error(msg), actual_exit_code(exit_code), error_name(std::move(name)) {}\n\n Error(std::string name, std::string msg, ExitCodes exit_code) : Error(name, msg, static_cast(exit_code)) {}\n};\n\n// Note: Using Error::Error constructors does not work on GCC 4.7\n\n/// Construction errors (not in parsing)\nclass ConstructionError : public Error {\n CLI11_ERROR_DEF(Error, ConstructionError)\n};\n\n/// Thrown when an option is set to conflicting values (non-vector and multi args, for example)\nclass IncorrectConstruction : public ConstructionError {\n CLI11_ERROR_DEF(ConstructionError, IncorrectConstruction)\n CLI11_ERROR_SIMPLE(IncorrectConstruction)\n static IncorrectConstruction PositionalFlag(std::string name) {\n return IncorrectConstruction(name + \": Flags cannot be positional\");\n }\n static IncorrectConstruction Set0Opt(std::string name) {\n return IncorrectConstruction(name + \": Cannot set 0 expected, use a flag instead\");\n }\n static IncorrectConstruction SetFlag(std::string name) {\n return IncorrectConstruction(name + \": Cannot set an expected number for flags\");\n }\n static IncorrectConstruction ChangeNotVector(std::string name) {\n return IncorrectConstruction(name + \": You can only change the expected arguments for vectors\");\n }\n static IncorrectConstruction AfterMultiOpt(std::string name) {\n return IncorrectConstruction(\n name + \": You can't change expected arguments after you've changed the multi option policy!\");\n }\n static IncorrectConstruction MissingOption(std::string name) {\n return IncorrectConstruction(\"Option \" + name + \" is not defined\");\n }\n static IncorrectConstruction MultiOptionPolicy(std::string name) {\n return IncorrectConstruction(name + \": multi_option_policy only works for flags and exact value options\");\n }\n};\n\n/// Thrown on construction of a bad name\nclass BadNameString : public ConstructionError {\n CLI11_ERROR_DEF(ConstructionError, BadNameString)\n CLI11_ERROR_SIMPLE(BadNameString)\n static BadNameString OneCharName(std::string name) { return BadNameString(\"Invalid one char name: \" + name); }\n static BadNameString BadLongName(std::string name) { return BadNameString(\"Bad long name: \" + name); }\n static BadNameString DashesOnly(std::string name) {\n return BadNameString(\"Must have a name, not just dashes: \" + name);\n }\n static BadNameString MultiPositionalNames(std::string name) {\n return BadNameString(\"Only one positional name allowed, remove: \" + name);\n }\n};\n\n/// Thrown when an option already exists\nclass OptionAlreadyAdded : public ConstructionError {\n CLI11_ERROR_DEF(ConstructionError, OptionAlreadyAdded)\n explicit OptionAlreadyAdded(std::string name)\n : OptionAlreadyAdded(name + \" is already added\", ExitCodes::OptionAlreadyAdded) {}\n static OptionAlreadyAdded Requires(std::string name, std::string other) {\n return {name + \" requires \" + other, ExitCodes::OptionAlreadyAdded};\n }\n static OptionAlreadyAdded Excludes(std::string name, std::string other) {\n return {name + \" excludes \" + other, ExitCodes::OptionAlreadyAdded};\n }\n};\n\n// Parsing errors\n\n/// Anything that can error in Parse\nclass ParseError : public Error {\n CLI11_ERROR_DEF(Error, ParseError)\n};\n\n// Not really \"errors\"\n\n/// This is a successful completion on parsing, supposed to exit\nclass Success : public ParseError {\n CLI11_ERROR_DEF(ParseError, Success)\n Success() : Success(\"Successfully completed, should be caught and quit\", ExitCodes::Success) {}\n};\n\n/// -h or --help on command line\nclass CallForHelp : public Success {\n CLI11_ERROR_DEF(Success, CallForHelp)\n CallForHelp() : CallForHelp(\"This should be caught in your main function, see examples\", ExitCodes::Success) {}\n};\n\n/// Usually something like --help-all on command line\nclass CallForAllHelp : public Success {\n CLI11_ERROR_DEF(Success, CallForAllHelp)\n CallForAllHelp()\n : CallForAllHelp(\"This should be caught in your main function, see examples\", ExitCodes::Success) {}\n};\n\n/// -v or --version on command line\nclass CallForVersion : public Success {\n CLI11_ERROR_DEF(Success, CallForVersion)\n CallForVersion()\n : CallForVersion(\"This should be caught in your main function, see examples\", ExitCodes::Success) {}\n};\n\n/// Does not output a diagnostic in CLI11_PARSE, but allows main() to return with a specific error code.\nclass RuntimeError : public ParseError {\n CLI11_ERROR_DEF(ParseError, RuntimeError)\n explicit RuntimeError(int exit_code = 1) : RuntimeError(\"Runtime error\", exit_code) {}\n};\n\n/// Thrown when parsing an INI file and it is missing\nclass FileError : public ParseError {\n CLI11_ERROR_DEF(ParseError, FileError)\n CLI11_ERROR_SIMPLE(FileError)\n static FileError Missing(std::string name) { return FileError(name + \" was not readable (missing?)\"); }\n};\n\n/// Thrown when conversion call back fails, such as when an int fails to coerce to a string\nclass ConversionError : public ParseError {\n CLI11_ERROR_DEF(ParseError, ConversionError)\n CLI11_ERROR_SIMPLE(ConversionError)\n ConversionError(std::string member, std::string name)\n : ConversionError(\"The value \" + member + \" is not an allowed value for \" + name) {}\n ConversionError(std::string name, std::vector results)\n : ConversionError(\"Could not convert: \" + name + \" = \" + detail::join(results)) {}\n static ConversionError TooManyInputsFlag(std::string name) {\n return ConversionError(name + \": too many inputs for a flag\");\n }\n static ConversionError TrueFalse(std::string name) {\n return ConversionError(name + \": Should be true/false or a number\");\n }\n};\n\n/// Thrown when validation of results fails\nclass ValidationError : public ParseError {\n CLI11_ERROR_DEF(ParseError, ValidationError)\n CLI11_ERROR_SIMPLE(ValidationError)\n explicit ValidationError(std::string name, std::string msg) : ValidationError(name + \": \" + msg) {}\n};\n\n/// Thrown when a required option is missing\nclass RequiredError : public ParseError {\n CLI11_ERROR_DEF(ParseError, RequiredError)\n explicit RequiredError(std::string name) : RequiredError(name + \" is required\", ExitCodes::RequiredError) {}\n static RequiredError Subcommand(std::size_t min_subcom) {\n if(min_subcom == 1) {\n return RequiredError(\"A subcommand\");\n }\n return {\"Requires at least \" + std::to_string(min_subcom) + \" subcommands\", ExitCodes::RequiredError};\n }\n static RequiredError\n Option(std::size_t min_option, std::size_t max_option, std::size_t used, const std::string &option_list) {\n if((min_option == 1) && (max_option == 1) && (used == 0))\n return RequiredError(\"Exactly 1 option from [\" + option_list + \"]\");\n if((min_option == 1) && (max_option == 1) && (used > 1)) {\n return {\"Exactly 1 option from [\" + option_list + \"] is required and \" + std::to_string(used) +\n \" were given\",\n ExitCodes::RequiredError};\n }\n if((min_option == 1) && (used == 0))\n return RequiredError(\"At least 1 option from [\" + option_list + \"]\");\n if(used < min_option) {\n return {\"Requires at least \" + std::to_string(min_option) + \" options used and only \" +\n std::to_string(used) + \"were given from [\" + option_list + \"]\",\n ExitCodes::RequiredError};\n }\n if(max_option == 1)\n return {\"Requires at most 1 options be given from [\" + option_list + \"]\", ExitCodes::RequiredError};\n\n return {\"Requires at most \" + std::to_string(max_option) + \" options be used and \" + std::to_string(used) +\n \"were given from [\" + option_list + \"]\",\n ExitCodes::RequiredError};\n }\n};\n\n/// Thrown when the wrong number of arguments has been received\nclass ArgumentMismatch : public ParseError {\n CLI11_ERROR_DEF(ParseError, ArgumentMismatch)\n CLI11_ERROR_SIMPLE(ArgumentMismatch)\n ArgumentMismatch(std::string name, int expected, std::size_t received)\n : ArgumentMismatch(expected > 0 ? (\"Expected exactly \" + std::to_string(expected) + \" arguments to \" + name +\n \", got \" + std::to_string(received))\n : (\"Expected at least \" + std::to_string(-expected) + \" arguments to \" + name +\n \", got \" + std::to_string(received)),\n ExitCodes::ArgumentMismatch) {}\n\n static ArgumentMismatch AtLeast(std::string name, int num, std::size_t received) {\n return ArgumentMismatch(name + \": At least \" + std::to_string(num) + \" required but received \" +\n std::to_string(received));\n }\n static ArgumentMismatch AtMost(std::string name, int num, std::size_t received) {\n return ArgumentMismatch(name + \": At Most \" + std::to_string(num) + \" required but received \" +\n std::to_string(received));\n }\n static ArgumentMismatch TypedAtLeast(std::string name, int num, std::string type) {\n return ArgumentMismatch(name + \": \" + std::to_string(num) + \" required \" + type + \" missing\");\n }\n static ArgumentMismatch FlagOverride(std::string name) {\n return ArgumentMismatch(name + \" was given a disallowed flag override\");\n }\n static ArgumentMismatch PartialType(std::string name, int num, std::string type) {\n return ArgumentMismatch(name + \": \" + type + \" only partially specified: \" + std::to_string(num) +\n \" required for each element\");\n }\n};\n\n/// Thrown when a requires option is missing\nclass RequiresError : public ParseError {\n CLI11_ERROR_DEF(ParseError, RequiresError)\n RequiresError(std::string curname, std::string subname)\n : RequiresError(curname + \" requires \" + subname, ExitCodes::RequiresError) {}\n};\n\n/// Thrown when an excludes option is present\nclass ExcludesError : public ParseError {\n CLI11_ERROR_DEF(ParseError, ExcludesError)\n ExcludesError(std::string curname, std::string subname)\n : ExcludesError(curname + \" excludes \" + subname, ExitCodes::ExcludesError) {}\n};\n\n/// Thrown when too many positionals or options are found\nclass ExtrasError : public ParseError {\n CLI11_ERROR_DEF(ParseError, ExtrasError)\n explicit ExtrasError(std::vector args)\n : ExtrasError((args.size() > 1 ? \"The following arguments were not expected: \"\n : \"The following argument was not expected: \") +\n detail::rjoin(args, \" \"),\n ExitCodes::ExtrasError) {}\n ExtrasError(const std::string &name, std::vector args)\n : ExtrasError(name,\n (args.size() > 1 ? \"The following arguments were not expected: \"\n : \"The following argument was not expected: \") +\n detail::rjoin(args, \" \"),\n ExitCodes::ExtrasError) {}\n};\n\n/// Thrown when extra values are found in an INI file\nclass ConfigError : public ParseError {\n CLI11_ERROR_DEF(ParseError, ConfigError)\n CLI11_ERROR_SIMPLE(ConfigError)\n static ConfigError Extras(std::string item) { return ConfigError(\"INI was not able to parse \" + item); }\n static ConfigError NotConfigurable(std::string item) {\n return ConfigError(item + \": This option is not allowed in a configuration file\");\n }\n};\n\n/// Thrown when validation fails before parsing\nclass InvalidError : public ParseError {\n CLI11_ERROR_DEF(ParseError, InvalidError)\n explicit InvalidError(std::string name)\n : InvalidError(name + \": Too many positional arguments with unlimited expected args\", ExitCodes::InvalidError) {\n }\n};\n\n/// This is just a safety check to verify selection and parsing match - you should not ever see it\n/// Strings are directly added to this error, but again, it should never be seen.\nclass HorribleError : public ParseError {\n CLI11_ERROR_DEF(ParseError, HorribleError)\n CLI11_ERROR_SIMPLE(HorribleError)\n};\n\n// After parsing\n\n/// Thrown when counting a non-existent option\nclass OptionNotFound : public Error {\n CLI11_ERROR_DEF(Error, OptionNotFound)\n explicit OptionNotFound(std::string name) : OptionNotFound(name + \" not found\", ExitCodes::OptionNotFound) {}\n};\n\n#undef CLI11_ERROR_DEF\n#undef CLI11_ERROR_SIMPLE\n\n/// @}\n\n\n\n\n// Type tools\n\n// Utilities for type enabling\nnamespace detail {\n// Based generally on https://rmf.io/cxx11/almost-static-if\n/// Simple empty scoped class\nenum class enabler {};\n\n/// An instance to use in EnableIf\nconstexpr enabler dummy = {};\n} // namespace detail\n\n/// A copy of enable_if_t from C++14, compatible with C++11.\n///\n/// We could check to see if C++14 is being used, but it does not hurt to redefine this\n/// (even Google does this: https://github.com/google/skia/blob/main/include/private/SkTLogic.h)\n/// It is not in the std namespace anyway, so no harm done.\ntemplate using enable_if_t = typename std::enable_if::type;\n\n/// A copy of std::void_t from C++17 (helper for C++11 and C++14)\ntemplate struct make_void {\n using type = void;\n};\n\n/// A copy of std::void_t from C++17 - same reasoning as enable_if_t, it does not hurt to redefine\ntemplate using void_t = typename make_void::type;\n\n/// A copy of std::conditional_t from C++14 - same reasoning as enable_if_t, it does not hurt to redefine\ntemplate using conditional_t = typename std::conditional::type;\n\n/// Check to see if something is bool (fail check by default)\ntemplate struct is_bool : std::false_type {};\n\n/// Check to see if something is bool (true if actually a bool)\ntemplate <> struct is_bool : std::true_type {};\n\n/// Check to see if something is a shared pointer\ntemplate struct is_shared_ptr : std::false_type {};\n\n/// Check to see if something is a shared pointer (True if really a shared pointer)\ntemplate struct is_shared_ptr> : std::true_type {};\n\n/// Check to see if something is a shared pointer (True if really a shared pointer)\ntemplate struct is_shared_ptr> : std::true_type {};\n\n/// Check to see if something is copyable pointer\ntemplate struct is_copyable_ptr {\n static bool const value = is_shared_ptr::value || std::is_pointer::value;\n};\n\n/// This can be specialized to override the type deduction for IsMember.\ntemplate struct IsMemberType {\n using type = T;\n};\n\n/// The main custom type needed here is const char * should be a string.\ntemplate <> struct IsMemberType {\n using type = std::string;\n};\n\nnamespace detail {\n\n// These are utilities for IsMember and other transforming objects\n\n/// Handy helper to access the element_type generically. This is not part of is_copyable_ptr because it requires that\n/// pointer_traits be valid.\n\n/// not a pointer\ntemplate struct element_type {\n using type = T;\n};\n\ntemplate struct element_type::value>::type> {\n using type = typename std::pointer_traits::element_type;\n};\n\n/// Combination of the element type and value type - remove pointer (including smart pointers) and get the value_type of\n/// the container\ntemplate struct element_value_type {\n using type = typename element_type::type::value_type;\n};\n\n/// Adaptor for set-like structure: This just wraps a normal container in a few utilities that do almost nothing.\ntemplate struct pair_adaptor : std::false_type {\n using value_type = typename T::value_type;\n using first_type = typename std::remove_const::type;\n using second_type = typename std::remove_const::type;\n\n /// Get the first value (really just the underlying value)\n template static auto first(Q &&pair_value) -> decltype(std::forward(pair_value)) {\n return std::forward(pair_value);\n }\n /// Get the second value (really just the underlying value)\n template static auto second(Q &&pair_value) -> decltype(std::forward(pair_value)) {\n return std::forward(pair_value);\n }\n};\n\n/// Adaptor for map-like structure (true version, must have key_type and mapped_type).\n/// This wraps a mapped container in a few utilities access it in a general way.\ntemplate \nstruct pair_adaptor<\n T,\n conditional_t, void>>\n : std::true_type {\n using value_type = typename T::value_type;\n using first_type = typename std::remove_const::type;\n using second_type = typename std::remove_const::type;\n\n /// Get the first value (really just the underlying value)\n template static auto first(Q &&pair_value) -> decltype(std::get<0>(std::forward(pair_value))) {\n return std::get<0>(std::forward(pair_value));\n }\n /// Get the second value (really just the underlying value)\n template static auto second(Q &&pair_value) -> decltype(std::get<1>(std::forward(pair_value))) {\n return std::get<1>(std::forward(pair_value));\n }\n};\n\n// Warning is suppressed due to \"bug\" in gcc<5.0 and gcc 7.0 with c++17 enabled that generates a Wnarrowing warning\n// in the unevaluated context even if the function that was using this wasn't used. The standard says narrowing in\n// brace initialization shouldn't be allowed but for backwards compatibility gcc allows it in some contexts. It is a\n// little fuzzy what happens in template constructs and I think that was something GCC took a little while to work out.\n// But regardless some versions of gcc generate a warning when they shouldn't from the following code so that should be\n// suppressed\n#ifdef __GNUC__\n#pragma GCC diagnostic push\n#pragma GCC diagnostic ignored \"-Wnarrowing\"\n#endif\n// check for constructibility from a specific type and copy assignable used in the parse detection\ntemplate class is_direct_constructible {\n template \n static auto test(int, std::true_type) -> decltype(\n// NVCC warns about narrowing conversions here\n#ifdef __CUDACC__\n#pragma diag_suppress 2361\n#endif\n TT{std::declval()}\n#ifdef __CUDACC__\n#pragma diag_default 2361\n#endif\n ,\n std::is_move_assignable());\n\n template static auto test(int, std::false_type) -> std::false_type;\n\n template static auto test(...) -> std::false_type;\n\n public:\n static constexpr bool value = decltype(test(0, typename std::is_constructible::type()))::value;\n};\n#ifdef __GNUC__\n#pragma GCC diagnostic pop\n#endif\n\n// Check for output streamability\n// Based on https://stackoverflow.com/questions/22758291/how-can-i-detect-if-a-type-can-be-streamed-to-an-stdostream\n\ntemplate class is_ostreamable {\n template \n static auto test(int) -> decltype(std::declval() << std::declval(), std::true_type());\n\n template static auto test(...) -> std::false_type;\n\n public:\n static constexpr bool value = decltype(test(0))::value;\n};\n\n/// Check for input streamability\ntemplate class is_istreamable {\n template \n static auto test(int) -> decltype(std::declval() >> std::declval(), std::true_type());\n\n template static auto test(...) -> std::false_type;\n\n public:\n static constexpr bool value = decltype(test(0))::value;\n};\n\n/// Check for complex\ntemplate class is_complex {\n template \n static auto test(int) -> decltype(std::declval().real(), std::declval().imag(), std::true_type());\n\n template static auto test(...) -> std::false_type;\n\n public:\n static constexpr bool value = decltype(test(0))::value;\n};\n\n/// Templated operation to get a value from a stream\ntemplate ::value, detail::enabler> = detail::dummy>\nbool from_stream(const std::string &istring, T &obj) {\n std::istringstream is;\n is.str(istring);\n is >> obj;\n return !is.fail() && !is.rdbuf()->in_avail();\n}\n\ntemplate ::value, detail::enabler> = detail::dummy>\nbool from_stream(const std::string & /*istring*/, T & /*obj*/) {\n return false;\n}\n\n// check to see if an object is a mutable container (fail by default)\ntemplate struct is_mutable_container : std::false_type {};\n\n/// type trait to test if a type is a mutable container meaning it has a value_type, it has an iterator, a clear, and\n/// end methods and an insert function. And for our purposes we exclude std::string and types that can be constructed\n/// from a std::string\ntemplate \nstruct is_mutable_container<\n T,\n conditional_t().end()),\n decltype(std::declval().clear()),\n decltype(std::declval().insert(std::declval().end())>(),\n std::declval()))>,\n void>>\n : public conditional_t::value, std::false_type, std::true_type> {};\n\n// check to see if an object is a mutable container (fail by default)\ntemplate struct is_readable_container : std::false_type {};\n\n/// type trait to test if a type is a container meaning it has a value_type, it has an iterator, a clear, and an end\n/// methods and an insert function. And for our purposes we exclude std::string and types that can be constructed from\n/// a std::string\ntemplate \nstruct is_readable_container<\n T,\n conditional_t().end()), decltype(std::declval().begin())>, void>>\n : public std::true_type {};\n\n// check to see if an object is a wrapper (fail by default)\ntemplate struct is_wrapper : std::false_type {};\n\n// check if an object is a wrapper (it has a value_type defined)\ntemplate \nstruct is_wrapper, void>> : public std::true_type {};\n\n// Check for tuple like types, as in classes with a tuple_size type trait\ntemplate class is_tuple_like {\n template \n // static auto test(int)\n // -> decltype(std::conditional<(std::tuple_size::value > 0), std::true_type, std::false_type>::type());\n static auto test(int) -> decltype(std::tuple_size::type>::value, std::true_type{});\n template static auto test(...) -> std::false_type;\n\n public:\n static constexpr bool value = decltype(test(0))::value;\n};\n\n/// Convert an object to a string (directly forward if this can become a string)\ntemplate ::value, detail::enabler> = detail::dummy>\nauto to_string(T &&value) -> decltype(std::forward(value)) {\n return std::forward(value);\n}\n\n/// Construct a string from the object\ntemplate ::value && !std::is_convertible::value,\n detail::enabler> = detail::dummy>\nstd::string to_string(const T &value) {\n return std::string(value); // NOLINT(google-readability-casting)\n}\n\n/// Convert an object to a string (streaming must be supported for that type)\ntemplate ::value && !std::is_constructible::value &&\n is_ostreamable::value,\n detail::enabler> = detail::dummy>\nstd::string to_string(T &&value) {\n std::stringstream stream;\n stream << value;\n return stream.str();\n}\n\n/// If conversion is not supported, return an empty string (streaming is not supported for that type)\ntemplate ::value && !is_ostreamable::value &&\n !is_readable_container::type>::value,\n detail::enabler> = detail::dummy>\nstd::string to_string(T &&) {\n return {};\n}\n\n/// convert a readable container to a string\ntemplate ::value && !is_ostreamable::value &&\n is_readable_container::value,\n detail::enabler> = detail::dummy>\nstd::string to_string(T &&variable) {\n auto cval = variable.begin();\n auto end = variable.end();\n if(cval == end) {\n return {\"{}\"};\n }\n std::vector defaults;\n while(cval != end) {\n defaults.emplace_back(CLI::detail::to_string(*cval));\n ++cval;\n }\n return {\"[\" + detail::join(defaults) + \"]\"};\n}\n\n/// special template overload\ntemplate ::value, detail::enabler> = detail::dummy>\nauto checked_to_string(T &&value) -> decltype(to_string(std::forward(value))) {\n return to_string(std::forward(value));\n}\n\n/// special template overload\ntemplate ::value, detail::enabler> = detail::dummy>\nstd::string checked_to_string(T &&) {\n return std::string{};\n}\n/// get a string as a convertible value for arithmetic types\ntemplate ::value, detail::enabler> = detail::dummy>\nstd::string value_string(const T &value) {\n return std::to_string(value);\n}\n/// get a string as a convertible value for enumerations\ntemplate ::value, detail::enabler> = detail::dummy>\nstd::string value_string(const T &value) {\n return std::to_string(static_cast::type>(value));\n}\n/// for other types just use the regular to_string function\ntemplate ::value && !std::is_arithmetic::value, detail::enabler> = detail::dummy>\nauto value_string(const T &value) -> decltype(to_string(value)) {\n return to_string(value);\n}\n\n/// template to get the underlying value type if it exists or use a default\ntemplate struct wrapped_type {\n using type = def;\n};\n\n/// Type size for regular object types that do not look like a tuple\ntemplate struct wrapped_type::value>::type> {\n using type = typename T::value_type;\n};\n\n/// This will only trigger for actual void type\ntemplate struct type_count_base {\n static const int value{0};\n};\n\n/// Type size for regular object types that do not look like a tuple\ntemplate \nstruct type_count_base::value && !is_mutable_container::value &&\n !std::is_void::value>::type> {\n static constexpr int value{1};\n};\n\n/// the base tuple size\ntemplate \nstruct type_count_base::value && !is_mutable_container::value>::type> {\n static constexpr int value{std::tuple_size::value};\n};\n\n/// Type count base for containers is the type_count_base of the individual element\ntemplate struct type_count_base::value>::type> {\n static constexpr int value{type_count_base::value};\n};\n\n/// Set of overloads to get the type size of an object\n\n/// forward declare the subtype_count structure\ntemplate struct subtype_count;\n\n/// forward declare the subtype_count_min structure\ntemplate struct subtype_count_min;\n\n/// This will only trigger for actual void type\ntemplate struct type_count {\n static const int value{0};\n};\n\n/// Type size for regular object types that do not look like a tuple\ntemplate \nstruct type_count::value && !is_tuple_like::value && !is_complex::value &&\n !std::is_void::value>::type> {\n static constexpr int value{1};\n};\n\n/// Type size for complex since it sometimes looks like a wrapper\ntemplate struct type_count::value>::type> {\n static constexpr int value{2};\n};\n\n/// Type size of types that are wrappers,except complex and tuples(which can also be wrappers sometimes)\ntemplate struct type_count::value>::type> {\n static constexpr int value{subtype_count::value};\n};\n\n/// Type size of types that are wrappers,except containers complex and tuples(which can also be wrappers sometimes)\ntemplate \nstruct type_count::value && !is_complex::value && !is_tuple_like::value &&\n !is_mutable_container::value>::type> {\n static constexpr int value{type_count::value};\n};\n\n/// 0 if the index > tuple size\ntemplate \nconstexpr typename std::enable_if::value, int>::type tuple_type_size() {\n return 0;\n}\n\n/// Recursively generate the tuple type name\ntemplate \n constexpr typename std::enable_if < I::value, int>::type tuple_type_size() {\n return subtype_count::type>::value + tuple_type_size();\n}\n\n/// Get the type size of the sum of type sizes for all the individual tuple types\ntemplate struct type_count::value>::type> {\n static constexpr int value{tuple_type_size()};\n};\n\n/// definition of subtype count\ntemplate struct subtype_count {\n static constexpr int value{is_mutable_container::value ? expected_max_vector_size : type_count::value};\n};\n\n/// This will only trigger for actual void type\ntemplate struct type_count_min {\n static const int value{0};\n};\n\n/// Type size for regular object types that do not look like a tuple\ntemplate \nstruct type_count_min<\n T,\n typename std::enable_if::value && !is_tuple_like::value && !is_wrapper::value &&\n !is_complex::value && !std::is_void::value>::type> {\n static constexpr int value{type_count::value};\n};\n\n/// Type size for complex since it sometimes looks like a wrapper\ntemplate struct type_count_min::value>::type> {\n static constexpr int value{1};\n};\n\n/// Type size min of types that are wrappers,except complex and tuples(which can also be wrappers sometimes)\ntemplate \nstruct type_count_min<\n T,\n typename std::enable_if::value && !is_complex::value && !is_tuple_like::value>::type> {\n static constexpr int value{subtype_count_min::value};\n};\n\n/// 0 if the index > tuple size\ntemplate \nconstexpr typename std::enable_if::value, int>::type tuple_type_size_min() {\n return 0;\n}\n\n/// Recursively generate the tuple type name\ntemplate \n constexpr typename std::enable_if < I::value, int>::type tuple_type_size_min() {\n return subtype_count_min::type>::value + tuple_type_size_min();\n}\n\n/// Get the type size of the sum of type sizes for all the individual tuple types\ntemplate struct type_count_min::value>::type> {\n static constexpr int value{tuple_type_size_min()};\n};\n\n/// definition of subtype count\ntemplate struct subtype_count_min {\n static constexpr int value{is_mutable_container::value\n ? ((type_count::value < expected_max_vector_size) ? type_count::value : 0)\n : type_count_min::value};\n};\n\n/// This will only trigger for actual void type\ntemplate struct expected_count {\n static const int value{0};\n};\n\n/// For most types the number of expected items is 1\ntemplate \nstruct expected_count::value && !is_wrapper::value &&\n !std::is_void::value>::type> {\n static constexpr int value{1};\n};\n/// number of expected items in a vector\ntemplate struct expected_count::value>::type> {\n static constexpr int value{expected_max_vector_size};\n};\n\n/// number of expected items in a vector\ntemplate \nstruct expected_count::value && is_wrapper::value>::type> {\n static constexpr int value{expected_count::value};\n};\n\n// Enumeration of the different supported categorizations of objects\nenum class object_category : int {\n char_value = 1,\n integral_value = 2,\n unsigned_integral = 4,\n enumeration = 6,\n boolean_value = 8,\n floating_point = 10,\n number_constructible = 12,\n double_constructible = 14,\n integer_constructible = 16,\n // string like types\n string_assignable = 23,\n string_constructible = 24,\n other = 45,\n // special wrapper or container types\n wrapper_value = 50,\n complex_number = 60,\n tuple_value = 70,\n container_value = 80,\n\n};\n\n/// Set of overloads to classify an object according to type\n\n/// some type that is not otherwise recognized\ntemplate struct classify_object {\n static constexpr object_category value{object_category::other};\n};\n\n/// Signed integers\ntemplate \nstruct classify_object<\n T,\n typename std::enable_if::value && !std::is_same::value && std::is_signed::value &&\n !is_bool::value && !std::is_enum::value>::type> {\n static constexpr object_category value{object_category::integral_value};\n};\n\n/// Unsigned integers\ntemplate \nstruct classify_object::value && std::is_unsigned::value &&\n !std::is_same::value && !is_bool::value>::type> {\n static constexpr object_category value{object_category::unsigned_integral};\n};\n\n/// single character values\ntemplate \nstruct classify_object::value && !std::is_enum::value>::type> {\n static constexpr object_category value{object_category::char_value};\n};\n\n/// Boolean values\ntemplate struct classify_object::value>::type> {\n static constexpr object_category value{object_category::boolean_value};\n};\n\n/// Floats\ntemplate struct classify_object::value>::type> {\n static constexpr object_category value{object_category::floating_point};\n};\n\n/// String and similar direct assignment\ntemplate \nstruct classify_object::value && !std::is_integral::value &&\n std::is_assignable::value>::type> {\n static constexpr object_category value{object_category::string_assignable};\n};\n\n/// String and similar constructible and copy assignment\ntemplate \nstruct classify_object<\n T,\n typename std::enable_if::value && !std::is_integral::value &&\n !std::is_assignable::value && (type_count::value == 1) &&\n std::is_constructible::value>::type> {\n static constexpr object_category value{object_category::string_constructible};\n};\n\n/// Enumerations\ntemplate struct classify_object::value>::type> {\n static constexpr object_category value{object_category::enumeration};\n};\n\ntemplate struct classify_object::value>::type> {\n static constexpr object_category value{object_category::complex_number};\n};\n\n/// Handy helper to contain a bunch of checks that rule out many common types (integers, string like, floating point,\n/// vectors, and enumerations\ntemplate struct uncommon_type {\n using type = typename std::conditional::value && !std::is_integral::value &&\n !std::is_assignable::value &&\n !std::is_constructible::value && !is_complex::value &&\n !is_mutable_container::value && !std::is_enum::value,\n std::true_type,\n std::false_type>::type;\n static constexpr bool value = type::value;\n};\n\n/// wrapper type\ntemplate \nstruct classify_object::value && is_wrapper::value &&\n !is_tuple_like::value && uncommon_type::value)>::type> {\n static constexpr object_category value{object_category::wrapper_value};\n};\n\n/// Assignable from double or int\ntemplate \nstruct classify_object::value && type_count::value == 1 &&\n !is_wrapper::value && is_direct_constructible::value &&\n is_direct_constructible::value>::type> {\n static constexpr object_category value{object_category::number_constructible};\n};\n\n/// Assignable from int\ntemplate \nstruct classify_object::value && type_count::value == 1 &&\n !is_wrapper::value && !is_direct_constructible::value &&\n is_direct_constructible::value>::type> {\n static constexpr object_category value{object_category::integer_constructible};\n};\n\n/// Assignable from double\ntemplate \nstruct classify_object::value && type_count::value == 1 &&\n !is_wrapper::value && is_direct_constructible::value &&\n !is_direct_constructible::value>::type> {\n static constexpr object_category value{object_category::double_constructible};\n};\n\n/// Tuple type\ntemplate \nstruct classify_object<\n T,\n typename std::enable_if::value &&\n ((type_count::value >= 2 && !is_wrapper::value) ||\n (uncommon_type::value && !is_direct_constructible::value &&\n !is_direct_constructible::value) ||\n (uncommon_type::value && type_count::value >= 2))>::type> {\n static constexpr object_category value{object_category::tuple_value};\n // the condition on this class requires it be like a tuple, but on some compilers (like Xcode) tuples can be\n // constructed from just the first element so tuples of can be constructed from a string, which\n // could lead to issues so there are two variants of the condition, the first isolates things with a type size >=2\n // mainly to get tuples on Xcode with the exception of wrappers, the second is the main one and just separating out\n // those cases that are caught by other object classifications\n};\n\n/// container type\ntemplate struct classify_object::value>::type> {\n static constexpr object_category value{object_category::container_value};\n};\n\n// Type name print\n\n/// Was going to be based on\n/// http://stackoverflow.com/questions/1055452/c-get-name-of-type-in-template\n/// But this is cleaner and works better in this case\n\ntemplate ::value == object_category::char_value, detail::enabler> = detail::dummy>\nconstexpr const char *type_name() {\n return \"CHAR\";\n}\n\ntemplate ::value == object_category::integral_value ||\n classify_object::value == object_category::integer_constructible,\n detail::enabler> = detail::dummy>\nconstexpr const char *type_name() {\n return \"INT\";\n}\n\ntemplate ::value == object_category::unsigned_integral, detail::enabler> = detail::dummy>\nconstexpr const char *type_name() {\n return \"UINT\";\n}\n\ntemplate ::value == object_category::floating_point ||\n classify_object::value == object_category::number_constructible ||\n classify_object::value == object_category::double_constructible,\n detail::enabler> = detail::dummy>\nconstexpr const char *type_name() {\n return \"FLOAT\";\n}\n\n/// Print name for enumeration types\ntemplate ::value == object_category::enumeration, detail::enabler> = detail::dummy>\nconstexpr const char *type_name() {\n return \"ENUM\";\n}\n\n/// Print name for enumeration types\ntemplate ::value == object_category::boolean_value, detail::enabler> = detail::dummy>\nconstexpr const char *type_name() {\n return \"BOOLEAN\";\n}\n\n/// Print name for enumeration types\ntemplate ::value == object_category::complex_number, detail::enabler> = detail::dummy>\nconstexpr const char *type_name() {\n return \"COMPLEX\";\n}\n\n/// Print for all other types\ntemplate ::value >= object_category::string_assignable &&\n classify_object::value <= object_category::other,\n detail::enabler> = detail::dummy>\nconstexpr const char *type_name() {\n return \"TEXT\";\n}\n/// typename for tuple value\ntemplate ::value == object_category::tuple_value && type_count_base::value >= 2,\n detail::enabler> = detail::dummy>\nstd::string type_name(); // forward declaration\n\n/// Generate type name for a wrapper or container value\ntemplate ::value == object_category::container_value ||\n classify_object::value == object_category::wrapper_value,\n detail::enabler> = detail::dummy>\nstd::string type_name(); // forward declaration\n\n/// Print name for single element tuple types\ntemplate ::value == object_category::tuple_value && type_count_base::value == 1,\n detail::enabler> = detail::dummy>\ninline std::string type_name() {\n return type_name::type>::type>();\n}\n\n/// Empty string if the index > tuple size\ntemplate \ninline typename std::enable_if::value, std::string>::type tuple_name() {\n return std::string{};\n}\n\n/// Recursively generate the tuple type name\ntemplate \ninline typename std::enable_if<(I < type_count_base::value), std::string>::type tuple_name() {\n auto str = std::string{type_name::type>::type>()} + ',' +\n tuple_name();\n if(str.back() == ',')\n str.pop_back();\n return str;\n}\n\n/// Print type name for tuples with 2 or more elements\ntemplate ::value == object_category::tuple_value && type_count_base::value >= 2,\n detail::enabler>>\ninline std::string type_name() {\n auto tname = std::string(1, '[') + tuple_name();\n tname.push_back(']');\n return tname;\n}\n\n/// get the type name for a type that has a value_type member\ntemplate ::value == object_category::container_value ||\n classify_object::value == object_category::wrapper_value,\n detail::enabler>>\ninline std::string type_name() {\n return type_name();\n}\n\n// Lexical cast\n\n/// Convert to an unsigned integral\ntemplate ::value, detail::enabler> = detail::dummy>\nbool integral_conversion(const std::string &input, T &output) noexcept {\n if(input.empty() || input.front() == '-') {\n return false;\n }\n char *val = nullptr;\n errno = 0;\n std::uint64_t output_ll = std::strtoull(input.c_str(), &val, 0);\n if(errno == ERANGE) {\n return false;\n }\n output = static_cast(output_ll);\n if(val == (input.c_str() + input.size()) && static_cast(output) == output_ll) {\n return true;\n }\n val = nullptr;\n std::int64_t output_sll = std::strtoll(input.c_str(), &val, 0);\n if(val == (input.c_str() + input.size())) {\n output = (output_sll < 0) ? static_cast(0) : static_cast(output_sll);\n return (static_cast(output) == output_sll);\n }\n return false;\n}\n\n/// Convert to a signed integral\ntemplate ::value, detail::enabler> = detail::dummy>\nbool integral_conversion(const std::string &input, T &output) noexcept {\n if(input.empty()) {\n return false;\n }\n char *val = nullptr;\n errno = 0;\n std::int64_t output_ll = std::strtoll(input.c_str(), &val, 0);\n if(errno == ERANGE) {\n return false;\n }\n output = static_cast(output_ll);\n if(val == (input.c_str() + input.size()) && static_cast(output) == output_ll) {\n return true;\n }\n if(input == \"true\") {\n // this is to deal with a few oddities with flags and wrapper int types\n output = static_cast(1);\n return true;\n }\n return false;\n}\n\n/// Convert a flag into an integer value typically binary flags\ninline std::int64_t to_flag_value(std::string val) {\n static const std::string trueString(\"true\");\n static const std::string falseString(\"false\");\n if(val == trueString) {\n return 1;\n }\n if(val == falseString) {\n return -1;\n }\n val = detail::to_lower(val);\n std::int64_t ret = 0;\n if(val.size() == 1) {\n if(val[0] >= '1' && val[0] <= '9') {\n return (static_cast(val[0]) - '0');\n }\n switch(val[0]) {\n case '0':\n case 'f':\n case 'n':\n case '-':\n ret = -1;\n break;\n case 't':\n case 'y':\n case '+':\n ret = 1;\n break;\n default:\n throw std::invalid_argument(\"unrecognized character\");\n }\n return ret;\n }\n if(val == trueString || val == \"on\" || val == \"yes\" || val == \"enable\") {\n ret = 1;\n } else if(val == falseString || val == \"off\" || val == \"no\" || val == \"disable\") {\n ret = -1;\n } else {\n ret = std::stoll(val);\n }\n return ret;\n}\n\n/// Integer conversion\ntemplate ::value == object_category::integral_value ||\n classify_object::value == object_category::unsigned_integral,\n detail::enabler> = detail::dummy>\nbool lexical_cast(const std::string &input, T &output) {\n return integral_conversion(input, output);\n}\n\n/// char values\ntemplate ::value == object_category::char_value, detail::enabler> = detail::dummy>\nbool lexical_cast(const std::string &input, T &output) {\n if(input.size() == 1) {\n output = static_cast(input[0]);\n return true;\n }\n return integral_conversion(input, output);\n}\n\n/// Boolean values\ntemplate ::value == object_category::boolean_value, detail::enabler> = detail::dummy>\nbool lexical_cast(const std::string &input, T &output) {\n try {\n auto out = to_flag_value(input);\n output = (out > 0);\n return true;\n } catch(const std::invalid_argument &) {\n return false;\n } catch(const std::out_of_range &) {\n // if the number is out of the range of a 64 bit value then it is still a number and for this purpose is still\n // valid all we care about the sign\n output = (input[0] != '-');\n return true;\n }\n}\n\n/// Floats\ntemplate ::value == object_category::floating_point, detail::enabler> = detail::dummy>\nbool lexical_cast(const std::string &input, T &output) {\n if(input.empty()) {\n return false;\n }\n char *val = nullptr;\n auto output_ld = std::strtold(input.c_str(), &val);\n output = static_cast(output_ld);\n return val == (input.c_str() + input.size());\n}\n\n/// complex\ntemplate ::value == object_category::complex_number, detail::enabler> = detail::dummy>\nbool lexical_cast(const std::string &input, T &output) {\n using XC = typename wrapped_type::type;\n XC x{0.0}, y{0.0};\n auto str1 = input;\n bool worked = false;\n auto nloc = str1.find_last_of(\"+-\");\n if(nloc != std::string::npos && nloc > 0) {\n worked = lexical_cast(str1.substr(0, nloc), x);\n str1 = str1.substr(nloc);\n if(str1.back() == 'i' || str1.back() == 'j')\n str1.pop_back();\n worked = worked && lexical_cast(str1, y);\n } else {\n if(str1.back() == 'i' || str1.back() == 'j') {\n str1.pop_back();\n worked = lexical_cast(str1, y);\n x = XC{0};\n } else {\n worked = lexical_cast(str1, x);\n y = XC{0};\n }\n }\n if(worked) {\n output = T{x, y};\n return worked;\n }\n return from_stream(input, output);\n}\n\n/// String and similar direct assignment\ntemplate ::value == object_category::string_assignable, detail::enabler> = detail::dummy>\nbool lexical_cast(const std::string &input, T &output) {\n output = input;\n return true;\n}\n\n/// String and similar constructible and copy assignment\ntemplate <\n typename T,\n enable_if_t::value == object_category::string_constructible, detail::enabler> = detail::dummy>\nbool lexical_cast(const std::string &input, T &output) {\n output = T(input);\n return true;\n}\n\n/// Enumerations\ntemplate ::value == object_category::enumeration, detail::enabler> = detail::dummy>\nbool lexical_cast(const std::string &input, T &output) {\n typename std::underlying_type::type val;\n if(!integral_conversion(input, val)) {\n return false;\n }\n output = static_cast(val);\n return true;\n}\n\n/// wrapper types\ntemplate ::value == object_category::wrapper_value &&\n std::is_assignable::value,\n detail::enabler> = detail::dummy>\nbool lexical_cast(const std::string &input, T &output) {\n typename T::value_type val;\n if(lexical_cast(input, val)) {\n output = val;\n return true;\n }\n return from_stream(input, output);\n}\n\ntemplate ::value == object_category::wrapper_value &&\n !std::is_assignable::value && std::is_assignable::value,\n detail::enabler> = detail::dummy>\nbool lexical_cast(const std::string &input, T &output) {\n typename T::value_type val;\n if(lexical_cast(input, val)) {\n output = T{val};\n return true;\n }\n return from_stream(input, output);\n}\n\n/// Assignable from double or int\ntemplate <\n typename T,\n enable_if_t::value == object_category::number_constructible, detail::enabler> = detail::dummy>\nbool lexical_cast(const std::string &input, T &output) {\n int val = 0;\n if(integral_conversion(input, val)) {\n output = T(val);\n return true;\n }\n\n double dval = 0.0;\n if(lexical_cast(input, dval)) {\n output = T{dval};\n return true;\n }\n\n return from_stream(input, output);\n}\n\n/// Assignable from int\ntemplate <\n typename T,\n enable_if_t::value == object_category::integer_constructible, detail::enabler> = detail::dummy>\nbool lexical_cast(const std::string &input, T &output) {\n int val = 0;\n if(integral_conversion(input, val)) {\n output = T(val);\n return true;\n }\n return from_stream(input, output);\n}\n\n/// Assignable from double\ntemplate <\n typename T,\n enable_if_t::value == object_category::double_constructible, detail::enabler> = detail::dummy>\nbool lexical_cast(const std::string &input, T &output) {\n double val = 0.0;\n if(lexical_cast(input, val)) {\n output = T{val};\n return true;\n }\n return from_stream(input, output);\n}\n\n/// Non-string convertible from an int\ntemplate ::value == object_category::other && std::is_assignable::value,\n detail::enabler> = detail::dummy>\nbool lexical_cast(const std::string &input, T &output) {\n int val = 0;\n if(integral_conversion(input, val)) {\n#ifdef _MSC_VER\n#pragma warning(push)\n#pragma warning(disable : 4800)\n#endif\n // with Atomic this could produce a warning due to the conversion but if atomic gets here it is an old style\n // so will most likely still work\n output = val;\n#ifdef _MSC_VER\n#pragma warning(pop)\n#endif\n return true;\n }\n // LCOV_EXCL_START\n // This version of cast is only used for odd cases in an older compilers the fail over\n // from_stream is tested elsewhere an not relevant for coverage here\n return from_stream(input, output);\n // LCOV_EXCL_STOP\n}\n\n/// Non-string parsable by a stream\ntemplate ::value == object_category::other && !std::is_assignable::value,\n detail::enabler> = detail::dummy>\nbool lexical_cast(const std::string &input, T &output) {\n static_assert(is_istreamable::value,\n \"option object type must have a lexical cast overload or streaming input operator(>>) defined, if it \"\n \"is convertible from another type use the add_option(...) with XC being the known type\");\n return from_stream(input, output);\n}\n\n/// Assign a value through lexical cast operations\n/// Strings can be empty so we need to do a little different\ntemplate ::value &&\n (classify_object::value == object_category::string_assignable ||\n classify_object::value == object_category::string_constructible),\n detail::enabler> = detail::dummy>\nbool lexical_assign(const std::string &input, AssignTo &output) {\n return lexical_cast(input, output);\n}\n\n/// Assign a value through lexical cast operations\ntemplate ::value && std::is_assignable::value &&\n classify_object::value != object_category::string_assignable &&\n classify_object::value != object_category::string_constructible,\n detail::enabler> = detail::dummy>\nbool lexical_assign(const std::string &input, AssignTo &output) {\n if(input.empty()) {\n output = AssignTo{};\n return true;\n }\n\n return lexical_cast(input, output);\n}\n\n/// Assign a value through lexical cast operations\ntemplate ::value && !std::is_assignable::value &&\n classify_object::value == object_category::wrapper_value,\n detail::enabler> = detail::dummy>\nbool lexical_assign(const std::string &input, AssignTo &output) {\n if(input.empty()) {\n typename AssignTo::value_type emptyVal{};\n output = emptyVal;\n return true;\n }\n return lexical_cast(input, output);\n}\n\n/// Assign a value through lexical cast operations for int compatible values\n/// mainly for atomic operations on some compilers\ntemplate ::value && !std::is_assignable::value &&\n classify_object::value != object_category::wrapper_value &&\n std::is_assignable::value,\n detail::enabler> = detail::dummy>\nbool lexical_assign(const std::string &input, AssignTo &output) {\n if(input.empty()) {\n output = 0;\n return true;\n }\n int val = 0;\n if(lexical_cast(input, val)) {\n output = val;\n return true;\n }\n return false;\n}\n\n/// Assign a value converted from a string in lexical cast to the output value directly\ntemplate ::value && std::is_assignable::value,\n detail::enabler> = detail::dummy>\nbool lexical_assign(const std::string &input, AssignTo &output) {\n ConvertTo val{};\n bool parse_result = (!input.empty()) ? lexical_cast(input, val) : true;\n if(parse_result) {\n output = val;\n }\n return parse_result;\n}\n\n/// Assign a value from a lexical cast through constructing a value and move assigning it\ntemplate <\n typename AssignTo,\n typename ConvertTo,\n enable_if_t::value && !std::is_assignable::value &&\n std::is_move_assignable::value,\n detail::enabler> = detail::dummy>\nbool lexical_assign(const std::string &input, AssignTo &output) {\n ConvertTo val{};\n bool parse_result = input.empty() ? true : lexical_cast(input, val);\n if(parse_result) {\n output = AssignTo(val); // use () form of constructor to allow some implicit conversions\n }\n return parse_result;\n}\n\n/// primary lexical conversion operation, 1 string to 1 type of some kind\ntemplate ::value <= object_category::other &&\n classify_object::value <= object_category::wrapper_value,\n detail::enabler> = detail::dummy>\nbool lexical_conversion(const std::vector &strings, AssignTo &output) {\n return lexical_assign(strings[0], output);\n}\n\n/// Lexical conversion if there is only one element but the conversion type is for two, then call a two element\n/// constructor\ntemplate ::value <= 2) && expected_count::value == 1 &&\n is_tuple_like::value && type_count_base::value == 2,\n detail::enabler> = detail::dummy>\nbool lexical_conversion(const std::vector &strings, AssignTo &output) {\n // the remove const is to handle pair types coming from a container\n typename std::remove_const::type>::type v1;\n typename std::tuple_element<1, ConvertTo>::type v2;\n bool retval = lexical_assign(strings[0], v1);\n if(strings.size() > 1) {\n retval = retval && lexical_assign(strings[1], v2);\n }\n if(retval) {\n output = AssignTo{v1, v2};\n }\n return retval;\n}\n\n/// Lexical conversion of a container types of single elements\ntemplate ::value && is_mutable_container::value &&\n type_count::value == 1,\n detail::enabler> = detail::dummy>\nbool lexical_conversion(const std::vector &strings, AssignTo &output) {\n output.erase(output.begin(), output.end());\n if(strings.size() == 1 && strings[0] == \"{}\") {\n return true;\n }\n bool skip_remaining = false;\n if(strings.size() == 2 && strings[0] == \"{}\" && is_separator(strings[1])) {\n skip_remaining = true;\n }\n for(const auto &elem : strings) {\n typename AssignTo::value_type out;\n bool retval = lexical_assign(elem, out);\n if(!retval) {\n return false;\n }\n output.insert(output.end(), std::move(out));\n if(skip_remaining) {\n break;\n }\n }\n return (!output.empty());\n}\n\n/// Lexical conversion for complex types\ntemplate ::value, detail::enabler> = detail::dummy>\nbool lexical_conversion(const std::vector &strings, AssignTo &output) {\n\n if(strings.size() >= 2 && !strings[1].empty()) {\n using XC2 = typename wrapped_type::type;\n XC2 x{0.0}, y{0.0};\n auto str1 = strings[1];\n if(str1.back() == 'i' || str1.back() == 'j') {\n str1.pop_back();\n }\n auto worked = lexical_cast(strings[0], x) && lexical_cast(str1, y);\n if(worked) {\n output = ConvertTo{x, y};\n }\n return worked;\n }\n return lexical_assign(strings[0], output);\n}\n\n/// Conversion to a vector type using a particular single type as the conversion type\ntemplate ::value && (expected_count::value == 1) &&\n (type_count::value == 1),\n detail::enabler> = detail::dummy>\nbool lexical_conversion(const std::vector &strings, AssignTo &output) {\n bool retval = true;\n output.clear();\n output.reserve(strings.size());\n for(const auto &elem : strings) {\n\n output.emplace_back();\n retval = retval && lexical_assign(elem, output.back());\n }\n return (!output.empty()) && retval;\n}\n\n// forward declaration\n\n/// Lexical conversion of a container types with conversion type of two elements\ntemplate ::value && is_mutable_container::value &&\n type_count_base::value == 2,\n detail::enabler> = detail::dummy>\nbool lexical_conversion(std::vector strings, AssignTo &output);\n\n/// Lexical conversion of a vector types with type_size >2 forward declaration\ntemplate ::value && is_mutable_container::value &&\n type_count_base::value != 2 &&\n ((type_count::value > 2) ||\n (type_count::value > type_count_base::value)),\n detail::enabler> = detail::dummy>\nbool lexical_conversion(const std::vector &strings, AssignTo &output);\n\n/// Conversion for tuples\ntemplate ::value && is_tuple_like::value &&\n (type_count_base::value != type_count::value ||\n type_count::value > 2),\n detail::enabler> = detail::dummy>\nbool lexical_conversion(const std::vector &strings, AssignTo &output); // forward declaration\n\n/// Conversion for operations where the assigned type is some class but the conversion is a mutable container or large\n/// tuple\ntemplate ::value && !is_mutable_container::value &&\n classify_object::value != object_category::wrapper_value &&\n (is_mutable_container::value || type_count::value > 2),\n detail::enabler> = detail::dummy>\nbool lexical_conversion(const std::vector &strings, AssignTo &output) {\n\n if(strings.size() > 1 || (!strings.empty() && !(strings.front().empty()))) {\n ConvertTo val;\n auto retval = lexical_conversion(strings, val);\n output = AssignTo{val};\n return retval;\n }\n output = AssignTo{};\n return true;\n}\n\n/// function template for converting tuples if the static Index is greater than the tuple size\ntemplate \ninline typename std::enable_if<(I >= type_count_base::value), bool>::type\ntuple_conversion(const std::vector &, AssignTo &) {\n return true;\n}\n\n/// Conversion of a tuple element where the type size ==1 and not a mutable container\ntemplate \ninline typename std::enable_if::value && type_count::value == 1, bool>::type\ntuple_type_conversion(std::vector &strings, AssignTo &output) {\n auto retval = lexical_assign(strings[0], output);\n strings.erase(strings.begin());\n return retval;\n}\n\n/// Conversion of a tuple element where the type size !=1 but the size is fixed and not a mutable container\ntemplate \ninline typename std::enable_if::value && (type_count::value > 1) &&\n type_count::value == type_count_min::value,\n bool>::type\ntuple_type_conversion(std::vector &strings, AssignTo &output) {\n auto retval = lexical_conversion(strings, output);\n strings.erase(strings.begin(), strings.begin() + type_count::value);\n return retval;\n}\n\n/// Conversion of a tuple element where the type is a mutable container or a type with different min and max type sizes\ntemplate \ninline typename std::enable_if::value ||\n type_count::value != type_count_min::value,\n bool>::type\ntuple_type_conversion(std::vector &strings, AssignTo &output) {\n\n std::size_t index{subtype_count_min::value};\n const std::size_t mx_count{subtype_count::value};\n const std::size_t mx{(std::max)(mx_count, strings.size())};\n\n while(index < mx) {\n if(is_separator(strings[index])) {\n break;\n }\n ++index;\n }\n bool retval = lexical_conversion(\n std::vector(strings.begin(), strings.begin() + static_cast(index)), output);\n strings.erase(strings.begin(), strings.begin() + static_cast(index) + 1);\n return retval;\n}\n\n/// Tuple conversion operation\ntemplate \ninline typename std::enable_if<(I < type_count_base::value), bool>::type\ntuple_conversion(std::vector strings, AssignTo &output) {\n bool retval = true;\n using ConvertToElement = typename std::\n conditional::value, typename std::tuple_element::type, ConvertTo>::type;\n if(!strings.empty()) {\n retval = retval && tuple_type_conversion::type, ConvertToElement>(\n strings, std::get(output));\n }\n retval = retval && tuple_conversion(std::move(strings), output);\n return retval;\n}\n\n/// Lexical conversion of a container types with tuple elements of size 2\ntemplate ::value && is_mutable_container::value &&\n type_count_base::value == 2,\n detail::enabler>>\nbool lexical_conversion(std::vector strings, AssignTo &output) {\n output.clear();\n while(!strings.empty()) {\n\n typename std::remove_const::type>::type v1;\n typename std::tuple_element<1, typename ConvertTo::value_type>::type v2;\n bool retval = tuple_type_conversion(strings, v1);\n if(!strings.empty()) {\n retval = retval && tuple_type_conversion(strings, v2);\n }\n if(retval) {\n output.insert(output.end(), typename AssignTo::value_type{v1, v2});\n } else {\n return false;\n }\n }\n return (!output.empty());\n}\n\n/// lexical conversion of tuples with type count>2 or tuples of types of some element with a type size>=2\ntemplate ::value && is_tuple_like::value &&\n (type_count_base::value != type_count::value ||\n type_count::value > 2),\n detail::enabler>>\nbool lexical_conversion(const std::vector &strings, AssignTo &output) {\n static_assert(\n !is_tuple_like::value || type_count_base::value == type_count_base::value,\n \"if the conversion type is defined as a tuple it must be the same size as the type you are converting to\");\n return tuple_conversion(strings, output);\n}\n\n/// Lexical conversion of a vector types for everything but tuples of two elements and types of size 1\ntemplate ::value && is_mutable_container::value &&\n type_count_base::value != 2 &&\n ((type_count::value > 2) ||\n (type_count::value > type_count_base::value)),\n detail::enabler>>\nbool lexical_conversion(const std::vector &strings, AssignTo &output) {\n bool retval = true;\n output.clear();\n std::vector temp;\n std::size_t ii{0};\n std::size_t icount{0};\n std::size_t xcm{type_count::value};\n auto ii_max = strings.size();\n while(ii < ii_max) {\n temp.push_back(strings[ii]);\n ++ii;\n ++icount;\n if(icount == xcm || is_separator(temp.back()) || ii == ii_max) {\n if(static_cast(xcm) > type_count_min::value && is_separator(temp.back())) {\n temp.pop_back();\n }\n typename AssignTo::value_type temp_out;\n retval = retval &&\n lexical_conversion(temp, temp_out);\n temp.clear();\n if(!retval) {\n return false;\n }\n output.insert(output.end(), std::move(temp_out));\n icount = 0;\n }\n }\n return retval;\n}\n\n/// conversion for wrapper types\ntemplate ::value == object_category::wrapper_value &&\n std::is_assignable::value,\n detail::enabler> = detail::dummy>\nbool lexical_conversion(const std::vector &strings, AssignTo &output) {\n if(strings.empty() || strings.front().empty()) {\n output = ConvertTo{};\n return true;\n }\n typename ConvertTo::value_type val;\n if(lexical_conversion(strings, val)) {\n output = ConvertTo{val};\n return true;\n }\n return false;\n}\n\n/// conversion for wrapper types\ntemplate ::value == object_category::wrapper_value &&\n !std::is_assignable::value,\n detail::enabler> = detail::dummy>\nbool lexical_conversion(const std::vector &strings, AssignTo &output) {\n using ConvertType = typename ConvertTo::value_type;\n if(strings.empty() || strings.front().empty()) {\n output = ConvertType{};\n return true;\n }\n ConvertType val;\n if(lexical_conversion(strings, val)) {\n output = val;\n return true;\n }\n return false;\n}\n\n/// Sum a vector of strings\ninline std::string sum_string_vector(const std::vector &values) {\n double val{0.0};\n bool fail{false};\n std::string output;\n for(const auto &arg : values) {\n double tv{0.0};\n auto comp = lexical_cast(arg, tv);\n if(!comp) {\n try {\n tv = static_cast(detail::to_flag_value(arg));\n } catch(const std::exception &) {\n fail = true;\n break;\n }\n }\n val += tv;\n }\n if(fail) {\n for(const auto &arg : values) {\n output.append(arg);\n }\n } else {\n if(val <= static_cast((std::numeric_limits::min)()) ||\n val >= static_cast((std::numeric_limits::max)()) ||\n std::ceil(val) == std::floor(val)) {\n output = detail::value_string(static_cast(val));\n } else {\n output = detail::value_string(val);\n }\n }\n return output;\n}\n\n} // namespace detail\n\n\n\nnamespace detail {\n\n// Returns false if not a short option. Otherwise, sets opt name and rest and returns true\nCLI11_INLINE bool split_short(const std::string ¤t, std::string &name, std::string &rest);\n\n// Returns false if not a long option. Otherwise, sets opt name and other side of = and returns true\nCLI11_INLINE bool split_long(const std::string ¤t, std::string &name, std::string &value);\n\n// Returns false if not a windows style option. Otherwise, sets opt name and value and returns true\nCLI11_INLINE bool split_windows_style(const std::string ¤t, std::string &name, std::string &value);\n\n// Splits a string into multiple long and short names\nCLI11_INLINE std::vector split_names(std::string current);\n\n/// extract default flag values either {def} or starting with a !\nCLI11_INLINE std::vector> get_default_flag_values(const std::string &str);\n\n/// Get a vector of short names, one of long names, and a single name\nCLI11_INLINE std::tuple, std::vector, std::string>\nget_names(const std::vector &input);\n\n} // namespace detail\n\n\n\nnamespace detail {\n\nCLI11_INLINE bool split_short(const std::string ¤t, std::string &name, std::string &rest) {\n if(current.size() > 1 && current[0] == '-' && valid_first_char(current[1])) {\n name = current.substr(1, 1);\n rest = current.substr(2);\n return true;\n }\n return false;\n}\n\nCLI11_INLINE bool split_long(const std::string ¤t, std::string &name, std::string &value) {\n if(current.size() > 2 && current.substr(0, 2) == \"--\" && valid_first_char(current[2])) {\n auto loc = current.find_first_of('=');\n if(loc != std::string::npos) {\n name = current.substr(2, loc - 2);\n value = current.substr(loc + 1);\n } else {\n name = current.substr(2);\n value = \"\";\n }\n return true;\n }\n return false;\n}\n\nCLI11_INLINE bool split_windows_style(const std::string ¤t, std::string &name, std::string &value) {\n if(current.size() > 1 && current[0] == '/' && valid_first_char(current[1])) {\n auto loc = current.find_first_of(':');\n if(loc != std::string::npos) {\n name = current.substr(1, loc - 1);\n value = current.substr(loc + 1);\n } else {\n name = current.substr(1);\n value = \"\";\n }\n return true;\n }\n return false;\n}\n\nCLI11_INLINE std::vector split_names(std::string current) {\n std::vector output;\n std::size_t val = 0;\n while((val = current.find(',')) != std::string::npos) {\n output.push_back(trim_copy(current.substr(0, val)));\n current = current.substr(val + 1);\n }\n output.push_back(trim_copy(current));\n return output;\n}\n\nCLI11_INLINE std::vector> get_default_flag_values(const std::string &str) {\n std::vector flags = split_names(str);\n flags.erase(std::remove_if(flags.begin(),\n flags.end(),\n [](const std::string &name) {\n return ((name.empty()) || (!(((name.find_first_of('{') != std::string::npos) &&\n (name.back() == '}')) ||\n (name[0] == '!'))));\n }),\n flags.end());\n std::vector> output;\n output.reserve(flags.size());\n for(auto &flag : flags) {\n auto def_start = flag.find_first_of('{');\n std::string defval = \"false\";\n if((def_start != std::string::npos) && (flag.back() == '}')) {\n defval = flag.substr(def_start + 1);\n defval.pop_back();\n flag.erase(def_start, std::string::npos); // NOLINT(readability-suspicious-call-argument)\n }\n flag.erase(0, flag.find_first_not_of(\"-!\"));\n output.emplace_back(flag, defval);\n }\n return output;\n}\n\nCLI11_INLINE std::tuple, std::vector, std::string>\nget_names(const std::vector &input) {\n\n std::vector short_names;\n std::vector long_names;\n std::string pos_name;\n\n for(std::string name : input) {\n if(name.length() == 0) {\n continue;\n }\n if(name.length() > 1 && name[0] == '-' && name[1] != '-') {\n if(name.length() == 2 && valid_first_char(name[1]))\n short_names.emplace_back(1, name[1]);\n else\n throw BadNameString::OneCharName(name);\n } else if(name.length() > 2 && name.substr(0, 2) == \"--\") {\n name = name.substr(2);\n if(valid_name_string(name))\n long_names.push_back(name);\n else\n throw BadNameString::BadLongName(name);\n } else if(name == \"-\" || name == \"--\") {\n throw BadNameString::DashesOnly(name);\n } else {\n if(pos_name.length() > 0)\n throw BadNameString::MultiPositionalNames(name);\n pos_name = name;\n }\n }\n\n return std::make_tuple(short_names, long_names, pos_name);\n}\n\n} // namespace detail\n\n\n\nclass App;\n\n/// Holds values to load into Options\nstruct ConfigItem {\n /// This is the list of parents\n std::vector parents{};\n\n /// This is the name\n std::string name{};\n\n /// Listing of inputs\n std::vector inputs{};\n\n /// The list of parents and name joined by \".\"\n CLI11_NODISCARD std::string fullname() const {\n std::vector tmp = parents;\n tmp.emplace_back(name);\n return detail::join(tmp, \".\");\n }\n};\n\n/// This class provides a converter for configuration files.\nclass Config {\n protected:\n std::vector items{};\n\n public:\n /// Convert an app into a configuration\n virtual std::string to_config(const App *, bool, bool, std::string) const = 0;\n\n /// Convert a configuration into an app\n virtual std::vector from_config(std::istream &) const = 0;\n\n /// Get a flag value\n CLI11_NODISCARD virtual std::string to_flag(const ConfigItem &item) const {\n if(item.inputs.size() == 1) {\n return item.inputs.at(0);\n }\n if(item.inputs.empty()) {\n return \"{}\";\n }\n throw ConversionError::TooManyInputsFlag(item.fullname()); // LCOV_EXCL_LINE\n }\n\n /// Parse a config file, throw an error (ParseError:ConfigParseError or FileError) on failure\n CLI11_NODISCARD std::vector from_file(const std::string &name) const {\n std::ifstream input{name};\n if(!input.good())\n throw FileError::Missing(name);\n\n return from_config(input);\n }\n\n /// Virtual destructor\n virtual ~Config() = default;\n};\n\n/// This converter works with INI/TOML files; to write INI files use ConfigINI\nclass ConfigBase : public Config {\n protected:\n /// the character used for comments\n char commentChar = '#';\n /// the character used to start an array '\\0' is a default to not use\n char arrayStart = '[';\n /// the character used to end an array '\\0' is a default to not use\n char arrayEnd = ']';\n /// the character used to separate elements in an array\n char arraySeparator = ',';\n /// the character used separate the name from the value\n char valueDelimiter = '=';\n /// the character to use around strings\n char stringQuote = '\"';\n /// the character to use around single characters\n char characterQuote = '\\'';\n /// the maximum number of layers to allow\n uint8_t maximumLayers{255};\n /// the separator used to separator parent layers\n char parentSeparatorChar{'.'};\n /// Specify the configuration index to use for arrayed sections\n int16_t configIndex{-1};\n /// Specify the configuration section that should be used\n std::string configSection{};\n\n public:\n std::string\n to_config(const App * /*app*/, bool default_also, bool write_description, std::string prefix) const override;\n\n std::vector from_config(std::istream &input) const override;\n /// Specify the configuration for comment characters\n ConfigBase *comment(char cchar) {\n commentChar = cchar;\n return this;\n }\n /// Specify the start and end characters for an array\n ConfigBase *arrayBounds(char aStart, char aEnd) {\n arrayStart = aStart;\n arrayEnd = aEnd;\n return this;\n }\n /// Specify the delimiter character for an array\n ConfigBase *arrayDelimiter(char aSep) {\n arraySeparator = aSep;\n return this;\n }\n /// Specify the delimiter between a name and value\n ConfigBase *valueSeparator(char vSep) {\n valueDelimiter = vSep;\n return this;\n }\n /// Specify the quote characters used around strings and characters\n ConfigBase *quoteCharacter(char qString, char qChar) {\n stringQuote = qString;\n characterQuote = qChar;\n return this;\n }\n /// Specify the maximum number of parents\n ConfigBase *maxLayers(uint8_t layers) {\n maximumLayers = layers;\n return this;\n }\n /// Specify the separator to use for parent layers\n ConfigBase *parentSeparator(char sep) {\n parentSeparatorChar = sep;\n return this;\n }\n /// get a reference to the configuration section\n std::string §ionRef() { return configSection; }\n /// get the section\n CLI11_NODISCARD const std::string §ion() const { return configSection; }\n /// specify a particular section of the configuration file to use\n ConfigBase *section(const std::string §ionName) {\n configSection = sectionName;\n return this;\n }\n\n /// get a reference to the configuration index\n int16_t &indexRef() { return configIndex; }\n /// get the section index\n CLI11_NODISCARD int16_t index() const { return configIndex; }\n /// specify a particular index in the section to use (-1) for all sections to use\n ConfigBase *index(int16_t sectionIndex) {\n configIndex = sectionIndex;\n return this;\n }\n};\n\n/// the default Config is the TOML file format\nusing ConfigTOML = ConfigBase;\n\n/// ConfigINI generates a \"standard\" INI compliant output\nclass ConfigINI : public ConfigTOML {\n\n public:\n ConfigINI() {\n commentChar = ';';\n arrayStart = '\\0';\n arrayEnd = '\\0';\n arraySeparator = ' ';\n valueDelimiter = '=';\n }\n};\n\n\n\nclass Option;\n\n/// @defgroup validator_group Validators\n\n/// @brief Some validators that are provided\n///\n/// These are simple `std::string(const std::string&)` validators that are useful. They return\n/// a string if the validation fails. A custom struct is provided, as well, with the same user\n/// semantics, but with the ability to provide a new type name.\n/// @{\n\n///\nclass Validator {\n protected:\n /// This is the description function, if empty the description_ will be used\n std::function desc_function_{[]() { return std::string{}; }};\n\n /// This is the base function that is to be called.\n /// Returns a string error message if validation fails.\n std::function func_{[](std::string &) { return std::string{}; }};\n /// The name for search purposes of the Validator\n std::string name_{};\n /// A Validator will only apply to an indexed value (-1 is all elements)\n int application_index_ = -1;\n /// Enable for Validator to allow it to be disabled if need be\n bool active_{true};\n /// specify that a validator should not modify the input\n bool non_modifying_{false};\n\n Validator(std::string validator_desc, std::function func)\n : desc_function_([validator_desc]() { return validator_desc; }), func_(std::move(func)) {}\n\n public:\n Validator() = default;\n /// Construct a Validator with just the description string\n explicit Validator(std::string validator_desc) : desc_function_([validator_desc]() { return validator_desc; }) {}\n /// Construct Validator from basic information\n Validator(std::function op, std::string validator_desc, std::string validator_name = \"\")\n : desc_function_([validator_desc]() { return validator_desc; }), func_(std::move(op)),\n name_(std::move(validator_name)) {}\n /// Set the Validator operation function\n Validator &operation(std::function op) {\n func_ = std::move(op);\n return *this;\n }\n /// This is the required operator for a Validator - provided to help\n /// users (CLI11 uses the member `func` directly)\n std::string operator()(std::string &str) const;\n\n /// This is the required operator for a Validator - provided to help\n /// users (CLI11 uses the member `func` directly)\n std::string operator()(const std::string &str) const {\n std::string value = str;\n return (active_) ? func_(value) : std::string{};\n }\n\n /// Specify the type string\n Validator &description(std::string validator_desc) {\n desc_function_ = [validator_desc]() { return validator_desc; };\n return *this;\n }\n /// Specify the type string\n CLI11_NODISCARD Validator description(std::string validator_desc) const;\n\n /// Generate type description information for the Validator\n CLI11_NODISCARD std::string get_description() const {\n if(active_) {\n return desc_function_();\n }\n return std::string{};\n }\n /// Specify the type string\n Validator &name(std::string validator_name) {\n name_ = std::move(validator_name);\n return *this;\n }\n /// Specify the type string\n CLI11_NODISCARD Validator name(std::string validator_name) const {\n Validator newval(*this);\n newval.name_ = std::move(validator_name);\n return newval;\n }\n /// Get the name of the Validator\n CLI11_NODISCARD const std::string &get_name() const { return name_; }\n /// Specify whether the Validator is active or not\n Validator &active(bool active_val = true) {\n active_ = active_val;\n return *this;\n }\n /// Specify whether the Validator is active or not\n CLI11_NODISCARD Validator active(bool active_val = true) const {\n Validator newval(*this);\n newval.active_ = active_val;\n return newval;\n }\n\n /// Specify whether the Validator can be modifying or not\n Validator &non_modifying(bool no_modify = true) {\n non_modifying_ = no_modify;\n return *this;\n }\n /// Specify the application index of a validator\n Validator &application_index(int app_index) {\n application_index_ = app_index;\n return *this;\n }\n /// Specify the application index of a validator\n CLI11_NODISCARD Validator application_index(int app_index) const {\n Validator newval(*this);\n newval.application_index_ = app_index;\n return newval;\n }\n /// Get the current value of the application index\n CLI11_NODISCARD int get_application_index() const { return application_index_; }\n /// Get a boolean if the validator is active\n CLI11_NODISCARD bool get_active() const { return active_; }\n\n /// Get a boolean if the validator is allowed to modify the input returns true if it can modify the input\n CLI11_NODISCARD bool get_modifying() const { return !non_modifying_; }\n\n /// Combining validators is a new validator. Type comes from left validator if function, otherwise only set if the\n /// same.\n Validator operator&(const Validator &other) const;\n\n /// Combining validators is a new validator. Type comes from left validator if function, otherwise only set if the\n /// same.\n Validator operator|(const Validator &other) const;\n\n /// Create a validator that fails when a given validator succeeds\n Validator operator!() const;\n\n private:\n void _merge_description(const Validator &val1, const Validator &val2, const std::string &merger);\n};\n\n/// Class wrapping some of the accessors of Validator\nclass CustomValidator : public Validator {\n public:\n};\n// The implementation of the built in validators is using the Validator class;\n// the user is only expected to use the const (static) versions (since there's no setup).\n// Therefore, this is in detail.\nnamespace detail {\n\n/// CLI enumeration of different file types\nenum class path_type { nonexistent, file, directory };\n\n/// get the type of the path from a file name\nCLI11_INLINE path_type check_path(const char *file) noexcept;\n\n/// Check for an existing file (returns error message if check fails)\nclass ExistingFileValidator : public Validator {\n public:\n ExistingFileValidator();\n};\n\n/// Check for an existing directory (returns error message if check fails)\nclass ExistingDirectoryValidator : public Validator {\n public:\n ExistingDirectoryValidator();\n};\n\n/// Check for an existing path\nclass ExistingPathValidator : public Validator {\n public:\n ExistingPathValidator();\n};\n\n/// Check for an non-existing path\nclass NonexistentPathValidator : public Validator {\n public:\n NonexistentPathValidator();\n};\n\n/// Validate the given string is a legal ipv4 address\nclass IPV4Validator : public Validator {\n public:\n IPV4Validator();\n};\n\n} // namespace detail\n\n// Static is not needed here, because global const implies static.\n\n/// Check for existing file (returns error message if check fails)\nconst detail::ExistingFileValidator ExistingFile;\n\n/// Check for an existing directory (returns error message if check fails)\nconst detail::ExistingDirectoryValidator ExistingDirectory;\n\n/// Check for an existing path\nconst detail::ExistingPathValidator ExistingPath;\n\n/// Check for an non-existing path\nconst detail::NonexistentPathValidator NonexistentPath;\n\n/// Check for an IP4 address\nconst detail::IPV4Validator ValidIPV4;\n\n/// Validate the input as a particular type\ntemplate class TypeValidator : public Validator {\n public:\n explicit TypeValidator(const std::string &validator_name)\n : Validator(validator_name, [](std::string &input_string) {\n using CLI::detail::lexical_cast;\n auto val = DesiredType();\n if(!lexical_cast(input_string, val)) {\n return std::string(\"Failed parsing \") + input_string + \" as a \" + detail::type_name();\n }\n return std::string();\n }) {}\n TypeValidator() : TypeValidator(detail::type_name()) {}\n};\n\n/// Check for a number\nconst TypeValidator Number(\"NUMBER\");\n\n/// Modify a path if the file is a particular default location, can be used as Check or transform\n/// with the error return optionally disabled\nclass FileOnDefaultPath : public Validator {\n public:\n explicit FileOnDefaultPath(std::string default_path, bool enableErrorReturn = true);\n};\n\n/// Produce a range (factory). Min and max are inclusive.\nclass Range : public Validator {\n public:\n /// This produces a range with min and max inclusive.\n ///\n /// Note that the constructor is templated, but the struct is not, so C++17 is not\n /// needed to provide nice syntax for Range(a,b).\n template \n Range(T min_val, T max_val, const std::string &validator_name = std::string{}) : Validator(validator_name) {\n if(validator_name.empty()) {\n std::stringstream out;\n out << detail::type_name() << \" in [\" << min_val << \" - \" << max_val << \"]\";\n description(out.str());\n }\n\n func_ = [min_val, max_val](std::string &input) {\n using CLI::detail::lexical_cast;\n T val;\n bool converted = lexical_cast(input, val);\n if((!converted) || (val < min_val || val > max_val)) {\n std::stringstream out;\n out << \"Value \" << input << \" not in range [\";\n out << min_val << \" - \" << max_val << \"]\";\n return out.str();\n }\n return std::string{};\n };\n }\n\n /// Range of one value is 0 to value\n template \n explicit Range(T max_val, const std::string &validator_name = std::string{})\n : Range(static_cast(0), max_val, validator_name) {}\n};\n\n/// Check for a non negative number\nconst Range NonNegativeNumber((std::numeric_limits::max)(), \"NONNEGATIVE\");\n\n/// Check for a positive valued number (val>0.0), ::min here is the smallest positive number\nconst Range PositiveNumber((std::numeric_limits::min)(), (std::numeric_limits::max)(), \"POSITIVE\");\n\n/// Produce a bounded range (factory). Min and max are inclusive.\nclass Bound : public Validator {\n public:\n /// This bounds a value with min and max inclusive.\n ///\n /// Note that the constructor is templated, but the struct is not, so C++17 is not\n /// needed to provide nice syntax for Range(a,b).\n template Bound(T min_val, T max_val) {\n std::stringstream out;\n out << detail::type_name() << \" bounded to [\" << min_val << \" - \" << max_val << \"]\";\n description(out.str());\n\n func_ = [min_val, max_val](std::string &input) {\n using CLI::detail::lexical_cast;\n T val;\n bool converted = lexical_cast(input, val);\n if(!converted) {\n return std::string(\"Value \") + input + \" could not be converted\";\n }\n if(val < min_val)\n input = detail::to_string(min_val);\n else if(val > max_val)\n input = detail::to_string(max_val);\n\n return std::string{};\n };\n }\n\n /// Range of one value is 0 to value\n template explicit Bound(T max_val) : Bound(static_cast(0), max_val) {}\n};\n\nnamespace detail {\ntemplate ::type>::value, detail::enabler> = detail::dummy>\nauto smart_deref(T value) -> decltype(*value) {\n return *value;\n}\n\ntemplate <\n typename T,\n enable_if_t::type>::value, detail::enabler> = detail::dummy>\ntypename std::remove_reference::type &smart_deref(T &value) {\n return value;\n}\n/// Generate a string representation of a set\ntemplate std::string generate_set(const T &set) {\n using element_t = typename detail::element_type::type;\n using iteration_type_t = typename detail::pair_adaptor::value_type; // the type of the object pair\n std::string out(1, '{');\n out.append(detail::join(\n detail::smart_deref(set),\n [](const iteration_type_t &v) { return detail::pair_adaptor::first(v); },\n \",\"));\n out.push_back('}');\n return out;\n}\n\n/// Generate a string representation of a map\ntemplate std::string generate_map(const T &map, bool key_only = false) {\n using element_t = typename detail::element_type::type;\n using iteration_type_t = typename detail::pair_adaptor::value_type; // the type of the object pair\n std::string out(1, '{');\n out.append(detail::join(\n detail::smart_deref(map),\n [key_only](const iteration_type_t &v) {\n std::string res{detail::to_string(detail::pair_adaptor::first(v))};\n\n if(!key_only) {\n res.append(\"->\");\n res += detail::to_string(detail::pair_adaptor::second(v));\n }\n return res;\n },\n \",\"));\n out.push_back('}');\n return out;\n}\n\ntemplate struct has_find {\n template \n static auto test(int) -> decltype(std::declval().find(std::declval()), std::true_type());\n template static auto test(...) -> decltype(std::false_type());\n\n static const auto value = decltype(test(0))::value;\n using type = std::integral_constant;\n};\n\n/// A search function\ntemplate ::value, detail::enabler> = detail::dummy>\nauto search(const T &set, const V &val) -> std::pair {\n using element_t = typename detail::element_type::type;\n auto &setref = detail::smart_deref(set);\n auto it = std::find_if(std::begin(setref), std::end(setref), [&val](decltype(*std::begin(setref)) v) {\n return (detail::pair_adaptor::first(v) == val);\n });\n return {(it != std::end(setref)), it};\n}\n\n/// A search function that uses the built in find function\ntemplate ::value, detail::enabler> = detail::dummy>\nauto search(const T &set, const V &val) -> std::pair {\n auto &setref = detail::smart_deref(set);\n auto it = setref.find(val);\n return {(it != std::end(setref)), it};\n}\n\n/// A search function with a filter function\ntemplate \nauto search(const T &set, const V &val, const std::function &filter_function)\n -> std::pair {\n using element_t = typename detail::element_type::type;\n // do the potentially faster first search\n auto res = search(set, val);\n if((res.first) || (!(filter_function))) {\n return res;\n }\n // if we haven't found it do the longer linear search with all the element translations\n auto &setref = detail::smart_deref(set);\n auto it = std::find_if(std::begin(setref), std::end(setref), [&](decltype(*std::begin(setref)) v) {\n V a{detail::pair_adaptor::first(v)};\n a = filter_function(a);\n return (a == val);\n });\n return {(it != std::end(setref)), it};\n}\n\n// the following suggestion was made by Nikita Ofitserov(@himikof)\n// done in templates to prevent compiler warnings on negation of unsigned numbers\n\n/// Do a check for overflow on signed numbers\ntemplate \ninline typename std::enable_if::value, T>::type overflowCheck(const T &a, const T &b) {\n if((a > 0) == (b > 0)) {\n return ((std::numeric_limits::max)() / (std::abs)(a) < (std::abs)(b));\n }\n return ((std::numeric_limits::min)() / (std::abs)(a) > -(std::abs)(b));\n}\n/// Do a check for overflow on unsigned numbers\ntemplate \ninline typename std::enable_if::value, T>::type overflowCheck(const T &a, const T &b) {\n return ((std::numeric_limits::max)() / a < b);\n}\n\n/// Performs a *= b; if it doesn't cause integer overflow. Returns false otherwise.\ntemplate typename std::enable_if::value, bool>::type checked_multiply(T &a, T b) {\n if(a == 0 || b == 0 || a == 1 || b == 1) {\n a *= b;\n return true;\n }\n if(a == (std::numeric_limits::min)() || b == (std::numeric_limits::min)()) {\n return false;\n }\n if(overflowCheck(a, b)) {\n return false;\n }\n a *= b;\n return true;\n}\n\n/// Performs a *= b; if it doesn't equal infinity. Returns false otherwise.\ntemplate \ntypename std::enable_if::value, bool>::type checked_multiply(T &a, T b) {\n T c = a * b;\n if(std::isinf(c) && !std::isinf(a) && !std::isinf(b)) {\n return false;\n }\n a = c;\n return true;\n}\n\n} // namespace detail\n/// Verify items are in a set\nclass IsMember : public Validator {\n public:\n using filter_fn_t = std::function;\n\n /// This allows in-place construction using an initializer list\n template \n IsMember(std::initializer_list values, Args &&...args)\n : IsMember(std::vector(values), std::forward(args)...) {}\n\n /// This checks to see if an item is in a set (empty function)\n template explicit IsMember(T &&set) : IsMember(std::forward(set), nullptr) {}\n\n /// This checks to see if an item is in a set: pointer or copy version. You can pass in a function that will filter\n /// both sides of the comparison before computing the comparison.\n template explicit IsMember(T set, F filter_function) {\n\n // Get the type of the contained item - requires a container have ::value_type\n // if the type does not have first_type and second_type, these are both value_type\n using element_t = typename detail::element_type::type; // Removes (smart) pointers if needed\n using item_t = typename detail::pair_adaptor::first_type; // Is value_type if not a map\n\n using local_item_t = typename IsMemberType::type; // This will convert bad types to good ones\n // (const char * to std::string)\n\n // Make a local copy of the filter function, using a std::function if not one already\n std::function filter_fn = filter_function;\n\n // This is the type name for help, it will take the current version of the set contents\n desc_function_ = [set]() { return detail::generate_set(detail::smart_deref(set)); };\n\n // This is the function that validates\n // It stores a copy of the set pointer-like, so shared_ptr will stay alive\n func_ = [set, filter_fn](std::string &input) {\n using CLI::detail::lexical_cast;\n local_item_t b;\n if(!lexical_cast(input, b)) {\n throw ValidationError(input); // name is added later\n }\n if(filter_fn) {\n b = filter_fn(b);\n }\n auto res = detail::search(set, b, filter_fn);\n if(res.first) {\n // Make sure the version in the input string is identical to the one in the set\n if(filter_fn) {\n input = detail::value_string(detail::pair_adaptor::first(*(res.second)));\n }\n\n // Return empty error string (success)\n return std::string{};\n }\n\n // If you reach this point, the result was not found\n return input + \" not in \" + detail::generate_set(detail::smart_deref(set));\n };\n }\n\n /// You can pass in as many filter functions as you like, they nest (string only currently)\n template \n IsMember(T &&set, filter_fn_t filter_fn_1, filter_fn_t filter_fn_2, Args &&...other)\n : IsMember(\n std::forward(set),\n [filter_fn_1, filter_fn_2](std::string a) { return filter_fn_2(filter_fn_1(a)); },\n other...) {}\n};\n\n/// definition of the default transformation object\ntemplate using TransformPairs = std::vector>;\n\n/// Translate named items to other or a value set\nclass Transformer : public Validator {\n public:\n using filter_fn_t = std::function;\n\n /// This allows in-place construction\n template \n Transformer(std::initializer_list> values, Args &&...args)\n : Transformer(TransformPairs(values), std::forward(args)...) {}\n\n /// direct map of std::string to std::string\n template explicit Transformer(T &&mapping) : Transformer(std::forward(mapping), nullptr) {}\n\n /// This checks to see if an item is in a set: pointer or copy version. You can pass in a function that will filter\n /// both sides of the comparison before computing the comparison.\n template explicit Transformer(T mapping, F filter_function) {\n\n static_assert(detail::pair_adaptor::type>::value,\n \"mapping must produce value pairs\");\n // Get the type of the contained item - requires a container have ::value_type\n // if the type does not have first_type and second_type, these are both value_type\n using element_t = typename detail::element_type::type; // Removes (smart) pointers if needed\n using item_t = typename detail::pair_adaptor::first_type; // Is value_type if not a map\n using local_item_t = typename IsMemberType::type; // Will convert bad types to good ones\n // (const char * to std::string)\n\n // Make a local copy of the filter function, using a std::function if not one already\n std::function filter_fn = filter_function;\n\n // This is the type name for help, it will take the current version of the set contents\n desc_function_ = [mapping]() { return detail::generate_map(detail::smart_deref(mapping)); };\n\n func_ = [mapping, filter_fn](std::string &input) {\n using CLI::detail::lexical_cast;\n local_item_t b;\n if(!lexical_cast(input, b)) {\n return std::string();\n // there is no possible way we can match anything in the mapping if we can't convert so just return\n }\n if(filter_fn) {\n b = filter_fn(b);\n }\n auto res = detail::search(mapping, b, filter_fn);\n if(res.first) {\n input = detail::value_string(detail::pair_adaptor::second(*res.second));\n }\n return std::string{};\n };\n }\n\n /// You can pass in as many filter functions as you like, they nest\n template \n Transformer(T &&mapping, filter_fn_t filter_fn_1, filter_fn_t filter_fn_2, Args &&...other)\n : Transformer(\n std::forward(mapping),\n [filter_fn_1, filter_fn_2](std::string a) { return filter_fn_2(filter_fn_1(a)); },\n other...) {}\n};\n\n/// translate named items to other or a value set\nclass CheckedTransformer : public Validator {\n public:\n using filter_fn_t = std::function;\n\n /// This allows in-place construction\n template \n CheckedTransformer(std::initializer_list> values, Args &&...args)\n : CheckedTransformer(TransformPairs(values), std::forward(args)...) {}\n\n /// direct map of std::string to std::string\n template explicit CheckedTransformer(T mapping) : CheckedTransformer(std::move(mapping), nullptr) {}\n\n /// This checks to see if an item is in a set: pointer or copy version. You can pass in a function that will filter\n /// both sides of the comparison before computing the comparison.\n template explicit CheckedTransformer(T mapping, F filter_function) {\n\n static_assert(detail::pair_adaptor::type>::value,\n \"mapping must produce value pairs\");\n // Get the type of the contained item - requires a container have ::value_type\n // if the type does not have first_type and second_type, these are both value_type\n using element_t = typename detail::element_type::type; // Removes (smart) pointers if needed\n using item_t = typename detail::pair_adaptor::first_type; // Is value_type if not a map\n using local_item_t = typename IsMemberType::type; // Will convert bad types to good ones\n // (const char * to std::string)\n using iteration_type_t = typename detail::pair_adaptor::value_type; // the type of the object pair\n\n // Make a local copy of the filter function, using a std::function if not one already\n std::function filter_fn = filter_function;\n\n auto tfunc = [mapping]() {\n std::string out(\"value in \");\n out += detail::generate_map(detail::smart_deref(mapping)) + \" OR {\";\n out += detail::join(\n detail::smart_deref(mapping),\n [](const iteration_type_t &v) { return detail::to_string(detail::pair_adaptor::second(v)); },\n \",\");\n out.push_back('}');\n return out;\n };\n\n desc_function_ = tfunc;\n\n func_ = [mapping, tfunc, filter_fn](std::string &input) {\n using CLI::detail::lexical_cast;\n local_item_t b;\n bool converted = lexical_cast(input, b);\n if(converted) {\n if(filter_fn) {\n b = filter_fn(b);\n }\n auto res = detail::search(mapping, b, filter_fn);\n if(res.first) {\n input = detail::value_string(detail::pair_adaptor::second(*res.second));\n return std::string{};\n }\n }\n for(const auto &v : detail::smart_deref(mapping)) {\n auto output_string = detail::value_string(detail::pair_adaptor::second(v));\n if(output_string == input) {\n return std::string();\n }\n }\n\n return \"Check \" + input + \" \" + tfunc() + \" FAILED\";\n };\n }\n\n /// You can pass in as many filter functions as you like, they nest\n template \n CheckedTransformer(T &&mapping, filter_fn_t filter_fn_1, filter_fn_t filter_fn_2, Args &&...other)\n : CheckedTransformer(\n std::forward(mapping),\n [filter_fn_1, filter_fn_2](std::string a) { return filter_fn_2(filter_fn_1(a)); },\n other...) {}\n};\n\n/// Helper function to allow ignore_case to be passed to IsMember or Transform\ninline std::string ignore_case(std::string item) { return detail::to_lower(item); }\n\n/// Helper function to allow ignore_underscore to be passed to IsMember or Transform\ninline std::string ignore_underscore(std::string item) { return detail::remove_underscore(item); }\n\n/// Helper function to allow checks to ignore spaces to be passed to IsMember or Transform\ninline std::string ignore_space(std::string item) {\n item.erase(std::remove(std::begin(item), std::end(item), ' '), std::end(item));\n item.erase(std::remove(std::begin(item), std::end(item), '\\t'), std::end(item));\n return item;\n}\n\n/// Multiply a number by a factor using given mapping.\n/// Can be used to write transforms for SIZE or DURATION inputs.\n///\n/// Example:\n/// With mapping = `{\"b\"->1, \"kb\"->1024, \"mb\"->1024*1024}`\n/// one can recognize inputs like \"100\", \"12kb\", \"100 MB\",\n/// that will be automatically transformed to 100, 14448, 104857600.\n///\n/// Output number type matches the type in the provided mapping.\n/// Therefore, if it is required to interpret real inputs like \"0.42 s\",\n/// the mapping should be of a type or .\nclass AsNumberWithUnit : public Validator {\n public:\n /// Adjust AsNumberWithUnit behavior.\n /// CASE_SENSITIVE/CASE_INSENSITIVE controls how units are matched.\n /// UNIT_OPTIONAL/UNIT_REQUIRED throws ValidationError\n /// if UNIT_REQUIRED is set and unit literal is not found.\n enum Options {\n CASE_SENSITIVE = 0,\n CASE_INSENSITIVE = 1,\n UNIT_OPTIONAL = 0,\n UNIT_REQUIRED = 2,\n DEFAULT = CASE_INSENSITIVE | UNIT_OPTIONAL\n };\n\n template \n explicit AsNumberWithUnit(std::map mapping,\n Options opts = DEFAULT,\n const std::string &unit_name = \"UNIT\") {\n description(generate_description(unit_name, opts));\n validate_mapping(mapping, opts);\n\n // transform function\n func_ = [mapping, opts](std::string &input) -> std::string {\n Number num{};\n\n detail::rtrim(input);\n if(input.empty()) {\n throw ValidationError(\"Input is empty\");\n }\n\n // Find split position between number and prefix\n auto unit_begin = input.end();\n while(unit_begin > input.begin() && std::isalpha(*(unit_begin - 1), std::locale())) {\n --unit_begin;\n }\n\n std::string unit{unit_begin, input.end()};\n input.resize(static_cast(std::distance(input.begin(), unit_begin)));\n detail::trim(input);\n\n if(opts & UNIT_REQUIRED && unit.empty()) {\n throw ValidationError(\"Missing mandatory unit\");\n }\n if(opts & CASE_INSENSITIVE) {\n unit = detail::to_lower(unit);\n }\n if(unit.empty()) {\n using CLI::detail::lexical_cast;\n if(!lexical_cast(input, num)) {\n throw ValidationError(std::string(\"Value \") + input + \" could not be converted to \" +\n detail::type_name());\n }\n // No need to modify input if no unit passed\n return {};\n }\n\n // find corresponding factor\n auto it = mapping.find(unit);\n if(it == mapping.end()) {\n throw ValidationError(unit +\n \" unit not recognized. \"\n \"Allowed values: \" +\n detail::generate_map(mapping, true));\n }\n\n if(!input.empty()) {\n using CLI::detail::lexical_cast;\n bool converted = lexical_cast(input, num);\n if(!converted) {\n throw ValidationError(std::string(\"Value \") + input + \" could not be converted to \" +\n detail::type_name());\n }\n // perform safe multiplication\n bool ok = detail::checked_multiply(num, it->second);\n if(!ok) {\n throw ValidationError(detail::to_string(num) + \" multiplied by \" + unit +\n \" factor would cause number overflow. Use smaller value.\");\n }\n } else {\n num = static_cast(it->second);\n }\n\n input = detail::to_string(num);\n\n return {};\n };\n }\n\n private:\n /// Check that mapping contains valid units.\n /// Update mapping for CASE_INSENSITIVE mode.\n template static void validate_mapping(std::map &mapping, Options opts) {\n for(auto &kv : mapping) {\n if(kv.first.empty()) {\n throw ValidationError(\"Unit must not be empty.\");\n }\n if(!detail::isalpha(kv.first)) {\n throw ValidationError(\"Unit must contain only letters.\");\n }\n }\n\n // make all units lowercase if CASE_INSENSITIVE\n if(opts & CASE_INSENSITIVE) {\n std::map lower_mapping;\n for(auto &kv : mapping) {\n auto s = detail::to_lower(kv.first);\n if(lower_mapping.count(s)) {\n throw ValidationError(std::string(\"Several matching lowercase unit representations are found: \") +\n s);\n }\n lower_mapping[detail::to_lower(kv.first)] = kv.second;\n }\n mapping = std::move(lower_mapping);\n }\n }\n\n /// Generate description like this: NUMBER [UNIT]\n template static std::string generate_description(const std::string &name, Options opts) {\n std::stringstream out;\n out << detail::type_name() << ' ';\n if(opts & UNIT_REQUIRED) {\n out << name;\n } else {\n out << '[' << name << ']';\n }\n return out.str();\n }\n};\n\ninline AsNumberWithUnit::Options operator|(const AsNumberWithUnit::Options &a, const AsNumberWithUnit::Options &b) {\n return static_cast(static_cast(a) | static_cast(b));\n}\n\n/// Converts a human-readable size string (with unit literal) to uin64_t size.\n/// Example:\n/// \"100\" => 100\n/// \"1 b\" => 100\n/// \"10Kb\" => 10240 // you can configure this to be interpreted as kilobyte (*1000) or kibibyte (*1024)\n/// \"10 KB\" => 10240\n/// \"10 kb\" => 10240\n/// \"10 kib\" => 10240 // *i, *ib are always interpreted as *bibyte (*1024)\n/// \"10kb\" => 10240\n/// \"2 MB\" => 2097152\n/// \"2 EiB\" => 2^61 // Units up to exibyte are supported\nclass AsSizeValue : public AsNumberWithUnit {\n public:\n using result_t = std::uint64_t;\n\n /// If kb_is_1000 is true,\n /// interpret 'kb', 'k' as 1000 and 'kib', 'ki' as 1024\n /// (same applies to higher order units as well).\n /// Otherwise, interpret all literals as factors of 1024.\n /// The first option is formally correct, but\n /// the second interpretation is more wide-spread\n /// (see https://en.wikipedia.org/wiki/Binary_prefix).\n explicit AsSizeValue(bool kb_is_1000);\n\n private:\n /// Get mapping\n static std::map init_mapping(bool kb_is_1000);\n\n /// Cache calculated mapping\n static std::map get_mapping(bool kb_is_1000);\n};\n\nnamespace detail {\n/// Split a string into a program name and command line arguments\n/// the string is assumed to contain a file name followed by other arguments\n/// the return value contains is a pair with the first argument containing the program name and the second\n/// everything else.\nCLI11_INLINE std::pair split_program_name(std::string commandline);\n\n} // namespace detail\n/// @}\n\n\n\n\nCLI11_INLINE std::string Validator::operator()(std::string &str) const {\n std::string retstring;\n if(active_) {\n if(non_modifying_) {\n std::string value = str;\n retstring = func_(value);\n } else {\n retstring = func_(str);\n }\n }\n return retstring;\n}\n\nCLI11_NODISCARD CLI11_INLINE Validator Validator::description(std::string validator_desc) const {\n Validator newval(*this);\n newval.desc_function_ = [validator_desc]() { return validator_desc; };\n return newval;\n}\n\nCLI11_INLINE Validator Validator::operator&(const Validator &other) const {\n Validator newval;\n\n newval._merge_description(*this, other, \" AND \");\n\n // Give references (will make a copy in lambda function)\n const std::function &f1 = func_;\n const std::function &f2 = other.func_;\n\n newval.func_ = [f1, f2](std::string &input) {\n std::string s1 = f1(input);\n std::string s2 = f2(input);\n if(!s1.empty() && !s2.empty())\n return std::string(\"(\") + s1 + \") AND (\" + s2 + \")\";\n return s1 + s2;\n };\n\n newval.active_ = active_ && other.active_;\n newval.application_index_ = application_index_;\n return newval;\n}\n\nCLI11_INLINE Validator Validator::operator|(const Validator &other) const {\n Validator newval;\n\n newval._merge_description(*this, other, \" OR \");\n\n // Give references (will make a copy in lambda function)\n const std::function &f1 = func_;\n const std::function &f2 = other.func_;\n\n newval.func_ = [f1, f2](std::string &input) {\n std::string s1 = f1(input);\n std::string s2 = f2(input);\n if(s1.empty() || s2.empty())\n return std::string();\n\n return std::string(\"(\") + s1 + \") OR (\" + s2 + \")\";\n };\n newval.active_ = active_ && other.active_;\n newval.application_index_ = application_index_;\n return newval;\n}\n\nCLI11_INLINE Validator Validator::operator!() const {\n Validator newval;\n const std::function &dfunc1 = desc_function_;\n newval.desc_function_ = [dfunc1]() {\n auto str = dfunc1();\n return (!str.empty()) ? std::string(\"NOT \") + str : std::string{};\n };\n // Give references (will make a copy in lambda function)\n const std::function &f1 = func_;\n\n newval.func_ = [f1, dfunc1](std::string &test) -> std::string {\n std::string s1 = f1(test);\n if(s1.empty()) {\n return std::string(\"check \") + dfunc1() + \" succeeded improperly\";\n }\n return std::string{};\n };\n newval.active_ = active_;\n newval.application_index_ = application_index_;\n return newval;\n}\n\nCLI11_INLINE void\nValidator::_merge_description(const Validator &val1, const Validator &val2, const std::string &merger) {\n\n const std::function &dfunc1 = val1.desc_function_;\n const std::function &dfunc2 = val2.desc_function_;\n\n desc_function_ = [=]() {\n std::string f1 = dfunc1();\n std::string f2 = dfunc2();\n if((f1.empty()) || (f2.empty())) {\n return f1 + f2;\n }\n return std::string(1, '(') + f1 + ')' + merger + '(' + f2 + ')';\n };\n}\n\nnamespace detail {\n\n#if defined CLI11_HAS_FILESYSTEM && CLI11_HAS_FILESYSTEM > 0\nCLI11_INLINE path_type check_path(const char *file) noexcept {\n std::error_code ec;\n auto stat = std::filesystem::status(file, ec);\n if(ec) {\n return path_type::nonexistent;\n }\n switch(stat.type()) {\n case std::filesystem::file_type::none: // LCOV_EXCL_LINE\n case std::filesystem::file_type::not_found:\n return path_type::nonexistent;\n case std::filesystem::file_type::directory:\n return path_type::directory;\n case std::filesystem::file_type::symlink:\n case std::filesystem::file_type::block:\n case std::filesystem::file_type::character:\n case std::filesystem::file_type::fifo:\n case std::filesystem::file_type::socket:\n case std::filesystem::file_type::regular:\n case std::filesystem::file_type::unknown:\n default:\n return path_type::file;\n }\n}\n#else\nCLI11_INLINE path_type check_path(const char *file) noexcept {\n#if defined(_MSC_VER)\n struct __stat64 buffer;\n if(_stat64(file, &buffer) == 0) {\n return ((buffer.st_mode & S_IFDIR) != 0) ? path_type::directory : path_type::file;\n }\n#else\n struct stat buffer;\n if(stat(file, &buffer) == 0) {\n return ((buffer.st_mode & S_IFDIR) != 0) ? path_type::directory : path_type::file;\n }\n#endif\n return path_type::nonexistent;\n}\n#endif\n\nCLI11_INLINE ExistingFileValidator::ExistingFileValidator() : Validator(\"FILE\") {\n func_ = [](std::string &filename) {\n auto path_result = check_path(filename.c_str());\n if(path_result == path_type::nonexistent) {\n return \"File does not exist: \" + filename;\n }\n if(path_result == path_type::directory) {\n return \"File is actually a directory: \" + filename;\n }\n return std::string();\n };\n}\n\nCLI11_INLINE ExistingDirectoryValidator::ExistingDirectoryValidator() : Validator(\"DIR\") {\n func_ = [](std::string &filename) {\n auto path_result = check_path(filename.c_str());\n if(path_result == path_type::nonexistent) {\n return \"Directory does not exist: \" + filename;\n }\n if(path_result == path_type::file) {\n return \"Directory is actually a file: \" + filename;\n }\n return std::string();\n };\n}\n\nCLI11_INLINE ExistingPathValidator::ExistingPathValidator() : Validator(\"PATH(existing)\") {\n func_ = [](std::string &filename) {\n auto path_result = check_path(filename.c_str());\n if(path_result == path_type::nonexistent) {\n return \"Path does not exist: \" + filename;\n }\n return std::string();\n };\n}\n\nCLI11_INLINE NonexistentPathValidator::NonexistentPathValidator() : Validator(\"PATH(non-existing)\") {\n func_ = [](std::string &filename) {\n auto path_result = check_path(filename.c_str());\n if(path_result != path_type::nonexistent) {\n return \"Path already exists: \" + filename;\n }\n return std::string();\n };\n}\n\nCLI11_INLINE IPV4Validator::IPV4Validator() : Validator(\"IPV4\") {\n func_ = [](std::string &ip_addr) {\n auto result = CLI::detail::split(ip_addr, '.');\n if(result.size() != 4) {\n return std::string(\"Invalid IPV4 address must have four parts (\") + ip_addr + ')';\n }\n int num = 0;\n for(const auto &var : result) {\n using CLI::detail::lexical_cast;\n bool retval = lexical_cast(var, num);\n if(!retval) {\n return std::string(\"Failed parsing number (\") + var + ')';\n }\n if(num < 0 || num > 255) {\n return std::string(\"Each IP number must be between 0 and 255 \") + var;\n }\n }\n return std::string();\n };\n}\n\n} // namespace detail\n\nCLI11_INLINE FileOnDefaultPath::FileOnDefaultPath(std::string default_path, bool enableErrorReturn)\n : Validator(\"FILE\") {\n func_ = [default_path, enableErrorReturn](std::string &filename) {\n auto path_result = detail::check_path(filename.c_str());\n if(path_result == detail::path_type::nonexistent) {\n std::string test_file_path = default_path;\n if(default_path.back() != '/' && default_path.back() != '\\\\') {\n // Add folder separator\n test_file_path += '/';\n }\n test_file_path.append(filename);\n path_result = detail::check_path(test_file_path.c_str());\n if(path_result == detail::path_type::file) {\n filename = test_file_path;\n } else {\n if(enableErrorReturn) {\n return \"File does not exist: \" + filename;\n }\n }\n }\n return std::string{};\n };\n}\n\nCLI11_INLINE AsSizeValue::AsSizeValue(bool kb_is_1000) : AsNumberWithUnit(get_mapping(kb_is_1000)) {\n if(kb_is_1000) {\n description(\"SIZE [b, kb(=1000b), kib(=1024b), ...]\");\n } else {\n description(\"SIZE [b, kb(=1024b), ...]\");\n }\n}\n\nCLI11_INLINE std::map AsSizeValue::init_mapping(bool kb_is_1000) {\n std::map m;\n result_t k_factor = kb_is_1000 ? 1000 : 1024;\n result_t ki_factor = 1024;\n result_t k = 1;\n result_t ki = 1;\n m[\"b\"] = 1;\n for(std::string p : {\"k\", \"m\", \"g\", \"t\", \"p\", \"e\"}) {\n k *= k_factor;\n ki *= ki_factor;\n m[p] = k;\n m[p + \"b\"] = k;\n m[p + \"i\"] = ki;\n m[p + \"ib\"] = ki;\n }\n return m;\n}\n\nCLI11_INLINE std::map AsSizeValue::get_mapping(bool kb_is_1000) {\n if(kb_is_1000) {\n static auto m = init_mapping(true);\n return m;\n }\n static auto m = init_mapping(false);\n return m;\n}\n\nnamespace detail {\n\nCLI11_INLINE std::pair split_program_name(std::string commandline) {\n // try to determine the programName\n std::pair vals;\n trim(commandline);\n auto esp = commandline.find_first_of(' ', 1);\n while(detail::check_path(commandline.substr(0, esp).c_str()) != path_type::file) {\n esp = commandline.find_first_of(' ', esp + 1);\n if(esp == std::string::npos) {\n // if we have reached the end and haven't found a valid file just assume the first argument is the\n // program name\n if(commandline[0] == '\"' || commandline[0] == '\\'' || commandline[0] == '`') {\n bool embeddedQuote = false;\n auto keyChar = commandline[0];\n auto end = commandline.find_first_of(keyChar, 1);\n while((end != std::string::npos) && (commandline[end - 1] == '\\\\')) { // deal with escaped quotes\n end = commandline.find_first_of(keyChar, end + 1);\n embeddedQuote = true;\n }\n if(end != std::string::npos) {\n vals.first = commandline.substr(1, end - 1);\n esp = end + 1;\n if(embeddedQuote) {\n vals.first = find_and_replace(vals.first, std::string(\"\\\\\") + keyChar, std::string(1, keyChar));\n }\n } else {\n esp = commandline.find_first_of(' ', 1);\n }\n } else {\n esp = commandline.find_first_of(' ', 1);\n }\n\n break;\n }\n }\n if(vals.first.empty()) {\n vals.first = commandline.substr(0, esp);\n rtrim(vals.first);\n }\n\n // strip the program name\n vals.second = (esp < commandline.length() - 1) ? commandline.substr(esp + 1) : std::string{};\n ltrim(vals.second);\n return vals;\n}\n\n} // namespace detail\n/// @}\n\n\n\n\nclass Option;\nclass App;\n\n/// This enum signifies the type of help requested\n///\n/// This is passed in by App; all user classes must accept this as\n/// the second argument.\n\nenum class AppFormatMode {\n Normal, ///< The normal, detailed help\n All, ///< A fully expanded help\n Sub, ///< Used when printed as part of expanded subcommand\n};\n\n/// This is the minimum requirements to run a formatter.\n///\n/// A user can subclass this is if they do not care at all\n/// about the structure in CLI::Formatter.\nclass FormatterBase {\n protected:\n /// @name Options\n ///@{\n\n /// The width of the first column\n std::size_t column_width_{30};\n\n /// @brief The required help printout labels (user changeable)\n /// Values are Needs, Excludes, etc.\n std::map labels_{};\n\n ///@}\n /// @name Basic\n ///@{\n\n public:\n FormatterBase() = default;\n FormatterBase(const FormatterBase &) = default;\n FormatterBase(FormatterBase &&) = default;\n FormatterBase &operator=(const FormatterBase &) = default;\n FormatterBase &operator=(FormatterBase &&) = default;\n\n /// Adding a destructor in this form to work around bug in GCC 4.7\n virtual ~FormatterBase() noexcept {} // NOLINT(modernize-use-equals-default)\n\n /// This is the key method that puts together help\n virtual std::string make_help(const App *, std::string, AppFormatMode) const = 0;\n\n ///@}\n /// @name Setters\n ///@{\n\n /// Set the \"REQUIRED\" label\n void label(std::string key, std::string val) { labels_[key] = val; }\n\n /// Set the column width\n void column_width(std::size_t val) { column_width_ = val; }\n\n ///@}\n /// @name Getters\n ///@{\n\n /// Get the current value of a name (REQUIRED, etc.)\n CLI11_NODISCARD std::string get_label(std::string key) const {\n if(labels_.find(key) == labels_.end())\n return key;\n return labels_.at(key);\n }\n\n /// Get the current column width\n CLI11_NODISCARD std::size_t get_column_width() const { return column_width_; }\n\n ///@}\n};\n\n/// This is a specialty override for lambda functions\nclass FormatterLambda final : public FormatterBase {\n using funct_t = std::function;\n\n /// The lambda to hold and run\n funct_t lambda_;\n\n public:\n /// Create a FormatterLambda with a lambda function\n explicit FormatterLambda(funct_t funct) : lambda_(std::move(funct)) {}\n\n /// Adding a destructor (mostly to make GCC 4.7 happy)\n ~FormatterLambda() noexcept override {} // NOLINT(modernize-use-equals-default)\n\n /// This will simply call the lambda function\n std::string make_help(const App *app, std::string name, AppFormatMode mode) const override {\n return lambda_(app, name, mode);\n }\n};\n\n/// This is the default Formatter for CLI11. It pretty prints help output, and is broken into quite a few\n/// overridable methods, to be highly customizable with minimal effort.\nclass Formatter : public FormatterBase {\n public:\n Formatter() = default;\n Formatter(const Formatter &) = default;\n Formatter(Formatter &&) = default;\n Formatter &operator=(const Formatter &) = default;\n Formatter &operator=(Formatter &&) = default;\n\n /// @name Overridables\n ///@{\n\n /// This prints out a group of options with title\n ///\n CLI11_NODISCARD virtual std::string\n make_group(std::string group, bool is_positional, std::vector opts) const;\n\n /// This prints out just the positionals \"group\"\n virtual std::string make_positionals(const App *app) const;\n\n /// This prints out all the groups of options\n std::string make_groups(const App *app, AppFormatMode mode) const;\n\n /// This prints out all the subcommands\n virtual std::string make_subcommands(const App *app, AppFormatMode mode) const;\n\n /// This prints out a subcommand\n virtual std::string make_subcommand(const App *sub) const;\n\n /// This prints out a subcommand in help-all\n virtual std::string make_expanded(const App *sub) const;\n\n /// This prints out all the groups of options\n virtual std::string make_footer(const App *app) const;\n\n /// This displays the description line\n virtual std::string make_description(const App *app) const;\n\n /// This displays the usage line\n virtual std::string make_usage(const App *app, std::string name) const;\n\n /// This puts everything together\n std::string make_help(const App * /*app*/, std::string, AppFormatMode) const override;\n\n ///@}\n /// @name Options\n ///@{\n\n /// This prints out an option help line, either positional or optional form\n virtual std::string make_option(const Option *opt, bool is_positional) const {\n std::stringstream out;\n detail::format_help(\n out, make_option_name(opt, is_positional) + make_option_opts(opt), make_option_desc(opt), column_width_);\n return out.str();\n }\n\n /// @brief This is the name part of an option, Default: left column\n virtual std::string make_option_name(const Option *, bool) const;\n\n /// @brief This is the options part of the name, Default: combined into left column\n virtual std::string make_option_opts(const Option *) const;\n\n /// @brief This is the description. Default: Right column, on new line if left column too large\n virtual std::string make_option_desc(const Option *) const;\n\n /// @brief This is used to print the name on the USAGE line\n virtual std::string make_option_usage(const Option *opt) const;\n\n ///@}\n};\n\n\n\n\nusing results_t = std::vector;\n/// callback function definition\nusing callback_t = std::function;\n\nclass Option;\nclass App;\n\nusing Option_p = std::unique_ptr