WPILibC++ 2027.0.0-alpha-4
Loading...
Searching...
No Matches
wpi::util::Argument Class Reference

#include <wpi/util/argparse.hpp>

Public Member Functions

template<std::size_t N>
 Argument (std::string_view prefix_chars, std::array< std::string_view, N > &&a)
Argument & help (std::string help_text)
Argument & metavar (std::string metavar)
template<typename T>
Argument & default_value (T &&value)
Argument & default_value (const char *value)
Argument & required ()
Argument & implicit_value (std::any value)
Argument & flag ()
template<class F, class... Args>
auto action (F &&callable, Args &&... bound_args) -> std::enable_if_t< std::is_invocable_v< F, Args..., std::string const >, Argument & >
auto & store_into (bool &var)
template<typename T, typename std::enable_if< std::is_integral< T >::value >::type * = nullptr>
auto & store_into (T &var)
auto & store_into (double &var)
auto & store_into (std::string &var)
auto & store_into (std::vector< std::string > &var)
auto & store_into (std::vector< int > &var)
auto & store_into (std::set< std::string > &var)
auto & store_into (std::set< int > &var)
auto & append ()
auto & hidden ()
template<char Shape, typename T>
auto scan () -> std::enable_if_t< std::is_arithmetic_v< T >, Argument & >
Argument & nargs (std::size_t num_args)
Argument & nargs (std::size_t num_args_min, std::size_t num_args_max)
Argument & nargs (nargs_pattern pattern)
Argument & remaining ()
template<typename T>
void add_choice (T &&choice)
Argument & choices ()
template<typename T, typename... U>
Argument & choices (T &&first, U &&... rest)
void find_default_value_in_choices_or_throw () const
template<typename Iterator>
void find_value_in_choices_or_throw (Iterator it) const
template<typename Iterator>
Iterator consume (Iterator start, Iterator end, std::string_view used_name={}, bool dry_run=false)
void validate () const
std::string get_names_csv (char separator=',') const
std::string get_usage_full () const
std::string get_inline_usage () const
std::size_t get_arguments_length () const
template<typename T>
bool operator!= (const T &rhs) const
template<typename T>
bool operator== (const T &rhs) const

Static Public Member Functions

static bool is_positional (std::string_view name, std::string_view prefix_chars)

Friends

class ArgumentParser
auto operator<< (std::ostream &stream, const ArgumentParser &parser) -> std::ostream &
std::ostream & operator<< (std::ostream &stream, const Argument &argument)

Constructor & Destructor Documentation

◆ Argument()

template<std::size_t N>
wpi::util::Argument::Argument ( std::string_view prefix_chars,
std::array< std::string_view, N > && a )
inlineexplicit

Member Function Documentation

◆ action()

template<class F, class... Args>
auto wpi::util::Argument::action ( F && callable,
Args &&... bound_args )->std::enable_if_t< std::is_invocable_v< F, Args..., std::stringconst >, Argument & >
inline

◆ add_choice()

template<typename T>
void wpi::util::Argument::add_choice ( T && choice)
inline

◆ append()

auto & wpi::util::Argument::append ( )
inline

◆ choices() [1/2]

Argument & wpi::util::Argument::choices ( )
inline

◆ choices() [2/2]

template<typename T, typename... U>
Argument & wpi::util::Argument::choices ( T && first,
U &&... rest )
inline

◆ consume()

template<typename Iterator>
Iterator wpi::util::Argument::consume ( Iterator start,
Iterator end,
std::string_view used_name = {},
bool dry_run = false )
inline

◆ default_value() [1/2]

Argument & wpi::util::Argument::default_value ( const char * value)
inline

◆ default_value() [2/2]

template<typename T>
Argument & wpi::util::Argument::default_value ( T && value)
inline

◆ find_default_value_in_choices_or_throw()

void wpi::util::Argument::find_default_value_in_choices_or_throw ( ) const
inline

◆ find_value_in_choices_or_throw()

template<typename Iterator>
void wpi::util::Argument::find_value_in_choices_or_throw ( Iterator it) const
inline

◆ flag()

Argument & wpi::util::Argument::flag ( )
inline

◆ get_arguments_length()

std::size_t wpi::util::Argument::get_arguments_length ( ) const
inline

◆ get_inline_usage()

std::string wpi::util::Argument::get_inline_usage ( ) const
inline

◆ get_names_csv()

std::string wpi::util::Argument::get_names_csv ( char separator = ',') const
inline

◆ get_usage_full()

std::string wpi::util::Argument::get_usage_full ( ) const
inline

◆ help()

Argument & wpi::util::Argument::help ( std::string help_text)
inline

◆ hidden()

auto & wpi::util::Argument::hidden ( )
inline

◆ implicit_value()

Argument & wpi::util::Argument::implicit_value ( std::any value)
inline

◆ is_positional()

bool wpi::util::Argument::is_positional ( std::string_view name,
std::string_view prefix_chars )
inlinestatic

◆ metavar()

Argument & wpi::util::Argument::metavar ( std::string metavar)
inline

◆ nargs() [1/3]

Argument & wpi::util::Argument::nargs ( nargs_pattern pattern)
inline

◆ nargs() [2/3]

Argument & wpi::util::Argument::nargs ( std::size_t num_args)
inline

◆ nargs() [3/3]

Argument & wpi::util::Argument::nargs ( std::size_t num_args_min,
std::size_t num_args_max )
inline

◆ operator!=()

template<typename T>
bool wpi::util::Argument::operator!= ( const T & rhs) const
inline

◆ operator==()

template<typename T>
bool wpi::util::Argument::operator== ( const T & rhs) const
inline

◆ remaining()

Argument & wpi::util::Argument::remaining ( )
inline

◆ required()

Argument & wpi::util::Argument::required ( )
inline

◆ scan()

template<char Shape, typename T>
auto wpi::util::Argument::scan ( ) ->std::enable_if_t< std::is_arithmetic_v< T >, Argument & >
inline

◆ store_into() [1/8]

auto & wpi::util::Argument::store_into ( bool & var)
inline

◆ store_into() [2/8]

auto & wpi::util::Argument::store_into ( double & var)
inline

◆ store_into() [3/8]

auto & wpi::util::Argument::store_into ( std::set< int > & var)
inline

◆ store_into() [4/8]

auto & wpi::util::Argument::store_into ( std::set< std::string > & var)
inline

◆ store_into() [5/8]

auto & wpi::util::Argument::store_into ( std::string & var)
inline

◆ store_into() [6/8]

auto & wpi::util::Argument::store_into ( std::vector< int > & var)
inline

◆ store_into() [7/8]

auto & wpi::util::Argument::store_into ( std::vector< std::string > & var)
inline

◆ store_into() [8/8]

template<typename T, typename std::enable_if< std::is_integral< T >::value >::type * = nullptr>
auto & wpi::util::Argument::store_into ( T & var)
inline

◆ validate()

void wpi::util::Argument::validate ( ) const
inline

◆ ArgumentParser

friend class ArgumentParser
friend

◆ operator<< [1/2]

std::ostream & operator<< ( std::ostream & stream,
const Argument & argument )
friend

◆ operator<< [2/2]

auto operator<< ( std::ostream & stream,
const ArgumentParser & parser )->std::ostream &
friend
The documentation for this class was generated from the following file: