CLI::AsSizeValue Class Reference

#include <CLI11.hpp>

Inheritance diagram for CLI::AsSizeValue:

Collaboration diagram for CLI::AsSizeValue:

Public Types
using	result_t = uint64_t
Public Types inherited from CLI::AsNumberWithUnit
enum	Options {   CASE_SENSITIVE = 0 , CASE_INSENSITIVE = 1 , UNIT_OPTIONAL = 0 , UNIT_REQUIRED = 2 ,   DEFAULT = CASE_INSENSITIVE | UNIT_OPTIONAL }

Public Member Functions
	AsSizeValue (bool kb_is_1000)
Public Member Functions inherited from CLI::AsNumberWithUnit
template<typename Number >
	AsNumberWithUnit (std::map< std::string, Number > mapping, Options opts=DEFAULT, const std::string &unit_name="UNIT")
Public Member Functions inherited from CLI::Validator
	Validator ()=default
	Validator (std::string validator_desc)
	Construct a Validator with just the description string.
	Validator (std::function< std::string(std::string &)> op, std::string validator_desc, std::string validator_name="")
	Construct Validator from basic information.
Validator &	operation (std::function< std::string(std::string &)> op)
	Set the Validator operation function.
std::string	operator() (std::string &str) const
std::string	operator() (const std::string &str) const
Validator &	description (std::string validator_desc)
	Specify the type string.
Validator	description (std::string validator_desc) const
	Specify the type string.
std::string	get_description () const
	Generate type description information for the Validator.
Validator &	name (std::string validator_name)
	Specify the type string.
Validator	name (std::string validator_name) const
	Specify the type string.
const std::string &	get_name () const
	Get the name of the Validator.
Validator &	active (bool active_val=true)
	Specify whether the Validator is active or not.
Validator	active (bool active_val=true) const
	Specify whether the Validator is active or not.
Validator &	non_modifying (bool no_modify=true)
	Specify whether the Validator can be modifying or not.
Validator &	application_index (int app_index)
	Specify the application index of a validator.
Validator	application_index (int app_index) const
	Specify the application index of a validator.
int	get_application_index () const
	Get the current value of the application index.
bool	get_active () const
	Get a boolean if the validator is active.
bool	get_modifying () const
	Get a boolean if the validator is allowed to modify the input returns true if it can modify the input.
Validator	operator& (const Validator &other) const
Validator	operator| (const Validator &other) const
Validator	operator! () const
	Create a validator that fails when a given validator succeeds.

Additional Inherited Members
Protected Attributes inherited from CLI::Validator
std::function< std::string()>	desc_function_ {[]() { return std::string{}; }}
	This is the description function, if empty the description_ will be used.
std::function< std::string(std::string &)>	func_ {[](std::string &) { return std::string{}; }}
std::string	name_ {}
	The name for search purposes of the Validator.
int	application_index_ = -1
	A Validator will only apply to an indexed value (-1 is all elements)
bool	active_ {true}
	Enable for Validator to allow it to be disabled if need be.
bool	non_modifying_ {false}
	specify that a validator should not modify the input

Detailed Description

Converts a human-readable size string (with unit literal) to uin64_t size. Example: "100" => 100 "1 b" => 100 "10Kb" => 10240 // you can configure this to be interpreted as kilobyte (*1000) or kibibyte (*1024) "10 KB" => 10240 "10 kb" => 10240 "10 kib" => 10240 // *i, *ib are always interpreted as *bibyte (*1024) "10kb" => 10240 "2 MB" => 2097152 "2 EiB" => 2^61 // Units up to exibyte are supported

Definition at line 3072 of file CLI11.hpp.

Member Typedef Documentation

result_t

using CLI::AsSizeValue::result_t = uint64_t

Definition at line 3074 of file CLI11.hpp.

Constructor & Destructor Documentation

AsSizeValue()

CLI::AsSizeValue::AsSizeValue ( bool kb_is_1000 )

inlineexplicit

If kb_is_1000 is true, interpret 'kb', 'k' as 1000 and 'kib', 'ki' as 1024 (same applies to higher order units as well). Otherwise, interpret all literals as factors of 1024. The first option is formally correct, but the second interpretation is more wide-spread (see https://en.wikipedia.org/wiki/Binary_prefix).

Definition at line 3083 of file CLI11.hpp.

                                          : AsNumberWithUnit(get_mapping(kb_is_1000)) {
        if(kb_is_1000) {
            description("SIZE [b, kb(=1000b), kib(=1024b), ...]");
        } else {
            description("SIZE [b, kb(=1024b), ...]");
        }
    }

Here is the call graph for this function:

---

The documentation for this class was generated from the following file:

• programs/clio/CLI11.hpp