A collection of utilities for processing command line arguments.
An osgGA::CmdLineArgs::Processor class is provided, which implements a chain
of responsibilty for handline command line arguments. Each item in the chain
is a subclass of the abstract osgGA::CmdLineArgs::ArgHandler. A number
of ArgHandlers are provided, though the user if free to implement their
own subclasses for specific needs (e.g. to validate an argument which
takes an integer which must be in a specific range).
Let's look at an example...
Example
\code
#include
int main(int argc, char* argv[])
{
using namespace osg;
using namespace osgGA::CmdLineArgs;
// Create some handlers
ref_ptr helpSwitch(new BoolHandler("[-h]","\t\tPrint this help and exit","-h"));
ref_ptr verboseSwitch(new BoolHandler("[-v]","\t\tActivate verbose output","-v"));
ref_ptr configFile(
new SwitchStringHandler("[-config ",
"\t\tSpecify a config file to load"), "-config");
Processor clp;
clp.push_back(helpSwitch.get());
clp.push_back(verboseSwitch.get());
clp.push_back(configFile.get());
try{
clp.process(argc,argv);
}
catch(ArgHandlerX& e){
cerr<if(helpSwitch->wasSpecified()){
clp.printHelp(cerr);
exit(0);
}
if(verboseSwitch->wasSpecified()){
// Activate verbosity...
}
if(configFile->wasSpecified()){
loadConfigFile(configFile->getString());
}
}
\endcode
The processor takes each argument on the command line in turn, and passes it
to the ArgHandler chain. Each ArgHandler is given the opportunity to handle
an argument and - if it requires - any subsequent arguments until the
end of the argument list (it can do this by incrementing the ArgIterator
passed to it. If an ArgHandler handles an argument (e.g. it's looking for
and recognises the argument '-h'), it returns true and further processing of
the argument stops. If an argument is not handled it is passed to the next
handler in the chain, and so on, until it is either handled, or it drops off
the end of the chain.
A number of pre-written ArgHandlers are supplied. User's may use these
directly, may write their own, or may extend a pre-written ArgHandler to
customise it for their specific needs.