Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

osgGA::CmdLineArgs Namespace Reference

A collection of utilities for processing command line arguments. More...


Detailed Description

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

#include <osgGA/CmdLineArgs>

int main(int argc, char* argv[])
{
        using namespace osg;
        using namespace osgGA::CmdLineArgs;

        // Create some handlers
        ref_ptr<BoolHandler> helpSwitch(new BoolHandler("[-h]","\t\tPrint this help and exit","-h"));
        ref_ptr<BoolHandler> verboseSwitch(new BoolHandler("[-v]","\t\tActivate verbose output","-v"));
        ref_ptr<SwitchStringHandler> configFile(
                                                                        new SwitchStringHandler("[-config <configfile>",
                                                                        "\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<<e.what()<<endl;
                clp.printUsage(cerr);
                exit(1);
        }
        catch(...){
                cerr<<"Unknown exception caught while processing command line arguments."<<endl;
                clp.printUsage(cerr);
                exit(1);
        }

        if(helpSwitch->wasSpecified()){
                clp.printHelp(cerr);
                exit(0);
        }

        if(verboseSwitch->wasSpecified()){
                // Activate verbosity...
        }

        if(configFile->wasSpecified()){
                loadConfigFile(configFile->getString());
        }

}

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.


Generated at Wed Sep 18 13:55:50 2002 for the Open Scene Graph by doxygen 1.2.16.