This is a helper class which defines one command-line argument which is bound with some specific variable. More...

#include <arg.h>

Inheritance diagram for chomp::homology::argunit< type >:

Public Member Functions
	argunit (const char *_name, type &_value)
	The constructor of a command line argument bound with one variable. More...

	argunit (const char *_name, type &_value, type defaultvalue)
	The constructor of a command line argument bound with one variable which has a default value if none found in the command line. More...

	argunit (const char _name, type _value, int &_count, int _size)
	The constructor of a command line argument bound with an array of the given size. More...

	argunit (const char _name, type _value, int &_count, int _size, type defaultvalue)
	The constructor of a command line argument bound with an array of the given size; a default value is provided. More...

int	setvalue (char str, char next)
	Sets the argument value from the text string. More...

void	restore ()
	Restores the previous argument value (except for tables). More...

void	show (std::ostream &out) const
	Displays the value and some information. More...

Public Member Functions inherited from chomp::homology::argelement
	argelement (const char *_name)
	The constructor. More...

virtual	~argelement ()
	The destructor. More...

const char *	getname () const
	Returns the name of the command-line argument. More...

char *	getvalue (char *str)
	Returns the argument's value string from the argument string or returns 0 if it is not this argument. More...

virtual int	setvalue (char str, char next)=0
	Sets the value of this argument according to the string. More...

virtual void	restore ()=0
	Restores the previous argument value (except for tables). More...

virtual void	show (std::ostream &out) const =0
	Outputs the argument element to the output stream. More...

void	resetflags ()
	Resets the flags. More...

void	set (int flag)
	Sets the given flag. More...

void	unset (int flag)
	Unsets (clears) the given flag. More...

bool	get (int flag) const
	Returns the value of the given flag. More...

Private Attributes
type &	value
	A reference to the variable which is bound to this command line argument. More...

type	defaultvalue
	The default value of the variable if any. More...

type	previousvalue
	The original value of the variable (before reading the command line). More...

type *	table
	A pointer to the array bound with the variable. More...

int *	count
	A pointer to the number of elements currently present in the array. More...

int	previouscount
	The initial value of the number of elements in the array. More...

int	size
	The size of the array if any. More...

Detailed Description

template<class type>
class chomp::homology::argunit< type >

This is a helper class which defines one command-line argument which is bound with some specific variable.

It is an extension of the "argelement" class defined in terms of a template whose parameter is the type of the variable which is to be set based on the value provided in the command line.

Definition at line 252 of file arg.h.

Constructor & Destructor Documentation

◆ argunit() [1/4]

template<class type >

chomp::homology::argunit< type >::argunit	(	const char *	_name,
		type &	_value
	)

inline

The constructor of a command line argument bound with one variable.

Definition at line 311 of file arg.h.

                                                             :
        argelement (_name), value (_value), previousvalue (_value),
        table (NULL)
{
        return;
} /* argunit<type>::argunit */

◆ argunit() [2/4]

template<class type >

chomp::homology::argunit< type >::argunit	(	const char *	_name,
		type &	_value,
		type	defaultvalue
	)

inline

The constructor of a command line argument bound with one variable which has a default value if none found in the command line.

Definition at line 319 of file arg.h.

                           :
        argelement (_name), value (_value), defaultvalue (_defaultvalue),
        previousvalue (_value), table (NULL)
{
        set (argflags::hasdefault);
        return;
} /* argunit<type>::argunit */

References chomp::homology::argflags::hasdefault, and chomp::homology::argelement::set().

◆ argunit() [3/4]

template<class type >

chomp::homology::argunit< type >::argunit	(	const char *	_name,
		type *	_value,
		int &	_count,
		int	_size
	)

inline

The constructor of a command line argument bound with an array of the given size.

Definition at line 329 of file arg.h.

                               :
        argelement (_name), value (*_value), previousvalue (*_value),
        table (_value), count (&_count), previouscount (_count),
        size (_size)
{
        return;
} /* argunit<type>::argunit */

◆ argunit() [4/4]

template<class type >

