Format code using uncrustify

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>

1 files changed, 348 insertions, 365 deletions

diff --git a/src/tclap/MultiArg.h b/src/tclap/MultiArg.h
index 460e5cb..467edd4 100755..100644
--- a/src/tclap/MultiArg.h
+++ b/src/tclap/MultiArg.h
@@ -1,22 +1,22 @@
-/****************************************************************************** 
- * 
+/******************************************************************************
+ *
  *  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.  
- *  
+ *
+ *  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.
+ *
  *****************************************************************************/
 
 
@@ -29,394 +29,377 @@
 #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
+namespace TCLAP
 {
-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.
+	 * 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.
 	 */
-	std::vector<T> _values;
+	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();
+	};
+
+	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), _typeDesc(typeDesc), _constraint(NULL), _allowMore(false)
+	{
+		_acceptsMultipleValues = true;
+	}
 
-	/**
-	 * The description of type T to be used in the usage.
-	 */
-	std::string _typeDesc;
+	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), _typeDesc(typeDesc), _constraint(NULL), _allowMore(false)
+	{
+		parser.add(this);
+		_acceptsMultipleValues = true;
+	}
 
 	/**
-	 * A list of constraint on this Arg. 
+	 *
 	 */
-	Constraint<T>* _constraint;
+	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), _typeDesc(constraint->shortID()),
+			_constraint(constraint), _allowMore(false)
+	{
+		_acceptsMultipleValues = true;
+	}
 
-	/**
-	 * 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 );
+	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), _typeDesc(constraint->shortID()),
+			_constraint(constraint), _allowMore(false)
+	{
+		parser.add(this);
+		_acceptsMultipleValues = true;
+	}
 
-	/**
-	 * Used by XorHandler to decide whether to keep parsing for this arg.
-	 */
-	bool _allowMore;
+	template<class T>
+	const std::vector<T>& MultiArg<T>::getValue()
+	{
+		return _values;
+	}
 
-public:
+	template<class T>
+	bool MultiArg<T>::processArg(int *i, std::vector<std::string> &args)
+	{
+		if (_ignoreable && Arg::ignoreRest())
+		{
+			return false;
+		}
 
-	/**
-	 * 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);
+		if (_hasBlanks(args[*i]))
+		{
+			return false;
+		}
 
-	/**
-	 * 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 );
+		std::string flag  = args[*i];
+		std::string value = "";
 
-	/**
-	 * 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); 
+		trimFlag(flag, value);
 
-	/**
-	 * Returns a vector of type T containing the values parsed from
-	 * the command line.
-	 */
-	const std::vector<T>& getValue();
+		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);
+			}
 
-	/**
-	 * Returns an iterator over the values parsed from the command
-	 * line.
-	 */
-	const_iterator begin() const { return _values.begin(); }
+			/*
+			// 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)] );
+			*/
 
-	/**
-	 * Returns the end of the values parsed from the command
-	 * line.
-	 */
-	const_iterator end() const { return _values.end(); }
+			_alreadySet = true;
+			_checkWithVisitor();
+
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
 
 	/**
-	 * 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;
+	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) + " ... ";
+	}
 
 	/**
-	 * 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;
+	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.
 	 */
-	virtual bool isRequired() const;
-
-	virtual bool allowMore();
-	
-	virtual void reset();
-
-};
-
-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 ),
-  _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 ),
-  _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 ),
-  _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 ),
-  _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 == "" )
+	template<class T>
+	bool MultiArg<T>::isRequired() const
+	{
+		if (_required)
 		{
-			(*i)++;
-			if ( static_cast<unsigned int>(*i) < args.size() )
-				_extractValue( args[*i] );
+			if (_values.size() > 1)
+			{
+				return false;
+			}
 			else
-				throw( ArgParseException("Missing a value for this argument!",
-                                         toString() ) );
-		} 
+			{
+				return true;
+			}
+		}
 		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;
+		{
+			return false;
+		}
 	}
-	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 )
+	template<class T>
+	void MultiArg<T>::_extractValue(const std::string &val)
 	{
-		if ( _values.size() > 1 )
-			return false;
-		else
-			return true;
-   	}
-   	else
-		return false;
-
-}
+		try
+		{
+			T tmp;
+			ExtractValue(tmp, val, typename ArgTraits<T>::ValueCategory());
+			_values.push_back(tmp);
+		}
+		catch (ArgParseException &e)
+		{
+			throw ArgParseException(e.error(), toString());
+		}
 
-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;
-}
+		if (_constraint != NULL)
+		{
+			if (!_constraint->check(_values.back()))
+			{
+				throw (CmdLineParseException("Value '" + val + "' does not meet constraint: " +
+				      _constraint->description(), toString()));
+			}
+		}
+	}
 
-template<class T>
-void MultiArg<T>::reset()
-{
-	Arg::reset();
-	_values.clear();
-}
+	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