CLI::Validator Class Reference

Some validators that are provided. More...

#include <CLI11.hpp>

Inheritance diagram for CLI::Validator:

Collaboration diagram for CLI::Validator:

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

Protected Attributes
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

These are simple std::string(const std::string&) validators that are useful. They return a string if the validation fails. A custom struct is provided, as well, with the same user semantics, but with the ability to provide a new type name.

Definition at line 2089 of file CLI11.hpp.

Constructor & Destructor Documentation

Validator() [1/3]

CLI::Validator::Validator ( )

default

Validator() [2/3]

CLI::Validator::Validator ( std::string validator_desc )

inlineexplicit

Definition at line 2109 of file CLI11.hpp.

: desc_function_([validator_desc]() { return validator_desc; }) {}

Validator() [3/3]

CLI::Validator::Validator ( std::function< std::string(std::string &)> op, std::string validator_desc, std::string validator_name = "" )

inline

Definition at line 2111 of file CLI11.hpp.

        : desc_function_([validator_desc]() { return validator_desc; }), func_(std::move(op)),
          name_(std::move(validator_name)) {}

Member Function Documentation

active() [1/2]

Validator & CLI::Validator::active ( bool active_val = true )

inline

Definition at line 2173 of file CLI11.hpp.

                                              {
        active_ = active_val;
        return *this;
    }

active() [2/2]

Validator CLI::Validator::active ( bool active_val = true ) const

inline

Definition at line 2178 of file CLI11.hpp.

                                                   {
        Validator newval(*this);
        newval.active_ = active_val;
        return newval;
    }

application_index() [1/2]

Validator & CLI::Validator::application_index ( int app_index )

inline

Definition at line 2190 of file CLI11.hpp.

                                                {
        application_index_ = app_index;
        return *this;
    };

Here is the caller graph for this function:

application_index() [2/2]

Validator CLI::Validator::application_index ( int app_index ) const

inline

Definition at line 2195 of file CLI11.hpp.

                                                     {
        Validator newval(*this);
        newval.application_index_ = app_index;
        return newval;
    };

description() [1/2]

Validator & CLI::Validator::description ( std::string validator_desc )

inline

Definition at line 2142 of file CLI11.hpp.

                                                     {
        desc_function_ = [validator_desc]() { return validator_desc; };
        return *this;
    }

Here is the caller graph for this function:

description() [2/2]

Validator CLI::Validator::description ( std::string validator_desc ) const

inline

Definition at line 2147 of file CLI11.hpp.

                                                          {
        Validator newval(*this);
        newval.desc_function_ = [validator_desc]() { return validator_desc; };
        return newval;
    }

get_active()

bool CLI::Validator::get_active ( ) const

inline

Definition at line 2203 of file CLI11.hpp.

{ return active_; }

get_application_index()

int CLI::Validator::get_application_index ( ) const

inline

Definition at line 2201 of file CLI11.hpp.

{ return application_index_; }

get_description()

std::string CLI::Validator::get_description ( ) const

inline

Definition at line 2153 of file CLI11.hpp.

                                      {
        if(active_) {
            return desc_function_();
        }
        return std::string{};
    }

Here is the caller graph for this function:

get_modifying()

bool CLI::Validator::get_modifying ( ) const

inline

Definition at line 2206 of file CLI11.hpp.

{ return !non_modifying_; }

get_name()

const std::string & CLI::Validator::get_name ( ) const

inline

Definition at line 2171 of file CLI11.hpp.

{ return name_; }

Here is the caller graph for this function:

name() [1/2]

Validator & CLI::Validator::name ( std::string validator_name )

inline

Definition at line 2160 of file CLI11.hpp.

                                              {
        name_ = std::move(validator_name);
        return *this;
    }

Here is the caller graph for this function:

name() [2/2]

Validator CLI::Validator::name ( std::string validator_name ) const

inline

Definition at line 2165 of file CLI11.hpp.

                                                   {
        Validator newval(*this);
        newval.name_ = std::move(validator_name);
        return newval;
    }

non_modifying()

Validator & CLI::Validator::non_modifying ( bool no_modify = true )

inline

Definition at line 2185 of file CLI11.hpp.

                                                    {
        non_modifying_ = no_modify;
        return *this;
    }

Here is the caller graph for this function:

operation()

Validator & CLI::Validator::operation ( std::function< std::string(std::string &)> op )

inline

Definition at line 2115 of file CLI11.hpp.

                                                                 {
        func_ = std::move(op);
        return *this;
    }

