32 m_sAppDescription = std::move(sAppDescription);
37 if (argc <= 0 || argv ==
nullptr)
44 m_Args.reserve(
static_cast<size_t>(argc));
45 for (
int i = 0; i < argc; ++i)
46 m_Args.push_back(
to_string(cstring_view(argv[i])));
53 [](
const string& sValue)
55 const string_view svValue = sValue;
56 return svValue == QXT(
"--help") || svValue == QXT(
"-h");
64 string_view svRuntimeName;
67 std::map<string_view, std::vector<data_with_runtime_name>> groups;
68 for (
const auto& [svRuntimeName, data] : m_VariableData)
70 groups[data.svGroupName].emplace_back(data, svRuntimeName);
73 for (std::vector<data_with_runtime_name>& lines : groups | std::views::values)
77 [](
const data_with_runtime_name& left,
const data_with_runtime_name& right)
79 return left.bRequired > right.bRequired && left.svFullCommandLineName > right.svFullCommandLineName;
86 constexpr string_view svRequired = QXT(
"required ");
88 size_t nMaxFullCommandLineNameLength = 0;
89 size_t nMaxShortCommandLineNameLength = 0;
90 size_t nMaxTypeNameLength = 0;
91 size_t nMaxRequiredNameLength = 0;
92 for (
const std::vector<data_with_runtime_name>& lines : groups | std::views::values)
94 for (
const data_with_runtime_name& line : lines)
96 nMaxFullCommandLineNameLength =
97 std::max(nMaxFullCommandLineNameLength, line.svFullCommandLineName.size());
98 nMaxShortCommandLineNameLength =
99 std::max(nMaxShortCommandLineNameLength, line.svShortCommandLineName.size());
100 nMaxTypeNameLength = std::max(nMaxTypeNameLength, line.svTypeName.size());
101 nMaxRequiredNameLength = std::max(
102 nMaxRequiredNameLength,
103 line.bRequired ? svRequired.size() : line.pTToString(m_Variables.at(line.svRuntimeName)).size());
107 sHelp.
append_format(QXT(
"\n\nUsage: {} [options]\n"), m_Args[0]);
108 sHelp += QXT(
"Using formats: [--key], [-k], [--key=value], [-k=value], [--key value], [-k value]\n\n");
110 if (!m_sAppDescription.empty())
113 for (
const auto& [svGroupName, lines] : groups)
115 if (!svGroupName.empty())
118 sHelp += QXT(
"General options:\n");
121 QXT(
"--------------------------------------------------------------------------------------------------"
122 "----------------------\n");
124 for (
const data_with_runtime_name& line : lines)
127 QXT(
"{:<{}} {:<{}} {:<{}} {:<{}}{}\n"),
128 line.svFullCommandLineName,
129 nMaxFullCommandLineNameLength,
130 line.svShortCommandLineName,
131 nMaxShortCommandLineNameLength,
134 line.bRequired ? svRequired
135 : string_view(line.pTToString(m_Variables.at(line.svRuntimeName)) + QXT(
" ")),
136 nMaxRequiredNameLength,
145 sHelp += QXT(
"This app doesn't have any command line arguments.\n\n");
146 if (!m_sAppDescription.empty())
150 QX_LOG(qx::verbosity::important, sHelp);
157 std::unordered_map<string_view, std::any> variables;
160 for (
const auto& [svRuntimeName, value] : m_DefaultVariables)
161 if (!m_Variables.contains(svRuntimeName))
162 variables[svRuntimeName] = value;
165 for (
const auto& [svRuntimeName, data] : m_VariableData)
167 if (
const char* pszEnvValue = std::getenv(
to_cstring(data.svEnvName).c_str()))
169 std::optional<std::any> optValue = data.pStringToT(
to_string(pszEnvValue));
173 variables[svRuntimeName] = std::move(*optValue);
178 for (
size_t i = 1; i < m_Args.size(); ++i)
180 const string_view svArgument = m_Args[i];
182 bool bShortKey =
false;
186 svKey = string_view(svArgument.begin(), svArgument.end());
187 if (svArgument.starts_with(QXT(
"--")))
191 else if (svArgument.starts_with(QXT(
"-")))
198 qx::verbosity::warning,
199 "Invalid command argument format: {}. "
200 "Use \"--key=value\", \"--key value\", \"-k value\", \"--key\", \"-k\" instead.",
206 if (
const size_t nEqualPos = svKey.find(
'='); nEqualPos != string_view::npos)
208 svValue = string_view(svKey.begin() + nEqualPos + 1, svKey.end());
209 svKey = string_view(svKey.begin(), svKey.begin() + nEqualPos);
212 else if (i + 1 < m_Args.size())
214 const string_view svNextArgument = m_Args[i + 1];
216 if (!svNextArgument.starts_with(QXT(
"-")))
218 svValue = svNextArgument;
224 svValue = QXT(
"true");
230 svValue = QXT(
"true");
235 QX_LOG(qx::verbosity::warning,
"Empty command argument key: {}.", svArgument);
241 QX_LOG(qx::verbosity::warning,
"Empty command argument value: {}.", svArgument);
245 for (
const auto& [svRuntimeName, data] : m_VariableData)
247 const bool bNameMatches =
248 bShortKey && svKey == data.svShortCommandLineName || !bShortKey && svKey == data.svFullCommandLineName;
252 std::optional<std::any> optValue = data.pStringToT(svValue);
256 variables[svRuntimeName] = std::move(*optValue);
261 bool bAllRequiredVariablesPresent =
true;
262 for (
const auto& [svRuntimeName, data] : m_VariableData)
264 if (data.bRequired && !variables.contains(svRuntimeName))
266 QX_LOG(qx::verbosity::error,
"Required variable missing: {}.", data.svFullCommandLineName);
267 bAllRequiredVariablesPresent =
false;
272 for (
const auto& [svRuntimeName, value] : variables)
273 m_Variables[svRuntimeName] = value;
275 return bAllRequiredVariablesPresent;
280 string_view svRuntimeName)
const noexcept
282 const auto value = get(svRuntimeName);
284 return std::unexpected(value.error());
286 const auto* pValue = std::any_cast<typename details::layered_config_variable_type<T>::type>(&value->get());
288 return std::unexpected(get_error::type_mismatch);
295 string_view svRuntimeName,
298 using stored_type =
typename details::layered_config_variable_type<T>::type;
299 return set(svRuntimeName, std::any(stored_type(std::move(value))));
305 const auto itValue = m_Variables.find(svRuntimeName);
306 if (itValue != m_Variables.end())
307 return std::cref(itValue->second);
309 const auto itDefault = m_DefaultVariables.find(svRuntimeName);
310 if (itDefault == m_DefaultVariables.end())
311 return std::unexpected(get_error::unknown_variable);
313 return std::cref(itDefault->second);
317 string_view svRuntimeName,
318 std::any value) noexcept
320 const auto it = m_DefaultVariables.find(svRuntimeName);
322 if (it == m_DefaultVariables.end())
323 return std::unexpected(set_error::unknown_variable);
325 if (it->second.type() != value.type())
326 return std::unexpected(set_error::type_mismatch);
328 m_Variables[it->first] = std::move(value);
333 string_view svRuntimeName)
const noexcept
335 const std::expected<std::reference_wrapper<const std::any>,
get_error> value = get(svRuntimeName);
337 return std::unexpected(value.error());
339 return m_VariableData.at(svRuntimeName).pTToString(value->get());
343 string_view svRuntimeName,
344 string_view svValue) noexcept
346 const auto itData = m_VariableData.find(svRuntimeName);
347 if (itData == m_VariableData.end())
348 return std::unexpected(set_error::unknown_variable);
350 auto optValue = itData->second.pStringToT(svValue);
352 return std::unexpected(set_error::invalid_value);
354 return set(svRuntimeName, std::move(*optValue));
359 std::vector<layered_config_variable_info> variables;
360 for (
const auto& [svName, data] : m_VariableData)
361 variables.emplace_back(svName, data.svDescription, data.svTypeName, data.svGroupName);
363 std::ranges::sort(variables, {}, &layered_config_variable_info::svName);
373 void layered_configs_manager::add_variable(
374 string_view svRuntimeName,
376 T defaultValue) noexcept
378 m_VariableData[svRuntimeName] = data;
379 m_DefaultVariables[svRuntimeName] =
typename details::layered_config_variable_type<T>::type(defaultValue);
requires format_acceptable_args_c< char_t, args_t... > void append_format(const format_string_type< std::type_identity_t< args_t >... > sFormat, args_t &&... args) noexcept
Append the formatted string to the current one.
std::expected< void, set_error > set_string(string_view svRuntimeName, string_view svValue) noexcept
Set a variable from text using its existing registered parser.
void set_app_description(string sAppDescription) noexcept
Set app description. It will be shown in help message.
get_error
Errors returned when reading a registered variable.
std::vector< layered_config_variable_info > get_variables() const noexcept
Enumerate registered variables without exposing converters or stored values.
std::expected< void, set_error > set(string_view svRuntimeName, T value) noexcept
Set variable value by runtime name. Only set if the variable type matches.
void reset() noexcept
Clear all variables and command line arguments. You should call parse() after that to set variables a...
std::expected< string, get_error > get_string(string_view svRuntimeName) const noexcept
Read a value through its registered string formatter without knowing its C++ type.
std::expected< T, get_error > get(string_view svRuntimeName) const noexcept
Get variable value by runtime name.
bool parse() noexcept
Parse command line arguments, environment variables, and default values.
bool show_help() const noexcept
Show help message if "--help" or "-h" argument is present in command line arguments.
void set_args(int argc, char *argv[]) noexcept
Copy command line arguments, converting narrow input with to_string().
bool contains_if(fwd_it_t itBegin, fwd_it_t itEnd, const predicate_t &predicate)
Check if at least one of range's elements satisfies a predicate.
#define QX_LOG(eVerbosity,...)
Log message.
void sort(random_it_t begin, random_it_t end, compare_t compare=compare_t())
Sort by the most suitable algorithm.
void to_cstring(cstring &out, wstring_view stringView, const std::locale &locale=get_locale())
Convert wstring to cstring.
void to_string(string &out, cstring_view stringView, const std::locale &locale=get_locale())
Convert a char string to common string type.