diff --git a/.gitmodules b/.gitmodules
index 86e0c20fe68579e7b0f1ccdd1dba498cf16b13fe..ae780729fd3c2e22a3a6f5029fb0b611977ccfeb 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -7,6 +7,3 @@
[submodule "modparser"]
path = external/modparser
url = git@github.com:eth-cscs/modparser.git
-[submodule "external/tclap"]
- path = external/tclap
- url = https://github.com/eile/tclap.git
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8da46487de7eb56194909cbcb81a1262ff2a6444..c7049ab2baf27e31181412b2f5d04305f3d309e6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -104,7 +104,7 @@ endif()
include_directories(${CMAKE_SOURCE_DIR}/external)
-include_directories(${CMAKE_SOURCE_DIR}/external/tclap/include)
+include_directories(${CMAKE_SOURCE_DIR}/tclap/include)
include_directories(${CMAKE_SOURCE_DIR}/include)
include_directories(${CMAKE_SOURCE_DIR}/src)
include_directories(${CMAKE_SOURCE_DIR}/miniapp)
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..a55edbeaf56f49d8c6dab0f3367cdd8c16999be1
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,12 @@
+Copyright (c) 2016, ETHZ
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/README.md b/README.md
index 32091a9364a52a70985abe288b50bfcc47d53d54..7c76215207038b458f0511ba145680f36dd1d960 100644
--- a/README.md
+++ b/README.md
@@ -1,17 +1,22 @@
-# cell_algorithms
+# NestMC Prototype
+
+This is the repository for the NestMC prototype code. Unfortunately we do not have thorough documentation of how-to guides.
+Below are some guides for how to build the project and run the miniapp.
+Contact us or submit a ticket if you have any questions or want help.
```bash
# clone repo
-git clone git@github.com:eth-cscs/cell_algorithms.git
-cd cell_algorithms/
+git clone git@github.com:eth-cscs/nestmc-proto.git
+cd nestmc-proto/
# setup sub modules
git submodule init
git submodule update
# setup environment
-# on a desktop system this might not be required
-# on a cluster this could be required
+# on a desktop system this is probably not required
+# on a cluster this is usually required to make sure that an appropriate
+# compiler is chosen.
module load gcc
module load cmake
export CC=`which gcc`
@@ -31,8 +36,7 @@ cd tests
## MPI
Set the `WITH_MPI` option either via the ccmake interface, or via the command line as shown below.
-For the time being our CMake configuration does not try to detect MPI.
-Instead, it relies on the user specifying an MPI wrapper for the compiler by setting the `CXX` and `CC` environment variables.
+To ensure that CMake detects MPI correctly, you should specify the MPI wrapper for the compiler by setting the `CXX` and `CC` environment variables.
```
export CXX=mpicxx
@@ -47,7 +51,6 @@ Support for multi-threading requires Intel Threading Building Blocks (TBB).
When TBB is installed, it comes with some scripts that can be run to set up the user environment.
The scripts set the `TBB_ROOT` environment variable, which is used by the CMake configuration to find TBB.
-
```
source <path to TBB installation>/tbbvars.sh
cmake <path to CMakeLists.txt> -DWITH_TBB=ON
@@ -56,6 +59,9 @@ cmake <path to CMakeLists.txt> -DWITH_TBB=ON
### TBB on Cray systems
To compile with TBB on Cray systems, load the intel module, which will automatically configure the environment.
+The guide below shows how to use the version of TBB that is installed as part of the Intel compiler toolchain.
+It is recommended that you install the most recent version of TBB yourself, and link against this, because older versions
+of TBB don't work with recent versions of GCC.
```
# load the gnu environment for compiling the application
@@ -80,7 +86,7 @@ cmake <path to CMakeLists.txt> -DWITH_TBB=ON -DWITH_MPI=ON -DSYSTEM_CRAY=ON
# targetting KNL
-## build modparser
+## build modparser
The source to source compiler "modparser" that generates the C++/CUDA kernels for the ion channels and synapses is in a separate repository.
It is included in our project as a git submodule, and by default it will be built with the same compiler and flags that are used to build the miniapp and tests.
@@ -116,8 +122,8 @@ which modcc
```bash
# clone the repo and set up the submodules
-git clone TODO
-cd cell_algorithms
+git clone https://github.com/eth-cscs/nestmc-proto.git
+cd nestmc-proto
git submodule init
git submodule update
@@ -127,13 +133,6 @@ cd build_knl
## build miniapp
-# clone the repo and set up the submodules
-git clone https://github.com/bcumming/cell_algorithms.git
-cd cell_algorithms
-
-# checkout the knl branch
-git checkout knl
-
# setup submodules
git submodule init
git submodule update
diff --git a/mechanisms/mod/exp2syn.mod b/mechanisms/mod/exp2syn.mod
old mode 100755
new mode 100644
index ea0cf025e9228216b4699161a2e574ca1d1dda6e..591fcbca8aff2779cc36286b554d6d17d9f475c1
--- a/mechanisms/mod/exp2syn.mod
+++ b/mechanisms/mod/exp2syn.mod
@@ -1,50 +1,47 @@
NEURON {
- POINT_PROCESS exp2syn
- RANGE tau1, tau2, e
- NONSPECIFIC_CURRENT i
+ POINT_PROCESS exp2syn
+ RANGE tau1, tau2, e
+ NONSPECIFIC_CURRENT i
}
UNITS {
- (nA) = (nanoamp)
- (mV) = (millivolt)
- (uS) = (microsiemens)
+ (mV) = (millivolt)
}
PARAMETER {
- tau1 = .5 (ms) : <1e-9,1e9>
- tau2 = 2 (ms) : <1e-9,1e9>
- e=0 (mV)
+ tau1 = 0.5 (ms)
+ tau2 = 2 (ms)
+ e = 0 (mV)
}
ASSIGNED {
- factor
+ factor
}
STATE {
- A : (uS)
- B : (uS)
+ A B
}
INITIAL {
- LOCAL tp
- A = 0
- B = 0
- tp = (tau1*tau2)/(tau2 - tau1) * log(tau2/tau1)
- factor = -exp(-tp/tau1) + exp(-tp/tau2)
- factor = 1/factor
+ LOCAL tp
+ A = 0
+ B = 0
+ tp = (tau1*tau2)/(tau2 - tau1) * log(tau2/tau1)
+ factor = 1 / (-exp(-tp/tau1) + exp(-tp/tau2))
}
BREAKPOINT {
- SOLVE state METHOD cnexp
- i = (B - A)*(v - e)
+ SOLVE state METHOD cnexp
+ i = (B - A)*(v - e)
}
DERIVATIVE state {
- A' = -A/tau1
- B' = -B/tau2
+ A' = -A/tau1
+ B' = -B/tau2
}
NET_RECEIVE(weight) {
- A = A + weight*factor
- B = B + weight*factor
+ A = A + weight*factor
+ B = B + weight*factor
}
+
diff --git a/mechanisms/mod/expsyn.mod b/mechanisms/mod/expsyn.mod
index 16d10c5cf856cd87e50252dca2163d844588e2b9..44da3697ddf01321ea9ee5991791baa0f0145880 100644
--- a/mechanisms/mod/expsyn.mod
+++ b/mechanisms/mod/expsyn.mod
@@ -5,22 +5,18 @@ NEURON {
}
UNITS {
- (nA) = (nanoamp)
(mV) = (millivolt)
- (uS) = (microsiemens)
}
PARAMETER {
- : the default for Neuron is 0.1
- :tau = 0.1 (ms) : <1e-9,1e9>
- tau = 2.0 (ms) : <1e-9,1e9>
+ tau = 2.0 (ms) : the default for Neuron is 0.1
e = 0 (mV)
}
ASSIGNED {}
STATE {
- g : (uS)
+ g
}
INITIAL {
@@ -39,3 +35,4 @@ DERIVATIVE state {
NET_RECEIVE(weight) {
g = g + weight
}
+
diff --git a/mechanisms/mod/hh.mod b/mechanisms/mod/hh.mod
index 8b23f44a4dc3e27cdbb2d78a161b9504c8651073..f5acc9fc7c66d283d170f5b11d1ba2da21e039fa 100644
--- a/mechanisms/mod/hh.mod
+++ b/mechanisms/mod/hh.mod
@@ -1,24 +1,3 @@
-TITLE hh.mod squid sodium, potassium, and leak channels
-
-: COMMENT
-: This is the original Hodgkin-Huxley treatment for the set of sodium,
-: potassium, and leakage channels found in the squid giant axon membrane.
-: ("A quantitative description of membrane current and its application
-: conduction and excitation in nerve" J.Physiol. (Lond.) 117:500-544 (1952).)
-: Membrane voltage is in absolute mV and has been reversed in polarity
-: from the original HH convention and shifted to reflect a resting potential
-: of -65 mV.
-: Remember to set celsius=6.3 (or whatever) in your HOC file.
-: See squid.hoc for an example of a simulation using this model.
-: SW Jaslove 6 March, 1992
-: ENDCOMMENT
-
-UNITS {
- (mA) = (milliamp)
- (mV) = (millivolt)
- (S) = (siemens)
-}
-
NEURON {
SUFFIX hh
USEION na READ ena WRITE ina
@@ -28,13 +7,17 @@ NEURON {
GLOBAL minf, hinf, ninf, mtau, htau, ntau
}
+UNITS {
+ (mV) = (millivolt)
+ (S) = (siemens)
+}
+
PARAMETER {
- gnabar = .12 (S/cm2) : <0,1e9>
- gkbar = .036 (S/cm2) : <0,1e9>
- gl = .0003 (S/cm2) : <0,1e9>
+ gnabar = .12 (S/cm2)
+ gkbar = .036 (S/cm2)
+ gl = .0003 (S/cm2)
el = -54.3 (mV)
celsius = 6.3 (degC)
- :celsius = 37 (degC)
}
STATE {
@@ -77,7 +60,7 @@ DERIVATIVE states {
n' = (ninf-n)/ntau
}
-PROCEDURE rates(v) :(mV))
+PROCEDURE rates(v)
{
LOCAL alpha, beta, sum, q10
@@ -105,21 +88,13 @@ PROCEDURE rates(v) :(mV))
ninf = alpha/sum
}
+: We don't trap for zero in the denominator like Neuron, because function
+: inlining in modparser won't support it. There is a good argument that
+: vtrap should be provided as a built in of the language, because
+: - it is a common pattern in many mechanisms.
+: - it can be implemented efficiently on different back ends if the
+: compiler has enough information.
FUNCTION vtrap(x,y) {
- : Traps for 0 in denominator of rate eqns.
-
- : Disabled for function inlining...
- : there is a very good case for making vtrap a builtin function for the language
- : - it is ubiquitous: used in so many models of ion channels
- : - platform specific optimizations written in assembly/intrinsics
- : required to facilitate vectorization/minimize branch misses
-
- :if (fabs(x/y) < 1e-6) {
- : vtrap = y*(1 - x/y/2)
- :}else{
- : vtrap = x/(exp(x/y) - 1)
- :}
-
vtrap = x/(exp(x/y) - 1)
}
diff --git a/mechanisms/mod/pas.mod b/mechanisms/mod/pas.mod
index b7dc2ad6d2a343bb2333c5b8ecfec17060150865..6653f34e1bf3a0b53f367c826f2d424ca7f86927 100644
--- a/mechanisms/mod/pas.mod
+++ b/mechanisms/mod/pas.mod
@@ -1,8 +1,5 @@
-TITLE passive membrane channel
-
UNITS {
(mV) = (millivolt)
- (mA) = (milliamp)
(S) = (siemens)
}
@@ -15,8 +12,8 @@ NEURON {
INITIAL {}
PARAMETER {
- g = .001 (S/cm2) :<0,1e9>
- e = -65 (mV) : we use -65 for the ball and stick model, instead of Neuron default of -70
+ g = .001 (S/cm2)
+ e = -65 (mV) : we use -65 for the ball and stick model, instead of Neuron default of -70
}
ASSIGNED {
diff --git a/tclap/AUTHORS b/tclap/AUTHORS
new file mode 100644
index 0000000000000000000000000000000000000000..875a852a9d5ab00e90fad2738e90f9c55e7621b6
--- /dev/null
+++ b/tclap/AUTHORS
@@ -0,0 +1,6 @@
+
+original author: Michael E. Smoot
+invaluable contributions: Daniel Aarno
+more contributions: Erik Zeek
+more contributions: Fabien Carmagnac (Tinbergen-AM)
+outstanding editing: Carol Smoot
diff --git a/tclap/COPYING b/tclap/COPYING
new file mode 100644
index 0000000000000000000000000000000000000000..987be0ce7cc4880bb75531a4a838983d61214f81
--- /dev/null
+++ b/tclap/COPYING
@@ -0,0 +1,25 @@
+
+
+Copyright (c) 2003 Michael E. Smoot
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software,
+and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+
diff --git a/tclap/README b/tclap/README
new file mode 100644
index 0000000000000000000000000000000000000000..225e33f4cda3ce0ca6ab56a7d96dfe812c898a8e
--- /dev/null
+++ b/tclap/README
@@ -0,0 +1,16 @@
+
+TCLAP - Templatized Command Line Argument Parser
+
+This is a simple C++ library that facilitates parsing command line
+arguments in a type independent manner. It doesn't conform exactly
+to either the GNU or POSIX standards, although it is close. See
+docs/manual.html for descriptions of how things work or look at the
+simple examples in the examples dir.
+
+To find out what the latest changes are read the NEWS file in this directory.
+
+
+Any and all feedback is welcome to: Mike Smoot <mes@aescon.com>
+
+
+
diff --git a/tclap/include/tclap/Arg.h b/tclap/include/tclap/Arg.h
new file mode 100644
index 0000000000000000000000000000000000000000..b28eef117c633f5e4108775cf9466a22402a9d07
--- /dev/null
+++ b/tclap/include/tclap/Arg.h
@@ -0,0 +1,692 @@
+// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
+
+/******************************************************************************
+ *
+ * file: Arg.h
+ *
+ * Copyright (c) 2003, Michael E. Smoot .
+ * Copyright (c) 2004, Michael E. Smoot, Daniel Aarno .
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+
+#ifndef TCLAP_ARGUMENT_H
+#define TCLAP_ARGUMENT_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#else
+#define HAVE_SSTREAM
+#endif
+
+#include <string>
+#include <vector>
+#include <list>
+#include <iostream>
+#include <iomanip>
+#include <cstdio>
+
+#if defined(HAVE_SSTREAM)
+#include <sstream>
+typedef std::istringstream istringstream;
+#elif defined(HAVE_STRSTREAM)
+#include <strstream>
+typedef std::istrstream istringstream;
+#else
+#error "Need a stringstream (sstream or strstream) to compile!"
+#endif
+
+#include <tclap/ArgException.h>
+#include <tclap/Visitor.h>
+#include <tclap/CmdLineInterface.h>
+#include <tclap/ArgTraits.h>
+#include <tclap/StandardTraits.h>
+
+namespace TCLAP {
+
+/**
+ * A virtual base class that defines the essential data for all arguments.
+ * This class, or one of its existing children, must be subclassed to do
+ * anything.
+ */
+class Arg
+{
+ private:
+ /**
+ * Prevent accidental copying.
+ */
+ Arg(const Arg& rhs);
+
+ /**
+ * Prevent accidental copying.
+ */
+ Arg& operator=(const Arg& rhs);
+
+ /**
+ * Indicates whether the rest of the arguments should be ignored.
+ */
+ static bool& ignoreRestRef() { static bool ign = false; return ign; }
+
+ /**
+ * The delimiter that separates an argument flag/name from the
+ * value.
+ */
+ static char& delimiterRef() { static char delim = ' '; return delim; }
+
+ protected:
+
+ /**
+ * The single char flag used to identify the argument.
+ * This value (preceded by a dash {-}), can be used to identify
+ * an argument on the command line. The _flag can be blank,
+ * in fact this is how unlabeled args work. Unlabeled args must
+ * override appropriate functions to get correct handling. Note
+ * that the _flag does NOT include the dash as part of the flag.
+ */
+ std::string _flag;
+
+ /**
+ * A single work namd indentifying the argument.
+ * This value (preceded by two dashed {--}) can also be used
+ * to identify an argument on the command line. Note that the
+ * _name does NOT include the two dashes as part of the _name. The
+ * _name cannot be blank.
+ */
+ std::string _name;
+
+ /**
+ * Description of the argument.
+ */
+ std::string _description;
+
+ /**
+ * Indicating whether the argument is required.
+ */
+ bool _required;
+
+ /**
+ * Label to be used in usage description. Normally set to
+ * "required", but can be changed when necessary.
+ */
+ std::string _requireLabel;
+
+ /**
+ * Indicates whether a value is required for the argument.
+ * Note that the value may be required but the argument/value
+ * combination may not be, as specified by _required.
+ */
+ bool _valueRequired;
+
+ /**
+ * Indicates whether the argument has been set.
+ * Indicates that a value on the command line has matched the
+ * name/flag of this argument and the values have been set accordingly.
+ */
+ bool _alreadySet;
+
+ /**
+ * A pointer to a vistitor object.
+ * The visitor allows special handling to occur as soon as the
+ * argument is matched. This defaults to NULL and should not
+ * be used unless absolutely necessary.
+ */
+ Visitor* _visitor;
+
+ /**
+ * Whether this argument can be ignored, if desired.
+ */
+ bool _ignoreable;
+
+ /**
+ * Indicates that the arg was set as part of an XOR and not on the
+ * command line.
+ */
+ bool _xorSet;
+
+ bool _acceptsMultipleValues;
+
+ /**
+ * Performs the special handling described by the Vistitor.
+ */
+ void _checkWithVisitor() const;
+
+ /**
+ * Primary constructor. YOU (yes you) should NEVER construct an Arg
+ * directly, this is a base class that is extended by various children
+ * that are meant to be used. Use SwitchArg, ValueArg, MultiArg,
+ * UnlabeledValueArg, or UnlabeledMultiArg instead.
+ *
+ * \param flag - The flag identifying the argument.
+ * \param name - The name identifying the argument.
+ * \param desc - The description of the argument, used in the usage.
+ * \param req - Whether the argument is required.
+ * \param valreq - Whether the a value is required for the argument.
+ * \param v - The visitor checked by the argument. Defaults to NULL.
+ */
+ Arg( const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ bool valreq,
+ Visitor* v = NULL );
+
+ public:
+ /**
+ * Destructor.
+ */
+ virtual ~Arg();
+
+ /**
+ * Adds this to the specified list of Args.
+ * \param argList - The list to add this to.
+ */
+ virtual void addToList( std::list<Arg*>& argList ) const;
+
+ /**
+ * Begin ignoring arguments since the "--" argument was specified.
+ */
+ static void beginIgnoring() { ignoreRestRef() = true; }
+
+ /**
+ * Whether to ignore the rest.
+ */
+ static bool ignoreRest() { return ignoreRestRef(); }
+
+ /**
+ * The delimiter that separates an argument flag/name from the
+ * value.
+ */
+ static char delimiter() { return delimiterRef(); }
+
+ /**
+ * The char used as a place holder when SwitchArgs are combined.
+ * Currently set to the bell char (ASCII 7).
+ */
+ static char blankChar() { return (char)7; }
+
+ /**
+ * The char that indicates the beginning of a flag. Defaults to '-', but
+ * clients can define TCLAP_FLAGSTARTCHAR to override.
+ */
+#ifndef TCLAP_FLAGSTARTCHAR
+#define TCLAP_FLAGSTARTCHAR '-'
+#endif
+ static char flagStartChar() { return TCLAP_FLAGSTARTCHAR; }
+
+ /**
+ * The sting that indicates the beginning of a flag. Defaults to "-", but
+ * clients can define TCLAP_FLAGSTARTSTRING to override. Should be the same
+ * as TCLAP_FLAGSTARTCHAR.
+ */
+#ifndef TCLAP_FLAGSTARTSTRING
+#define TCLAP_FLAGSTARTSTRING "-"
+#endif
+ static const std::string flagStartString() { return TCLAP_FLAGSTARTSTRING; }
+
+ /**
+ * The sting that indicates the beginning of a name. Defaults to "--", but
+ * clients can define TCLAP_NAMESTARTSTRING to override.
+ */
+#ifndef TCLAP_NAMESTARTSTRING
+#define TCLAP_NAMESTARTSTRING "--"
+#endif
+ static const std::string nameStartString() { return TCLAP_NAMESTARTSTRING; }
+
+ /**
+ * The name used to identify the ignore rest argument.
+ */
+ static const std::string ignoreNameString() { return "ignore_rest"; }
+
+ /**
+ * Sets the delimiter for all arguments.
+ * \param c - The character that delimits flags/names from values.
+ */
+ static void setDelimiter( char c ) { delimiterRef() = c; }
+
+ /**
+ * Pure virtual method meant to handle the parsing and value assignment
+ * of the string on the command line.
+ * \param i - Pointer the the current argument in the list.
+ * \param args - Mutable list of strings. What is
+ * passed in from main.
+ */
+ virtual bool processArg(int *i, std::vector<std::string>& args) = 0;
+
+ /**
+ * Operator ==.
+ * Equality operator. Must be virtual to handle unlabeled args.
+ * \param a - The Arg to be compared to this.
+ */
+ virtual bool operator==(const Arg& a) const;
+
+ /**
+ * Returns the argument flag.
+ */
+ const std::string& getFlag() const;
+
+ /**
+ * Returns the argument name.
+ */
+ const std::string& getName() const;
+
+ /**
+ * Returns the argument description.
+ */
+ std::string getDescription() const;
+
+ /**
+ * Indicates whether the argument is required.
+ */
+ virtual bool isRequired() const;
+
+ /**
+ * Sets _required to true. This is used by the XorHandler.
+ * You really have no reason to ever use it.
+ */
+ void forceRequired();
+
+ /**
+ * Sets the _alreadySet value to true. This is used by the XorHandler.
+ * You really have no reason to ever use it.
+ */
+ void xorSet();
+
+ /**
+ * Indicates whether a value must be specified for argument.
+ */
+ bool isValueRequired() const;
+
+ /**
+ * Indicates whether the argument has already been set. Only true
+ * if the arg has been matched on the command line.
+ */
+ bool isSet() const;
+
+ /**
+ * Indicates whether the argument can be ignored, if desired.
+ */
+ bool isIgnoreable() const;
+
+ /**
+ * A method that tests whether a string matches this argument.
+ * This is generally called by the processArg() method. This
+ * method could be re-implemented by a child to change how
+ * arguments are specified on the command line.
+ * \param s - The string to be compared to the flag/name to determine
+ * whether the arg matches.
+ */
+ virtual bool argMatches( const std::string& s ) const;
+
+ /**
+ * Returns a simple string representation of the argument.
+ * Primarily for debugging.
+ */
+ virtual std::string toString() const;
+
+ /**
+ * Returns a short ID for the usage.
+ * \param valueId - The value used in the id.
+ */
+ virtual std::string shortID( const std::string& valueId = "val" ) const;
+
+ /**
+ * Returns a long ID for the usage.
+ * \param valueId - The value used in the id.
+ */
+ virtual std::string longID( const std::string& valueId = "val" ) const;
+
+ /**
+ * Trims a value off of the flag.
+ * \param flag - The string from which the flag and value will be
+ * trimmed. Contains the flag once the value has been trimmed.
+ * \param value - Where the value trimmed from the string will
+ * be stored.
+ */
+ virtual void trimFlag( std::string& flag, std::string& value ) const;
+
+ /**
+ * Checks whether a given string has blank chars, indicating that
+ * it is a combined SwitchArg. If so, return true, otherwise return
+ * false.
+ * \param s - string to be checked.
+ */
+ bool _hasBlanks( const std::string& s ) const;
+
+ /**
+ * Sets the requireLabel. Used by XorHandler. You shouldn't ever
+ * use this.
+ * \param s - Set the requireLabel to this value.
+ */
+ void setRequireLabel( const std::string& s );
+
+ /**
+ * Used for MultiArgs and XorHandler to determine whether args
+ * can still be set.
+ */
+ virtual bool allowMore();
+
+ /**
+ * Use by output classes to determine whether an Arg accepts
+ * multiple values.
+ */
+ virtual bool acceptsMultipleValues();
+
+ /**
+ * Clears the Arg object and allows it to be reused by new
+ * command lines.
+ */
+ virtual void reset();
+};
+
+/**
+ * Typedef of an Arg list iterator.
+ */
+typedef std::list<Arg*>::iterator ArgListIterator;
+
+/**
+ * Typedef of an Arg vector iterator.
+ */
+typedef std::vector<Arg*>::iterator ArgVectorIterator;
+
+/**
+ * Typedef of a Visitor list iterator.
+ */
+typedef std::list<Visitor*>::iterator VisitorListIterator;
+
+/*
+ * Extract a value of type T from it's string representation contained
+ * in strVal. The ValueLike parameter used to select the correct
+ * specialization of ExtractValue depending on the value traits of T.
+ * ValueLike traits use operator>> to assign the value from strVal.
+ */
+template<typename T> void
+ExtractValue(T &destVal, const std::string& strVal, ValueLike vl)
+{
+ static_cast<void>(vl); // Avoid warning about unused vl
+ std::istringstream is(strVal);
+
+ int valuesRead = 0;
+ while ( is.good() ) {
+ if ( is.peek() != EOF )
+#ifdef TCLAP_SETBASE_ZERO
+ is >> std::setbase(0) >> destVal;
+#else
+ is >> destVal;
+#endif
+ else
+ break;
+
+ valuesRead++;
+ }
+
+ if ( is.fail() )
+ throw( ArgParseException("Couldn't read argument value "
+ "from string '" + strVal + "'"));
+
+
+ if ( valuesRead > 1 )
+ throw( ArgParseException("More than one valid value parsed from "
+ "string '" + strVal + "'"));
+
+}
+
+/*
+ * Extract a value of type T from it's string representation contained
+ * in strVal. The ValueLike parameter used to select the correct
+ * specialization of ExtractValue depending on the value traits of T.
+ * StringLike uses assignment (operator=) to assign from strVal.
+ */
+template<typename T> void
+ExtractValue(T &destVal, const std::string& strVal, StringLike sl)
+{
+ static_cast<void>(sl); // Avoid warning about unused sl
+ SetString(destVal, strVal);
+}
+
+//////////////////////////////////////////////////////////////////////
+//BEGIN Arg.cpp
+//////////////////////////////////////////////////////////////////////
+
+inline Arg::Arg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ bool valreq,
+ Visitor* v) :
+ _flag(flag),
+ _name(name),
+ _description(desc),
+ _required(req),
+ _requireLabel("required"),
+ _valueRequired(valreq),
+ _alreadySet(false),
+ _visitor( v ),
+ _ignoreable(true),
+ _xorSet(false),
+ _acceptsMultipleValues(false)
+{
+ if ( _flag.length() > 1 )
+ throw(SpecificationException(
+ "Argument flag can only be one character long", toString() ) );
+
+ if ( _name != ignoreNameString() &&
+ ( _flag == Arg::flagStartString() ||
+ _flag == Arg::nameStartString() ||
+ _flag == " " ) )
+ throw(SpecificationException("Argument flag cannot be either '" +
+ Arg::flagStartString() + "' or '" +
+ Arg::nameStartString() + "' or a space.",
+ toString() ) );
+
+ if ( ( _name.substr( 0, Arg::flagStartString().length() ) == Arg::flagStartString() ) ||
+ ( _name.substr( 0, Arg::nameStartString().length() ) == Arg::nameStartString() ) ||
+ ( _name.find( " ", 0 ) != std::string::npos ) )
+ throw(SpecificationException("Argument name begin with either '" +
+ Arg::flagStartString() + "' or '" +
+ Arg::nameStartString() + "' or space.",
+ toString() ) );
+
+}
+
+inline Arg::~Arg() { }
+
+inline std::string Arg::shortID( const std::string& valueId ) const
+{
+ std::string id = "";
+
+ if ( _flag != "" )
+ id = Arg::flagStartString() + _flag;
+ else
+ id = Arg::nameStartString() + _name;
+
+ if ( _valueRequired )
+ id += std::string( 1, Arg::delimiter() ) + "<" + valueId + ">";
+
+ if ( !_required )
+ id = "[" + id + "]";
+
+ return id;
+}
+
+inline std::string Arg::longID( const std::string& valueId ) const
+{
+ std::string id = "";
+
+ if ( _flag != "" )
+ {
+ id += Arg::flagStartString() + _flag;
+
+ if ( _valueRequired )
+ id += std::string( 1, Arg::delimiter() ) + "<" + valueId + ">";
+
+ id += ", ";
+ }
+
+ id += Arg::nameStartString() + _name;
+
+ if ( _valueRequired )
+ id += std::string( 1, Arg::delimiter() ) + "<" + valueId + ">";
+
+ return id;
+
+}
+
+inline bool Arg::operator==(const Arg& a) const
+{
+ if ( ( _flag != "" && _flag == a._flag ) || _name == a._name)
+ return true;
+ else
+ return false;
+}
+
+inline std::string Arg::getDescription() const
+{
+ std::string desc = "";
+ if ( _required )
+ desc = "(" + _requireLabel + ") ";
+
+// if ( _valueRequired )
+// desc += "(value required) ";
+
+ desc += _description;
+ return desc;
+}
+
+inline const std::string& Arg::getFlag() const { return _flag; }
+
+inline const std::string& Arg::getName() const { return _name; }
+
+inline bool Arg::isRequired() const { return _required; }
+
+inline bool Arg::isValueRequired() const { return _valueRequired; }
+
+inline bool Arg::isSet() const
+{
+ if ( _alreadySet && !_xorSet )
+ return true;
+ else
+ return false;
+}
+
+inline bool Arg::isIgnoreable() const { return _ignoreable; }
+
+inline void Arg::setRequireLabel( const std::string& s)
+{
+ _requireLabel = s;
+}
+
+inline bool Arg::argMatches( const std::string& argFlag ) const
+{
+ if ( ( argFlag == Arg::flagStartString() + _flag && _flag != "" ) ||
+ argFlag == Arg::nameStartString() + _name )
+ return true;
+ else
+ return false;
+}
+
+inline std::string Arg::toString() const
+{
+ std::string s = "";
+
+ if ( _flag != "" )
+ s += Arg::flagStartString() + _flag + " ";
+
+ s += "(" + Arg::nameStartString() + _name + ")";
+
+ return s;
+}
+
+inline void Arg::_checkWithVisitor() const
+{
+ if ( _visitor != NULL )
+ _visitor->visit();
+}
+
+/**
+ * Implementation of trimFlag.
+ */
+inline void Arg::trimFlag(std::string& flag, std::string& value) const
+{
+ int stop = 0;
+ for ( int i = 0; static_cast<unsigned int>(i) < flag.length(); i++ )
+ if ( flag[i] == Arg::delimiter() )
+ {
+ stop = i;
+ break;
+ }
+
+ if ( stop > 1 )
+ {
+ value = flag.substr(stop+1);
+ flag = flag.substr(0,stop);
+ }
+
+}
+
+/**
+ * Implementation of _hasBlanks.
+ */
+inline bool Arg::_hasBlanks( const std::string& s ) const
+{
+ for ( int i = 1; static_cast<unsigned int>(i) < s.length(); i++ )
+ if ( s[i] == Arg::blankChar() )
+ return true;
+
+ return false;
+}
+
+inline void Arg::forceRequired()
+{
+ _required = true;
+}
+
+inline void Arg::xorSet()
+{
+ _alreadySet = true;
+ _xorSet = true;
+}
+
+/**
+ * Overridden by Args that need to added to the end of the list.
+ */
+inline void Arg::addToList( std::list<Arg*>& argList ) const
+{
+ argList.push_front( const_cast<Arg*>(this) );
+}
+
+inline bool Arg::allowMore()
+{
+ return false;
+}
+
+inline bool Arg::acceptsMultipleValues()
+{
+ return _acceptsMultipleValues;
+}
+
+inline void Arg::reset()
+{
+ _xorSet = false;
+ _alreadySet = false;
+}
+
+//////////////////////////////////////////////////////////////////////
+//END Arg.cpp
+//////////////////////////////////////////////////////////////////////
+
+} //namespace TCLAP
+
+#endif
+
diff --git a/tclap/include/tclap/ArgException.h b/tclap/include/tclap/ArgException.h
new file mode 100644
index 0000000000000000000000000000000000000000..3411aa9543fe3643053ab2aff7c8994b3a900327
--- /dev/null
+++ b/tclap/include/tclap/ArgException.h
@@ -0,0 +1,200 @@
+// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
+
+/******************************************************************************
+ *
+ * file: ArgException.h
+ *
+ * Copyright (c) 2003, Michael E. Smoot .
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+
+#ifndef TCLAP_ARG_EXCEPTION_H
+#define TCLAP_ARG_EXCEPTION_H
+
+#include <string>
+#include <exception>
+
+namespace TCLAP {
+
+/**
+ * A simple class that defines and argument exception. Should be caught
+ * whenever a CmdLine is created and parsed.
+ */
+class ArgException : public std::exception
+{
+ public:
+
+ /**
+ * Constructor.
+ * \param text - The text of the exception.
+ * \param id - The text identifying the argument source.
+ * \param td - Text describing the type of ArgException it is.
+ * of the exception.
+ */
+ ArgException( const std::string& text = "undefined exception",
+ const std::string& id = "undefined",
+ const std::string& td = "Generic ArgException")
+ : std::exception(),
+ _errorText(text),
+ _argId( id ),
+ _typeDescription(td)
+ { }
+
+ /**
+ * Destructor.
+ */
+ virtual ~ArgException() throw() { }
+
+ /**
+ * Returns the error text.
+ */
+ std::string error() const { return ( _errorText ); }
+
+ /**
+ * Returns the argument id.
+ */
+ std::string argId() const
+ {
+ if ( _argId == "undefined" )
+ return " ";
+ else
+ return ( "Argument: " + _argId );
+ }
+
+ /**
+ * Returns the arg id and error text.
+ */
+ const char* what() const throw()
+ {
+ static std::string ex;
+ ex = _argId + " -- " + _errorText;
+ return ex.c_str();
+ }
+
+ /**
+ * Returns the type of the exception. Used to explain and distinguish
+ * between different child exceptions.
+ */
+ std::string typeDescription() const
+ {
+ return _typeDescription;
+ }
+
+
+ private:
+
+ /**
+ * The text of the exception message.
+ */
+ std::string _errorText;
+
+ /**
+ * The argument related to this exception.
+ */
+ std::string _argId;
+
+ /**
+ * Describes the type of the exception. Used to distinguish
+ * between different child exceptions.
+ */
+ std::string _typeDescription;
+
+};
+
+/**
+ * Thrown from within the child Arg classes when it fails to properly
+ * parse the argument it has been passed.
+ */
+class ArgParseException : public ArgException
+{
+ public:
+ /**
+ * Constructor.
+ * \param text - The text of the exception.
+ * \param id - The text identifying the argument source
+ * of the exception.
+ */
+ ArgParseException( const std::string& text = "undefined exception",
+ const std::string& id = "undefined" )
+ : ArgException( text,
+ id,
+ std::string( "Exception found while parsing " ) +
+ std::string( "the value the Arg has been passed." ))
+ { }
+};
+
+/**
+ * Thrown from CmdLine when the arguments on the command line are not
+ * properly specified, e.g. too many arguments, required argument missing, etc.
+ */
+class CmdLineParseException : public ArgException
+{
+ public:
+ /**
+ * Constructor.
+ * \param text - The text of the exception.
+ * \param id - The text identifying the argument source
+ * of the exception.
+ */
+ CmdLineParseException( const std::string& text = "undefined exception",
+ const std::string& id = "undefined" )
+ : ArgException( text,
+ id,
+ std::string( "Exception found when the values ") +
+ std::string( "on the command line do not meet ") +
+ std::string( "the requirements of the defined ") +
+ std::string( "Args." ))
+ { }
+};
+
+/**
+ * Thrown from Arg and CmdLine when an Arg is improperly specified, e.g.
+ * same flag as another Arg, same name, etc.
+ */
+class SpecificationException : public ArgException
+{
+ public:
+ /**
+ * Constructor.
+ * \param text - The text of the exception.
+ * \param id - The text identifying the argument source
+ * of the exception.
+ */
+ SpecificationException( const std::string& text = "undefined exception",
+ const std::string& id = "undefined" )
+ : ArgException( text,
+ id,
+ std::string("Exception found when an Arg object ")+
+ std::string("is improperly defined by the ") +
+ std::string("developer." ))
+ { }
+
+};
+
+class ExitException {
+public:
+ ExitException(int estat) : _estat(estat) {}
+
+ int getExitStatus() const { return _estat; }
+
+private:
+ int _estat;
+};
+
+} // namespace TCLAP
+
+#endif
+
diff --git a/tclap/include/tclap/ArgTraits.h b/tclap/include/tclap/ArgTraits.h
new file mode 100644
index 0000000000000000000000000000000000000000..0b2c18f70c68200b431794eb6bec28927b6ec9aa
--- /dev/null
+++ b/tclap/include/tclap/ArgTraits.h
@@ -0,0 +1,87 @@
+// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
+
+/******************************************************************************
+ *
+ * file: ArgTraits.h
+ *
+ * Copyright (c) 2007, Daniel Aarno, Michael E. Smoot .
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+// This is an internal tclap file, you should probably not have to
+// include this directly
+
+#ifndef TCLAP_ARGTRAITS_H
+#define TCLAP_ARGTRAITS_H
+
+namespace TCLAP {
+
+// We use two empty structs to get compile type specialization
+// function to work
+
+/**
+ * A value like argument value type is a value that can be set using
+ * operator>>. This is the default value type.
+ */
+struct ValueLike {
+ typedef ValueLike ValueCategory;
+ virtual ~ValueLike() {}
+};
+
+/**
+ * A string like argument value type is a value that can be set using
+ * operator=(string). Usefull if the value type contains spaces which
+ * will be broken up into individual tokens by operator>>.
+ */
+struct StringLike {
+ virtual ~StringLike() {}
+};
+
+/**
+ * A class can inherit from this object to make it have string like
+ * traits. This is a compile time thing and does not add any overhead
+ * to the inherenting class.
+ */
+struct StringLikeTrait {
+ typedef StringLike ValueCategory;
+ virtual ~StringLikeTrait() {}
+};
+
+/**
+ * A class can inherit from this object to make it have value like
+ * traits. This is a compile time thing and does not add any overhead
+ * to the inherenting class.
+ */
+struct ValueLikeTrait {
+ typedef ValueLike ValueCategory;
+ virtual ~ValueLikeTrait() {}
+};
+
+/**
+ * Arg traits are used to get compile type specialization when parsing
+ * argument values. Using an ArgTraits you can specify the way that
+ * values gets assigned to any particular type during parsing. The two
+ * supported types are StringLike and ValueLike.
+ */
+template<typename T>
+struct ArgTraits {
+ typedef typename T::ValueCategory ValueCategory;
+ virtual ~ArgTraits() {}
+ //typedef ValueLike ValueCategory;
+};
+
+#endif
+
+} // namespace
diff --git a/tclap/include/tclap/CmdLine.h b/tclap/include/tclap/CmdLine.h
new file mode 100644
index 0000000000000000000000000000000000000000..aabe3a28e49a53a82f375786ee23ba3ee799eb24
--- /dev/null
+++ b/tclap/include/tclap/CmdLine.h
@@ -0,0 +1,651 @@
+// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
+
+/******************************************************************************
+ *
+ * file: CmdLine.h
+ *
+ * Copyright (c) 2003, Michael E. Smoot .
+ * Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+#ifndef TCLAP_CMDLINE_H
+#define TCLAP_CMDLINE_H
+
+#include <tclap/SwitchArg.h>
+#include <tclap/MultiSwitchArg.h>
+#include <tclap/UnlabeledValueArg.h>
+#include <tclap/UnlabeledMultiArg.h>
+
+#include <tclap/XorHandler.h>
+#include <tclap/HelpVisitor.h>
+#include <tclap/VersionVisitor.h>
+#include <tclap/IgnoreRestVisitor.h>
+
+#include <tclap/CmdLineOutput.h>
+#include <tclap/StdOutput.h>
+
+#include <tclap/Constraint.h>
+#include <tclap/ValuesConstraint.h>
+
+#include <string>
+#include <vector>
+#include <list>
+#include <iostream>
+#include <iomanip>
+#include <algorithm>
+#include <stdlib.h> // Needed for exit(), which isn't defined in some envs.
+
+namespace TCLAP {
+
+template<typename T> void DelPtr(T ptr)
+{
+ delete ptr;
+}
+
+template<typename C> void ClearContainer(C &c)
+{
+ typedef typename C::value_type value_type;
+ std::for_each(c.begin(), c.end(), DelPtr<value_type>);
+ c.clear();
+}
+
+
+/**
+ * The base class that manages the command line definition and passes
+ * along the parsing to the appropriate Arg classes.
+ */
+class CmdLine : public CmdLineInterface
+{
+ protected:
+
+ /**
+ * The list of arguments that will be tested against the
+ * command line.
+ */
+ std::list<Arg*> _argList;
+
+ /**
+ * The name of the program. Set to argv[0].
+ */
+ std::string _progName;
+
+ /**
+ * A message used to describe the program. Used in the usage output.
+ */
+ std::string _message;
+
+ /**
+ * The version to be displayed with the --version switch.
+ */
+ std::string _version;
+
+ /**
+ * The number of arguments that are required to be present on
+ * the command line. This is set dynamically, based on the
+ * Args added to the CmdLine object.
+ */
+ int _numRequired;
+
+ /**
+ * The character that is used to separate the argument flag/name
+ * from the value. Defaults to ' ' (space).
+ */
+ char _delimiter;
+
+ /**
+ * The handler that manages xoring lists of args.
+ */
+ XorHandler _xorHandler;
+
+ /**
+ * A list of Args to be explicitly deleted when the destructor
+ * is called. At the moment, this only includes the three default
+ * Args.
+ */
+ std::list<Arg*> _argDeleteOnExitList;
+
+ /**
+ * A list of Visitors to be explicitly deleted when the destructor
+ * is called. At the moment, these are the Vistors created for the
+ * default Args.
+ */
+ std::list<Visitor*> _visitorDeleteOnExitList;
+
+ /**
+ * Object that handles all output for the CmdLine.
+ */
+ CmdLineOutput* _output;
+
+ /**
+ * Should CmdLine handle parsing exceptions internally?
+ */
+ bool _handleExceptions;
+
+ /**
+ * Throws an exception listing the missing args.
+ */
+ void missingArgsException();
+
+ /**
+ * Checks whether a name/flag string matches entirely matches
+ * the Arg::blankChar. Used when multiple switches are combined
+ * into a single argument.
+ * \param s - The message to be used in the usage.
+ */
+ bool _emptyCombined(const std::string& s);
+
+ /**
+ * Perform a delete ptr; operation on ptr when this object is deleted.
+ */
+ void deleteOnExit(Arg* ptr);
+
+ /**
+ * Perform a delete ptr; operation on ptr when this object is deleted.
+ */
+ void deleteOnExit(Visitor* ptr);
+
+private:
+
+ /**
+ * Prevent accidental copying.
+ */
+ CmdLine(const CmdLine& rhs);
+ CmdLine& operator=(const CmdLine& rhs);
+
+ /**
+ * Encapsulates the code common to the constructors
+ * (which is all of it).
+ */
+ void _constructor();
+
+
+ /**
+ * Is set to true when a user sets the output object. We use this so
+ * that we don't delete objects that are created outside of this lib.
+ */
+ bool _userSetOutput;
+
+ /**
+ * Whether or not to automatically create help and version switches.
+ */
+ bool _helpAndVersion;
+
+ /**
+ * Whether or not to ignore unmatched args.
+ */
+ bool _ignoreUnmatched;
+
+ public:
+
+ /**
+ * Command line constructor. Defines how the arguments will be
+ * parsed.
+ * \param message - The message to be used in the usage
+ * output.
+ * \param delimiter - The character that is used to separate
+ * the argument flag/name from the value. Defaults to ' ' (space).
+ * \param version - The version number to be used in the
+ * --version switch.
+ * \param helpAndVersion - Whether or not to create the Help and
+ * Version switches. Defaults to true.
+ */
+ CmdLine(const std::string& message,
+ const char delimiter = ' ',
+ const std::string& version = "none",
+ bool helpAndVersion = true);
+
+ /**
+ * Deletes any resources allocated by a CmdLine object.
+ */
+ virtual ~CmdLine();
+
+ /**
+ * Adds an argument to the list of arguments to be parsed.
+ * \param a - Argument to be added.
+ */
+ void add( Arg& a );
+
+ /**
+ * An alternative add. Functionally identical.
+ * \param a - Argument to be added.
+ */
+ void add( Arg* a );
+
+ /**
+ * Add two Args that will be xor'd. If this method is used, add does
+ * not need to be called.
+ * \param a - Argument to be added and xor'd.
+ * \param b - Argument to be added and xor'd.
+ */
+ void xorAdd( Arg& a, Arg& b );
+
+ /**
+ * Add a list of Args that will be xor'd. If this method is used,
+ * add does not need to be called.
+ * \param xors - List of Args to be added and xor'd.
+ */
+ void xorAdd( std::vector<Arg*>& xors );
+
+ /**
+ * Parses the command line.
+ * \param argc - Number of arguments.
+ * \param argv - Array of arguments.
+ */
+ void parse(int argc, const char * const * argv);
+
+ /**
+ * Parses the command line.
+ * \param args - A vector of strings representing the args.
+ * args[0] is still the program name.
+ */
+ void parse(std::vector<std::string>& args);
+
+ /**
+ *
+ */
+ CmdLineOutput* getOutput();
+
+ /**
+ *
+ */
+ void setOutput(CmdLineOutput* co);
+
+ /**
+ *
+ */
+ std::string& getVersion();
+
+ /**
+ *
+ */
+ std::string& getProgramName();
+
+ /**
+ *
+ */
+ std::list<Arg*>& getArgList();
+
+ /**
+ *
+ */
+ XorHandler& getXorHandler();
+
+ /**
+ *
+ */
+ char getDelimiter();
+
+ /**
+ *
+ */
+ std::string& getMessage();
+
+ /**
+ *
+ */
+ bool hasHelpAndVersion();
+
+ /**
+ * Disables or enables CmdLine's internal parsing exception handling.
+ *
+ * @param state Should CmdLine handle parsing exceptions internally?
+ */
+ void setExceptionHandling(const bool state);
+
+ /**
+ * Returns the current state of the internal exception handling.
+ *
+ * @retval true Parsing exceptions are handled internally.
+ * @retval false Parsing exceptions are propagated to the caller.
+ */
+ bool getExceptionHandling() const;
+
+ /**
+ * Allows the CmdLine object to be reused.
+ */
+ void reset();
+
+ /**
+ * Allows unmatched args to be ignored. By default false.
+ *
+ * @param ignore If true the cmdline will ignore any unmatched args
+ * and if false it will behave as normal.
+ */
+ void ignoreUnmatched(const bool ignore);
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+//Begin CmdLine.cpp
+///////////////////////////////////////////////////////////////////////////////
+
+inline CmdLine::CmdLine(const std::string& m,
+ char delim,
+ const std::string& v,
+ bool help )
+ :
+ _argList(std::list<Arg*>()),
+ _progName("not_set_yet"),
+ _message(m),
+ _version(v),
+ _numRequired(0),
+ _delimiter(delim),
+ _xorHandler(XorHandler()),
+ _argDeleteOnExitList(std::list<Arg*>()),
+ _visitorDeleteOnExitList(std::list<Visitor*>()),
+ _output(0),
+ _handleExceptions(true),
+ _userSetOutput(false),
+ _helpAndVersion(help),
+ _ignoreUnmatched(false)
+{
+ _constructor();
+}
+
+inline CmdLine::~CmdLine()
+{
+ ClearContainer(_argDeleteOnExitList);
+ ClearContainer(_visitorDeleteOnExitList);
+
+ if ( !_userSetOutput ) {
+ delete _output;
+ _output = 0;
+ }
+}
+
+inline void CmdLine::_constructor()
+{
+ _output = new StdOutput;
+
+ Arg::setDelimiter( _delimiter );
+
+ Visitor* v;
+
+ if ( _helpAndVersion )
+ {
+ v = new HelpVisitor( this, &_output );
+ SwitchArg* help = new SwitchArg("h","help",
+ "Displays usage information and exits.",
+ false, v);
+ add( help );
+ deleteOnExit(help);
+ deleteOnExit(v);
+
+ v = new VersionVisitor( this, &_output );
+ SwitchArg* vers = new SwitchArg("","version",
+ "Displays version information and exits.",
+ false, v);
+ add( vers );
+ deleteOnExit(vers);
+ deleteOnExit(v);
+ }
+
+ v = new IgnoreRestVisitor();
+ SwitchArg* ignore = new SwitchArg(Arg::flagStartString(),
+ Arg::ignoreNameString(),
+ "Ignores the rest of the labeled arguments following this flag.",
+ false, v);
+ add( ignore );
+ deleteOnExit(ignore);
+ deleteOnExit(v);
+}
+
+inline void CmdLine::xorAdd( std::vector<Arg*>& ors )
+{
+ _xorHandler.add( ors );
+
+ for (ArgVectorIterator it = ors.begin(); it != ors.end(); it++)
+ {
+ (*it)->forceRequired();
+ (*it)->setRequireLabel( "OR required" );
+ add( *it );
+ }
+}
+
+inline void CmdLine::xorAdd( Arg& a, Arg& b )
+{
+ std::vector<Arg*> ors;
+ ors.push_back( &a );
+ ors.push_back( &b );
+ xorAdd( ors );
+}
+
+inline void CmdLine::add( Arg& a )
+{
+ add( &a );
+}
+
+inline void CmdLine::add( Arg* a )
+{
+ for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ )
+ if ( *a == *(*it) )
+ throw( SpecificationException(
+ "Argument with same flag/name already exists!",
+ a->longID() ) );
+
+ a->addToList( _argList );
+
+ if ( a->isRequired() )
+ _numRequired++;
+}
+
+
+inline void CmdLine::parse(int argc, const char * const * argv)
+{
+ // this step is necessary so that we have easy access to
+ // mutable strings.
+ std::vector<std::string> args;
+ for (int i = 0; i < argc; i++)
+ args.push_back(argv[i]);
+
+ parse(args);
+}
+
+inline void CmdLine::parse(std::vector<std::string>& args)
+{
+ bool shouldExit = false;
+ int estat = 0;
+
+ try {
+ _progName = args.front();
+ args.erase(args.begin());
+
+ int requiredCount = 0;
+
+ for (int i = 0; static_cast<unsigned int>(i) < args.size(); i++)
+ {
+ bool matched = false;
+ for (ArgListIterator it = _argList.begin();
+ it != _argList.end(); it++) {
+ if ( (*it)->processArg( &i, args ) )
+ {
+ requiredCount += _xorHandler.check( *it );
+ matched = true;
+ break;
+ }
+ }
+
+ // checks to see if the argument is an empty combined
+ // switch and if so, then we've actually matched it
+ if ( !matched && _emptyCombined( args[i] ) )
+ matched = true;
+
+ if ( !matched && !Arg::ignoreRest() && !_ignoreUnmatched)
+ throw(CmdLineParseException("Couldn't find match "
+ "for argument",
+ args[i]));
+ }
+
+ if ( requiredCount < _numRequired )
+ missingArgsException();
+
+ if ( requiredCount > _numRequired )
+ throw(CmdLineParseException("Too many arguments!"));
+
+ } catch ( ArgException& e ) {
+ // If we're not handling the exceptions, rethrow.
+ if ( !_handleExceptions) {
+ throw;
+ }
+
+ try {
+ _output->failure(*this,e);
+ } catch ( ExitException &ee ) {
+ estat = ee.getExitStatus();
+ shouldExit = true;
+ }
+ } catch (ExitException &ee) {
+ // If we're not handling the exceptions, rethrow.
+ if ( !_handleExceptions) {
+ throw;
+ }
+
+ estat = ee.getExitStatus();
+ shouldExit = true;
+ }
+
+ if (shouldExit)
+ exit(estat);
+}
+
+inline bool CmdLine::_emptyCombined(const std::string& s)
+{
+ if ( s.length() > 0 && s[0] != Arg::flagStartChar() )
+ return false;
+
+ for ( int i = 1; static_cast<unsigned int>(i) < s.length(); i++ )
+ if ( s[i] != Arg::blankChar() )
+ return false;
+
+ return true;
+}
+
+inline void CmdLine::missingArgsException()
+{
+ int count = 0;
+
+ std::string missingArgList;
+ for (ArgListIterator it = _argList.begin(); it != _argList.end(); it++)
+ {
+ if ( (*it)->isRequired() && !(*it)->isSet() )
+ {
+ missingArgList += (*it)->getName();
+ missingArgList += ", ";
+ count++;
+ }
+ }
+ missingArgList = missingArgList.substr(0,missingArgList.length()-2);
+
+ std::string msg;
+ if ( count > 1 )
+ msg = "Required arguments missing: ";
+ else
+ msg = "Required argument missing: ";
+
+ msg += missingArgList;
+
+ throw(CmdLineParseException(msg));
+}
+
+inline void CmdLine::deleteOnExit(Arg* ptr)
+{
+ _argDeleteOnExitList.push_back(ptr);
+}
+
+inline void CmdLine::deleteOnExit(Visitor* ptr)
+{
+ _visitorDeleteOnExitList.push_back(ptr);
+}
+
+inline CmdLineOutput* CmdLine::getOutput()
+{
+ return _output;
+}
+
+inline void CmdLine::setOutput(CmdLineOutput* co)
+{
+ if ( !_userSetOutput )
+ delete _output;
+ _userSetOutput = true;
+ _output = co;
+}
+
+inline std::string& CmdLine::getVersion()
+{
+ return _version;
+}
+
+inline std::string& CmdLine::getProgramName()
+{
+ return _progName;
+}
+
+inline std::list<Arg*>& CmdLine::getArgList()
+{
+ return _argList;
+}
+
+inline XorHandler& CmdLine::getXorHandler()
+{
+ return _xorHandler;
+}
+
+inline char CmdLine::getDelimiter()
+{
+ return _delimiter;
+}
+
+inline std::string& CmdLine::getMessage()
+{
+ return _message;
+}
+
+inline bool CmdLine::hasHelpAndVersion()
+{
+ return _helpAndVersion;
+}
+
+inline void CmdLine::setExceptionHandling(const bool state)
+{
+ _handleExceptions = state;
+}
+
+inline bool CmdLine::getExceptionHandling() const
+{
+ return _handleExceptions;
+}
+
+inline void CmdLine::reset()
+{
+ for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ )
+ (*it)->reset();
+
+ _progName.clear();
+}
+
+inline void CmdLine::ignoreUnmatched(const bool ignore)
+{
+ _ignoreUnmatched = ignore;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//End CmdLine.cpp
+///////////////////////////////////////////////////////////////////////////////
+
+
+
+} //namespace TCLAP
+#endif
diff --git a/tclap/include/tclap/CmdLineInterface.h b/tclap/include/tclap/CmdLineInterface.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b25e9b8c950a29988bd510c9f3b3a2a6b1b3b58
--- /dev/null
+++ b/tclap/include/tclap/CmdLineInterface.h
@@ -0,0 +1,150 @@
+
+/******************************************************************************
+ *
+ * file: CmdLineInterface.h
+ *
+ * Copyright (c) 2003, Michael E. Smoot .
+ * Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+#ifndef TCLAP_COMMANDLINE_INTERFACE_H
+#define TCLAP_COMMANDLINE_INTERFACE_H
+
+#include <string>
+#include <vector>
+#include <list>
+#include <iostream>
+#include <algorithm>
+
+
+namespace TCLAP {
+
+class Arg;
+class CmdLineOutput;
+class XorHandler;
+
+/**
+ * The base class that manages the command line definition and passes
+ * along the parsing to the appropriate Arg classes.
+ */
+class CmdLineInterface
+{
+ public:
+
+ /**
+ * Destructor
+ */
+ virtual ~CmdLineInterface() {}
+
+ /**
+ * Adds an argument to the list of arguments to be parsed.
+ * \param a - Argument to be added.
+ */
+ virtual void add( Arg& a )=0;
+
+ /**
+ * An alternative add. Functionally identical.
+ * \param a - Argument to be added.
+ */
+ virtual void add( Arg* a )=0;
+
+ /**
+ * Add two Args that will be xor'd.
+ * If this method is used, add does
+ * not need to be called.
+ * \param a - Argument to be added and xor'd.
+ * \param b - Argument to be added and xor'd.
+ */
+ virtual void xorAdd( Arg& a, Arg& b )=0;
+
+ /**
+ * Add a list of Args that will be xor'd. If this method is used,
+ * add does not need to be called.
+ * \param xors - List of Args to be added and xor'd.
+ */
+ virtual void xorAdd( std::vector<Arg*>& xors )=0;
+
+ /**
+ * Parses the command line.
+ * \param argc - Number of arguments.
+ * \param argv - Array of arguments.
+ */
+ virtual void parse(int argc, const char * const * argv)=0;
+
+ /**
+ * Parses the command line.
+ * \param args - A vector of strings representing the args.
+ * args[0] is still the program name.
+ */
+ void parse(std::vector<std::string>& args);
+
+ /**
+ * Returns the CmdLineOutput object.
+ */
+ virtual CmdLineOutput* getOutput()=0;
+
+ /**
+ * \param co - CmdLineOutput object that we want to use instead.
+ */
+ virtual void setOutput(CmdLineOutput* co)=0;
+
+ /**
+ * Returns the version string.
+ */
+ virtual std::string& getVersion()=0;
+
+ /**
+ * Returns the program name string.
+ */
+ virtual std::string& getProgramName()=0;
+
+ /**
+ * Returns the argList.
+ */
+ virtual std::list<Arg*>& getArgList()=0;
+
+ /**
+ * Returns the XorHandler.
+ */
+ virtual XorHandler& getXorHandler()=0;
+
+ /**
+ * Returns the delimiter string.
+ */
+ virtual char getDelimiter()=0;
+
+ /**
+ * Returns the message string.
+ */
+ virtual std::string& getMessage()=0;
+
+ /**
+ * Indicates whether or not the help and version switches were created
+ * automatically.
+ */
+ virtual bool hasHelpAndVersion()=0;
+
+ /**
+ * Resets the instance as if it had just been constructed so that the
+ * instance can be reused.
+ */
+ virtual void reset()=0;
+};
+
+} //namespace
+
+
+#endif
diff --git a/tclap/include/tclap/CmdLineOutput.h b/tclap/include/tclap/CmdLineOutput.h
new file mode 100644
index 0000000000000000000000000000000000000000..71ee5a3b418b4d3aaf7b2bdfd30282bc5d4e0e3b
--- /dev/null
+++ b/tclap/include/tclap/CmdLineOutput.h
@@ -0,0 +1,74 @@
+
+
+/******************************************************************************
+ *
+ * file: CmdLineOutput.h
+ *
+ * Copyright (c) 2004, Michael E. Smoot
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+#ifndef TCLAP_CMDLINEOUTPUT_H
+#define TCLAP_CMDLINEOUTPUT_H
+
+#include <string>
+#include <vector>
+#include <list>
+#include <iostream>
+#include <iomanip>
+#include <algorithm>
+
+namespace TCLAP {
+
+class CmdLineInterface;
+class ArgException;
+
+/**
+ * The interface that any output object must implement.
+ */
+class CmdLineOutput
+{
+
+ public:
+
+ /**
+ * Virtual destructor.
+ */
+ virtual ~CmdLineOutput() {}
+
+ /**
+ * Generates some sort of output for the USAGE.
+ * \param c - The CmdLine object the output is generated for.
+ */
+ virtual void usage(CmdLineInterface& c)=0;
+
+ /**
+ * Generates some sort of output for the version.
+ * \param c - The CmdLine object the output is generated for.
+ */
+ virtual void version(CmdLineInterface& c)=0;
+
+ /**
+ * Generates some sort of output for a failure.
+ * \param c - The CmdLine object the output is generated for.
+ * \param e - The ArgException that caused the failure.
+ */
+ virtual void failure( CmdLineInterface& c,
+ ArgException& e )=0;
+
+};
+
+} //namespace TCLAP
+#endif
diff --git a/tclap/include/tclap/Constraint.h b/tclap/include/tclap/Constraint.h
new file mode 100644
index 0000000000000000000000000000000000000000..a92acf9a9a29e5b15f655b3d0caa6d280193f60d
--- /dev/null
+++ b/tclap/include/tclap/Constraint.h
@@ -0,0 +1,68 @@
+
+/******************************************************************************
+ *
+ * file: Constraint.h
+ *
+ * Copyright (c) 2005, Michael E. Smoot
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+#ifndef TCLAP_CONSTRAINT_H
+#define TCLAP_CONSTRAINT_H
+
+#include <string>
+#include <vector>
+#include <list>
+#include <iostream>
+#include <iomanip>
+#include <algorithm>
+
+namespace TCLAP {
+
+/**
+ * The interface that defines the interaction between the Arg and Constraint.
+ */
+template<class T>
+class Constraint
+{
+
+ public:
+ /**
+ * Returns a description of the Constraint.
+ */
+ virtual std::string description() const =0;
+
+ /**
+ * Returns the short ID for the Constraint.
+ */
+ virtual std::string shortID() const =0;
+
+ /**
+ * The method used to verify that the value parsed from the command
+ * line meets the constraint.
+ * \param value - The value that will be checked.
+ */
+ virtual bool check(const T& value) const =0;
+
+ /**
+ * Destructor.
+ * Silences warnings about Constraint being a base class with virtual
+ * functions but without a virtual destructor.
+ */
+ virtual ~Constraint() { ; }
+};
+
+} //namespace TCLAP
+#endif
diff --git a/tclap/include/tclap/DocBookOutput.h b/tclap/include/tclap/DocBookOutput.h
new file mode 100644
index 0000000000000000000000000000000000000000..a42ca274dfbb4648adb62962773310e902151973
--- /dev/null
+++ b/tclap/include/tclap/DocBookOutput.h
@@ -0,0 +1,299 @@
+// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
+
+/******************************************************************************
+ *
+ * file: DocBookOutput.h
+ *
+ * Copyright (c) 2004, Michael E. Smoot
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+#ifndef TCLAP_DOCBOOKOUTPUT_H
+#define TCLAP_DOCBOOKOUTPUT_H
+
+#include <string>
+#include <vector>
+#include <list>
+#include <iostream>
+#include <algorithm>
+
+#include <tclap/CmdLineInterface.h>
+#include <tclap/CmdLineOutput.h>
+#include <tclap/XorHandler.h>
+#include <tclap/Arg.h>
+
+namespace TCLAP {
+
+/**
+ * A class that generates DocBook output for usage() method for the
+ * given CmdLine and its Args.
+ */
+class DocBookOutput : public CmdLineOutput
+{
+
+ public:
+
+ /**
+ * Prints the usage to stdout. Can be overridden to
+ * produce alternative behavior.
+ * \param c - The CmdLine object the output is generated for.
+ */
+ virtual void usage(CmdLineInterface& c);
+
+ /**
+ * Prints the version to stdout. Can be overridden
+ * to produce alternative behavior.
+ * \param c - The CmdLine object the output is generated for.
+ */
+ virtual void version(CmdLineInterface& c);
+
+ /**
+ * Prints (to stderr) an error message, short usage
+ * Can be overridden to produce alternative behavior.
+ * \param c - The CmdLine object the output is generated for.
+ * \param e - The ArgException that caused the failure.
+ */
+ virtual void failure(CmdLineInterface& c,
+ ArgException& e );
+
+ protected:
+
+ /**
+ * Substitutes the char r for string x in string s.
+ * \param s - The string to operate on.
+ * \param r - The char to replace.
+ * \param x - What to replace r with.
+ */
+ void substituteSpecialChars( std::string& s, char r, std::string& x );
+ void removeChar( std::string& s, char r);
+ void basename( std::string& s );
+
+ void printShortArg(Arg* it);
+ void printLongArg(Arg* it);
+
+ char theDelimiter;
+};
+
+
+inline void DocBookOutput::version(CmdLineInterface& _cmd)
+{
+ std::cout << _cmd.getVersion() << std::endl;
+}
+
+inline void DocBookOutput::usage(CmdLineInterface& _cmd )
+{
+ std::list<Arg*> argList = _cmd.getArgList();
+ std::string progName = _cmd.getProgramName();
+ std::string xversion = _cmd.getVersion();
+ theDelimiter = _cmd.getDelimiter();
+ XorHandler xorHandler = _cmd.getXorHandler();
+ std::vector< std::vector<Arg*> > xorList = xorHandler.getXorList();
+ basename(progName);
+
+ std::cout << "<?xml version='1.0'?>" << std::endl;
+ std::cout << "<!DOCTYPE refentry PUBLIC \"-//OASIS//DTD DocBook XML V4.2//EN\"" << std::endl;
+ std::cout << "\t\"http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd\">" << std::endl << std::endl;
+
+ std::cout << "<refentry>" << std::endl;
+
+ std::cout << "<refmeta>" << std::endl;
+ std::cout << "<refentrytitle>" << progName << "</refentrytitle>" << std::endl;
+ std::cout << "<manvolnum>1</manvolnum>" << std::endl;
+ std::cout << "</refmeta>" << std::endl;
+
+ std::cout << "<refnamediv>" << std::endl;
+ std::cout << "<refname>" << progName << "</refname>" << std::endl;
+ std::cout << "<refpurpose>" << _cmd.getMessage() << "</refpurpose>" << std::endl;
+ std::cout << "</refnamediv>" << std::endl;
+
+ std::cout << "<refsynopsisdiv>" << std::endl;
+ std::cout << "<cmdsynopsis>" << std::endl;
+
+ std::cout << "<command>" << progName << "</command>" << std::endl;
+
+ // xor
+ for ( int i = 0; (unsigned int)i < xorList.size(); i++ )
+ {
+ std::cout << "<group choice='req'>" << std::endl;
+ for ( ArgVectorIterator it = xorList[i].begin();
+ it != xorList[i].end(); it++ )
+ printShortArg((*it));
+
+ std::cout << "</group>" << std::endl;
+ }
+
+ // rest of args
+ for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
+ if ( !xorHandler.contains( (*it) ) )
+ printShortArg((*it));
+
+ std::cout << "</cmdsynopsis>" << std::endl;
+ std::cout << "</refsynopsisdiv>" << std::endl;
+
+ std::cout << "<refsect1>" << std::endl;
+ std::cout << "<title>Description</title>" << std::endl;
+ std::cout << "<para>" << std::endl;
+ std::cout << _cmd.getMessage() << std::endl;
+ std::cout << "</para>" << std::endl;
+ std::cout << "</refsect1>" << std::endl;
+
+ std::cout << "<refsect1>" << std::endl;
+ std::cout << "<title>Options</title>" << std::endl;
+
+ std::cout << "<variablelist>" << std::endl;
+
+ for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
+ printLongArg((*it));
+
+ std::cout << "</variablelist>" << std::endl;
+ std::cout << "</refsect1>" << std::endl;
+
+ std::cout << "<refsect1>" << std::endl;
+ std::cout << "<title>Version</title>" << std::endl;
+ std::cout << "<para>" << std::endl;
+ std::cout << xversion << std::endl;
+ std::cout << "</para>" << std::endl;
+ std::cout << "</refsect1>" << std::endl;
+
+ std::cout << "</refentry>" << std::endl;
+
+}
+
+inline void DocBookOutput::failure( CmdLineInterface& _cmd,
+ ArgException& e )
+{
+ static_cast<void>(_cmd); // unused
+ std::cout << e.what() << std::endl;
+ throw ExitException(1);
+}
+
+inline void DocBookOutput::substituteSpecialChars( std::string& s,
+ char r,
+ std::string& x )
+{
+ size_t p;
+ while ( (p = s.find_first_of(r)) != std::string::npos )
+ {
+ s.erase(p,1);
+ s.insert(p,x);
+ }
+}
+
+inline void DocBookOutput::removeChar( std::string& s, char r)
+{
+ size_t p;
+ while ( (p = s.find_first_of(r)) != std::string::npos )
+ {
+ s.erase(p,1);
+ }
+}
+
+inline void DocBookOutput::basename( std::string& s )
+{
+ size_t p = s.find_last_of('/');
+ if ( p != std::string::npos )
+ {
+ s.erase(0, p + 1);
+ }
+}
+
+inline void DocBookOutput::printShortArg(Arg* a)
+{
+ std::string lt = "<";
+ std::string gt = ">";
+
+ std::string id = a->shortID();
+ substituteSpecialChars(id,'<',lt);
+ substituteSpecialChars(id,'>',gt);
+ removeChar(id,'[');
+ removeChar(id,']');
+
+ std::string choice = "opt";
+ if ( a->isRequired() )
+ choice = "plain";
+
+ std::cout << "<arg choice='" << choice << '\'';
+ if ( a->acceptsMultipleValues() )
+ std::cout << " rep='repeat'";
+
+
+ std::cout << '>';
+ if ( !a->getFlag().empty() )
+ std::cout << a->flagStartChar() << a->getFlag();
+ else
+ std::cout << a->nameStartString() << a->getName();
+ if ( a->isValueRequired() )
+ {
+ std::string arg = a->shortID();
+ removeChar(arg,'[');
+ removeChar(arg,']');
+ removeChar(arg,'<');
+ removeChar(arg,'>');
+ arg.erase(0, arg.find_last_of(theDelimiter) + 1);
+ std::cout << theDelimiter;
+ std::cout << "<replaceable>" << arg << "</replaceable>";
+ }
+ std::cout << "</arg>" << std::endl;
+
+}
+
+inline void DocBookOutput::printLongArg(Arg* a)
+{
+ std::string lt = "<";
+ std::string gt = ">";
+
+ std::string desc = a->getDescription();
+ substituteSpecialChars(desc,'<',lt);
+ substituteSpecialChars(desc,'>',gt);
+
+ std::cout << "<varlistentry>" << std::endl;
+
+ if ( !a->getFlag().empty() )
+ {
+ std::cout << "<term>" << std::endl;
+ std::cout << "<option>";
+ std::cout << a->flagStartChar() << a->getFlag();
+ std::cout << "</option>" << std::endl;
+ std::cout << "</term>" << std::endl;
+ }
+
+ std::cout << "<term>" << std::endl;
+ std::cout << "<option>";
+ std::cout << a->nameStartString() << a->getName();
+ if ( a->isValueRequired() )
+ {
+ std::string arg = a->shortID();
+ removeChar(arg,'[');
+ removeChar(arg,']');
+ removeChar(arg,'<');
+ removeChar(arg,'>');
+ arg.erase(0, arg.find_last_of(theDelimiter) + 1);
+ std::cout << theDelimiter;
+ std::cout << "<replaceable>" << arg << "</replaceable>";
+ }
+ std::cout << "</option>" << std::endl;
+ std::cout << "</term>" << std::endl;
+
+ std::cout << "<listitem>" << std::endl;
+ std::cout << "<para>" << std::endl;
+ std::cout << desc << std::endl;
+ std::cout << "</para>" << std::endl;
+ std::cout << "</listitem>" << std::endl;
+
+ std::cout << "</varlistentry>" << std::endl;
+}
+
+} //namespace TCLAP
+#endif
diff --git a/tclap/include/tclap/HelpVisitor.h b/tclap/include/tclap/HelpVisitor.h
new file mode 100644
index 0000000000000000000000000000000000000000..cc3bd070cad5903ea67b15ae38ed5d605c5ac694
--- /dev/null
+++ b/tclap/include/tclap/HelpVisitor.h
@@ -0,0 +1,76 @@
+
+/******************************************************************************
+ *
+ * file: HelpVisitor.h
+ *
+ * Copyright (c) 2003, Michael E. Smoot .
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+#ifndef TCLAP_HELP_VISITOR_H
+#define TCLAP_HELP_VISITOR_H
+
+#include <tclap/CmdLineInterface.h>
+#include <tclap/CmdLineOutput.h>
+#include <tclap/Visitor.h>
+
+namespace TCLAP {
+
+/**
+ * A Visitor object that calls the usage method of the given CmdLineOutput
+ * object for the specified CmdLine object.
+ */
+class HelpVisitor: public Visitor
+{
+ private:
+ /**
+ * Prevent accidental copying.
+ */
+ HelpVisitor(const HelpVisitor& rhs);
+ HelpVisitor& operator=(const HelpVisitor& rhs);
+
+ protected:
+
+ /**
+ * The CmdLine the output will be generated for.
+ */
+ CmdLineInterface* _cmd;
+
+ /**
+ * The output object.
+ */
+ CmdLineOutput** _out;
+
+ public:
+
+ /**
+ * Constructor.
+ * \param cmd - The CmdLine the output will be generated for.
+ * \param out - The type of output.
+ */
+ HelpVisitor(CmdLineInterface* cmd, CmdLineOutput** out)
+ : Visitor(), _cmd( cmd ), _out( out ) { }
+
+ /**
+ * Calls the usage method of the CmdLineOutput for the
+ * specified CmdLine.
+ */
+ void visit() { (*_out)->usage(*_cmd); throw ExitException(0); }
+
+};
+
+}
+
+#endif
diff --git a/tclap/include/tclap/IgnoreRestVisitor.h b/tclap/include/tclap/IgnoreRestVisitor.h
new file mode 100644
index 0000000000000000000000000000000000000000..e328649e511eb737e098e411e17552dbc3da1b73
--- /dev/null
+++ b/tclap/include/tclap/IgnoreRestVisitor.h
@@ -0,0 +1,52 @@
+
+/******************************************************************************
+ *
+ * file: IgnoreRestVisitor.h
+ *
+ * Copyright (c) 2003, Michael E. Smoot .
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+
+#ifndef TCLAP_IGNORE_REST_VISITOR_H
+#define TCLAP_IGNORE_REST_VISITOR_H
+
+#include <tclap/Visitor.h>
+#include <tclap/Arg.h>
+
+namespace TCLAP {
+
+/**
+ * A Vistor that tells the CmdLine to begin ignoring arguments after
+ * this one is parsed.
+ */
+class IgnoreRestVisitor: public Visitor
+{
+ public:
+
+ /**
+ * Constructor.
+ */
+ IgnoreRestVisitor() : Visitor() {}
+
+ /**
+ * Sets Arg::_ignoreRest.
+ */
+ void visit() { Arg::beginIgnoring(); }
+};
+
+}
+
+#endif
diff --git a/tclap/include/tclap/Makefile.am b/tclap/include/tclap/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..0e247bf5bf317de4a0e1a40270598092c56d95fc
--- /dev/null
+++ b/tclap/include/tclap/Makefile.am
@@ -0,0 +1,28 @@
+
+libtclapincludedir = $(includedir)/tclap
+
+libtclapinclude_HEADERS = \
+ CmdLineInterface.h \
+ ArgException.h \
+ CmdLine.h \
+ XorHandler.h \
+ MultiArg.h \
+ UnlabeledMultiArg.h \
+ ValueArg.h \
+ UnlabeledValueArg.h \
+ Visitor.h Arg.h \
+ HelpVisitor.h \
+ SwitchArg.h \
+ MultiSwitchArg.h \
+ VersionVisitor.h \
+ IgnoreRestVisitor.h \
+ CmdLineOutput.h \
+ StdOutput.h \
+ DocBookOutput.h \
+ ZshCompletionOutput.h \
+ OptionalUnlabeledTracker.h \
+ Constraint.h \
+ ValuesConstraint.h \
+ ArgTraits.h \
+ StandardTraits.h
+
diff --git a/tclap/include/tclap/MultiArg.h b/tclap/include/tclap/MultiArg.h
new file mode 100644
index 0000000000000000000000000000000000000000..34bb2d7895269cb676ff06b792bb914c79b5cc91
--- /dev/null
+++ b/tclap/include/tclap/MultiArg.h
@@ -0,0 +1,433 @@
+/******************************************************************************
+ *
+ * file: MultiArg.h
+ *
+ * Copyright (c) 2003, Michael E. Smoot .
+ * Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+
+#ifndef TCLAP_MULTIPLE_ARGUMENT_H
+#define TCLAP_MULTIPLE_ARGUMENT_H
+
+#include <string>
+#include <vector>
+
+#include <tclap/Arg.h>
+#include <tclap/Constraint.h>
+
+namespace TCLAP {
+/**
+ * An argument that allows multiple values of type T to be specified. Very
+ * similar to a ValueArg, except a vector of values will be returned
+ * instead of just one.
+ */
+template<class T>
+class MultiArg : public Arg
+{
+public:
+ typedef std::vector<T> container_type;
+ typedef typename container_type::iterator iterator;
+ typedef typename container_type::const_iterator const_iterator;
+
+protected:
+
+ /**
+ * The list of values parsed from the CmdLine.
+ */
+ std::vector<T> _values;
+
+ /**
+ * The description of type T to be used in the usage.
+ */
+ std::string _typeDesc;
+
+ /**
+ * A list of constraint on this Arg.
+ */
+ Constraint<T>* _constraint;
+
+ /**
+ * Extracts the value from the string.
+ * Attempts to parse string as type T, if this fails an exception
+ * is thrown.
+ * \param val - The string to be read.
+ */
+ void _extractValue( const std::string& val );
+
+ /**
+ * Used by XorHandler to decide whether to keep parsing for this arg.
+ */
+ bool _allowMore;
+
+public:
+
+ /**
+ * Constructor.
+ * \param flag - The one character flag that identifies this
+ * argument on the command line.
+ * \param name - A one word name for the argument. Can be
+ * used as a long flag on the command line.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param req - Whether the argument is required on the command
+ * line.
+ * \param typeDesc - A short, human readable description of the
+ * type that this object expects. This is used in the generation
+ * of the USAGE statement. The goal is to be helpful to the end user
+ * of the program.
+ * \param v - An optional visitor. You probably should not
+ * use this unless you have a very good reason.
+ */
+ MultiArg( const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ const std::string& typeDesc,
+ Visitor* v = NULL);
+
+ /**
+ * Constructor.
+ * \param flag - The one character flag that identifies this
+ * argument on the command line.
+ * \param name - A one word name for the argument. Can be
+ * used as a long flag on the command line.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param req - Whether the argument is required on the command
+ * line.
+ * \param typeDesc - A short, human readable description of the
+ * type that this object expects. This is used in the generation
+ * of the USAGE statement. The goal is to be helpful to the end user
+ * of the program.
+ * \param parser - A CmdLine parser object to add this Arg to
+ * \param v - An optional visitor. You probably should not
+ * use this unless you have a very good reason.
+ */
+ MultiArg( const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ const std::string& typeDesc,
+ CmdLineInterface& parser,
+ Visitor* v = NULL );
+
+ /**
+ * Constructor.
+ * \param flag - The one character flag that identifies this
+ * argument on the command line.
+ * \param name - A one word name for the argument. Can be
+ * used as a long flag on the command line.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param req - Whether the argument is required on the command
+ * line.
+ * \param constraint - A pointer to a Constraint object used
+ * to constrain this Arg.
+ * \param v - An optional visitor. You probably should not
+ * use this unless you have a very good reason.
+ */
+ MultiArg( const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ Constraint<T>* constraint,
+ Visitor* v = NULL );
+
+ /**
+ * Constructor.
+ * \param flag - The one character flag that identifies this
+ * argument on the command line.
+ * \param name - A one word name for the argument. Can be
+ * used as a long flag on the command line.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param req - Whether the argument is required on the command
+ * line.
+ * \param constraint - A pointer to a Constraint object used
+ * to constrain this Arg.
+ * \param parser - A CmdLine parser object to add this Arg to
+ * \param v - An optional visitor. You probably should not
+ * use this unless you have a very good reason.
+ */
+ MultiArg( const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ Constraint<T>* constraint,
+ CmdLineInterface& parser,
+ Visitor* v = NULL );
+
+ /**
+ * Handles the processing of the argument.
+ * This re-implements the Arg version of this method to set the
+ * _value of the argument appropriately. It knows the difference
+ * between labeled and unlabeled.
+ * \param i - Pointer the the current argument in the list.
+ * \param args - Mutable list of strings. Passed from main().
+ */
+ virtual bool processArg(int* i, std::vector<std::string>& args);
+
+ /**
+ * Returns a vector of type T containing the values parsed from
+ * the command line.
+ */
+ const std::vector<T>& getValue();
+
+ /**
+ * Returns an iterator over the values parsed from the command
+ * line.
+ */
+ const_iterator begin() const { return _values.begin(); }
+
+ /**
+ * Returns the end of the values parsed from the command
+ * line.
+ */
+ const_iterator end() const { return _values.end(); }
+
+ /**
+ * Returns the a short id string. Used in the usage.
+ * \param val - value to be used.
+ */
+ virtual std::string shortID(const std::string& val="val") const;
+
+ /**
+ * Returns the a long id string. Used in the usage.
+ * \param val - value to be used.
+ */
+ virtual std::string longID(const std::string& val="val") const;
+
+ /**
+ * Once we've matched the first value, then the arg is no longer
+ * required.
+ */
+ virtual bool isRequired() const;
+
+ virtual bool allowMore();
+
+ virtual void reset();
+
+private:
+ /**
+ * Prevent accidental copying
+ */
+ MultiArg<T>(const MultiArg<T>& rhs);
+ MultiArg<T>& operator=(const MultiArg<T>& rhs);
+
+};
+
+template<class T>
+MultiArg<T>::MultiArg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ const std::string& typeDesc,
+ Visitor* v) :
+ Arg( flag, name, desc, req, true, v ),
+ _values(std::vector<T>()),
+ _typeDesc( typeDesc ),
+ _constraint( NULL ),
+ _allowMore(false)
+{
+ _acceptsMultipleValues = true;
+}
+
+template<class T>
+MultiArg<T>::MultiArg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ const std::string& typeDesc,
+ CmdLineInterface& parser,
+ Visitor* v)
+: Arg( flag, name, desc, req, true, v ),
+ _values(std::vector<T>()),
+ _typeDesc( typeDesc ),
+ _constraint( NULL ),
+ _allowMore(false)
+{
+ parser.add( this );
+ _acceptsMultipleValues = true;
+}
+
+/**
+ *
+ */
+template<class T>
+MultiArg<T>::MultiArg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ Constraint<T>* constraint,
+ Visitor* v)
+: Arg( flag, name, desc, req, true, v ),
+ _values(std::vector<T>()),
+ _typeDesc( constraint->shortID() ),
+ _constraint( constraint ),
+ _allowMore(false)
+{
+ _acceptsMultipleValues = true;
+}
+
+template<class T>
+MultiArg<T>::MultiArg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ Constraint<T>* constraint,
+ CmdLineInterface& parser,
+ Visitor* v)
+: Arg( flag, name, desc, req, true, v ),
+ _values(std::vector<T>()),
+ _typeDesc( constraint->shortID() ),
+ _constraint( constraint ),
+ _allowMore(false)
+{
+ parser.add( this );
+ _acceptsMultipleValues = true;
+}
+
+template<class T>
+const std::vector<T>& MultiArg<T>::getValue() { return _values; }
+
+template<class T>
+bool MultiArg<T>::processArg(int *i, std::vector<std::string>& args)
+{
+ if ( _ignoreable && Arg::ignoreRest() )
+ return false;
+
+ if ( _hasBlanks( args[*i] ) )
+ return false;
+
+ std::string flag = args[*i];
+ std::string value = "";
+
+ trimFlag( flag, value );
+
+ if ( argMatches( flag ) )
+ {
+ if ( Arg::delimiter() != ' ' && value == "" )
+ throw( ArgParseException(
+ "Couldn't find delimiter for this argument!",
+ toString() ) );
+
+ // always take the first one, regardless of start string
+ if ( value == "" )
+ {
+ (*i)++;
+ if ( static_cast<unsigned int>(*i) < args.size() )
+ _extractValue( args[*i] );
+ else
+ throw( ArgParseException("Missing a value for this argument!",
+ toString() ) );
+ }
+ else
+ _extractValue( value );
+
+ /*
+ // continuing taking the args until we hit one with a start string
+ while ( (unsigned int)(*i)+1 < args.size() &&
+ args[(*i)+1].find_first_of( Arg::flagStartString() ) != 0 &&
+ args[(*i)+1].find_first_of( Arg::nameStartString() ) != 0 )
+ _extractValue( args[++(*i)] );
+ */
+
+ _alreadySet = true;
+ _checkWithVisitor();
+
+ return true;
+ }
+ else
+ return false;
+}
+
+/**
+ *
+ */
+template<class T>
+std::string MultiArg<T>::shortID(const std::string& val) const
+{
+ static_cast<void>(val); // Ignore input, don't warn
+ return Arg::shortID(_typeDesc) + " ... ";
+}
+
+/**
+ *
+ */
+template<class T>
+std::string MultiArg<T>::longID(const std::string& val) const
+{
+ static_cast<void>(val); // Ignore input, don't warn
+ return Arg::longID(_typeDesc) + " (accepted multiple times)";
+}
+
+/**
+ * Once we've matched the first value, then the arg is no longer
+ * required.
+ */
+template<class T>
+bool MultiArg<T>::isRequired() const
+{
+ if ( _required )
+ {
+ if ( _values.size() > 1 )
+ return false;
+ else
+ return true;
+ }
+ else
+ return false;
+
+}
+
+template<class T>
+void MultiArg<T>::_extractValue( const std::string& val )
+{
+ try {
+ T tmp;
+ ExtractValue(tmp, val, typename ArgTraits<T>::ValueCategory());
+ _values.push_back(tmp);
+ } catch( ArgParseException &e) {
+ throw ArgParseException(e.error(), toString());
+ }
+
+ if ( _constraint != NULL )
+ if ( ! _constraint->check( _values.back() ) )
+ throw( CmdLineParseException( "Value '" + val +
+ "' does not meet constraint: " +
+ _constraint->description(),
+ toString() ) );
+}
+
+template<class T>
+bool MultiArg<T>::allowMore()
+{
+ bool am = _allowMore;
+ _allowMore = true;
+ return am;
+}
+
+template<class T>
+void MultiArg<T>::reset()
+{
+ Arg::reset();
+ _values.clear();
+}
+
+} // namespace TCLAP
+
+#endif
diff --git a/tclap/include/tclap/MultiSwitchArg.h b/tclap/include/tclap/MultiSwitchArg.h
new file mode 100644
index 0000000000000000000000000000000000000000..8820b641626ed8dd28fb000211076e37d14f6c33
--- /dev/null
+++ b/tclap/include/tclap/MultiSwitchArg.h
@@ -0,0 +1,216 @@
+
+/******************************************************************************
+*
+* file: MultiSwitchArg.h
+*
+* Copyright (c) 2003, Michael E. Smoot .
+* Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
+* Copyright (c) 2005, Michael E. Smoot, Daniel Aarno, Erik Zeek.
+* All rights reverved.
+*
+* See the file COPYING in the top directory of this distribution for
+* more information.
+*
+* THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+* DEALINGS IN THE SOFTWARE.
+*
+*****************************************************************************/
+
+
+#ifndef TCLAP_MULTI_SWITCH_ARG_H
+#define TCLAP_MULTI_SWITCH_ARG_H
+
+#include <string>
+#include <vector>
+
+#include <tclap/SwitchArg.h>
+
+namespace TCLAP {
+
+/**
+* A multiple switch argument. If the switch is set on the command line, then
+* the getValue method will return the number of times the switch appears.
+*/
+class MultiSwitchArg : public SwitchArg
+{
+ protected:
+
+ /**
+ * The value of the switch.
+ */
+ int _value;
+
+ /**
+ * Used to support the reset() method so that ValueArg can be
+ * reset to their constructed value.
+ */
+ int _default;
+
+ public:
+
+ /**
+ * MultiSwitchArg constructor.
+ * \param flag - The one character flag that identifies this
+ * argument on the command line.
+ * \param name - A one word name for the argument. Can be
+ * used as a long flag on the command line.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param init - Optional. The initial/default value of this Arg.
+ * Defaults to 0.
+ * \param v - An optional visitor. You probably should not
+ * use this unless you have a very good reason.
+ */
+ MultiSwitchArg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ int init = 0,
+ Visitor* v = NULL);
+
+
+ /**
+ * MultiSwitchArg constructor.
+ * \param flag - The one character flag that identifies this
+ * argument on the command line.
+ * \param name - A one word name for the argument. Can be
+ * used as a long flag on the command line.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param parser - A CmdLine parser object to add this Arg to
+ * \param init - Optional. The initial/default value of this Arg.
+ * Defaults to 0.
+ * \param v - An optional visitor. You probably should not
+ * use this unless you have a very good reason.
+ */
+ MultiSwitchArg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ CmdLineInterface& parser,
+ int init = 0,
+ Visitor* v = NULL);
+
+
+ /**
+ * Handles the processing of the argument.
+ * This re-implements the SwitchArg version of this method to set the
+ * _value of the argument appropriately.
+ * \param i - Pointer the the current argument in the list.
+ * \param args - Mutable list of strings. Passed
+ * in from main().
+ */
+ virtual bool processArg(int* i, std::vector<std::string>& args);
+
+ /**
+ * Returns int, the number of times the switch has been set.
+ */
+ int getValue();
+
+ /**
+ * Returns the shortID for this Arg.
+ */
+ std::string shortID(const std::string& val) const;
+
+ /**
+ * Returns the longID for this Arg.
+ */
+ std::string longID(const std::string& val) const;
+
+ void reset();
+
+};
+
+//////////////////////////////////////////////////////////////////////
+//BEGIN MultiSwitchArg.cpp
+//////////////////////////////////////////////////////////////////////
+inline MultiSwitchArg::MultiSwitchArg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ int init,
+ Visitor* v )
+: SwitchArg(flag, name, desc, false, v),
+_value( init ),
+_default( init )
+{ }
+
+inline MultiSwitchArg::MultiSwitchArg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ CmdLineInterface& parser,
+ int init,
+ Visitor* v )
+: SwitchArg(flag, name, desc, false, v),
+_value( init ),
+_default( init )
+{
+ parser.add( this );
+}
+
+inline int MultiSwitchArg::getValue() { return _value; }
+
+inline bool MultiSwitchArg::processArg(int *i, std::vector<std::string>& args)
+{
+ if ( _ignoreable && Arg::ignoreRest() )
+ return false;
+
+ if ( argMatches( args[*i] ))
+ {
+ // so the isSet() method will work
+ _alreadySet = true;
+
+ // Matched argument: increment value.
+ ++_value;
+
+ _checkWithVisitor();
+
+ return true;
+ }
+ else if ( combinedSwitchesMatch( args[*i] ) )
+ {
+ // so the isSet() method will work
+ _alreadySet = true;
+
+ // Matched argument: increment value.
+ ++_value;
+
+ // Check for more in argument and increment value.
+ while ( combinedSwitchesMatch( args[*i] ) )
+ ++_value;
+
+ _checkWithVisitor();
+
+ return false;
+ }
+ else
+ return false;
+}
+
+inline std::string
+MultiSwitchArg::shortID(const std::string& val) const
+{
+ return Arg::shortID(val) + " ... ";
+}
+
+inline std::string
+MultiSwitchArg::longID(const std::string& val) const
+{
+ return Arg::longID(val) + " (accepted multiple times)";
+}
+
+inline void
+MultiSwitchArg::reset()
+{
+ MultiSwitchArg::_value = MultiSwitchArg::_default;
+}
+
+//////////////////////////////////////////////////////////////////////
+//END MultiSwitchArg.cpp
+//////////////////////////////////////////////////////////////////////
+
+} //namespace TCLAP
+
+#endif
diff --git a/tclap/include/tclap/OptionalUnlabeledTracker.h b/tclap/include/tclap/OptionalUnlabeledTracker.h
new file mode 100644
index 0000000000000000000000000000000000000000..8174c5f624b8e208abda65a84aadfbb2da83b10e
--- /dev/null
+++ b/tclap/include/tclap/OptionalUnlabeledTracker.h
@@ -0,0 +1,62 @@
+
+
+/******************************************************************************
+ *
+ * file: OptionalUnlabeledTracker.h
+ *
+ * Copyright (c) 2005, Michael E. Smoot .
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+
+#ifndef TCLAP_OPTIONAL_UNLABELED_TRACKER_H
+#define TCLAP_OPTIONAL_UNLABELED_TRACKER_H
+
+#include <string>
+
+namespace TCLAP {
+
+class OptionalUnlabeledTracker
+{
+
+ public:
+
+ static void check( bool req, const std::string& argName );
+
+ static void gotOptional() { alreadyOptionalRef() = true; }
+
+ static bool& alreadyOptional() { return alreadyOptionalRef(); }
+
+ private:
+
+ static bool& alreadyOptionalRef() { static bool ct = false; return ct; }
+};
+
+
+inline void OptionalUnlabeledTracker::check( bool req, const std::string& argName )
+{
+ if ( OptionalUnlabeledTracker::alreadyOptional() )
+ throw( SpecificationException(
+ "You can't specify ANY Unlabeled Arg following an optional Unlabeled Arg",
+ argName ) );
+
+ if ( !req )
+ OptionalUnlabeledTracker::gotOptional();
+}
+
+
+} // namespace TCLAP
+
+#endif
diff --git a/tclap/include/tclap/StandardTraits.h b/tclap/include/tclap/StandardTraits.h
new file mode 100644
index 0000000000000000000000000000000000000000..46d7f6fafdeda744890e223c13ef3630c9784e72
--- /dev/null
+++ b/tclap/include/tclap/StandardTraits.h
@@ -0,0 +1,208 @@
+// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
+
+/******************************************************************************
+ *
+ * file: StandardTraits.h
+ *
+ * Copyright (c) 2007, Daniel Aarno, Michael E. Smoot .
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+// This is an internal tclap file, you should probably not have to
+// include this directly
+
+#ifndef TCLAP_STANDARD_TRAITS_H
+#define TCLAP_STANDARD_TRAITS_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h> // To check for long long
+#endif
+
+// If Microsoft has already typedef'd wchar_t as an unsigned
+// short, then compiles will break because it's as if we're
+// creating ArgTraits twice for unsigned short. Thus...
+#ifdef _MSC_VER
+#ifndef _NATIVE_WCHAR_T_DEFINED
+#define TCLAP_DONT_DECLARE_WCHAR_T_ARGTRAITS
+#endif
+#endif
+
+namespace TCLAP {
+
+// ======================================================================
+// Integer types
+// ======================================================================
+
+/**
+ * longs have value-like semantics.
+ */
+template<>
+struct ArgTraits<long> {
+ typedef ValueLike ValueCategory;
+};
+
+/**
+ * ints have value-like semantics.
+ */
+template<>
+struct ArgTraits<int> {
+ typedef ValueLike ValueCategory;
+};
+
+/**
+ * shorts have value-like semantics.
+ */
+template<>
+struct ArgTraits<short> {
+ typedef ValueLike ValueCategory;
+};
+
+/**
+ * chars have value-like semantics.
+ */
+template<>
+struct ArgTraits<char> {
+ typedef ValueLike ValueCategory;
+};
+
+#ifdef HAVE_LONG_LONG
+/**
+ * long longs have value-like semantics.
+ */
+template<>
+struct ArgTraits<long long> {
+ typedef ValueLike ValueCategory;
+};
+#endif
+
+// ======================================================================
+// Unsigned integer types
+// ======================================================================
+
+/**
+ * unsigned longs have value-like semantics.
+ */
+template<>
+struct ArgTraits<unsigned long> {
+ typedef ValueLike ValueCategory;
+};
+
+/**
+ * unsigned ints have value-like semantics.
+ */
+template<>
+struct ArgTraits<unsigned int> {
+ typedef ValueLike ValueCategory;
+};
+
+/**
+ * unsigned shorts have value-like semantics.
+ */
+template<>
+struct ArgTraits<unsigned short> {
+ typedef ValueLike ValueCategory;
+};
+
+/**
+ * unsigned chars have value-like semantics.
+ */
+template<>
+struct ArgTraits<unsigned char> {
+ typedef ValueLike ValueCategory;
+};
+
+// Microsoft implements size_t awkwardly.
+#if defined(_MSC_VER) && defined(_M_X64)
+/**
+ * size_ts have value-like semantics.
+ */
+template<>
+struct ArgTraits<size_t> {
+ typedef ValueLike ValueCategory;
+};
+#endif
+
+
+#ifdef HAVE_LONG_LONG
+/**
+ * unsigned long longs have value-like semantics.
+ */
+template<>
+struct ArgTraits<unsigned long long> {
+ typedef ValueLike ValueCategory;
+};
+#endif
+
+// ======================================================================
+// Float types
+// ======================================================================
+
+/**
+ * floats have value-like semantics.
+ */
+template<>
+struct ArgTraits<float> {
+ typedef ValueLike ValueCategory;
+};
+
+/**
+ * doubles have value-like semantics.
+ */
+template<>
+struct ArgTraits<double> {
+ typedef ValueLike ValueCategory;
+};
+
+// ======================================================================
+// Other types
+// ======================================================================
+
+/**
+ * bools have value-like semantics.
+ */
+template<>
+struct ArgTraits<bool> {
+ typedef ValueLike ValueCategory;
+};
+
+
+/**
+ * wchar_ts have value-like semantics.
+ */
+#ifndef TCLAP_DONT_DECLARE_WCHAR_T_ARGTRAITS
+template<>
+struct ArgTraits<wchar_t> {
+ typedef ValueLike ValueCategory;
+};
+#endif
+
+/**
+ * Strings have string like argument traits.
+ */
+template<>
+struct ArgTraits<std::string> {
+ typedef StringLike ValueCategory;
+};
+
+template<typename T>
+void SetString(T &dst, const std::string &src)
+{
+ dst = src;
+}
+
+} // namespace
+
+#endif
+
diff --git a/tclap/include/tclap/StdOutput.h b/tclap/include/tclap/StdOutput.h
new file mode 100644
index 0000000000000000000000000000000000000000..944cff4dd10c24f6df8f9345d15f2e11ea994d11
--- /dev/null
+++ b/tclap/include/tclap/StdOutput.h
@@ -0,0 +1,299 @@
+// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
+
+/******************************************************************************
+ *
+ * file: StdOutput.h
+ *
+ * Copyright (c) 2004, Michael E. Smoot
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+#ifndef TCLAP_STDCMDLINEOUTPUT_H
+#define TCLAP_STDCMDLINEOUTPUT_H
+
+#include <string>
+#include <vector>
+#include <list>
+#include <iostream>
+#include <algorithm>
+
+#include <tclap/CmdLineInterface.h>
+#include <tclap/CmdLineOutput.h>
+#include <tclap/XorHandler.h>
+#include <tclap/Arg.h>
+
+namespace TCLAP {
+
+/**
+ * A class that isolates any output from the CmdLine object so that it
+ * may be easily modified.
+ */
+class StdOutput : public CmdLineOutput
+{
+
+ public:
+
+ /**
+ * Prints the usage to stdout. Can be overridden to
+ * produce alternative behavior.
+ * \param c - The CmdLine object the output is generated for.
+ */
+ virtual void usage(CmdLineInterface& c);
+
+ /**
+ * Prints the version to stdout. Can be overridden
+ * to produce alternative behavior.
+ * \param c - The CmdLine object the output is generated for.
+ */
+ virtual void version(CmdLineInterface& c);
+
+ /**
+ * Prints (to stderr) an error message, short usage
+ * Can be overridden to produce alternative behavior.
+ * \param c - The CmdLine object the output is generated for.
+ * \param e - The ArgException that caused the failure.
+ */
+ virtual void failure(CmdLineInterface& c,
+ ArgException& e );
+
+ protected:
+
+ /**
+ * Writes a brief usage message with short args.
+ * \param c - The CmdLine object the output is generated for.
+ * \param os - The stream to write the message to.
+ */
+ void _shortUsage( CmdLineInterface& c, std::ostream& os ) const;
+
+ /**
+ * Writes a longer usage message with long and short args,
+ * provides descriptions and prints message.
+ * \param c - The CmdLine object the output is generated for.
+ * \param os - The stream to write the message to.
+ */
+ void _longUsage( CmdLineInterface& c, std::ostream& os ) const;
+
+ /**
+ * This function inserts line breaks and indents long strings
+ * according the params input. It will only break lines at spaces,
+ * commas and pipes.
+ * \param os - The stream to be printed to.
+ * \param s - The string to be printed.
+ * \param maxWidth - The maxWidth allowed for the output line.
+ * \param indentSpaces - The number of spaces to indent the first line.
+ * \param secondLineOffset - The number of spaces to indent the second
+ * and all subsequent lines in addition to indentSpaces.
+ */
+ void spacePrint( std::ostream& os,
+ const std::string& s,
+ int maxWidth,
+ int indentSpaces,
+ int secondLineOffset ) const;
+
+};
+
+
+inline void StdOutput::version(CmdLineInterface& _cmd)
+{
+ std::string progName = _cmd.getProgramName();
+ std::string xversion = _cmd.getVersion();
+
+ std::cout << std::endl << progName << " version: "
+ << xversion << std::endl << std::endl;
+}
+
+inline void StdOutput::usage(CmdLineInterface& _cmd )
+{
+ std::cout << std::endl << "USAGE: " << std::endl << std::endl;
+
+ _shortUsage( _cmd, std::cout );
+
+ std::cout << std::endl << std::endl << "Where: " << std::endl << std::endl;
+
+ _longUsage( _cmd, std::cout );
+
+ std::cout << std::endl;
+
+}
+
+inline void StdOutput::failure( CmdLineInterface& _cmd,
+ ArgException& e )
+{
+ std::string progName = _cmd.getProgramName();
+
+ std::cerr << "PARSE ERROR: " << e.argId() << std::endl
+ << " " << e.error() << std::endl << std::endl;
+
+ if ( _cmd.hasHelpAndVersion() )
+ {
+ std::cerr << "Brief USAGE: " << std::endl;
+
+ _shortUsage( _cmd, std::cerr );
+
+ std::cerr << std::endl << "For complete USAGE and HELP type: "
+ << std::endl << " " << progName << " "
+ << Arg::nameStartString() << "help"
+ << std::endl << std::endl;
+ }
+ else
+ usage(_cmd);
+
+ throw ExitException(1);
+}
+
+inline void
+StdOutput::_shortUsage( CmdLineInterface& _cmd,
+ std::ostream& os ) const
+{
+ std::list<Arg*> argList = _cmd.getArgList();
+ std::string progName = _cmd.getProgramName();
+ XorHandler xorHandler = _cmd.getXorHandler();
+ std::vector< std::vector<Arg*> > xorList = xorHandler.getXorList();
+
+ std::string s = progName + " ";
+
+ // first the xor
+ for ( int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++ )
+ {
+ s += " {";
+ for ( ArgVectorIterator it = xorList[i].begin();
+ it != xorList[i].end(); it++ )
+ s += (*it)->shortID() + "|";
+
+ s[s.length()-1] = '}';
+ }
+
+ // then the rest
+ for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
+ if ( !xorHandler.contains( (*it) ) )
+ s += " " + (*it)->shortID();
+
+ // if the program name is too long, then adjust the second line offset
+ int secondLineOffset = static_cast<int>(progName.length()) + 2;
+ if ( secondLineOffset > 75/2 )
+ secondLineOffset = static_cast<int>(75/2);
+
+ spacePrint( os, s, 75, 3, secondLineOffset );
+}
+
+inline void
+StdOutput::_longUsage( CmdLineInterface& _cmd,
+ std::ostream& os ) const
+{
+ std::list<Arg*> argList = _cmd.getArgList();
+ std::string message = _cmd.getMessage();
+ XorHandler xorHandler = _cmd.getXorHandler();
+ std::vector< std::vector<Arg*> > xorList = xorHandler.getXorList();
+
+ // first the xor
+ for ( int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++ )
+ {
+ for ( ArgVectorIterator it = xorList[i].begin();
+ it != xorList[i].end();
+ it++ )
+ {
+ spacePrint( os, (*it)->longID(), 75, 3, 3 );
+ spacePrint( os, (*it)->getDescription(), 75, 5, 0 );
+
+ if ( it+1 != xorList[i].end() )
+ spacePrint(os, "-- OR --", 75, 9, 0);
+ }
+ os << std::endl << std::endl;
+ }
+
+ // then the rest
+ for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
+ if ( !xorHandler.contains( (*it) ) )
+ {
+ spacePrint( os, (*it)->longID(), 75, 3, 3 );
+ spacePrint( os, (*it)->getDescription(), 75, 5, 0 );
+ os << std::endl;
+ }
+
+ os << std::endl;
+
+ spacePrint( os, message, 75, 3, 0 );
+}
+
+inline void StdOutput::spacePrint( std::ostream& os,
+ const std::string& s,
+ int maxWidth,
+ int indentSpaces,
+ int secondLineOffset ) const
+{
+ int len = static_cast<int>(s.length());
+
+ if ( (len + indentSpaces > maxWidth) && maxWidth > 0 )
+ {
+ int allowedLen = maxWidth - indentSpaces;
+ int start = 0;
+ while ( start < len )
+ {
+ // find the substring length
+ // int stringLen = std::min<int>( len - start, allowedLen );
+ // doing it this way to support a VisualC++ 2005 bug
+ using namespace std;
+ int stringLen = min<int>( len - start, allowedLen );
+
+ // trim the length so it doesn't end in middle of a word
+ if ( stringLen == allowedLen )
+ while ( stringLen >= 0 &&
+ s[stringLen+start] != ' ' &&
+ s[stringLen+start] != ',' &&
+ s[stringLen+start] != '|' )
+ stringLen--;
+
+ // ok, the word is longer than the line, so just split
+ // wherever the line ends
+ if ( stringLen <= 0 )
+ stringLen = allowedLen;
+
+ // check for newlines
+ for ( int i = 0; i < stringLen; i++ )
+ if ( s[start+i] == '\n' )
+ stringLen = i+1;
+
+ // print the indent
+ for ( int i = 0; i < indentSpaces; i++ )
+ os << " ";
+
+ if ( start == 0 )
+ {
+ // handle second line offsets
+ indentSpaces += secondLineOffset;
+
+ // adjust allowed len
+ allowedLen -= secondLineOffset;
+ }
+
+ os << s.substr(start,stringLen) << std::endl;
+
+ // so we don't start a line with a space
+ while ( s[stringLen+start] == ' ' && start < len )
+ start++;
+
+ start += stringLen;
+ }
+ }
+ else
+ {
+ for ( int i = 0; i < indentSpaces; i++ )
+ os << " ";
+ os << s << std::endl;
+ }
+}
+
+} //namespace TCLAP
+#endif
diff --git a/tclap/include/tclap/SwitchArg.h b/tclap/include/tclap/SwitchArg.h
new file mode 100644
index 0000000000000000000000000000000000000000..39161090692aebc454b10a330191cce6250a67e2
--- /dev/null
+++ b/tclap/include/tclap/SwitchArg.h
@@ -0,0 +1,266 @@
+
+/******************************************************************************
+ *
+ * file: SwitchArg.h
+ *
+ * Copyright (c) 2003, Michael E. Smoot .
+ * Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+
+#ifndef TCLAP_SWITCH_ARG_H
+#define TCLAP_SWITCH_ARG_H
+
+#include <string>
+#include <vector>
+
+#include <tclap/Arg.h>
+
+namespace TCLAP {
+
+/**
+ * A simple switch argument. If the switch is set on the command line, then
+ * the getValue method will return the opposite of the default value for the
+ * switch.
+ */
+class SwitchArg : public Arg
+{
+ protected:
+
+ /**
+ * The value of the switch.
+ */
+ bool _value;
+
+ /**
+ * Used to support the reset() method so that ValueArg can be
+ * reset to their constructed value.
+ */
+ bool _default;
+
+ public:
+
+ /**
+ * SwitchArg constructor.
+ * \param flag - The one character flag that identifies this
+ * argument on the command line.
+ * \param name - A one word name for the argument. Can be
+ * used as a long flag on the command line.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param def - The default value for this Switch.
+ * \param v - An optional visitor. You probably should not
+ * use this unless you have a very good reason.
+ */
+ SwitchArg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool def = false,
+ Visitor* v = NULL);
+
+
+ /**
+ * SwitchArg constructor.
+ * \param flag - The one character flag that identifies this
+ * argument on the command line.
+ * \param name - A one word name for the argument. Can be
+ * used as a long flag on the command line.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param parser - A CmdLine parser object to add this Arg to
+ * \param def - The default value for this Switch.
+ * \param v - An optional visitor. You probably should not
+ * use this unless you have a very good reason.
+ */
+ SwitchArg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ CmdLineInterface& parser,
+ bool def = false,
+ Visitor* v = NULL);
+
+
+ /**
+ * Handles the processing of the argument.
+ * This re-implements the Arg version of this method to set the
+ * _value of the argument appropriately.
+ * \param i - Pointer the the current argument in the list.
+ * \param args - Mutable list of strings. Passed
+ * in from main().
+ */
+ virtual bool processArg(int* i, std::vector<std::string>& args);
+
+ /**
+ * Checks a string to see if any of the chars in the string
+ * match the flag for this Switch.
+ */
+ bool combinedSwitchesMatch(std::string& combined);
+
+ /**
+ * Returns bool, whether or not the switch has been set.
+ */
+ bool getValue();
+
+ virtual void reset();
+
+ private:
+ /**
+ * Checks to see if we've found the last match in
+ * a combined string.
+ */
+ bool lastCombined(std::string& combined);
+
+ /**
+ * Does the common processing of processArg.
+ */
+ void commonProcessing();
+};
+
+//////////////////////////////////////////////////////////////////////
+//BEGIN SwitchArg.cpp
+//////////////////////////////////////////////////////////////////////
+inline SwitchArg::SwitchArg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool default_val,
+ Visitor* v )
+: Arg(flag, name, desc, false, false, v),
+ _value( default_val ),
+ _default( default_val )
+{ }
+
+inline SwitchArg::SwitchArg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ CmdLineInterface& parser,
+ bool default_val,
+ Visitor* v )
+: Arg(flag, name, desc, false, false, v),
+ _value( default_val ),
+ _default(default_val)
+{
+ parser.add( this );
+}
+
+inline bool SwitchArg::getValue() { return _value; }
+
+inline bool SwitchArg::lastCombined(std::string& combinedSwitches )
+{
+ for ( unsigned int i = 1; i < combinedSwitches.length(); i++ )
+ if ( combinedSwitches[i] != Arg::blankChar() )
+ return false;
+
+ return true;
+}
+
+inline bool SwitchArg::combinedSwitchesMatch(std::string& combinedSwitches )
+{
+ // make sure this is actually a combined switch
+ if ( combinedSwitches.length() > 0 &&
+ combinedSwitches[0] != Arg::flagStartString()[0] )
+ return false;
+
+ // make sure it isn't a long name
+ if ( combinedSwitches.substr( 0, Arg::nameStartString().length() ) ==
+ Arg::nameStartString() )
+ return false;
+
+ // make sure the delimiter isn't in the string
+ if ( combinedSwitches.find_first_of( Arg::delimiter() ) != std::string::npos )
+ return false;
+
+ // ok, we're not specifying a ValueArg, so we know that we have
+ // a combined switch list.
+ for ( unsigned int i = 1; i < combinedSwitches.length(); i++ )
+ if ( _flag.length() > 0 &&
+ combinedSwitches[i] == _flag[0] &&
+ _flag[0] != Arg::flagStartString()[0] )
+ {
+ // update the combined switches so this one is no longer present
+ // this is necessary so that no unlabeled args are matched
+ // later in the processing.
+ //combinedSwitches.erase(i,1);
+ combinedSwitches[i] = Arg::blankChar();
+ return true;
+ }
+
+ // none of the switches passed in the list match.
+ return false;
+}
+
+inline void SwitchArg::commonProcessing()
+{
+ if ( _xorSet )
+ throw(CmdLineParseException(
+ "Mutually exclusive argument already set!", toString()));
+
+ if ( _alreadySet )
+ throw(CmdLineParseException("Argument already set!", toString()));
+
+ _alreadySet = true;
+
+ if ( _value == true )
+ _value = false;
+ else
+ _value = true;
+
+ _checkWithVisitor();
+}
+
+inline bool SwitchArg::processArg(int *i, std::vector<std::string>& args)
+{
+ if ( _ignoreable && Arg::ignoreRest() )
+ return false;
+
+ // if the whole string matches the flag or name string
+ if ( argMatches( args[*i] ) )
+ {
+ commonProcessing();
+
+ return true;
+ }
+ // if a substring matches the flag as part of a combination
+ else if ( combinedSwitchesMatch( args[*i] ) )
+ {
+ // check again to ensure we don't misinterpret
+ // this as a MultiSwitchArg
+ if ( combinedSwitchesMatch( args[*i] ) )
+ throw(CmdLineParseException("Argument already set!",
+ toString()));
+
+ commonProcessing();
+
+ // We only want to return true if we've found the last combined
+ // match in the string, otherwise we return true so that other
+ // switches in the combination will have a chance to match.
+ return lastCombined( args[*i] );
+ }
+ else
+ return false;
+}
+
+inline void SwitchArg::reset()
+{
+ Arg::reset();
+ _value = _default;
+}
+//////////////////////////////////////////////////////////////////////
+//End SwitchArg.cpp
+//////////////////////////////////////////////////////////////////////
+
+} //namespace TCLAP
+
+#endif
diff --git a/tclap/include/tclap/UnlabeledMultiArg.h b/tclap/include/tclap/UnlabeledMultiArg.h
new file mode 100644
index 0000000000000000000000000000000000000000..d5e1781060dceb3fe59c504825fcf888c930f7e8
--- /dev/null
+++ b/tclap/include/tclap/UnlabeledMultiArg.h
@@ -0,0 +1,301 @@
+
+/******************************************************************************
+ *
+ * file: UnlabeledMultiArg.h
+ *
+ * Copyright (c) 2003, Michael E. Smoot.
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+
+#ifndef TCLAP_MULTIPLE_UNLABELED_ARGUMENT_H
+#define TCLAP_MULTIPLE_UNLABELED_ARGUMENT_H
+
+#include <string>
+#include <vector>
+
+#include <tclap/MultiArg.h>
+#include <tclap/OptionalUnlabeledTracker.h>
+
+namespace TCLAP {
+
+/**
+ * Just like a MultiArg, except that the arguments are unlabeled. Basically,
+ * this Arg will slurp up everything that hasn't been matched to another
+ * Arg.
+ */
+template<class T>
+class UnlabeledMultiArg : public MultiArg<T>
+{
+
+ // If compiler has two stage name lookup (as gcc >= 3.4 does)
+ // this is requried to prevent undef. symbols
+ using MultiArg<T>::_ignoreable;
+ using MultiArg<T>::_hasBlanks;
+ using MultiArg<T>::_extractValue;
+ using MultiArg<T>::_typeDesc;
+ using MultiArg<T>::_name;
+ using MultiArg<T>::_description;
+ using MultiArg<T>::_alreadySet;
+ using MultiArg<T>::toString;
+
+ public:
+
+ /**
+ * Constructor.
+ * \param name - The name of the Arg. Note that this is used for
+ * identification, not as a long flag.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param req - Whether the argument is required on the command
+ * line.
+ * \param typeDesc - A short, human readable description of the
+ * type that this object expects. This is used in the generation
+ * of the USAGE statement. The goal is to be helpful to the end user
+ * of the program.
+ * \param ignoreable - Whether or not this argument can be ignored
+ * using the "--" flag.
+ * \param v - An optional visitor. You probably should not
+ * use this unless you have a very good reason.
+ */
+ UnlabeledMultiArg( const std::string& name,
+ const std::string& desc,
+ bool req,
+ const std::string& typeDesc,
+ bool ignoreable = false,
+ Visitor* v = NULL );
+ /**
+ * Constructor.
+ * \param name - The name of the Arg. Note that this is used for
+ * identification, not as a long flag.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param req - Whether the argument is required on the command
+ * line.
+ * \param typeDesc - A short, human readable description of the
+ * type that this object expects. This is used in the generation
+ * of the USAGE statement. The goal is to be helpful to the end user
+ * of the program.
+ * \param parser - A CmdLine parser object to add this Arg to
+ * \param ignoreable - Whether or not this argument can be ignored
+ * using the "--" flag.
+ * \param v - An optional visitor. You probably should not
+ * use this unless you have a very good reason.
+ */
+ UnlabeledMultiArg( const std::string& name,
+ const std::string& desc,
+ bool req,
+ const std::string& typeDesc,
+ CmdLineInterface& parser,
+ bool ignoreable = false,
+ Visitor* v = NULL );
+
+ /**
+ * Constructor.
+ * \param name - The name of the Arg. Note that this is used for
+ * identification, not as a long flag.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param req - Whether the argument is required on the command
+ * line.
+ * \param constraint - A pointer to a Constraint object used
+ * to constrain this Arg.
+ * \param ignoreable - Whether or not this argument can be ignored
+ * using the "--" flag.
+ * \param v - An optional visitor. You probably should not
+ * use this unless you have a very good reason.
+ */
+ UnlabeledMultiArg( const std::string& name,
+ const std::string& desc,
+ bool req,
+ Constraint<T>* constraint,
+ bool ignoreable = false,
+ Visitor* v = NULL );
+
+ /**
+ * Constructor.
+ * \param name - The name of the Arg. Note that this is used for
+ * identification, not as a long flag.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param req - Whether the argument is required on the command
+ * line.
+ * \param constraint - A pointer to a Constraint object used
+ * to constrain this Arg.
+ * \param parser - A CmdLine parser object to add this Arg to
+ * \param ignoreable - Whether or not this argument can be ignored
+ * using the "--" flag.
+ * \param v - An optional visitor. You probably should not
+ * use this unless you have a very good reason.
+ */
+ UnlabeledMultiArg( const std::string& name,
+ const std::string& desc,
+ bool req,
+ Constraint<T>* constraint,
+ CmdLineInterface& parser,
+ bool ignoreable = false,
+ Visitor* v = NULL );
+
+ /**
+ * Handles the processing of the argument.
+ * This re-implements the Arg version of this method to set the
+ * _value of the argument appropriately. It knows the difference
+ * between labeled and unlabeled.
+ * \param i - Pointer the the current argument in the list.
+ * \param args - Mutable list of strings. Passed from main().
+ */
+ virtual bool processArg(int* i, std::vector<std::string>& args);
+
+ /**
+ * Returns the a short id string. Used in the usage.
+ * \param val - value to be used.
+ */
+ virtual std::string shortID(const std::string& val="val") const;
+
+ /**
+ * Returns the a long id string. Used in the usage.
+ * \param val - value to be used.
+ */
+ virtual std::string longID(const std::string& val="val") const;
+
+ /**
+ * Opertor ==.
+ * \param a - The Arg to be compared to this.
+ */
+ virtual bool operator==(const Arg& a) const;
+
+ /**
+ * Pushes this to back of list rather than front.
+ * \param argList - The list this should be added to.
+ */
+ virtual void addToList( std::list<Arg*>& argList ) const;
+};
+
+template<class T>
+UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string& name,
+ const std::string& desc,
+ bool req,
+ const std::string& typeDesc,
+ bool ignoreable,
+ Visitor* v)
+: MultiArg<T>("", name, desc, req, typeDesc, v)
+{
+ _ignoreable = ignoreable;
+ OptionalUnlabeledTracker::check(true, toString());
+}
+
+template<class T>
+UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string& name,
+ const std::string& desc,
+ bool req,
+ const std::string& typeDesc,
+ CmdLineInterface& parser,
+ bool ignoreable,
+ Visitor* v)
+: MultiArg<T>("", name, desc, req, typeDesc, v)
+{
+ _ignoreable = ignoreable;
+ OptionalUnlabeledTracker::check(true, toString());
+ parser.add( this );
+}
+
+
+template<class T>
+UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string& name,
+ const std::string& desc,
+ bool req,
+ Constraint<T>* constraint,
+ bool ignoreable,
+ Visitor* v)
+: MultiArg<T>("", name, desc, req, constraint, v)
+{
+ _ignoreable = ignoreable;
+ OptionalUnlabeledTracker::check(true, toString());
+}
+
+template<class T>
+UnlabeledMultiArg<T>::UnlabeledMultiArg(const std::string& name,
+ const std::string& desc,
+ bool req,
+ Constraint<T>* constraint,
+ CmdLineInterface& parser,
+ bool ignoreable,
+ Visitor* v)
+: MultiArg<T>("", name, desc, req, constraint, v)
+{
+ _ignoreable = ignoreable;
+ OptionalUnlabeledTracker::check(true, toString());
+ parser.add( this );
+}
+
+
+template<class T>
+bool UnlabeledMultiArg<T>::processArg(int *i, std::vector<std::string>& args)
+{
+
+ if ( _hasBlanks( args[*i] ) )
+ return false;
+
+ // never ignore an unlabeled multi arg
+
+
+ // always take the first value, regardless of the start string
+ _extractValue( args[(*i)] );
+
+ /*
+ // continue taking args until we hit the end or a start string
+ while ( (unsigned int)(*i)+1 < args.size() &&
+ args[(*i)+1].find_first_of( Arg::flagStartString() ) != 0 &&
+ args[(*i)+1].find_first_of( Arg::nameStartString() ) != 0 )
+ _extractValue( args[++(*i)] );
+ */
+
+ _alreadySet = true;
+
+ return true;
+}
+
+template<class T>
+std::string UnlabeledMultiArg<T>::shortID(const std::string& val) const
+{
+ static_cast<void>(val); // Ignore input, don't warn
+ return std::string("<") + _typeDesc + "> ...";
+}
+
+template<class T>
+std::string UnlabeledMultiArg<T>::longID(const std::string& val) const
+{
+ static_cast<void>(val); // Ignore input, don't warn
+ return std::string("<") + _typeDesc + "> (accepted multiple times)";
+}
+
+template<class T>
+bool UnlabeledMultiArg<T>::operator==(const Arg& a) const
+{
+ if ( _name == a.getName() || _description == a.getDescription() )
+ return true;
+ else
+ return false;
+}
+
+template<class T>
+void UnlabeledMultiArg<T>::addToList( std::list<Arg*>& argList ) const
+{
+ argList.push_back( const_cast<Arg*>(static_cast<const Arg* const>(this)) );
+}
+
+}
+
+#endif
diff --git a/tclap/include/tclap/UnlabeledValueArg.h b/tclap/include/tclap/UnlabeledValueArg.h
new file mode 100644
index 0000000000000000000000000000000000000000..5721d61252f20180c349bb126e582a79f939367b
--- /dev/null
+++ b/tclap/include/tclap/UnlabeledValueArg.h
@@ -0,0 +1,340 @@
+
+/******************************************************************************
+ *
+ * file: UnlabeledValueArg.h
+ *
+ * Copyright (c) 2003, Michael E. Smoot .
+ * Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+
+#ifndef TCLAP_UNLABELED_VALUE_ARGUMENT_H
+#define TCLAP_UNLABELED_VALUE_ARGUMENT_H
+
+#include <string>
+#include <vector>
+
+#include <tclap/ValueArg.h>
+#include <tclap/OptionalUnlabeledTracker.h>
+
+
+namespace TCLAP {
+
+/**
+ * The basic unlabeled argument that parses a value.
+ * This is a template class, which means the type T defines the type
+ * that a given object will attempt to parse when an UnlabeledValueArg
+ * is reached in the list of args that the CmdLine iterates over.
+ */
+template<class T>
+class UnlabeledValueArg : public ValueArg<T>
+{
+
+ // If compiler has two stage name lookup (as gcc >= 3.4 does)
+ // this is requried to prevent undef. symbols
+ using ValueArg<T>::_ignoreable;
+ using ValueArg<T>::_hasBlanks;
+ using ValueArg<T>::_extractValue;
+ using ValueArg<T>::_typeDesc;
+ using ValueArg<T>::_name;
+ using ValueArg<T>::_description;
+ using ValueArg<T>::_alreadySet;
+ using ValueArg<T>::toString;
+
+ public:
+
+ /**
+ * UnlabeledValueArg constructor.
+ * \param name - A one word name for the argument. Note that this is used for
+ * identification, not as a long flag.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param req - Whether the argument is required on the command
+ * line.
+ * \param value - The default value assigned to this argument if it
+ * is not present on the command line.
+ * \param typeDesc - A short, human readable description of the
+ * type that this object expects. This is used in the generation
+ * of the USAGE statement. The goal is to be helpful to the end user
+ * of the program.
+ * \param ignoreable - Allows you to specify that this argument can be
+ * ignored if the '--' flag is set. This defaults to false (cannot
+ * be ignored) and should generally stay that way unless you have
+ * some special need for certain arguments to be ignored.
+ * \param v - Optional Vistor. You should leave this blank unless
+ * you have a very good reason.
+ */
+ UnlabeledValueArg( const std::string& name,
+ const std::string& desc,
+ bool req,
+ T value,
+ const std::string& typeDesc,
+ bool ignoreable = false,
+ Visitor* v = NULL);
+
+ /**
+ * UnlabeledValueArg constructor.
+ * \param name - A one word name for the argument. Note that this is used for
+ * identification, not as a long flag.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param req - Whether the argument is required on the command
+ * line.
+ * \param value - The default value assigned to this argument if it
+ * is not present on the command line.
+ * \param typeDesc - A short, human readable description of the
+ * type that this object expects. This is used in the generation
+ * of the USAGE statement. The goal is to be helpful to the end user
+ * of the program.
+ * \param parser - A CmdLine parser object to add this Arg to
+ * \param ignoreable - Allows you to specify that this argument can be
+ * ignored if the '--' flag is set. This defaults to false (cannot
+ * be ignored) and should generally stay that way unless you have
+ * some special need for certain arguments to be ignored.
+ * \param v - Optional Vistor. You should leave this blank unless
+ * you have a very good reason.
+ */
+ UnlabeledValueArg( const std::string& name,
+ const std::string& desc,
+ bool req,
+ T value,
+ const std::string& typeDesc,
+ CmdLineInterface& parser,
+ bool ignoreable = false,
+ Visitor* v = NULL );
+
+ /**
+ * UnlabeledValueArg constructor.
+ * \param name - A one word name for the argument. Note that this is used for
+ * identification, not as a long flag.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param req - Whether the argument is required on the command
+ * line.
+ * \param value - The default value assigned to this argument if it
+ * is not present on the command line.
+ * \param constraint - A pointer to a Constraint object used
+ * to constrain this Arg.
+ * \param ignoreable - Allows you to specify that this argument can be
+ * ignored if the '--' flag is set. This defaults to false (cannot
+ * be ignored) and should generally stay that way unless you have
+ * some special need for certain arguments to be ignored.
+ * \param v - Optional Vistor. You should leave this blank unless
+ * you have a very good reason.
+ */
+ UnlabeledValueArg( const std::string& name,
+ const std::string& desc,
+ bool req,
+ T value,
+ Constraint<T>* constraint,
+ bool ignoreable = false,
+ Visitor* v = NULL );
+
+
+ /**
+ * UnlabeledValueArg constructor.
+ * \param name - A one word name for the argument. Note that this is used for
+ * identification, not as a long flag.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param req - Whether the argument is required on the command
+ * line.
+ * \param value - The default value assigned to this argument if it
+ * is not present on the command line.
+ * \param constraint - A pointer to a Constraint object used
+ * to constrain this Arg.
+ * \param parser - A CmdLine parser object to add this Arg to
+ * \param ignoreable - Allows you to specify that this argument can be
+ * ignored if the '--' flag is set. This defaults to false (cannot
+ * be ignored) and should generally stay that way unless you have
+ * some special need for certain arguments to be ignored.
+ * \param v - Optional Vistor. You should leave this blank unless
+ * you have a very good reason.
+ */
+ UnlabeledValueArg( const std::string& name,
+ const std::string& desc,
+ bool req,
+ T value,
+ Constraint<T>* constraint,
+ CmdLineInterface& parser,
+ bool ignoreable = false,
+ Visitor* v = NULL);
+
+ /**
+ * Handles the processing of the argument.
+ * This re-implements the Arg version of this method to set the
+ * _value of the argument appropriately. Handling specific to
+ * unlabled arguments.
+ * \param i - Pointer the the current argument in the list.
+ * \param args - Mutable list of strings.
+ */
+ virtual bool processArg(int* i, std::vector<std::string>& args);
+
+ /**
+ * Overrides shortID for specific behavior.
+ */
+ virtual std::string shortID(const std::string& val="val") const;
+
+ /**
+ * Overrides longID for specific behavior.
+ */
+ virtual std::string longID(const std::string& val="val") const;
+
+ /**
+ * Overrides operator== for specific behavior.
+ */
+ virtual bool operator==(const Arg& a ) const;
+
+ /**
+ * Instead of pushing to the front of list, push to the back.
+ * \param argList - The list to add this to.
+ */
+ virtual void addToList( std::list<Arg*>& argList ) const;
+
+};
+
+/**
+ * Constructor implemenation.
+ */
+template<class T>
+UnlabeledValueArg<T>::UnlabeledValueArg(const std::string& name,
+ const std::string& desc,
+ bool req,
+ T val,
+ const std::string& typeDesc,
+ bool ignoreable,
+ Visitor* v)
+: ValueArg<T>("", name, desc, req, val, typeDesc, v)
+{
+ _ignoreable = ignoreable;
+
+ OptionalUnlabeledTracker::check(req, toString());
+
+}
+
+template<class T>
+UnlabeledValueArg<T>::UnlabeledValueArg(const std::string& name,
+ const std::string& desc,
+ bool req,
+ T val,
+ const std::string& typeDesc,
+ CmdLineInterface& parser,
+ bool ignoreable,
+ Visitor* v)
+: ValueArg<T>("", name, desc, req, val, typeDesc, v)
+{
+ _ignoreable = ignoreable;
+ OptionalUnlabeledTracker::check(req, toString());
+ parser.add( this );
+}
+
+/**
+ * Constructor implemenation.
+ */
+template<class T>
+UnlabeledValueArg<T>::UnlabeledValueArg(const std::string& name,
+ const std::string& desc,
+ bool req,
+ T val,
+ Constraint<T>* constraint,
+ bool ignoreable,
+ Visitor* v)
+: ValueArg<T>("", name, desc, req, val, constraint, v)
+{
+ _ignoreable = ignoreable;
+ OptionalUnlabeledTracker::check(req, toString());
+}
+
+template<class T>
+UnlabeledValueArg<T>::UnlabeledValueArg(const std::string& name,
+ const std::string& desc,
+ bool req,
+ T val,
+ Constraint<T>* constraint,
+ CmdLineInterface& parser,
+ bool ignoreable,
+ Visitor* v)
+: ValueArg<T>("", name, desc, req, val, constraint, v)
+{
+ _ignoreable = ignoreable;
+ OptionalUnlabeledTracker::check(req, toString());
+ parser.add( this );
+}
+
+/**
+ * Implementation of processArg().
+ */
+template<class T>
+bool UnlabeledValueArg<T>::processArg(int *i, std::vector<std::string>& args)
+{
+
+ if ( _alreadySet )
+ return false;
+
+ if ( _hasBlanks( args[*i] ) )
+ return false;
+
+ // never ignore an unlabeled arg
+
+ _extractValue( args[*i] );
+ _alreadySet = true;
+ return true;
+}
+
+/**
+ * Overriding shortID for specific output.
+ */
+template<class T>
+std::string UnlabeledValueArg<T>::shortID(const std::string& val) const
+{
+ static_cast<void>(val); // Ignore input, don't warn
+ return std::string("<") + _typeDesc + ">";
+}
+
+/**
+ * Overriding longID for specific output.
+ */
+template<class T>
+std::string UnlabeledValueArg<T>::longID(const std::string& val) const
+{
+ static_cast<void>(val); // Ignore input, don't warn
+
+ // Ideally we would like to be able to use RTTI to return the name
+ // of the type required for this argument. However, g++ at least,
+ // doesn't appear to return terribly useful "names" of the types.
+ return std::string("<") + _typeDesc + ">";
+}
+
+/**
+ * Overriding operator== for specific behavior.
+ */
+template<class T>
+bool UnlabeledValueArg<T>::operator==(const Arg& a ) const
+{
+ if ( _name == a.getName() || _description == a.getDescription() )
+ return true;
+ else
+ return false;
+}
+
+template<class T>
+void UnlabeledValueArg<T>::addToList( std::list<Arg*>& argList ) const
+{
+ argList.push_back( const_cast<Arg*>(static_cast<const Arg* const>(this)) );
+}
+
+}
+#endif
diff --git a/tclap/include/tclap/ValueArg.h b/tclap/include/tclap/ValueArg.h
new file mode 100644
index 0000000000000000000000000000000000000000..7ac29526b94393a4b5441921307fbf5b419805fb
--- /dev/null
+++ b/tclap/include/tclap/ValueArg.h
@@ -0,0 +1,425 @@
+/******************************************************************************
+ *
+ * file: ValueArg.h
+ *
+ * Copyright (c) 2003, Michael E. Smoot .
+ * Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+
+#ifndef TCLAP_VALUE_ARGUMENT_H
+#define TCLAP_VALUE_ARGUMENT_H
+
+#include <string>
+#include <vector>
+
+#include <tclap/Arg.h>
+#include <tclap/Constraint.h>
+
+namespace TCLAP {
+
+/**
+ * The basic labeled argument that parses a value.
+ * This is a template class, which means the type T defines the type
+ * that a given object will attempt to parse when the flag/name is matched
+ * on the command line. While there is nothing stopping you from creating
+ * an unflagged ValueArg, it is unwise and would cause significant problems.
+ * Instead use an UnlabeledValueArg.
+ */
+template<class T>
+class ValueArg : public Arg
+{
+ protected:
+
+ /**
+ * The value parsed from the command line.
+ * Can be of any type, as long as the >> operator for the type
+ * is defined.
+ */
+ T _value;
+
+ /**
+ * Used to support the reset() method so that ValueArg can be
+ * reset to their constructed value.
+ */
+ T _default;
+
+ /**
+ * A human readable description of the type to be parsed.
+ * This is a hack, plain and simple. Ideally we would use RTTI to
+ * return the name of type T, but until there is some sort of
+ * consistent support for human readable names, we are left to our
+ * own devices.
+ */
+ std::string _typeDesc;
+
+ /**
+ * A Constraint this Arg must conform to.
+ */
+ Constraint<T>* _constraint;
+
+ /**
+ * Extracts the value from the string.
+ * Attempts to parse string as type T, if this fails an exception
+ * is thrown.
+ * \param val - value to be parsed.
+ */
+ void _extractValue( const std::string& val );
+
+ public:
+
+ /**
+ * Labeled ValueArg constructor.
+ * You could conceivably call this constructor with a blank flag,
+ * but that would make you a bad person. It would also cause
+ * an exception to be thrown. If you want an unlabeled argument,
+ * use the other constructor.
+ * \param flag - The one character flag that identifies this
+ * argument on the command line.
+ * \param name - A one word name for the argument. Can be
+ * used as a long flag on the command line.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param req - Whether the argument is required on the command
+ * line.
+ * \param value - The default value assigned to this argument if it
+ * is not present on the command line.
+ * \param typeDesc - A short, human readable description of the
+ * type that this object expects. This is used in the generation
+ * of the USAGE statement. The goal is to be helpful to the end user
+ * of the program.
+ * \param v - An optional visitor. You probably should not
+ * use this unless you have a very good reason.
+ */
+ ValueArg( const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ T value,
+ const std::string& typeDesc,
+ Visitor* v = NULL);
+
+
+ /**
+ * Labeled ValueArg constructor.
+ * You could conceivably call this constructor with a blank flag,
+ * but that would make you a bad person. It would also cause
+ * an exception to be thrown. If you want an unlabeled argument,
+ * use the other constructor.
+ * \param flag - The one character flag that identifies this
+ * argument on the command line.
+ * \param name - A one word name for the argument. Can be
+ * used as a long flag on the command line.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param req - Whether the argument is required on the command
+ * line.
+ * \param value - The default value assigned to this argument if it
+ * is not present on the command line.
+ * \param typeDesc - A short, human readable description of the
+ * type that this object expects. This is used in the generation
+ * of the USAGE statement. The goal is to be helpful to the end user
+ * of the program.
+ * \param parser - A CmdLine parser object to add this Arg to
+ * \param v - An optional visitor. You probably should not
+ * use this unless you have a very good reason.
+ */
+ ValueArg( const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ T value,
+ const std::string& typeDesc,
+ CmdLineInterface& parser,
+ Visitor* v = NULL );
+
+ /**
+ * Labeled ValueArg constructor.
+ * You could conceivably call this constructor with a blank flag,
+ * but that would make you a bad person. It would also cause
+ * an exception to be thrown. If you want an unlabeled argument,
+ * use the other constructor.
+ * \param flag - The one character flag that identifies this
+ * argument on the command line.
+ * \param name - A one word name for the argument. Can be
+ * used as a long flag on the command line.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param req - Whether the argument is required on the command
+ * line.
+ * \param value - The default value assigned to this argument if it
+ * is not present on the command line.
+ * \param constraint - A pointer to a Constraint object used
+ * to constrain this Arg.
+ * \param parser - A CmdLine parser object to add this Arg to.
+ * \param v - An optional visitor. You probably should not
+ * use this unless you have a very good reason.
+ */
+ ValueArg( const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ T value,
+ Constraint<T>* constraint,
+ CmdLineInterface& parser,
+ Visitor* v = NULL );
+
+ /**
+ * Labeled ValueArg constructor.
+ * You could conceivably call this constructor with a blank flag,
+ * but that would make you a bad person. It would also cause
+ * an exception to be thrown. If you want an unlabeled argument,
+ * use the other constructor.
+ * \param flag - The one character flag that identifies this
+ * argument on the command line.
+ * \param name - A one word name for the argument. Can be
+ * used as a long flag on the command line.
+ * \param desc - A description of what the argument is for or
+ * does.
+ * \param req - Whether the argument is required on the command
+ * line.
+ * \param value - The default value assigned to this argument if it
+ * is not present on the command line.
+ * \param constraint - A pointer to a Constraint object used
+ * to constrain this Arg.
+ * \param v - An optional visitor. You probably should not
+ * use this unless you have a very good reason.
+ */
+ ValueArg( const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ T value,
+ Constraint<T>* constraint,
+ Visitor* v = NULL );
+
+ /**
+ * Handles the processing of the argument.
+ * This re-implements the Arg version of this method to set the
+ * _value of the argument appropriately. It knows the difference
+ * between labeled and unlabeled.
+ * \param i - Pointer the the current argument in the list.
+ * \param args - Mutable list of strings. Passed
+ * in from main().
+ */
+ virtual bool processArg(int* i, std::vector<std::string>& args);
+
+ /**
+ * Returns the value of the argument.
+ */
+ T& getValue() ;
+
+ /**
+ * Specialization of shortID.
+ * \param val - value to be used.
+ */
+ virtual std::string shortID(const std::string& val = "val") const;
+
+ /**
+ * Specialization of longID.
+ * \param val - value to be used.
+ */
+ virtual std::string longID(const std::string& val = "val") const;
+
+ virtual void reset() ;
+
+private:
+ /**
+ * Prevent accidental copying
+ */
+ ValueArg<T>(const ValueArg<T>& rhs);
+ ValueArg<T>& operator=(const ValueArg<T>& rhs);
+};
+
+
+/**
+ * Constructor implementation.
+ */
+template<class T>
+ValueArg<T>::ValueArg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ T val,
+ const std::string& typeDesc,
+ Visitor* v)
+: Arg(flag, name, desc, req, true, v),
+ _value( val ),
+ _default( val ),
+ _typeDesc( typeDesc ),
+ _constraint( NULL )
+{ }
+
+template<class T>
+ValueArg<T>::ValueArg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ T val,
+ const std::string& typeDesc,
+ CmdLineInterface& parser,
+ Visitor* v)
+: Arg(flag, name, desc, req, true, v),
+ _value( val ),
+ _default( val ),
+ _typeDesc( typeDesc ),
+ _constraint( NULL )
+{
+ parser.add( this );
+}
+
+template<class T>
+ValueArg<T>::ValueArg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ T val,
+ Constraint<T>* constraint,
+ Visitor* v)
+: Arg(flag, name, desc, req, true, v),
+ _value( val ),
+ _default( val ),
+ _typeDesc( constraint->shortID() ),
+ _constraint( constraint )
+{ }
+
+template<class T>
+ValueArg<T>::ValueArg(const std::string& flag,
+ const std::string& name,
+ const std::string& desc,
+ bool req,
+ T val,
+ Constraint<T>* constraint,
+ CmdLineInterface& parser,
+ Visitor* v)
+: Arg(flag, name, desc, req, true, v),
+ _value( val ),
+ _default( val ),
+ _typeDesc( constraint->shortID() ),
+ _constraint( constraint )
+{
+ parser.add( this );
+}
+
+
+/**
+ * Implementation of getValue().
+ */
+template<class T>
+T& ValueArg<T>::getValue() { return _value; }
+
+/**
+ * Implementation of processArg().
+ */
+template<class T>
+bool ValueArg<T>::processArg(int *i, std::vector<std::string>& args)
+{
+ if ( _ignoreable && Arg::ignoreRest() )
+ return false;
+
+ if ( _hasBlanks( args[*i] ) )
+ return false;
+
+ std::string flag = args[*i];
+
+ std::string value = "";
+ trimFlag( flag, value );
+
+ if ( argMatches( flag ) )
+ {
+ if ( _alreadySet )
+ {
+ if ( _xorSet )
+ throw( CmdLineParseException(
+ "Mutually exclusive argument already set!",
+ toString()) );
+ else
+ throw( CmdLineParseException("Argument already set!",
+ toString()) );
+ }
+
+ if ( Arg::delimiter() != ' ' && value == "" )
+ throw( ArgParseException(
+ "Couldn't find delimiter for this argument!",
+ toString() ) );
+
+ if ( value == "" )
+ {
+ (*i)++;
+ if ( static_cast<unsigned int>(*i) < args.size() )
+ _extractValue( args[*i] );
+ else
+ throw( ArgParseException("Missing a value for this argument!",
+ toString() ) );
+ }
+ else
+ _extractValue( value );
+
+ _alreadySet = true;
+ _checkWithVisitor();
+ return true;
+ }
+ else
+ return false;
+}
+
+/**
+ * Implementation of shortID.
+ */
+template<class T>
+std::string ValueArg<T>::shortID(const std::string& val) const
+{
+ static_cast<void>(val); // Ignore input, don't warn
+ return Arg::shortID( _typeDesc );
+}
+
+/**
+ * Implementation of longID.
+ */
+template<class T>
+std::string ValueArg<T>::longID(const std::string& val) const
+{
+ static_cast<void>(val); // Ignore input, don't warn
+ return Arg::longID( _typeDesc );
+}
+
+template<class T>
+void ValueArg<T>::_extractValue( const std::string& val )
+{
+ try {
+ ExtractValue(_value, val, typename ArgTraits<T>::ValueCategory());
+ } catch( ArgParseException &e) {
+ throw ArgParseException(e.error(), toString());
+ }
+
+ if ( _constraint != NULL )
+ if ( ! _constraint->check( _value ) )
+ throw( CmdLineParseException( "Value '" + val +
+ + "' does not meet constraint: "
+ + _constraint->description(),
+ toString() ) );
+}
+
+template<class T>
+void ValueArg<T>::reset()
+{
+ Arg::reset();
+ _value = _default;
+}
+
+} // namespace TCLAP
+
+#endif
diff --git a/tclap/include/tclap/ValuesConstraint.h b/tclap/include/tclap/ValuesConstraint.h
new file mode 100644
index 0000000000000000000000000000000000000000..cb41f645e55b7352dd85d0bb0657ad8e2c0324bf
--- /dev/null
+++ b/tclap/include/tclap/ValuesConstraint.h
@@ -0,0 +1,148 @@
+
+
+/******************************************************************************
+ *
+ * file: ValuesConstraint.h
+ *
+ * Copyright (c) 2005, Michael E. Smoot
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+#ifndef TCLAP_VALUESCONSTRAINT_H
+#define TCLAP_VALUESCONSTRAINT_H
+
+#include <string>
+#include <vector>
+#include <tclap/Constraint.h>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#else
+#define HAVE_SSTREAM
+#endif
+
+#if defined(HAVE_SSTREAM)
+#include <sstream>
+#elif defined(HAVE_STRSTREAM)
+#include <strstream>
+#else
+#error "Need a stringstream (sstream or strstream) to compile!"
+#endif
+
+namespace TCLAP {
+
+/**
+ * A Constraint that constrains the Arg to only those values specified
+ * in the constraint.
+ */
+template<class T>
+class ValuesConstraint : public Constraint<T>
+{
+
+ public:
+
+ /**
+ * Constructor.
+ * \param allowed - vector of allowed values.
+ */
+ ValuesConstraint(std::vector<T>& allowed);
+
+ /**
+ * Virtual destructor.
+ */
+ virtual ~ValuesConstraint() {}
+
+ /**
+ * Returns a description of the Constraint.
+ */
+ virtual std::string description() const;
+
+ /**
+ * Returns the short ID for the Constraint.
+ */
+ virtual std::string shortID() const;
+
+ /**
+ * The method used to verify that the value parsed from the command
+ * line meets the constraint.
+ * \param value - The value that will be checked.
+ */
+ virtual bool check(const T& value) const;
+
+ protected:
+
+ /**
+ * The list of valid values.
+ */
+ std::vector<T> _allowed;
+
+ /**
+ * The string used to describe the allowed values of this constraint.
+ */
+ std::string _typeDesc;
+
+};
+
+template<class T>
+ValuesConstraint<T>::ValuesConstraint(std::vector<T>& allowed)
+: _allowed(allowed),
+ _typeDesc("")
+{
+ for ( unsigned int i = 0; i < _allowed.size(); i++ )
+ {
+
+#if defined(HAVE_SSTREAM)
+ std::ostringstream os;
+#elif defined(HAVE_STRSTREAM)
+ std::ostrstream os;
+#else
+#error "Need a stringstream (sstream or strstream) to compile!"
+#endif
+
+ os << _allowed[i];
+
+ std::string temp( os.str() );
+
+ if ( i > 0 )
+ _typeDesc += "|";
+ _typeDesc += temp;
+ }
+}
+
+template<class T>
+bool ValuesConstraint<T>::check( const T& val ) const
+{
+ if ( std::find(_allowed.begin(),_allowed.end(),val) == _allowed.end() )
+ return false;
+ else
+ return true;
+}
+
+template<class T>
+std::string ValuesConstraint<T>::shortID() const
+{
+ return _typeDesc;
+}
+
+template<class T>
+std::string ValuesConstraint<T>::description() const
+{
+ return _typeDesc;
+}
+
+
+} //namespace TCLAP
+#endif
+
diff --git a/tclap/include/tclap/VersionVisitor.h b/tclap/include/tclap/VersionVisitor.h
new file mode 100644
index 0000000000000000000000000000000000000000..c110d4fa009401bcf88533b9f7d7101e9735bb1d
--- /dev/null
+++ b/tclap/include/tclap/VersionVisitor.h
@@ -0,0 +1,81 @@
+// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
+
+/******************************************************************************
+ *
+ * file: VersionVisitor.h
+ *
+ * Copyright (c) 2003, Michael E. Smoot .
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+
+#ifndef TCLAP_VERSION_VISITOR_H
+#define TCLAP_VERSION_VISITOR_H
+
+#include <tclap/CmdLineInterface.h>
+#include <tclap/CmdLineOutput.h>
+#include <tclap/Visitor.h>
+
+namespace TCLAP {
+
+/**
+ * A Vistor that will call the version method of the given CmdLineOutput
+ * for the specified CmdLine object and then exit.
+ */
+class VersionVisitor: public Visitor
+{
+ private:
+ /**
+ * Prevent accidental copying
+ */
+ VersionVisitor(const VersionVisitor& rhs);
+ VersionVisitor& operator=(const VersionVisitor& rhs);
+
+ protected:
+
+ /**
+ * The CmdLine of interest.
+ */
+ CmdLineInterface* _cmd;
+
+ /**
+ * The output object.
+ */
+ CmdLineOutput** _out;
+
+ public:
+
+ /**
+ * Constructor.
+ * \param cmd - The CmdLine the output is generated for.
+ * \param out - The type of output.
+ */
+ VersionVisitor( CmdLineInterface* cmd, CmdLineOutput** out )
+ : Visitor(), _cmd( cmd ), _out( out ) { }
+
+ /**
+ * Calls the version method of the output object using the
+ * specified CmdLine.
+ */
+ void visit() {
+ (*_out)->version(*_cmd);
+ throw ExitException(0);
+ }
+
+};
+
+}
+
+#endif
diff --git a/tclap/include/tclap/Visitor.h b/tclap/include/tclap/Visitor.h
new file mode 100644
index 0000000000000000000000000000000000000000..38ddcbdb86107a52300b99ca1369f65b0efa1354
--- /dev/null
+++ b/tclap/include/tclap/Visitor.h
@@ -0,0 +1,53 @@
+
+/******************************************************************************
+ *
+ * file: Visitor.h
+ *
+ * Copyright (c) 2003, Michael E. Smoot .
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+
+#ifndef TCLAP_VISITOR_H
+#define TCLAP_VISITOR_H
+
+namespace TCLAP {
+
+/**
+ * A base class that defines the interface for visitors.
+ */
+class Visitor
+{
+ public:
+
+ /**
+ * Constructor. Does nothing.
+ */
+ Visitor() { }
+
+ /**
+ * Destructor. Does nothing.
+ */
+ virtual ~Visitor() { }
+
+ /**
+ * Does nothing. Should be overridden by child.
+ */
+ virtual void visit() { }
+};
+
+}
+
+#endif
diff --git a/tclap/include/tclap/XorHandler.h b/tclap/include/tclap/XorHandler.h
new file mode 100644
index 0000000000000000000000000000000000000000..d9dfad31f6ff6b7d18a7b045d8f8347f1118c172
--- /dev/null
+++ b/tclap/include/tclap/XorHandler.h
@@ -0,0 +1,166 @@
+
+/******************************************************************************
+ *
+ * file: XorHandler.h
+ *
+ * Copyright (c) 2003, Michael E. Smoot .
+ * Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+#ifndef TCLAP_XORHANDLER_H
+#define TCLAP_XORHANDLER_H
+
+#include <tclap/Arg.h>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <iostream>
+
+namespace TCLAP {
+
+/**
+ * This class handles lists of Arg's that are to be XOR'd on the command
+ * line. This is used by CmdLine and you shouldn't ever use it.
+ */
+class XorHandler
+{
+ protected:
+
+ /**
+ * The list of of lists of Arg's to be or'd together.
+ */
+ std::vector< std::vector<Arg*> > _orList;
+
+ public:
+
+ /**
+ * Constructor. Does nothing.
+ */
+ XorHandler( ) : _orList(std::vector< std::vector<Arg*> >()) {}
+
+ /**
+ * Add a list of Arg*'s that will be orred together.
+ * \param ors - list of Arg* that will be xor'd.
+ */
+ void add( std::vector<Arg*>& ors );
+
+ /**
+ * Checks whether the specified Arg is in one of the xor lists and
+ * if it does match one, returns the size of the xor list that the
+ * Arg matched. If the Arg matches, then it also sets the rest of
+ * the Arg's in the list. You shouldn't use this.
+ * \param a - The Arg to be checked.
+ */
+ int check( const Arg* a );
+
+ /**
+ * Returns the XOR specific short usage.
+ */
+ std::string shortUsage();
+
+ /**
+ * Prints the XOR specific long usage.
+ * \param os - Stream to print to.
+ */
+ void printLongUsage(std::ostream& os);
+
+ /**
+ * Simply checks whether the Arg is contained in one of the arg
+ * lists.
+ * \param a - The Arg to be checked.
+ */
+ bool contains( const Arg* a );
+
+ std::vector< std::vector<Arg*> >& getXorList();
+
+};
+
+
+//////////////////////////////////////////////////////////////////////
+//BEGIN XOR.cpp
+//////////////////////////////////////////////////////////////////////
+inline void XorHandler::add( std::vector<Arg*>& ors )
+{
+ _orList.push_back( ors );
+}
+
+inline int XorHandler::check( const Arg* a )
+{
+ // iterate over each XOR list
+ for ( int i = 0; static_cast<unsigned int>(i) < _orList.size(); i++ )
+ {
+ // if the XOR list contains the arg..
+ ArgVectorIterator ait = std::find( _orList[i].begin(),
+ _orList[i].end(), a );
+ if ( ait != _orList[i].end() )
+ {
+ // first check to see if a mutually exclusive switch
+ // has not already been set
+ for ( ArgVectorIterator it = _orList[i].begin();
+ it != _orList[i].end();
+ it++ )
+ if ( a != (*it) && (*it)->isSet() )
+ throw(CmdLineParseException(
+ "Mutually exclusive argument already set!",
+ (*it)->toString()));
+
+ // go through and set each arg that is not a
+ for ( ArgVectorIterator it = _orList[i].begin();
+ it != _orList[i].end();
+ it++ )
+ if ( a != (*it) )
+ (*it)->xorSet();
+
+ // return the number of required args that have now been set
+ if ( (*ait)->allowMore() )
+ return 0;
+ else
+ return static_cast<int>(_orList[i].size());
+ }
+ }
+
+ if ( a->isRequired() )
+ return 1;
+ else
+ return 0;
+}
+
+inline bool XorHandler::contains( const Arg* a )
+{
+ for ( int i = 0; static_cast<unsigned int>(i) < _orList.size(); i++ )
+ for ( ArgVectorIterator it = _orList[i].begin();
+ it != _orList[i].end();
+ it++ )
+ if ( a == (*it) )
+ return true;
+
+ return false;
+}
+
+inline std::vector< std::vector<Arg*> >& XorHandler::getXorList()
+{
+ return _orList;
+}
+
+
+
+//////////////////////////////////////////////////////////////////////
+//END XOR.cpp
+//////////////////////////////////////////////////////////////////////
+
+} //namespace TCLAP
+
+#endif
diff --git a/tclap/include/tclap/ZshCompletionOutput.h b/tclap/include/tclap/ZshCompletionOutput.h
new file mode 100644
index 0000000000000000000000000000000000000000..0b37fc7296c6b5f4179467318d590c350fb84832
--- /dev/null
+++ b/tclap/include/tclap/ZshCompletionOutput.h
@@ -0,0 +1,323 @@
+// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
+
+/******************************************************************************
+ *
+ * file: ZshCompletionOutput.h
+ *
+ * Copyright (c) 2006, Oliver Kiddle
+ * All rights reverved.
+ *
+ * See the file COPYING in the top directory of this distribution for
+ * more information.
+ *
+ * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *****************************************************************************/
+
+#ifndef TCLAP_ZSHCOMPLETIONOUTPUT_H
+#define TCLAP_ZSHCOMPLETIONOUTPUT_H
+
+#include <string>
+#include <vector>
+#include <list>
+#include <iostream>
+#include <map>
+
+#include <tclap/CmdLineInterface.h>
+#include <tclap/CmdLineOutput.h>
+#include <tclap/XorHandler.h>
+#include <tclap/Arg.h>
+
+namespace TCLAP {
+
+/**
+ * A class that generates a Zsh completion function as output from the usage()
+ * method for the given CmdLine and its Args.
+ */
+class ZshCompletionOutput : public CmdLineOutput
+{
+
+ public:
+
+ ZshCompletionOutput();
+
+ /**
+ * Prints the usage to stdout. Can be overridden to
+ * produce alternative behavior.
+ * \param c - The CmdLine object the output is generated for.
+ */
+ virtual void usage(CmdLineInterface& c);
+
+ /**
+ * Prints the version to stdout. Can be overridden
+ * to produce alternative behavior.
+ * \param c - The CmdLine object the output is generated for.
+ */
+ virtual void version(CmdLineInterface& c);
+
+ /**
+ * Prints (to stderr) an error message, short usage
+ * Can be overridden to produce alternative behavior.
+ * \param c - The CmdLine object the output is generated for.
+ * \param e - The ArgException that caused the failure.
+ */
+ virtual void failure(CmdLineInterface& c,
+ ArgException& e );
+
+ protected:
+
+ void basename( std::string& s );
+ void quoteSpecialChars( std::string& s );
+
+ std::string getMutexList( CmdLineInterface& _cmd, Arg* a );
+ void printOption( Arg* it, std::string mutex );
+ void printArg( Arg* it );
+
+ std::map<std::string, std::string> common;
+ char theDelimiter;
+};
+
+ZshCompletionOutput::ZshCompletionOutput()
+: common(std::map<std::string, std::string>()),
+ theDelimiter('=')
+{
+ common["host"] = "_hosts";
+ common["hostname"] = "_hosts";
+ common["file"] = "_files";
+ common["filename"] = "_files";
+ common["user"] = "_users";
+ common["username"] = "_users";
+ common["directory"] = "_directories";
+ common["path"] = "_directories";
+ common["url"] = "_urls";
+}
+
+inline void ZshCompletionOutput::version(CmdLineInterface& _cmd)
+{
+ std::cout << _cmd.getVersion() << std::endl;
+}
+
+inline void ZshCompletionOutput::usage(CmdLineInterface& _cmd )
+{
+ std::list<Arg*> argList = _cmd.getArgList();
+ std::string progName = _cmd.getProgramName();
+ std::string xversion = _cmd.getVersion();
+ theDelimiter = _cmd.getDelimiter();
+ basename(progName);
+
+ std::cout << "#compdef " << progName << std::endl << std::endl <<
+ "# " << progName << " version " << _cmd.getVersion() << std::endl << std::endl <<
+ "_arguments -s -S";
+
+ for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
+ {
+ if ( (*it)->shortID().at(0) == '<' )
+ printArg((*it));
+ else if ( (*it)->getFlag() != "-" )
+ printOption((*it), getMutexList(_cmd, *it));
+ }
+
+ std::cout << std::endl;
+}
+
+inline void ZshCompletionOutput::failure( CmdLineInterface& _cmd,
+ ArgException& e )
+{
+ static_cast<void>(_cmd); // unused
+ std::cout << e.what() << std::endl;
+}
+
+inline void ZshCompletionOutput::quoteSpecialChars( std::string& s )
+{
+ size_t idx = s.find_last_of(':');
+ while ( idx != std::string::npos )
+ {
+ s.insert(idx, 1, '\\');
+ idx = s.find_last_of(':', idx);
+ }
+ idx = s.find_last_of('\'');
+ while ( idx != std::string::npos )
+ {
+ s.insert(idx, "'\\'");
+ if (idx == 0)
+ idx = std::string::npos;
+ else
+ idx = s.find_last_of('\'', --idx);
+ }
+}
+
+inline void ZshCompletionOutput::basename( std::string& s )
+{
+ size_t p = s.find_last_of('/');
+ if ( p != std::string::npos )
+ {
+ s.erase(0, p + 1);
+ }
+}
+
+inline void ZshCompletionOutput::printArg(Arg* a)
+{
+ static int count = 1;
+
+ std::cout << " \\" << std::endl << " '";
+ if ( a->acceptsMultipleValues() )
+ std::cout << '*';
+ else
+ std::cout << count++;
+ std::cout << ':';
+ if ( !a->isRequired() )
+ std::cout << ':';
+
+ std::cout << a->getName() << ':';
+ std::map<std::string, std::string>::iterator compArg = common.find(a->getName());
+ if ( compArg != common.end() )
+ {
+ std::cout << compArg->second;
+ }
+ else
+ {
+ std::cout << "_guard \"^-*\" " << a->getName();
+ }
+ std::cout << '\'';
+}
+
+inline void ZshCompletionOutput::printOption(Arg* a, std::string mutex)
+{
+ std::string flag = a->flagStartChar() + a->getFlag();
+ std::string name = a->nameStartString() + a->getName();
+ std::string desc = a->getDescription();
+
+ // remove full stop and capitalisation from description as
+ // this is the convention for zsh function
+ if (!desc.compare(0, 12, "(required) "))
+ {
+ desc.erase(0, 12);
+ }
+ if (!desc.compare(0, 15, "(OR required) "))
+ {
+ desc.erase(0, 15);
+ }
+ size_t len = desc.length();
+ if (len && desc.at(--len) == '.')
+ {
+ desc.erase(len);
+ }
+ if (len)
+ {
+ desc.replace(0, 1, 1, tolower(desc.at(0)));
+ }
+
+ std::cout << " \\" << std::endl << " '" << mutex;
+
+ if ( a->getFlag().empty() )
+ {
+ std::cout << name;
+ }
+ else
+ {
+ std::cout << "'{" << flag << ',' << name << "}'";
+ }
+ if ( theDelimiter == '=' && a->isValueRequired() )
+ std::cout << "=-";
+ quoteSpecialChars(desc);
+ std::cout << '[' << desc << ']';
+
+ if ( a->isValueRequired() )
+ {
+ std::string arg = a->shortID();
+ arg.erase(0, arg.find_last_of(theDelimiter) + 1);
+ if ( arg.at(arg.length()-1) == ']' )
+ arg.erase(arg.length()-1);
+ if ( arg.at(arg.length()-1) == ']' )
+ {
+ arg.erase(arg.length()-1);
+ }
+ if ( arg.at(0) == '<' )
+ {
+ arg.erase(arg.length()-1);
+ arg.erase(0, 1);
+ }
+ size_t p = arg.find('|');
+ if ( p != std::string::npos )
+ {
+ do
+ {
+ arg.replace(p, 1, 1, ' ');
+ }
+ while ( (p = arg.find_first_of('|', p)) != std::string::npos );
+ quoteSpecialChars(arg);
+ std::cout << ": :(" << arg << ')';
+ }
+ else
+ {
+ std::cout << ':' << arg;
+ std::map<std::string, std::string>::iterator compArg = common.find(arg);
+ if ( compArg != common.end() )
+ {
+ std::cout << ':' << compArg->second;
+ }
+ }
+ }
+
+ std::cout << '\'';
+}
+
+inline std::string ZshCompletionOutput::getMutexList( CmdLineInterface& _cmd, Arg* a)
+{
+ XorHandler xorHandler = _cmd.getXorHandler();
+ std::vector< std::vector<Arg*> > xorList = xorHandler.getXorList();
+
+ if (a->getName() == "help" || a->getName() == "version")
+ {
+ return "(-)";
+ }
+
+ std::ostringstream list;
+ if ( a->acceptsMultipleValues() )
+ {
+ list << '*';
+ }
+
+ for ( int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++ )
+ {
+ for ( ArgVectorIterator it = xorList[i].begin();
+ it != xorList[i].end();
+ it++)
+ if ( a == (*it) )
+ {
+ list << '(';
+ for ( ArgVectorIterator iu = xorList[i].begin();
+ iu != xorList[i].end();
+ iu++ )
+ {
+ bool notCur = (*iu) != a;
+ bool hasFlag = !(*iu)->getFlag().empty();
+ if ( iu != xorList[i].begin() && (notCur || hasFlag) )
+ list << ' ';
+ if (hasFlag)
+ list << (*iu)->flagStartChar() << (*iu)->getFlag() << ' ';
+ if ( notCur || hasFlag )
+ list << (*iu)->nameStartString() << (*iu)->getName();
+ }
+ list << ')';
+ return list.str();
+ }
+ }
+
+ // wasn't found in xor list
+ if (!a->getFlag().empty()) {
+ list << "(" << a->flagStartChar() << a->getFlag() << ' ' <<
+ a->nameStartString() << a->getName() << ')';
+ }
+
+ return list.str();
+}
+
+} //namespace TCLAP
+#endif