CLI::CheckedTransformer Class Reference

translate named items to other or a value set More...

#include <CLI11.hpp>

Inheritance diagram for CLI::CheckedTransformer:

Collaboration diagram for CLI::CheckedTransformer:

Public Types
using	filter_fn_t = std::function<std::string(std::string)>

Public Member Functions
template<typename... Args>
	CheckedTransformer (std::initializer_list< std::pair< std::string, std::string > > values, Args &&... args)
	This allows in-place construction.
template<typename T >
	CheckedTransformer (T mapping)
	direct map of std::string to std::string
template<typename T , typename F >
	CheckedTransformer (T mapping, F filter_function)
template<typename T , typename... Args>
	CheckedTransformer (T &&mapping, filter_fn_t filter_fn_1, filter_fn_t filter_fn_2, Args &&... other)
	You can pass in as many filter functions as you like, they nest.
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

Definition at line 2841 of file CLI11.hpp.

Member Typedef Documentation

filter_fn_t

using CLI::CheckedTransformer::filter_fn_t = std::function<std::string(std::string)>

Definition at line 2843 of file CLI11.hpp.

Constructor & Destructor Documentation

CheckedTransformer() [1/4]

template<typename... Args>

CLI::CheckedTransformer::CheckedTransformer ( std::initializer_list< std::pair< std::string, std::string > > values, Args &&... args )

inline

Definition at line 2847 of file CLI11.hpp.

        : CheckedTransformer(TransformPairs<std::string>(values), std::forward<Args>(args)...) {}

CheckedTransformer() [2/4]

template<typename T >

CLI::CheckedTransformer::CheckedTransformer ( T mapping )

inlineexplicit

Definition at line 2851 of file CLI11.hpp.

: CheckedTransformer(std::move(mapping), nullptr) {}

CheckedTransformer() [3/4]

template<typename T , typename F >

CLI::CheckedTransformer::CheckedTransformer ( T mapping, F filter_function )

inlineexplicit

This checks to see if an item is in a set: pointer or copy version. You can pass in a function that will filter both sides of the comparison before computing the comparison.

Definition at line 2855 of file CLI11.hpp.

                                                                                                {
 
        static_assert(detail::pair_adaptor<typename detail::element_type<T>::type>::value,
                      "mapping must produce value pairs");
        // Get the type of the contained item - requires a container have ::value_type
        // if the type does not have first_type and second_type, these are both value_type
        using element_t = typename detail::element_type<T>::type;            // Removes (smart) pointers if needed
        using item_t = typename detail::pair_adaptor<element_t>::first_type; // Is value_type if not a map
        using local_item_t = typename IsMemberType<item_t>::type;            // This will convert bad types to good ones
                                                                             // (const char * to std::string)
        using iteration_type_t = typename detail::pair_adaptor<element_t>::value_type; // the type of the object pair //
                                                                                       // the type of the object pair
 
        // Make a local copy of the filter function, using a std::function if not one already
        std::function<local_item_t(local_item_t)> filter_fn = filter_function;
 
        auto tfunc = [mapping]() {
            std::string out("value in ");
            out += detail::generate_map(detail::smart_deref(mapping)) + " OR {";
            out += detail::join(
                detail::smart_deref(mapping),
                [](const iteration_type_t &v) { return detail::to_string(detail::pair_adaptor<element_t>::second(v)); },
                ",");
            out.push_back('}');
            return out;
        };
 
        desc_function_ = tfunc;
 
        func_ = [mapping, tfunc, filter_fn](std::string &input) {
            local_item_t b;
            bool converted = detail::lexical_cast(input, b);
            if(converted) {
                if(filter_fn) {
                    b = filter_fn(b);
                }
                auto res = detail::search(mapping, b, filter_fn);
                if(res.first) {
                    input = detail::value_string(detail::pair_adaptor<element_t>::second(*res.second));
                    return std::string{};
                }
            }
            for(const auto &v : detail::smart_deref(mapping)) {
                auto output_string = detail::value_string(detail::pair_adaptor<element_t>::second(v));
                if(output_string == input) {
                    return std::string();
                }
            }
 
            return "Check " + input + " " + tfunc() + " FAILED";
        };
    }

Here is the call graph for this function:

CheckedTransformer() [4/4]

template<typename T , typename... Args>

CLI::CheckedTransformer::CheckedTransformer ( T && mapping, filter_fn_t filter_fn_1, filter_fn_t filter_fn_2, Args &&... other )

inline

Definition at line 2910 of file CLI11.hpp.

        : CheckedTransformer(
              std::forward<T>(mapping),
              [filter_fn_1, filter_fn_2](std::string a) { return filter_fn_2(filter_fn_1(a)); },
              other...) {}

---

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

• programs/clio/CLI11.hpp