CLI::AsNumberWithUnit Class Reference

#include <CLI11.hpp>

Inheritance diagram for CLI::AsNumberWithUnit:

Collaboration diagram for CLI::AsNumberWithUnit:

Public Types
enum	Options {   CASE_SENSITIVE = 0 , CASE_INSENSITIVE = 1 , UNIT_OPTIONAL = 0 , UNIT_REQUIRED = 2 ,   DEFAULT = CASE_INSENSITIVE | UNIT_OPTIONAL }

Public Member Functions
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

Multiply a number by a factor using given mapping. Can be used to write transforms for SIZE or DURATION inputs.

Example: With mapping = {"b"->1, "kb"->1024, "mb"->1024*1024} one can recognize inputs like "100", "12kb", "100 MB", that will be automatically transformed to 100, 14448, 104857600.

Output number type matches the type in the provided mapping. Therefore, if it is required to interpret real inputs like "0.42 s", the mapping should be of a type <string, float> or <string, double>.

Definition at line 2941 of file CLI11.hpp.

Member Enumeration Documentation

Options

enum CLI::AsNumberWithUnit::Options

Adjust AsNumberWithUnit behavior. CASE_SENSITIVE/CASE_INSENSITIVE controls how units are matched. UNIT_OPTIONAL/UNIT_REQUIRED throws ValidationError if UNIT_REQUIRED is set and unit literal is not found.

Enumerator
CASE_SENSITIVE
CASE_INSENSITIVE
UNIT_OPTIONAL
UNIT_REQUIRED
DEFAULT

Definition at line 2947 of file CLI11.hpp.

                 {
        CASE_SENSITIVE = 0,
        CASE_INSENSITIVE = 1,
        UNIT_OPTIONAL = 0,
        UNIT_REQUIRED = 2,
        DEFAULT = CASE_INSENSITIVE | UNIT_OPTIONAL
    };

Constructor & Destructor Documentation

AsNumberWithUnit()

template<typename Number >

CLI::AsNumberWithUnit::AsNumberWithUnit ( std::map< std::string, Number > mapping, Options opts = DEFAULT, const std::string & unit_name = "UNIT" )

inlineexplicit

Definition at line 2956 of file CLI11.hpp.

                                                                   {
        description(generate_description<Number>(unit_name, opts));
        validate_mapping(mapping, opts);
 
        // transform function
        func_ = [mapping, opts](std::string &input) -> std::string {
            Number num;
 
            detail::rtrim(input);
            if(input.empty()) {
                throw ValidationError("Input is empty");
            }
 
            // Find split position between number and prefix
            auto unit_begin = input.end();
            while(unit_begin > input.begin() && std::isalpha(*(unit_begin - 1), std::locale())) {
                --unit_begin;
            }
 
            std::string unit{unit_begin, input.end()};
            input.resize(static_cast<std::size_t>(std::distance(input.begin(), unit_begin)));
            detail::trim(input);
 
            if(opts & UNIT_REQUIRED && unit.empty()) {
                throw ValidationError("Missing mandatory unit");
            }
            if(opts & CASE_INSENSITIVE) {
                unit = detail::to_lower(unit);
            }
 
            bool converted = detail::lexical_cast(input, num);
            if(!converted) {
                throw ValidationError(std::string("Value ") + input + " could not be converted to " +
                                      detail::type_name<Number>());
            }
 
            if(unit.empty()) {
                // No need to modify input if no unit passed
                return {};
            }
 
            // find corresponding factor
            auto it = mapping.find(unit);
            if(it == mapping.end()) {
                throw ValidationError(unit +
                                      " unit not recognized. "
                                      "Allowed values: " +
                                      detail::generate_map(mapping, true));
            }
 
            // perform safe multiplication
            bool ok = detail::checked_multiply(num, it->second);
            if(!ok) {
                throw ValidationError(detail::to_string(num) + " multiplied by " + unit +
                                      " factor would cause number overflow. Use smaller value.");
            }
            input = detail::to_string(num);
 
            return {};
        };
    }

Here is the call graph for this function:

---

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

• programs/clio/CLI11.hpp