diff options
Diffstat (limited to 'tclap-1.2.1/docs/manual.html')
| -rw-r--r-- | tclap-1.2.1/docs/manual.html | 891 |
1 files changed, 891 insertions, 0 deletions
diff --git a/tclap-1.2.1/docs/manual.html b/tclap-1.2.1/docs/manual.html new file mode 100644 index 0000000..5a12863 --- /dev/null +++ b/tclap-1.2.1/docs/manual.html @@ -0,0 +1,891 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Templatized C++ Command Line Parser Manual</title><link rel="stylesheet" href="style.css" type="text/css" /><meta name="generator" content="DocBook XSL Stylesheets V1.71.1" /></head><body><div class="book" lang="en" xml:lang="en"><div class="titlepage"><div><div><h1 class="title"><a id="id400620"></a>Templatized C++ Command Line Parser Manual</h1></div><div><div class="author"><h3 class="author"><span class="firstname">Michael</span> <span class="othername">E</span> <span class="surname">Smoot</span></h3></div></div><div><p class="copyright">Copyright © 2003,2004,2005,2006,2009,2011 Michael E. Smoot</p></div></div><hr /></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="chapter"><a href="#BASIC_USAGE">1. Basic Usage</a></span></dt><dd><dl><dt><span class="sect1"><a href="#OVERVIEW">Overview</a></span></dt><dt><span class="sect1"><a href="#EXAMPLE">Example</a></span></dt><dd><dl><dt><span class="sect2"><a href="#LIBRARY_PROPERTIES">Library Properties</a></span></dt><dt><span class="sect2"><a href="#ARG_PROPERTIES">Common Argument Properties</a></span></dt></dl></dd><dt><span class="sect1"><a href="#COMPILING">Compiling</a></span></dt></dl></dd><dt><span class="chapter"><a href="#FUNDAMENTAL_CLASSES">2. Fundamental Classes</a></span></dt><dd><dl><dt><span class="sect1"><a href="#COMMAND_LINE"><code class="classname">CmdLine</code></a></span></dt><dt><span class="sect1"><a href="#SWITCH_ARG"><code class="classname">SwitchArg</code></a></span></dt><dt><span class="sect1"><a href="#VALUE_ARG"><code class="classname">ValueArg</code></a></span></dt><dt><span class="sect1"><a href="#MULTI_ARG"><code class="classname">MultiArg</code></a></span></dt><dt><span class="sect1"><a href="#MULTI_SWITCH_ARG"><code class="classname">MultiSwitchArg</code></a></span></dt><dt><span class="sect1"><a href="#UNLABELED_VALUE_ARG"><code class="classname">UnlabeledValueArg</code></a></span></dt><dt><span class="sect1"><a href="#UNLABELED_MULTI_ARG"><code class="classname">UnlabeledMultiArg</code></a></span></dt></dl></dd><dt><span class="chapter"><a href="#COMPLICATIONS">3. Complications</a></span></dt><dd><dl><dt><span class="sect1"><a href="#COMBINE_SWITCHES">I want to combine multiple switches into one argument...</a></span></dt><dt><span class="sect1"><a href="#XOR">I want one argument or the other, but not both...</a></span></dt><dt><span class="sect1"><a href="#NO_FLAG">I have more arguments than single flags make sense for...</a></span></dt><dt><span class="sect1"><a href="#CONSTRAINT">I want to constrain the values allowed for a particular +argument...</a></span></dt><dt><span class="sect1"><a href="#ARG_ADD_CMDLINE">I want the Args to add themselves to the CmdLine...</a></span></dt><dt><span class="sect1"><a href="#CHANGE_OUTPUT">I want different output than what is provided...</a></span></dt><dt><span class="sect1"><a href="#NO_HELP_VERSION">I don't want the --help and --version switches to be created automatically...</a></span></dt><dt><span class="sect1"><a href="#IGNORE_ARGS">I want to ignore certain arguments...</a></span></dt><dt><span class="sect1"><a href="#READING_HEX_INTEGERS">I want to read hex integers as arguments...</a></span></dt><dt><span class="sect1"><a href="#USING_ARGTRAITS">I want to use different types...</a></span></dt><dt><span class="sect1"><a href="#CHANGING_STARTSTRINGS">I want to use Windows-style flags like "/x" and "/y"...</a></span></dt></dl></dd><dt><span class="chapter"><a href="#NOTES">4. Notes</a></span></dt><dd><dl><dt><span class="sect1"><a href="#DESCRIPTION_EXCEPTIONS">Type Descriptions</a></span></dt><dt><span class="sect1"><a href="#VISITORS">Visitors</a></span></dt><dt><span class="sect1"><a href="#MORE_INFO">More Information</a></span></dt></dl></dd></dl></div><div class="chapter" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title"><a id="BASIC_USAGE"></a>Chapter 1. Basic Usage</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="sect1"><a href="#OVERVIEW">Overview</a></span></dt><dt><span class="sect1"><a href="#EXAMPLE">Example</a></span></dt><dd><dl><dt><span class="sect2"><a href="#LIBRARY_PROPERTIES">Library Properties</a></span></dt><dt><span class="sect2"><a href="#ARG_PROPERTIES">Common Argument Properties</a></span></dt></dl></dd><dt><span class="sect1"><a href="#COMPILING">Compiling</a></span></dt></dl></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="OVERVIEW"></a>Overview</h2></div></div></div><p> +<span class="emphasis"><em>TCLAP</em></span> has a few key classes to be aware of. +The first is the +<code class="classname">CmdLine</code> (command line) class. This class parses +the command line passed to it according to the arguments that it +contains. Arguments are separate objects that are added to the +<code class="classname">CmdLine</code> object one at a time. The six +argument classes are: <code class="classname">ValueArg</code>, +<code class="classname">UnlabeledValueArg</code>, +<code class="classname">SwitchArg</code>, <code class="classname">MultiSwitchArg</code>, +<code class="classname">MultiArg</code> and +<code class="classname">UnlabeledMultiArg</code>. +These classes are templatized, which means they can be defined to parse +a value of any <a href="#USING_ARGTRAITS" title="I want to use different types..."> type</a>. Once you add the +arguments to the <code class="classname">CmdLine</code> object, it parses the +command line +and assigns the data it finds to the specific argument objects it +contains. Your program accesses the values parsed by +calls to the <code class="methodname">getValue()</code> methods of the +argument objects. +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="EXAMPLE"></a>Example</h2></div></div></div><p> +Here is a simple <a href="test1.cpp" target="_top"> example</a> ... + +</p><pre class="programlisting"> +#include <string> +#include <iostream> +#include <algorithm> +#include <tclap/CmdLine.h> + +int main(int argc, char** argv) +{ + + // Wrap everything in a try block. Do this every time, + // because exceptions will be thrown for problems. + try { + + // Define the command line object, and insert a message + // that describes the program. The "Command description message" + // is printed last in the help text. The second argument is the + // delimiter (usually space) and the last one is the version number. + // The CmdLine object parses the argv array based on the Arg objects + // that it contains. + TCLAP::CmdLine cmd("Command description message", ' ', "0.9"); + + // Define a value argument and add it to the command line. + // A value arg defines a flag and a type of value that it expects, + // such as "-n Bishop". + TCLAP::ValueArg<std::string> nameArg("n","name","Name to print",true,"homer","string"); + + // Add the argument nameArg to the CmdLine object. The CmdLine object + // uses this Arg to parse the command line. + cmd.add( nameArg ); + + // Define a switch and add it to the command line. + // A switch arg is a boolean argument and only defines a flag that + // indicates true or false. In this example the SwitchArg adds itself + // to the CmdLine object as part of the constructor. This eliminates + // the need to call the cmd.add() method. All args have support in + // their constructors to add themselves directly to the CmdLine object. + // It doesn't matter which idiom you choose, they accomplish the same thing. + TCLAP::SwitchArg reverseSwitch("r","reverse","Print name backwards", cmd, false); + + // Parse the argv array. + cmd.parse( argc, argv ); + + // Get the value parsed by each arg. + std::string name = nameArg.getValue(); + bool reverseName = reverseSwitch.getValue(); + + // Do what you intend. + if ( reverseName ) + { + std::reverse(name.begin(),name.end()); + std::cout << "My name (spelled backwards) is: " << name << std::endl; + } + else + std::cout << "My name is: " << name << std::endl; + + + } catch (TCLAP::ArgException &e) // catch any exceptions + { std::cerr << "error: " << e.error() << " for arg " << e.argId() << std::endl; } +} +</pre><p> + +The output should look like: + +</p><pre class="programlisting"> + +% test1 -n mike +My name is: mike + +% test1 -n mike -r +My name (spelled backwards) is: ekim + +% test1 -r -n mike +My name (spelled backwards) is: ekim + +% test1 -r +PARSE ERROR: + One or more required arguments missing! + +Brief USAGE: + test1 [-r] -n <string> [--] [-v] [-h] + +For complete USAGE and HELP type: + test1 --help + + +% test1 --help + +USAGE: + + test1 [-r] -n <string> [--] [-v] [-h] + + +Where: + + -r, --reverse + Print name backwards + + -n <string> --name <string> + (required) (value required) Name to print + + --, --ignore_rest + Ignores the rest of the labeled arguments following this flag. + + -v, --version + Displays version information and exits. + + -h, --help + Displays usage information and exits. + + + Command description message + +</pre><p> +</p><div class="sect2" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="LIBRARY_PROPERTIES"></a>Library Properties</h3></div></div></div><p> +This example shows a number of different properties of the +library... +</p><div class="itemizedlist"><ul type="disc"><li>Arguments can appear in any order (...mostly, +<a href="#COMPLICATIONS" title="Chapter 3. Complications"> more</a> on this later).</li><li>The <em class="parameter"><code>help</code></em>, <em class="parameter"><code>version</code></em> +and <em class="parameter"><code>--</code></em><code class="classname">SwitchArg</code>s +are specified automatically. Using either the <em class="parameter"><code>-h</code></em> or +<em class="parameter"><code>--help</code></em> flag will cause the USAGE message to be displayed, +<em class="parameter"><code>-v</code></em> or <em class="parameter"><code>--version</code></em> will cause +any version information to +be displayed, and <em class="parameter"><code>--</code></em> or +<em class="parameter"><code>--ignore_rest</code></em> will cause the +remaining labeled arguments to be ignored. These switches are +included by default on every command line. You can <a href="#">disable this functionality</a> if desired (although we don't recommend it). +How we generate the behavior behind these flags is described +<a href="#VISITORS" title="Visitors"> later</a>. +</li><li>If there is an error parsing the command line (e.g. a required +argument isn't provided), the program exits and displays a brief +USAGE and an error message.</li><li>The program name is assumed to always be argv[0], so it isn't +specified directly.</li><li>A value delimiter character can be specified. This means that if you +prefer arguments of the style <em class="parameter"><code>-s=asdf</code></em> instead of +<em class="parameter"><code>-s asdf</code></em>, you can do so.</li><li><span class="emphasis"><em>Always wrap everything in a try block that catches +ArgExceptions!</em></span> Any problems found in constructing the +<code class="classname">CmdLine</code>, constructing the <code class="classname">Arg</code>s, +or parsing the command line will throw an +<code class="classname">ArgException</code>.</li></ul></div><p> +</p></div><div class="sect2" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="ARG_PROPERTIES"></a>Common Argument Properties</h3></div></div></div><p> +Arguments, whatever their type, have a few common properties. +These properties are set in the constructors of the arguments. +</p><div class="itemizedlist"><ul type="disc"><li>First is the flag or the character preceded by a dash(-) that +signals the beginning of the argument on the command line.</li><li>Arguments also have names, which can also be used +as an alternative flag on the command line, this time preceded by two dashes +(--) [like the familiar <code class="function">getopt_long()</code>].</li><li>Next is the description of the argument. This is a short +description of the argument displayed in the help/usage message +when needed.</li><li>The following parameters in the constructors vary depending on +the type of argument. Some possible values include: +<div class="itemizedlist"><ul type="circle"><li>A boolean value indicating whether the Arg is required or not. </li><li>A default value.</li><li>A <a href="#DESCRIPTION_EXCEPTIONS" title="Type Descriptions">description</a> of the type of value expected.</li><li>A <a href="#CONSTRAINT" title="I want to constrain the values allowed for a particular argument...">constraint</a> on the value expected.</li><li>The CmdLine instance that the Arg should be added to.</li><li>A <a href="#VISITORS" title="Visitors">Visitor</a>.</li></ul></div></li><li>See the <a href="html/index.html" target="_top">API Documentation</a> for more detail.</li></ul></div><p> +</p></div></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="COMPILING"></a>Compiling</h2></div></div></div><p> +<span class="emphasis"><em>TCLAP</em></span> is implemented entirely in header files +which means you only need to include CmdLine.h to use the library. +</p><pre class="programlisting"> + #include <tclap/CmdLine.h> +</pre><p> +You'll need to make sure that your compiler can see the header +files. If you do the usual "make install" then your compiler should +see the files by default. Alternatively, you can use the -I +complier argument to specify the exact location of the libraries. +</p><pre class="programlisting"> + c++ -o my_program -I /some/place/tclap-1.X/include my_program.cpp +</pre><p> +Where /some/place/tclap-1.X is the place you have unpacked the +distribution. +</p><p> +Finally, if you want to include <span class="emphasis"><em>TCLAP</em></span> as part of +your software +(which is perfectly OK, even encouraged) then simply copy the +contents of /some/place/tclap-1.X/include (the tclap directory and +all of the header files it contains) into your include +directory. The necessary m4 macros for proper configuration are included +in the config directory. +</p><p> +<span class="emphasis"><em>TCLAP</em></span> was developed on Linux and MacOSX systems. +It is also known +to work on Windows, Sun and Alpha platforms. We've made every +effort to keep the library compliant with the ANSI C++ standard so +if your compiler meets the standard, then this library should work +for you. Please let us know if this is not the case! +</p><div class="sect2" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="WINDOWS_NOTE"></a>Windows Note</h3></div></div></div><p> +As we understand things, Visual C++ does not have the file +<code class="filename">config.h</code> which is used to make platform +specific definitions. In this situation, we assume that you +have access to <code class="classname">sstream</code>. Our understanding is that +this should not be a problem for VC++ 7.x. However, if this +is not the case and you need to use <code class="classname">strstream</code>, +then simply tell your compiler to define the variable +<code class="constant">HAVE_STRSTREAM</code> and undefine +<code class="constant">HAVE_SSTREAM</code> That +<span class="emphasis"><em>should</em></span> work. We think. Alternatively, just edit +the files <code class="filename">ValueArg.h</code> and <code class="filename">MultiArg.h</code>. +</p></div><p> +</p><div class="sect2" lang="en" xml:lang="en"><div class="titlepage"><div><div><h3 class="title"><a id="RANDOM_NOTE"></a>Random Note</h3></div></div></div><p> +If your compiler doesn't support the <code class="methodname">using</code> syntax used +in <code class="classname">UnlabeledValueArg</code> and +<code class="classname">UnlabeledMultiArg</code> to support two stage name lookup, +then you have two options. Either comment out the statements if you don't +need two stage name lookup, or do a bunch of search and replace and use +the <code class="methodname">this</code> pointer syntax: e.g. +<code class="methodname">this->_ignoreable</code> instead +of just <code class="methodname">_ignorable</code> (do this for each variable +or method referenced by <code class="methodname">using</code>). +</p></div><p> +</p></div></div><div class="chapter" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title"><a id="FUNDAMENTAL_CLASSES"></a>Chapter 2. Fundamental Classes</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="sect1"><a href="#COMMAND_LINE"><code class="classname">CmdLine</code></a></span></dt><dt><span class="sect1"><a href="#SWITCH_ARG"><code class="classname">SwitchArg</code></a></span></dt><dt><span class="sect1"><a href="#VALUE_ARG"><code class="classname">ValueArg</code></a></span></dt><dt><span class="sect1"><a href="#MULTI_ARG"><code class="classname">MultiArg</code></a></span></dt><dt><span class="sect1"><a href="#MULTI_SWITCH_ARG"><code class="classname">MultiSwitchArg</code></a></span></dt><dt><span class="sect1"><a href="#UNLABELED_VALUE_ARG"><code class="classname">UnlabeledValueArg</code></a></span></dt><dt><span class="sect1"><a href="#UNLABELED_MULTI_ARG"><code class="classname">UnlabeledMultiArg</code></a></span></dt></dl></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="COMMAND_LINE"></a><code class="classname">CmdLine</code></h2></div></div></div><p> +The <code class="classname">CmdLine</code> class contains the arguments that define +the command line and manages the parsing of the command line. The +<code class="classname">CmdLine</code> doesn't parse the command line itself it only +manages the parsing. The actual parsing of individual arguments occurs within +the arguments themselves. The <code class="classname">CmdLine</code> keeps track of +of the required arguments, <a href="#XOR" title="I want one argument or the other, but not both...">relationships</a> +between arguments, and <a href="#CHANGE_OUTPUT" title="I want different output than what is provided...">output</a> generation. +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="SWITCH_ARG"></a><code class="classname">SwitchArg</code></h2></div></div></div><p><code class="classname">SwitchArg</code>s are what the name implies: +simple, on/off, boolean switches. Use <code class="classname">SwitchArg</code>s +anytime you want to turn +some sort of system property on or off. <code class="classname">SwitchArg</code>s +don't parse a value. They return <code class="constant">TRUE</code> or +<code class="constant">FALSE</code>, depending on whether the switch has been found +on the command line and what the default value was defined as.</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="VALUE_ARG"></a><code class="classname">ValueArg</code></h2></div></div></div><p><code class="classname">ValueArg</code>s are arguments that read a +value of some type +from the command line. Any time you need a file name, a number, +etc. use a <code class="classname">ValueArg</code> or one of its variants. +All <code class="classname">ValueArg</code>s are +<a href="#USING_ARGTRAITS" title="I want to use different types..."> templatized</a> and will attempt to parse +the string its flag matches on the command line as the type it is +specified as. <code class="classname">ValueArg<int></code> +will attempt to parse an +int, <code class="classname">ValueArg<float></code> will attempt to +parse a float, etc. If <code class="methodname">operator>></code> +for the specified type doesn't +recognize the string on the command line as its defined type, then +an exception will be thrown. +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="MULTI_ARG"></a><code class="classname">MultiArg</code></h2></div></div></div><p> +A <code class="classname">MultiArg</code> is a <code class="classname">ValueArg</code> that +can be specified more than once on a command line and instead of returning +a single value, returns a <code class="classname">vector</code> of values. +</p><p> +Imagine a compiler that allows you to specify multiple directories +to search for libraries... +</p><pre class="programlisting"> + % fooCompiler -L /dir/num1 -L /dir/num2 file.foo +</pre><p> +Exceptions will occur if you try to do this +with a <code class="classname">ValueArg</code> or a <code class="classname">SwitchArg</code>. +In situations like this, you will want to use a +<code class="classname">MultiArg</code>. A +<code class="classname">MultiArg</code> is essentially a +<code class="classname">ValueArg</code> that appends any +value that it matches and parses onto a vector of values. When the +<code class="methodname">getValue()</code> method is called, a vector of +values, instead of a single value is returned. A +<code class="classname">MultiArg</code> is declared much like +a <code class="classname">ValueArg</code>: + + +</p><pre class="programlisting"> + MultiArg<int> itest("i", "intTest", "multi int test", false,"int" ); + cmd.add( itest ); +</pre><p> +Note that <code class="classname">MultiArg</code>s can be added to the +<code class="classname">CmdLine</code> in any order (unlike +<a href="#UNLABELED_MULTI_ARG" title="UnlabeledMultiArg"> UnlabeledMultiArg</a>). +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="MULTI_SWITCH_ARG"></a><code class="classname">MultiSwitchArg</code></h2></div></div></div><p> +A <code class="classname">MultiSwitchArg</code> is a <code class="classname">SwitchArg</code> +that can be specified more than once on a command line. +This can be useful +when command lines are constructed automatically from within other applications +or when a switch occurring +more than once indicates a value (-V means a little verbose -V -V -V means a lot +verbose), You can use a <code class="classname">MultiSwitchArg</code>. +The call +to <code class="methodname">getValue()</code> for a <code class="classname">MultiSwitchArg</code> returns the number (int) of times +the switch has been found on the command line in addition to the default value. +Here is an example using the default initial value of 0: +</p><pre class="programlisting"> + MultiSwitchArg quiet("q","quiet","Reduce the volume of output"); + cmd.add( quiet ); +</pre><p> +Alternatively, you can specify your own initial value: +</p><pre class="programlisting"> + MultiSwitchArg quiet("q","quiet","Reduce the volume of output",5); + cmd.add( quiet ); +</pre><p> +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="UNLABELED_VALUE_ARG"></a><code class="classname">UnlabeledValueArg</code></h2></div></div></div><p> +An <code class="classname">UnlabeledValueArg</code> is a <code class="classname">ValueArg</code> that is not identified by a flag on the command line. Instead +<code class="classname">UnlabeledValueArg</code>s are identified by their position in +the argv array. +</p><p> +To this point all of our arguments have had labels (flags) +identifying them on the command line, but there are some +situations where flags are burdensome and not worth the effort. One +example might be if you want to implement a magical command we'll +call <span><strong class="command">copy</strong></span>. All <span><strong class="command">copy</strong></span> does is +copy the file specified +in the first argument to the file specified in the second argument. +We can do this using <code class="classname">UnlabeledValueArg</code>s which are pretty +much just <code class="classname">ValueArg</code>s without the flag specified, +which tells +the <code class="classname">CmdLine</code> object to treat them accordingly. +The code would look like this: + +</p><pre class="programlisting"> + + UnlabeledValueArg<float> nolabel( "name", "unlabeled test", 3.14, + "nameString" ); + cmd.add( nolabel ); + +</pre><p> + +Everything else is handled identically to what is seen above. The +only difference to be aware of, and this is important: <span class="emphasis"><em>the order +that UnlabeledValueArgs are added to the <code class="classname">CmdLine</code> +is the order that they will be parsed!!!!</em></span> +This is <span class="emphasis"><em>not</em></span> the case for normal +<code class="classname">SwitchArg</code>s and <code class="classname">ValueArg</code>s. +What happens internally is the first argument that the +<code class="classname">CmdLine</code> doesn't recognize is assumed to be +the first <code class="classname">UnlabeledValueArg</code> and +parses it as such. Note that you are allowed to intersperse labeled +args (SwitchArgs and ValueArgs) in between +<code class="classname">UnlabeledValueArgs</code> (either on the command line +or in the declaration), but the <code class="classname">UnlabeledValueArgs</code> +will still be parsed in the order they are added. Just remember that order is +important for unlabeled arguments. +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="UNLABELED_MULTI_ARG"></a><code class="classname">UnlabeledMultiArg</code></h2></div></div></div><p> +An <code class="classname">UnlabeledMultiArg</code> is an <code class="classname">UnlabeledValueArg</code> that allows more than one value to be specified. Only one +<code class="classname">UnlabeledMultiArg</code> can be specified per command line. +The <code class="classname">UnlabeledMultiArg</code> simply reads the remaining +values from argv up until -- or the end of the array is reached. +</p><p> +Say you want a strange command +that searches each file specified for a given string (let's call it +<span><strong class="command">grep</strong></span>), but you don't want to have to type in all of the file +names or write a script to do it for you. Say, + +</p><pre class="programlisting"> + % grep pattern *.txt +</pre><p> + +First remember that the <span class="emphasis"><em>*</em></span> is handled by the shell and +expanded accordingly, so what the program <span><strong class="command">grep</strong></span> sees is +really something like: + +</p><pre class="programlisting"> + % grep pattern file1.txt file2.txt fileZ.txt +</pre><p> + +To handle situations where multiple, unlabeled arguments are needed, +we provide the <code class="classname">UnlabeledMultiArg</code>. +<code class="classname">UnlabeledMultiArg</code>s +are declared much like everything else, but with only a description +of the arguments. By default, if an <code class="classname">UnlabeledMultiArg</code> +is specified, then at least one is required to be present or an +exception will be thrown. The most important thing to remember is, +that like <code class="classname">UnlabeledValueArg</code>s: order matters! +In fact, <span class="emphasis"><em>an UnlabeledMultiArg must be the last argument added to the +CmdLine!</em></span>. Here is what a declaration looks like: + +</p><pre class="programlisting"> + + // + // UnlabeledMultiArg must be the LAST argument added! + // + UnlabeledMultiArg<string> multi("file names"); + cmd.add( multi ); + cmd.parse(argc, argv); + + vector<string> fileNames = multi.getValue(); + +</pre><p> + +You must only ever specify one (1) <code class="classname">UnlabeledMultiArg</code>. +One <code class="classname">UnlabeledMultiArg</code> will read every unlabeled +Arg that wasn't already processed by a +<code class="classname">UnlabeledValueArg</code> into a +<code class="classname">vector</code> of type T. Any +<code class="classname">UnlabeledValueArg</code> or other +<code class="classname">UnlabeledMultiArg</code> specified after the first +<code class="classname">UnlabeledMultiArg</code> will be ignored, and if +they are required, +exceptions will be thrown. When you call the +<code class="methodname">getValue()</code> +method of the <code class="classname">UnlabeledValueArg</code> argument, +a <code class="classname">vector</code> +will be returned. If you can imagine a situation where there will +be multiple args of multiple types (stings, ints, floats, etc.) +then just declare the <code class="classname">UnlabeledMultiArg</code> as type +<code class="classname">string</code> and parse the different values yourself or use +several <code class="classname">UnlabeledValueArg</code>s. +</p></div></div><div class="chapter" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title"><a id="COMPLICATIONS"></a>Chapter 3. Complications</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="sect1"><a href="#COMBINE_SWITCHES">I want to combine multiple switches into one argument...</a></span></dt><dt><span class="sect1"><a href="#XOR">I want one argument or the other, but not both...</a></span></dt><dt><span class="sect1"><a href="#NO_FLAG">I have more arguments than single flags make sense for...</a></span></dt><dt><span class="sect1"><a href="#CONSTRAINT">I want to constrain the values allowed for a particular +argument...</a></span></dt><dt><span class="sect1"><a href="#ARG_ADD_CMDLINE">I want the Args to add themselves to the CmdLine...</a></span></dt><dt><span class="sect1"><a href="#CHANGE_OUTPUT">I want different output than what is provided...</a></span></dt><dt><span class="sect1"><a href="#NO_HELP_VERSION">I don't want the --help and --version switches to be created automatically...</a></span></dt><dt><span class="sect1"><a href="#IGNORE_ARGS">I want to ignore certain arguments...</a></span></dt><dt><span class="sect1"><a href="#READING_HEX_INTEGERS">I want to read hex integers as arguments...</a></span></dt><dt><span class="sect1"><a href="#USING_ARGTRAITS">I want to use different types...</a></span></dt><dt><span class="sect1"><a href="#CHANGING_STARTSTRINGS">I want to use Windows-style flags like "/x" and "/y"...</a></span></dt></dl></div><p> +Naturally, what we have seen to this point doesn't satisfy all of +our needs. +</p><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="COMBINE_SWITCHES"></a>I want to combine multiple switches into one argument...</h2></div></div></div><p> +Multiple <code class="classname">SwitchArg</code>s can be combined into a +single argument on the command line. If you have switches -a, -b and -c +it is valid to do either: + +</p><pre class="programlisting"> + % command -a -b -c +</pre><p> + +<span class="emphasis"><em>or</em></span> + +</p><pre class="programlisting"> + % command -abc +</pre><p> + +<span class="emphasis"><em>or</em></span> + +</p><pre class="programlisting"> + % command -ba -c +</pre><p> + +This is to make this library more in line with the POSIX and GNU +standards (as I understand them). +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="XOR"></a>I want one argument or the other, but not both...</h2></div></div></div><p> +Suppose you have a command that must read input from one of two +possible locations, either a local file or a URL. The command +<span class="emphasis"><em>must</em></span> read something, so <span class="emphasis"><em>one</em></span> +argument is required, but +not both, yet neither argument is strictly necessary by itself. +This is called "exclusive or" or "XOR". To accommodate this +situation, there is now an option to add two or more +<code class="classname">Arg</code>s to +a <code class="classname">CmdLine</code> that are exclusively or'd with one another: +<code class="methodname">xorAdd()</code>. This means that exactly one of the +<code class="classname">Arg</code>s must be set and no more. +</p><p> +<code class="methodname">xorAdd()</code> comes in two flavors, either +<code class="methodname">xorAdd(Arg& a, Arg& b)</code> +to add just two <code class="classname">Arg</code>s to be xor'd and +<code class="methodname">xorAdd( vector<Arg*> xorList )</code> +to add more than two <code class="classname">Arg</code>s. + +</p><pre class="programlisting"> + + + ValueArg<string> fileArg("f","file","File name to read",true,"/dev/null", "filename"); + ValueArg<string> urlArg("u","url","URL to load",true, "http://example.com", "URL"); + + cmd.xorAdd( fileArg, urlArg ); + cmd.parse(argc, argv); + +</pre><p> + +Once one <code class="classname">Arg</code> in the xor list is matched on the +<code class="classname">CmdLine</code> then the others in the xor list will be +marked as set. The question then, is how to determine which of the +<code class="classname">Arg</code>s has been set? This is accomplished by calling the +isSet() method for each <code class="classname">Arg</code>. If the +<code class="classname">Arg</code> has been +matched on the command line, the <code class="methodname">isSet()</code> will return +<code class="constant">TRUE</code>, whereas if the <code class="classname">Arg</code> +has been set as a result of matching the other <code class="classname">Arg</code> +that was xor'd <code class="methodname">isSet()</code> will +return <code class="constant">FALSE</code>. +(Of course, if the <code class="classname">Arg</code> was not xor'd and +wasn't matched, it will also return <code class="constant">FALSE</code>.) + +</p><pre class="programlisting"> + + if ( fileArg.isSet() ) + readFile( fileArg.getValue() ); + else if ( urlArg.isSet() ) + readURL( urlArg.getValue() ); + else + // Should never get here because TCLAP will note that one of the + // required args above has not been set. + throw("Very bad things..."); + +</pre><p> + +It is helpful to note that <code class="classname">Arg</code>s of any type can be xor'd together. +This means that you can xor a <code class="classname">SwitchArg</code> with a <code class="classname">ValueArg</code>. +This is helpful in situations where one of several options is necessary and one of the options +requires additional information. + +</p><pre class="programlisting"> + + SwitchArg stdinArg("s", "stdin", "Read from STDIN", false); + ValueArg<string> fileArg("f","file","File name to read",true,"/dev/null", "filename"); + ValueArg<string> urlArg("u","url","URL to load",true, "http://example.com", "URL"); + + vector<Arg*> xorlist; + xorlist.push_back(&stdinArg); + xorlist.push_back(&fileArg); + xorlist.push_back(&urlArg); + + cmd.xorAdd( xorlist ); + +</pre><p> + + +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="NO_FLAG"></a>I have more arguments than single flags make sense for...</h2></div></div></div><p> +Some commands have so many options that single flags no longer map +sensibly to the available options. In this case, it is desirable to +specify <code class="classname">Arg</code>s using only long options. This one is easy to +accomplish, just make the flag value blank in the <code class="classname">Arg</code> +constructor. This will tell the <code class="classname">Arg</code> that only the long +option should be matched and will force users to specify the long +option on the command line. The help output is updated accordingly. + +</p><pre class="programlisting"> + + ValueArg<string> fileArg("","file","File name",true,"homer","filename"); + + SwitchArg caseSwitch("","upperCase","Print in upper case",false); + +</pre><p> +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="CONSTRAINT"></a>I want to constrain the values allowed for a particular +argument...</h2></div></div></div><p> +<span class="emphasis"><em>Interface Change!!!</em></span> Sorry folks, but we've changed +the interface since version 1.0.X for constraining <code class="classname">Arg</code>s. +Constraints are now hidden behind the <code class="classname">Constraint</code> +interface. To +constrain an <code class="classname">Arg</code> simply implement the interface +and specify the new class in the constructor as before. +</p><p> +You can still constrain <code class="classname">Arg</code>s based on +a list of values. Instead of adding a <code class="classname">vector</code> of +allowed values to the <code class="classname">Arg</code> directly, +create a <code class="classname">ValuesConstraint</code> object +with a <code class="classname">vector</code> of values and add that to the +<code class="classname">Arg</code>. The <code class="classname">Arg</code> constructors +have been modified accordingly. +</p><p> +When the value for the +<code class="classname">Arg</code> is parsed, +it is checked against the list of values specified in the +<code class="classname">ValuesConstraint</code>. +If the value is in the list then it is accepted. If +not, then an exception is thrown. Here is a simple example: + +</p><pre class="programlisting"> + vector<string> allowed; + allowed.push_back("homer"); + allowed.push_back("marge"); + allowed.push_back("bart"); + allowed.push_back("lisa"); + allowed.push_back("maggie"); + ValuesConstraint<string> allowedVals( allowed ); + + ValueArg<string> nameArg("n","name","Name to print",true,"homer",&allowedVals); + cmd.add( nameArg ); +</pre><p> + +When a <code class="classname">ValuesConstraint</code> is specified, +instead of a type description being specified in the +<code class="classname">Arg</code>, a +type description is created by concatenating the values in the +allowed list using operator<< for the specified type. The +help/usage for the <code class="classname">Arg</code> therefore lists the +allowable values. Because of this, you might want to keep the list +relatively small, however there is no limit on this. +</p><p> +Obviously, a list of allowed values isn't always the best way to +constrain things. For instance, one might wish to allow only +integers greater than 0. In this case, simply create a class that +implements the <code class="classname">Constraint<int></code> interface and +checks whether the value parsed is greater than 0 (done in the +<code class="methodname">check()</code> method) and create your +<code class="classname">Arg</code> with your new <code class="classname">Constraint</code>. +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="ARG_ADD_CMDLINE"></a>I want the Args to add themselves to the CmdLine...</h2></div></div></div><p> +New constructors have been added for each <code class="classname">Arg</code> +that take a <code class="classname">CmdLine</code> object as an argument. +Each <code class="classname">Arg</code> then +<code class="methodname">add</code>s itself to the <code class="classname">CmdLine</code> +object. There is no difference in how the <code class="classname">Arg</code> +is handled between this method and calling the +<code class="methodname">add()</code> method directly. At the moment, there is +no way to do an <code class="methodname">xorAdd()</code> from the constructor. Here +is an example: + +</p><pre class="programlisting"> + + // Create the command line. + CmdLine cmd("this is a message", '=', "0.99" ); + + // Note that the following args take the "cmd" object as arguments. + SwitchArg btest("B","existTestB", "exist Test B", cmd, false ); + + ValueArg<string> stest("s", "stringTest", "string test", true, "homer", + "string", cmd ); + + UnlabeledValueArg<string> utest("unTest1","unlabeled test one", + "default","string", cmd ); + + // NO add() calls! + + // Parse the command line. + cmd.parse(argc,argv); + +</pre><p> +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="CHANGE_OUTPUT"></a>I want different output than what is provided...</h2></div></div></div><p> +It is straightforward to change the output generated by +<span class="emphasis"><em>TCLAP</em></span>. Either subclass the +<code class="classname">StdOutput</code> class and re-implement the methods you choose, +or write your own class that implements the +<code class="classname">CmdLineOutput</code> interface. Once you have done this, +then use the <code class="classname">CmdLine</code> <code class="methodname">setOutput</code> +method to tell the <code class="classname">CmdLine</code> to use your new output +class. Here is a simple example: +</p><pre class="programlisting"> +class MyOutput : public StdOutput +{ + public: + virtual void failure(CmdLineInterface& c, ArgException& e) + { + cerr << "My special failure message for: " << endl + << e.what() << endl; + exit(1); + } + + virtual void usage(CmdLineInterface& c) + { + cout << "my usage message:" << endl; + list<Arg*> args = c.getArgList(); + for (ArgListIterator it = args.begin(); it != args.end(); it++) + cout << (*it)->longID() + << " (" << (*it)->getDescription() << ")" << endl; + } + + virtual void version(CmdLineInterface& c) + { + cout << "my version message: 0.1" << endl; + } +}; + +int main(int argc, char** argv) +{ + CmdLine cmd("this is a message", ' ', "0.99" ); + + // set the output + MyOutput my; + cmd.setOutput( &my ); + + // proceed normally ... +</pre><p> + +See <code class="filename">test4.cpp</code> in the examples directory for the full +example. <span class="emphasis"><em>NOTE</em></span>: if you supply your own Output object, we +will not delete it in the <code class="classname">CmdLine</code> destructor. This +could lead to a (very small) memory leak if you don't take care of the object +yourself. Also note that the <code class="methodname">failure</code> method is +now responsible for exiting the application (assuming that is the desired +behavior). +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="NO_HELP_VERSION"></a>I don't want the --help and --version switches to be created automatically...</h2></div></div></div><p> +Help and version information is useful for nearly all command line applications +and as such we generate flags that provide those options automatically. +However, there are situations when these flags are undesirable. For these +cases we've added we've added a forth parameter to the +<code class="classname">CmdLine</code> constructor. Making this boolean parameter +false will disable automatic help and version generation. +</p><pre class="programlisting"> + CmdLine cmd("this is a message", ' ', "0.99", false ); +</pre><p> +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="IGNORE_ARGS"></a>I want to ignore certain arguments...</h2></div></div></div><p> +The <em class="parameter"><code>--</code></em> flag is automatically included in the +<code class="classname">CmdLine</code>. +As (almost) per POSIX and GNU standards, any argument specified +after the <em class="parameter"><code>--</code></em> flag is ignored. +<span class="emphasis"><em>Almost</em></span> because if an +<code class="classname">UnlabeledValueArg</code> that has not been set or an +<code class="classname">UnlabeledMultiArg</code> has been specified, by default +we will assign any arguments beyond the <em class="parameter"><code>--</code></em> +to the those arguments as +per the rules above. This is primarily useful if you want to pass +in arguments with a dash as the first character of the argument. It +should be noted that even if the <em class="parameter"><code>--</code></em> flag is +passed on the command line, the <code class="classname">CmdLine</code> will +<span class="emphasis"><em>still</em></span> test to make sure all of the required +arguments are present. +</p><p> +Of course, this isn't how POSIX/GNU handle things, they explicitly +ignore arguments after the <em class="parameter"><code>--</code></em>. To accommodate this, +we can make both <code class="classname">UnlabeledValueArg</code>s and +<code class="classname">UnlabeledMultiArg</code>s ignoreable in their constructors. +See the <a href="html/index.html" target="_top"> API Documentation</a> for details. +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="READING_HEX_INTEGERS"></a>I want to read hex integers as arguments...</h2></div></div></div><p> +Sometimes it's desirable to read integers formatted in decimal, hexadecimal, +and octal format. This is now possible by #defining the <em class="parameter"><code>TCLAP_SETBASE_ZERO</code></em> +directive. Simply define this directive in your code and integer arguments will be parsed +in each base. +</p><pre class="programlisting"> + +#define TCLAP_SETBASE_ZERO 1 + +#include "tclap/CmdLine.h" +#include <iostream> + +using namespace TCLAP; +using namespace std; + +int main(int argc, char** argv) +{ + + try { + + CmdLine cmd("this is a message", ' ', "0.99" ); + + ValueArg<int> itest("i", "intTest", "integer test", true, 5, "int"); + cmd.add( itest ); + + // + // Parse the command line. + // + cmd.parse(argc,argv); + + // + // Set variables + // + int _intTest = itest.getValue(); + cout << "found int: " << _intTest << endl; + + } catch ( ArgException& e ) + { cout << "ERROR: " << e.error() << " " << e.argId() << endl; } +} +</pre><p> +</p><p> +The reason that this behavior is not the default behavior for <span class="emphasis"><em>TCLAP</em></span> is that the use of +<code class="methodname">setbase(0)</code> appears to be something of a side effect and is not necessarily how +<code class="methodname">setbase()</code> is meant to be used. So while we're making this functionality +available, we're not turning it on by default for fear of bad things happening in different compilers. +If you know otherwise, please let us know. +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="USING_ARGTRAITS"></a>I want to use different types...</h2></div></div></div><p> +The usual C++ types (int, long, bool, etc.) are supported by <span class="emphasis"><em>TCLAP</em></span> out +of the box. As +long as operator>> and operator<< are supported, other types should work fine +too, you'll just need to specify the <code class="classname">ArgTraits</code> which +tells <span class="emphasis"><em>TCLAP</em></span> how you expect the type to be handled. +</p><p> +For example, assume that you'd like to read one argument on the command line in as a +<code class="classname">std::pair</code> object. All you'll need to do is tell +<span class="emphasis"><em>TCLAP</em></span> whether to treat <code class="classname">std::pair</code> as a +String or Value. StringLike means to treat the string on the command line as a string +and use it directly, whereas ValueLike means that a value object should be extracted from the +string using operator>>. For <code class="classname">std::pair</code> we'll choose ValueLike. +To accomplish this, add the following declaration to your file: + +</p><pre class="programlisting"> + + template<class T, class U> + struct ArgTraits<std::pair<T, U>> { + typedef ValueLike ValueCategory; + }; + +</pre><p> + +For complete examples see the files <code class="filename">test11.cpp</code> +and <code class="filename">test12.cpp</code> in the examples directory. +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="CHANGING_STARTSTRINGS"></a>I want to use Windows-style flags like "/x" and "/y"...</h2></div></div></div><p> +It is traditional in Posix environments that the "-" and "--" strings are used to signify +the beginning of argument flags and long argument names. However, other environments, +namely Windows, use different strings. <span class="emphasis"><em>TCLAP</em></span> allows you to +control which strings are used with <code class="methodname">#define</code> directives. This allows +you to use different strings based on your operating environment. Here is an example: + +</p><pre class="programlisting"> +// +// This illustrates how to change the flag and name start strings for +// Windows, otherwise the defaults are used. +// +// Note that these defines need to happen *before* tclap is included! +// +#ifdef WINDOWS +#define TCLAP_NAMESTARTSTRING "~~" +#define TCLAP_FLAGSTARTSTRING "/" +#endif + +#include "tclap/CmdLine.h" + +using namespace TCLAP; +using namespace std; + +int main(int argc, char** argv) +{ + // Everything else is identical! + ... +</pre><p> + + +</p></div></div><div class="chapter" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title"><a id="NOTES"></a>Chapter 4. Notes</h2></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="sect1"><a href="#DESCRIPTION_EXCEPTIONS">Type Descriptions</a></span></dt><dt><span class="sect1"><a href="#VISITORS">Visitors</a></span></dt><dt><span class="sect1"><a href="#MORE_INFO">More Information</a></span></dt></dl></div><p> +Like all good rules, there are many exceptions.... +</p><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="DESCRIPTION_EXCEPTIONS"></a>Type Descriptions</h2></div></div></div><p> +Ideally this library would use RTTI to return a human readable name +of the type declared for a particular argument. Unfortunately, at +least for <span><strong class="command">g++</strong></span>, the names returned aren't +particularly useful. +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="VISITORS"></a>Visitors</h2></div></div></div><p> +Disclaimer: Almost no one will have any use for +<code class="classname">Visitor</code>s, they were +added to provide special handling for default arguments. Nothing +that <code class="classname">Visitor</code>s do couldn't be accomplished +by the user after the +command line has been parsed. If you're still interested, keep +reading... +</p><p> +Some of you may be wondering how we get the <em class="parameter"><code>--help</code></em>, +<em class="parameter"><code>--version</code></em> and <em class="parameter"><code>--</code></em> +arguments to do their thing without mucking up the +<code class="classname">CmdLine</code> code with lots of <span class="emphasis"><em>if</em></span> +statements and type checking. This is accomplished by using a +variation on the Visitor Pattern. Actually, it may not be a Visitor +Pattern at all, but that's what inspired me. +</p><p> +If we want some argument to do some sort of special handling, +besides simply parsing a value, then we add a <code class="classname">Visitor</code> +pointer to the <code class="classname">Arg</code>. More specifically, we add a +<span class="emphasis"><em>subclass</em></span> of the <code class="classname">Visitor</code> +class. Once the argument has been successfully parsed, the +<code class="classname">Visitor</code> for that argument is +called. Any data that needs to be operated on is declared in the +<code class="classname">Visitor</code> constructor and then operated on in the +<code class="methodname">visit()</code> method. A <code class="classname">Visitor</code> +is added to an <code class="classname">Arg</code> as the last argument in its +declaration. This may sound +complicated, but it is pretty straightforward. Let's see an +example. +</p><p> +Say you want to add an <em class="parameter"><code>--authors</code></em> flag to a program that +prints the names of the authors when present. First subclass +<code class="classname">Visitor</code>: + +</p><pre class="programlisting"> + +#include "Visitor.h" +#include <string> +#include <iostream> + +class AuthorVisitor : public Visitor +{ + protected: + string _author; + public: + AuthorVisitor(const string& name ) : Visitor(), _author(name) {} ; + void visit() { cout << "AUTHOR: " << _author << endl; exit(0); }; +}; + +</pre><p> + +Now include this class definition somewhere and go about creating +your command line. When you create the author switch, add the +<code class="classname">AuthorVisitor</code> pointer as follows: + +</p><pre class="programlisting"> + + SwitchArg author("a","author","Prints author name", false, + new AuthorVisitor("Homer J. Simpson") ); + cmd.add( author ); + +</pre><p> + +Now, any time the <em class="parameter"><code>-a</code></em> or +<em class="parameter"><code>--author</code></em> flag is specified, +the program will print the author name, Homer J. Simpson and exit +without processing any further (as specified in the +<code class="methodname">visit()</code> method). +</p></div><div class="sect1" lang="en" xml:lang="en"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a id="MORE_INFO"></a>More Information</h2></div></div></div><p> +For more information, look at the <a href="html/index.html" target="_top"> +API Documentation</a> and the examples included with the +distribution. +</p><p> +<span class="emphasis"><em>Happy coding!</em></span> +</p></div></div></div></body></html> |