OptionMultiple< T > Class Template Reference

#include <CommandLine.h>

Inheritance diagram for OptionMultiple< T >:

Public Types
typedef std::vector< OptionPossibility< T > >	OptionPossibilities

Public Member Functions
	OptionMultiple (std::string description, OptionPossibilities possibilities)
virtual bool	canSet (void) const override
	Can this option be set? More...
virtual bool	parseAndSetValue (const std::string s) override
	From a given string, set the value of this option. More...
virtual bool	isMultiple (void) const override
	Whether this option is an OptionMultiple. More...
bool	nothingSet (void) const
	If the bitset is empty. More...
bool	operator() (const T v) const
	Returns whether the value v had been set as an option. More...

Private Attributes
std::unordered_map< T, bool >	optionValues
OptionPossibilities	possibilities

Additional Inherited Members
Static Public Member Functions inherited from OptionBase
static std::vector< std::string >	parseOptions (int argc, char *argv[], std::string description, std::string callFormat)
Protected Types inherited from OptionBase
typedef std::pair< std::string, std::string >	PossibilityDescription
	Name/description pairs. More...
typedef std::vector< std::pair< std::string, std::string > >	PossibilityDescriptions
template<typename T >
using	OptionPossibility = std::tuple< T, std::string, std::string >
Protected Member Functions inherited from OptionBase
	OptionBase (std::string name, std::string description)
	OptionBase (std::string name, std::string description, PossibilityDescriptions possibilityDescriptions)
virtual bool	isBool (void) const
Static Protected Member Functions inherited from OptionBase
template<typename T >
static PossibilityDescriptions	extractPossibilityDescriptions (const std::vector< OptionPossibility< T >> possibilities)
static std::map< std::string, OptionBase * > &	getOptionsMap (void)
Protected Attributes inherited from OptionBase
std::string	name
std::string	description
PossibilityDescriptions	possibilityDescriptions
	For when we have possibilities like in an OptionMap. More...

Detailed Description

template<typename T>
class OptionMultiple< T >

Options which form a kind of bit set. There are multiple names and n of them can be set. Opt(v) tests whether v had been set, aborting if v is invalid.

Definition at line 457 of file CommandLine.h.

Member Typedef Documentation

OptionPossibilities

template<typename T >

typedef std::vector<OptionPossibility<T> > OptionMultiple< T >::OptionPossibilities

Definition at line 460 of file CommandLine.h.

Constructor & Destructor Documentation

OptionMultiple()

template<typename T >

OptionMultiple< T >::OptionMultiple ( std::string  description, OptionPossibilities  possibilities  )

inline

Definition at line 462 of file CommandLine.h.

        : OptionBase("", description, extractPossibilityDescriptions(possibilities)), possibilities(possibilities)
    {
        for (const OptionPossibility<T> &op : possibilities)
        {
            optionValues[std::get<0>(op)] = false;
        }
 
        for (const OptionPossibility<T> &op : possibilities)
        {
            std::string possibilityName = std::get<1>(op);
            getOptionsMap()[possibilityName] = this;
        }
    }

Member Function Documentation

canSet()

template<typename T >

virtual bool OptionMultiple< T >::canSet ( void  ) const

inlineoverridevirtual

Can this option be set?

Implements OptionBase.

Definition at line 477 of file CommandLine.h.

    {
        return true;
    }

isMultiple()

template<typename T >

virtual bool OptionMultiple< T >::isMultiple ( void  ) const

inlineoverridevirtual

Whether this option is an OptionMultiple.

Reimplemented from OptionBase.

Definition at line 497 of file CommandLine.h.

    {
        return true;
    }

nothingSet()

template<typename T >

bool OptionMultiple< T >::nothingSet ( void  ) const

inline

If the bitset is empty.

Definition at line 503 of file CommandLine.h.

    {
        for (const std::pair<T, bool> tb : optionValues)
        {
            if (tb.second) return false;
        }
 
        return true;
    }

operator()()

template<typename T >

bool OptionMultiple< T >::operator() ( const T  v ) const

inline

Returns whether the value v had been set as an option.

Definition at line 514 of file CommandLine.h.

    {
        typename std::unordered_map<T, bool>::const_iterator ovIt = optionValues.find(v);
        // TODO: disabled as we check for "invalid" values in some places.
        // assert(ovIt != optionValues.end() && "OptionMultiple: bad value checked");
        if (ovIt == optionValues.end()) return false;
        return ovIt->second;
    }

parseAndSetValue()

template<typename T >

virtual bool OptionMultiple< T >::parseAndSetValue ( const std::string  value )

inlineoverridevirtual

From a given string, set the value of this option.

Implements OptionBase.

Definition at line 482 of file CommandLine.h.

    {
        // Like in OptionMap basically, except we can have many values.
        for (const OptionPossibility<T> &op : possibilities)
        {
            if (s == std::get<1>(op))
            {
                optionValues[std::get<0>(op)] = true;
                return true;
            }
        }
 
        return false;
    }

Member Data Documentation

optionValues

template<typename T >

std::unordered_map<T, bool> OptionMultiple< T >::optionValues

private

Is the option set? Use a map rather than a set because it's now easier in one DS to determine whether something is 1) valid, and 2) set.

Definition at line 526 of file CommandLine.h.

possibilities

template<typename T >

OptionPossibilities OptionMultiple< T >::possibilities

private

Definition at line 527 of file CommandLine.h.

---

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

• /home/runner/work/SVF/SVF/svf/include/Util/CommandLine.h