template for map-based options. More...

#include <Options.h>

Inheritance diagram for options::map< T, Container >:

Collaboration diagram for options::map< T, Container >:

Public Member Functions
	map (char aShortName, const std::string &aLongName, const std::string &aExplanation, std::initializer_list< typename Container::value_type > aDefault={})

	map (const map &)=delete

void	fWriteCfgLines (std::ostream &aStream, const char *aPrefix) const override

void	fWriteValue (std::ostream &aStream) const override
	write textual representation of value to a std::ostream More...

template<typename C = Container>
std::enable_if< std::is_same< std::map< typename std::remove_const< typename Container::value_type::first_type >::type, typename Container::value_type::second_type >, C >::value, typename C::iterator >::type	insertOrUpdate (typename C::value_type aPair)

template<typename C = Container>
std::enable_if< !std::is_same< std::map< typename std::remove_const< typename Container::value_type::first_type >::type, typename Container::value_type::second_type >, C >::value, typename Container::iterator >::type	insertOrUpdate (typename C::value_type aPair)

void	fSetMe (std::istream &aStream, const internal::sourceItem &aSource) override
	function to set the value from a string, remembering the source More...

void	fCheckRange () const override

std::add_rvalue_reference< std::add_const< Container > >::type	fGetValue () const

Public Member Functions inherited from options::internal::baseForMap< T >
	baseForMap (char aShortName, std::string aLongName, std::string aExplanation, short aNargs)

void	fAddSource (const T *aValueLocation, const internal::sourceItem &aSource)

const internal::sourceItem	fGetSource (const T *aValueLocation) const

bool	fIsSet () const override
	check if this option was set, regardless of from command line or config file More...

bool	fIsContainer () const override

void	fAddDefaultFromStream (std::istream &aStream) override
	special for use in the shellScriptOptionParser More...

Public Member Functions inherited from options::internal::typed_base< T >
	typed_base (Types ... args)

virtual void	fAddToRange (rangeValueType aValue)
	add a value to the range of allowed values More...

std::enable_if<(!std::is_same< rangeValueType, std::string >::value) &&std::is_same< TT, std::string >::value, void >::type	fAddToRange (const TT &aString)

void	fAddToRange (InputIt aBegin, InputIt aEnd)
	add values from the iterator range [aBegin,aEnd) to the range of allowed values More...

void	fAddToRange (const std::vector< TT > &aRange)
	add values from a vector (may be given as initializer list) to the range of allowed values More...

void	fAddToRangeFromStream (std::istream &aStream) override

void	fWriteRange (std::ostream &aStream) const override

virtual void	fCheckValueForRange (const compareValueType &aValue) const

Public Member Functions inherited from options::base
	base (char aShortName, const std::string &aLongName, const std::string &aExplanation, short aNargs)
	construct an object of type base More...

virtual	~base ()

virtual void	fRequire (const base *aOtherOption)
	require aOtherOption when this option is set More...

virtual void	fRequire (std::vector< const base * > aOtherOptions)
	add vector of other options, particlularly nice for use with initializer list More...

template<typename InputIt >
void	fRequire (InputIt aBegin, InputIt aEnd)
	add all options from the pair of iterators [aBegin,aEnd) to the list of required options More...

virtual void	fForbid (const base *aOtherOption)
	forbid aOtherOption when this option is set More...

virtual void	fForbid (std::vector< const base * > aOtherOptions)
	add vector of other options, particlularly nice for use with initializer list More...

template<typename InputIt >
void	fForbid (InputIt aBegin, InputIt aEnd)
	add all options from the pair of iterators [aBegin,aEnd) to the list of forbidden options More...

const std::string &	fGetLongName () const
	returns long name of option, usually only for internal use. More...

Additional Inherited Members
Public Types inherited from options::internal::typed_base< T >
typedef T	valueType

typedef std::conditional< std::is_same< T, const char * >::value\|\|false, std::string, T >::type	rangeValueType