chomp::homology::argunit< type >::argunit	(	const char *	_name,
		type *	_value,
		int &	_count,
		int	_size,
		type	defaultvalue
	)

inline

The constructor of a command line argument bound with an array of the given size; a default value is provided.

Definition at line 339 of file arg.h.

                                                   :
        argelement (_name), value (*_value), defaultvalue (_defaultvalue),
        previousvalue (*_value), table (_value),
        count (&_count), previouscount (_count), size (_size)
        
{
        set (argflags::hasdefault);
        return;
} /* argunit<type>::argunit */

References chomp::homology::argflags::hasdefault, and chomp::homology::argelement::set().

Member Function Documentation

◆ restore()

template<class type >

void chomp::homology::argunit< type >::restore

virtual

Restores the previous argument value (except for tables).

Implements chomp::homology::argelement.

Definition at line 476 of file arg.h.

{
        if (!table)
                value = previousvalue;
        else
                *count = previouscount;
        resetflags ();
        return;
} /* argunit<type>::restore */

◆ setvalue()

template<class type >

int chomp::homology::argunit< type >::setvalue	(	char *	str,
		char *	next
	)

inlinevirtual

Sets the argument value from the text string.

Implements chomp::homology::argelement.

Definition at line 412 of file arg.h.

{
        // determine the string from which the value should be read
        int usenext = 0;
        char *s;
        if (str && *str)
                s = str;
        else
        {
                if (next && *next && ((*next != '-') ||
                        std::isdigit (next [1])))
                {
                        s = next;
                        usenext = 1;
                }
                else
                        s = NULL;
        }
 
        // read the element from the string if available
        int result = -1;
        type element;
        if (s)
                result = readfromstring (s, element);
 
        // if could not read the string, try the default value
        if (result < 0)
        {
                if (get (argflags::hasdefault))
                {
                        element = defaultvalue;
                        usenext = 0;
                }
                else
                {
                        if (s)
                                set (argflags::readerror);
                        else
                                set (argflags::missingvalue);
                        return 0;
                }
        }
 
        // put the element to its place
        if (table)
                // if there is still room in the table, put the element there
                if (*count < size)
                        table [(*count) ++] = element;
                // if the table is full, indicate it
                else
                {
                        set (argflags::toomany);
                        set (argflags::filled);
                }
        else
        {
                value = element;
                set (argflags::filled);
        }
 
        return usenext;
} /* argunit<type>::setvalue */

References chomp::homology::argflags::filled, chomp::homology::argflags::hasdefault, chomp::homology::argflags::missingvalue, chomp::homology::argflags::readerror, chomp::homology::readfromstring(), and chomp::homology::argflags::toomany.

◆ show()

template<class type >

void chomp::homology::argunit< type >::show ( std::ostream & out ) const

virtual

Displays the value and some information.

Implements chomp::homology::argelement.

Definition at line 487 of file arg.h.

{
        if (get (argflags::obligatory))
                out << "Oblig. ";
        if (getname () && *getname ())
        {
                if (get (argflags::ignorevalue))
                        out << "Switch";
                else
                        out << "Param.";
                out << " '-" << getname () << "'";
        }
        else
                out << "Word";
        if (!table && get (argflags::filled))
                out << " set to '" << value << "'";
        else if (table && *count)
        {
                for (int i = 0; i < *count; ++ i)
                        out << (i ? ", " : " set to '") << table [i];
                out << "'";
                if (get (argflags::toomany))
                        out << " [too many!]";
        }
        else
                out << " not found";
        if (get (argflags::hasdefault))
                out << " (default: '" << defaultvalue << "')";
        else
                out << " (no default value)";
        out << "." << std::endl;
        return;
} /* argunit<type>::show */

A reference to the variable which is bound to this command line argument.

Definition at line 286 of file arg.h.

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

chomp/system/arg.h

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ argunit() [1/4]

◆ argunit() [2/4]

◆ argunit() [3/4]

◆ argunit() [4/4]

Member Function Documentation

◆ restore()

◆ setvalue()

◆ show()

Member Data Documentation

◆ count

◆ defaultvalue

◆ previouscount

◆ previousvalue

◆ size

◆ table

◆ value