OptionsParser Class Reference

#include <OptionsParser.h>

---

Detailed Description

Parses command line arguments.

The only public method parses the given list of arguments. It returns false when something failed. This may happen if the syntax of the arguments is invalid, a value is tried to be set several times or an unknown option is tried to be set.

The class assumes all options are unset or using default values only.

Definition at line 53 of file OptionsParser.h.

Static Public Member Functions
static bool	parse (int argc, char **argv) throw (InvalidArgument)
	Parses the given command line arguments.
Static Private Member Functions
static int	check (char *arg1, char *arg2, bool &ok) throw (InvalidArgument)
	parses the previous arguments
static bool	checkParameter (char *arg1) throw ()
	Returns the whether the given token is an option.
static std::string	convert (char abbr) throw ()
	converts char to string
static std::string	convert (char *arg) throw ()
	Converts char* to string.
static bool	isAbbreviation (char *arg1) throw ()
	returns the whether the given token is an abbreviation
static bool	processNonBooleanSingleSwitch (OptionsCont &oc, char *arg) throw (InvalidArgument)
	Extracts the parameter directly attached to an option.

---

Member Function Documentation

int OptionsParser::check	(	char *	arg1,
		char *	arg2,
		bool &	ok
	)			throw (InvalidArgument) [static, private]

parses the previous arguments

Parameters:

[in]	arg1	The first token to parse
[in]	arg2	The second token to parse, 0 if there is none
[in,out]	ok	Whether the parsing was successfull

Returns:

Number of read tokens (1 or 2)

Exceptions:

InvalidArgument

If a performed setting of an option failed (see Option::set)

Definition at line 70 of file OptionsParser.cpp.

References convert(), OptionsCont::getOptions(), OptionsCont::isBool(), and OptionsCont::set().

                                                                            {
    // the first argument should be an option
    // (only the second may be a free string)
    if (!checkParameter(arg1)) {
        ok = false;
        return 1;
    }

    OptionsCont &oc = OptionsCont::getOptions();
    // process not abbreviated switches
    if (!isAbbreviation(arg1)) {
        std::string tmp(arg1+2);
        size_t idx1 = tmp.find('=');
        // check whether a parameter was submitted
        if (idx1!=std::string::npos) {
            ok &= oc.set(tmp.substr(0, idx1), tmp.substr(idx1+1));
        } else {
            if (arg2==0||oc.isBool(convert(arg1+2))) {
                ok &= oc.set(convert(arg1+2), true);
            } else {
                ok &= oc.set(convert(arg1+2), convert(arg2));
                return 2;
            }
        }
        return 1;
    }
    // go through the abbreviated switches
    for (int i=1; arg1[i]!=0; i++) {
        // set boolean switches
        if (oc.isBool(convert(arg1[i]))) {
            ok &= oc.set(convert(arg1[i]), true);
            // set non-boolean switches
        } else {
            // check whether the parameter comes directly after the switch
            //  and process if so
            if (arg2==0||arg1[i+1]!=0) {
                ok &= processNonBooleanSingleSwitch(oc, arg1+i);
                return 1;
                // process parameter following after a space
            } else {
                ok &= oc.set(convert(arg1[i]), convert(arg2));
                // option name and attribute were in two arguments
                return 2;
            }
        }
    }
    // all switches within the current argument were boolean switches
    return 1;
}

bool OptionsParser::checkParameter

(

char *

arg1

)

throw () [static, private]

Returns the whether the given token is an option.

The given token is assumed to be an option if it starts with a '-'.

Parameters:

[in]

arg1

The token to check

Returns:

Whether the token is an option

Definition at line 142 of file OptionsParser.cpp.

References MsgHandler::getErrorInstance(), and MsgHandler::inform().

                                                {
    if (arg1[0]!='-') {
        MsgHandler::getErrorInstance()->inform("The parameter '" + std::string(arg1) + "' is not allowed in this context.\n Switch or parameter name expected.");
        return false;
    }
    return true;
}

std::string OptionsParser::convert

(

char

abbr

)

throw () [static, private]

converts char to string

Parameters:

[in]

abbr

The char to convert

Returns:

The char converted into a std::string

Definition at line 165 of file OptionsParser.cpp.

                                        {
    char buf[2];
    buf[0] = abbr;
    buf[1] = 0;
    std::string s(buf);
    return buf;
}

std::string OptionsParser::convert

(

char *

arg

)

throw () [static, private]

Converts char* to string.

Parameters:

[in]

arg

The c-string to convert

Returns:

The string converted into a std::string

Definition at line 158 of file OptionsParser.cpp.

                                        {
    std::string s(arg);
    return s;
}

bool OptionsParser::isAbbreviation

(

char *

arg1

)

throw () [static, private]

returns the whether the given token is an abbreviation

The given token is assumed to be an option if it starts with two '-'.

Parameters:

[in]

arg1

The token to check

Returns:

Whether the token is an abbreviation

Definition at line 152 of file OptionsParser.cpp.

                                                {
    return arg1[1]!='-';
}

bool OptionsParser::parse	(	int	argc,
		char **	argv
	)			throw (InvalidArgument) [static]

Parses the given command line arguments.

Parameters:

[in]	oc	The options container to fill
[in]	argc	The number of given command line arguments
[in]	argv	The command line arguments

Returns:

Whether the parsing was successfull

Exceptions:

InvalidArgument

If a performed setting of an option failed (see Option::set)

Definition at line 47 of file OptionsParser.cpp.

References MsgHandler::getErrorInstance(), and MsgHandler::inform().

Referenced by OptionsIO::getOptions().

                                                                 {
    bool ok = true;
    for (int i=1; i<argc;) {
        try {
            int add;
            // try to set the current option
            if (i<argc-1) {
                add = check(argv[i], argv[i+1], ok);
            } else {
                add = check(argv[i], 0, ok);
            }
            i += add;
        } catch (InvalidArgument &e) {
            MsgHandler::getErrorInstance()->inform("On processing option '" + std::string(argv[i]) + "':\n " + e.what());
            i++;
            ok = false;
        }
    }
    return ok;
}

bool OptionsParser::processNonBooleanSingleSwitch	(	OptionsCont &	oc,
		char *	arg
	)			throw (InvalidArgument) [static, private]

Extracts the parameter directly attached to an option.

Parses single tokens which contain an option and the parameter (like -c=myconfig.cfg)

Parameters:

[in]	oc	The container to store the result into
[in]	arg	The token to parse

Exceptions:

InvalidArgument

If a performed setting of an option failed (see Option::set)

Definition at line 122 of file OptionsParser.cpp.

References convert(), MsgHandler::getErrorInstance(), and MsgHandler::inform().

                                                                                              {
    if (arg[1]=='=') {
        if (strlen(arg)<3) {
            MsgHandler::getErrorInstance()->inform("Missing value for parameter '" + std::string(arg).substr(0, 1) + "'.");
            return false;
        } else {
            return oc.set(convert(arg[0]), std::string(arg+2));
        }
    } else {
        if (strlen(arg)<2) {
            MsgHandler::getErrorInstance()->inform("Missing value for parameter '" + std::string(arg) + "'.");
            return false;
        } else {
            return oc.set(convert(arg[0]), std::string(arg+1));
        }
    }
}

---

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

• OptionsParser.h
• OptionsParser.cpp