typedef std::conditional< false, std::string, T >::type	compareValueType

Protected Member Functions inherited from options::base
virtual void	fSetMeNoarg (const internal::sourceItem &)

virtual void	fSetSource (const internal::sourceItem &aSource)
	remember the source that provided the value, e.g. commandline or a config file More...

void	fSetPreserveWorthyStuff (std::vector< std::string > *aStuff)

void	fHide ()
	hide option, will be respected by help More...

bool	fIsHidden () const

void	fDisable ()
	disable option by removing it from the maps More...

Static Protected Member Functions inherited from options::base
static std::map< std::string, base * > &	fGetOptionMap ()

static std::map< char, base * > &	fGetShortOptionMap ()

Protected Attributes inherited from options::internal::baseForMap< T >
std::map< const T *, const internal::sourceItem >	lSources

Protected Attributes inherited from options::internal::typed_base< T >
std::multiset< rangeValueType >	lRange

Protected Attributes inherited from options::base
char	lShortName

const std::string	lLongName

const std::string	lExplanation

internal::sourceItem	lSource

short	lNargs

bool	lHidden

std::vector< std::string > *	lPreserveWorthyStuff

std::vector< const base * >	lRequiredOptions

std::vector< const base * >	lForbiddenOptions

Detailed Description

template<typename T, typename Container = std::map<std::string, T>>
class options::map< T, Container >

template for map-based options.

The map key is always a std::string but the mapped value is arbitrary. the container is by defalt a std::map. It is assumed that the container always contains std::pairs of a std::string as first and the value type T as second, e.g. a std::list<std::pair<std::string,int>> which, in contrast to the map would preserve the order in which the items were specified.

Definition at line 671 of file Options.h.

Constructor & Destructor Documentation

◆ map() [1/2]

template<typename T , typename Container = std::map<std::string, T>>

options::map< T, Container >::map	(	char	aShortName,
		const std::string &	aLongName,
		const std::string &	aExplanation,
		std::initializer_list< typename Container::value_type >	aDefault = `{}`
	)

inline

Definition at line 673 of file Options.h.

                                                                          {}) :
             internal::baseForMap<T>(aShortName, aLongName, aExplanation, 1) {
             for (const auto& defaultValue : aDefault) {
                 this->insert(this->end(), defaultValue);
             }
         }

◆ map() [2/2]

template<typename T , typename Container = std::map<std::string, T>>

options::map< T, Container >::map ( const map< T, Container > & )

delete

Member Function Documentation

◆ fCheckRange()

template<typename T , typename Container = std::map<std::string, T>>

void options::map< T, Container >::fCheckRange ( ) const

inlineoverridevirtual

Implements options::base.

Definition at line 751 of file Options.h.

                                           {
             for (const auto& pair : *this) {
                 this->fCheckValueForRange(pair.second);
             }
         };

◆ fGetValue()

template<typename T , typename Container = std::map<std::string, T>>

std::add_rvalue_reference<std::add_const<Container> >::type options::map< T, Container >::fGetValue ( ) const

inline

Definition at line 757 of file Options.h.

                                                                                          {
             return *static_cast<typename std::add_pointer<std::add_const<Container>>::type>(this);
         }

◆ fSetMe()

template<typename T , typename Container = std::map<std::string, T>>

void options::map< T, Container >::fSetMe	(	std::istream &	aStream,
		const internal::sourceItem &	aSource
	)

inlineoverridevirtual

function to set the value from a string, remembering the source

Implements options::base.