operator!()

Validator CLI::Validator::operator! ( ) const

inline

Definition at line 2258 of file CLI11.hpp.

                                {
        Validator newval;
        const std::function<std::string()> &dfunc1 = desc_function_;
        newval.desc_function_ = [dfunc1]() {
            auto str = dfunc1();
            return (!str.empty()) ? std::string("NOT ") + str : std::string{};
        };
        // Give references (will make a copy in lambda function)
        const std::function<std::string(std::string & res)> &f1 = func_;
 
        newval.func_ = [f1, dfunc1](std::string &test) -> std::string {
            std::string s1 = f1(test);
            if(s1.empty()) {
                return std::string("check ") + dfunc1() + " succeeded improperly";
            }
            return std::string{};
        };
        newval.active_ = active_;
        newval.application_index_ = application_index_;
        return newval;
    }

operator&()

Validator CLI::Validator::operator& ( const Validator & other ) const

inline

Combining validators is a new validator. Type comes from left validator if function, otherwise only set if the same.

Definition at line 2210 of file CLI11.hpp.

                                                      {
        Validator newval;
 
        newval._merge_description(*this, other, " AND ");
 
        // Give references (will make a copy in lambda function)
        const std::function<std::string(std::string & filename)> &f1 = func_;
        const std::function<std::string(std::string & filename)> &f2 = other.func_;
 
        newval.func_ = [f1, f2](std::string &input) {
            std::string s1 = f1(input);
            std::string s2 = f2(input);
            if(!s1.empty() && !s2.empty())
                return std::string("(") + s1 + ") AND (" + s2 + ")";
            else
                return s1 + s2;
        };
 
        newval.active_ = (active_ & other.active_);
        newval.application_index_ = application_index_;
        return newval;
    }

operator()() [1/2]

std::string CLI::Validator::operator() ( const std::string & str ) const

inline

This is the required operator for a Validator - provided to help users (CLI11 uses the member func directly)

Definition at line 2136 of file CLI11.hpp.

                                                     {
        std::string value = str;
        return (active_) ? func_(value) : std::string{};
    };

operator()() [2/2]

std::string CLI::Validator::operator() ( std::string & str ) const

inline

This is the required operator for a Validator - provided to help users (CLI11 uses the member func directly)

Definition at line 2121 of file CLI11.hpp.

                                               {
        std::string retstring;
        if(active_) {
            if(non_modifying_) {
                std::string value = str;
                retstring = func_(value);
            } else {
                retstring = func_(str);
            }
        }
        return retstring;
    };

operator|()

Validator CLI::Validator::operator| ( const Validator & other ) const

inline

Combining validators is a new validator. Type comes from left validator if function, otherwise only set if the same.

Definition at line 2235 of file CLI11.hpp.

                                                      {
        Validator newval;
 
        newval._merge_description(*this, other, " OR ");
 
        // Give references (will make a copy in lambda function)
        const std::function<std::string(std::string &)> &f1 = func_;
        const std::function<std::string(std::string &)> &f2 = other.func_;
 
        newval.func_ = [f1, f2](std::string &input) {
            std::string s1 = f1(input);
            std::string s2 = f2(input);
            if(s1.empty() || s2.empty())
                return std::string();
 
            return std::string("(") + s1 + ") OR (" + s2 + ")";
        };
        newval.active_ = (active_ & other.active_);
        newval.application_index_ = application_index_;
        return newval;
    }

Member Data Documentation

active_

bool CLI::Validator::active_ {true}

protected

Definition at line 2102 of file CLI11.hpp.

{true};

application_index_

int CLI::Validator::application_index_ = -1

protected

Definition at line 2100 of file CLI11.hpp.

desc_function_

std::function<std::string()> CLI::Validator::desc_function_ {[]() { return std::string{}; }}

protected

Definition at line 2092 of file CLI11.hpp.

{[]() { return std::string{}; }};

func_

std::function<std::string(std::string &)> CLI::Validator::func_ {[](std::string &) { return std::string{}; }}

protected

This is the base function that is to be called. Returns a string error message if validation fails.

Definition at line 2096 of file CLI11.hpp.

{[](std::string &) { return std::string{}; }};

name_

std::string CLI::Validator::name_ {}

protected

Definition at line 2098 of file CLI11.hpp.

{};

non_modifying_

bool CLI::Validator::non_modifying_ {false}

protected

Definition at line 2104 of file CLI11.hpp.

{false};

---

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

• programs/clio/CLI11.hpp