Definition at line 726 of file Options.h.

                                                                                      {
             std::string name;
             std::getline(aStream, name, parser::fGetInstance()->fGetSecondaryAssignment());
             if (aStream.eof()) { // not found, complain!
                 throw internal::optionError(this, internal::conCat(" a '", parser::fGetInstance()->fGetSecondaryAssignment(), "' separator is required, none given"));
             }
             T value;
             using escapedIO::operator>>;
             aStream >> std::setbase(0) >> value;
             if (aStream.fail()) {
                 std::string arg;
                 aStream.clear();
                 aStream >> arg;
                 throw internal::conversionError(this, arg, typeid(value));
             }
             typename std::remove_const<typename Container::value_type::first_type>::type key;
             std::istringstream conversionStream(name);
             conversionStream >> key;
             if (conversionStream.fail()) {
                 throw internal::conversionError(this, name, typeid(key));
             }
             auto result = (*this).insertOrUpdate(std::make_pair(key, value));
             this->fAddSource(&(result->second), aSource);
         };

◆ fWriteCfgLines()

template<typename T , typename Container = std::map<std::string, T>>

void options::map< T, Container >::fWriteCfgLines	(	std::ostream &	aStream,
		const char *	aPrefix
	)		const

inlineoverridevirtual

Reimplemented from options::base.

Definition at line 681 of file Options.h.

                                                                                      {
             if (this->empty()) {
                 aStream << aPrefix << this->lLongName << "=key" << parser::fGetInstance()->fGetSecondaryAssignment() << "value\n";
             }
             for (const auto& it : *this) {
                 auto source = this->fGetSource(&(it.second));
                 aStream << (source.fIsUnset() ? aPrefix : "") << this->lLongName << "=" << it.first <<  parser::fGetInstance()->fGetSecondaryAssignment();
                 {
                     using escapedIO::operator<<;
                     aStream << it.second << "\n";
                 }
                 if (!source.fIsUnset()) {
                     aStream << "# set from " << source << "\n";
                 }
             }
         }

◆ fWriteValue()

template<typename T , typename Container = std::map<std::string, T>>

void options::map< T, Container >::fWriteValue ( std::ostream & aStream ) const

inlineoverridevirtual

write textual representation of value to a std::ostream

Implements options::base.

Definition at line 698 of file Options.h.

                                                              {
             using escapedIO::operator<<;
             if (this->empty()) {
                 aStream << "\"\"";
             } else {
                 for (const auto& it : *this) {
                     aStream << it.first << parser::fGetInstance()->fGetSecondaryAssignment() << it.second << " ";
                 }
             }
         }

◆ insertOrUpdate() [1/2]

template<typename T , typename Container = std::map<std::string, T>>

template<typename C = Container>

std::enable_if<std::is_same<std::map<typename std::remove_const<typename Container::value_type::first_type>::type, typename Container::value_type::second_type>, C>::value, typename C::iterator>::type options::map< T, Container >::insertOrUpdate ( typename C::value_type aPair )

inline

Definition at line 713 of file Options.h.

                                                    {
             (*this)[aPair.first] = aPair.second;
             return this->find(aPair.first);
         }

◆ insertOrUpdate() [2/2]

template<typename T , typename Container = std::map<std::string, T>>

template<typename C = Container>

std::enable_if< !std::is_same<std::map<typename std::remove_const<typename Container::value_type::first_type>::type, typename Container::value_type::second_type>, C>::value, typename Container::iterator >::type options::map< T, Container >::insertOrUpdate ( typename C::value_type aPair )

inline

Definition at line 722 of file Options.h.

                                                    {
             return this->insert(this->end(), aPair);
         }

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

OptionParser/src/include/Options.h (v0.19-24-g0617ca1 with changes)

Public Member Functions

Additional Inherited Members

Detailed Description

template<typename T, typename Container = std::map<std::string, T>> class options::map< T, Container >

Constructor & Destructor Documentation

◆ map() [1/2]

◆ map() [2/2]

Member Function Documentation

◆ fCheckRange()

◆ fGetValue()

◆ fSetMe()

◆ fWriteCfgLines()

◆ fWriteValue()

◆ insertOrUpdate() [1/2]

◆ insertOrUpdate() [2/2]

template<typename T, typename Container = std::map<std::string, T>>
class options::map< T, Container >