tclap 1.2.2
ValueArg.h
Go to the documentation of this file.
1/******************************************************************************
2 *
3 * file: ValueArg.h
4 *
5 * Copyright (c) 2003, Michael E. Smoot .
6 * Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
7 * All rights reserved.
8 *
9 * See the file COPYING in the top directory of this distribution for
10 * more information.
11 *
12 * THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS
13 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
15 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
16 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
17 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
18 * DEALINGS IN THE SOFTWARE.
19 *
20 *****************************************************************************/
21
22
23#ifndef TCLAP_VALUE_ARGUMENT_H
24#define TCLAP_VALUE_ARGUMENT_H
25
26#include <string>
27#include <vector>
28
29#include <tclap/Arg.h>
30#include <tclap/Constraint.h>
31
32namespace TCLAP {
33
42template<class T>
43class ValueArg : public Arg
44{
45 protected:
46
53
59
67 std::string _typeDesc;
68
73
80 void _extractValue( const std::string& val );
81
82 public:
83
107 ValueArg( const std::string& flag,
108 const std::string& name,
109 const std::string& desc,
110 bool req,
111 T value,
112 const std::string& typeDesc,
113 Visitor* v = NULL);
114
115
140 ValueArg( const std::string& flag,
141 const std::string& name,
142 const std::string& desc,
143 bool req,
144 T value,
145 const std::string& typeDesc,
146 CmdLineInterface& parser,
147 Visitor* v = NULL );
148
171 ValueArg( const std::string& flag,
172 const std::string& name,
173 const std::string& desc,
174 bool req,
175 T value,
176 Constraint<T>* constraint,
177 CmdLineInterface& parser,
178 Visitor* v = NULL );
179
201 ValueArg( const std::string& flag,
202 const std::string& name,
203 const std::string& desc,
204 bool req,
205 T value,
206 Constraint<T>* constraint,
207 Visitor* v = NULL );
208
218 virtual bool processArg(int* i, std::vector<std::string>& args);
219
223 T& getValue() ;
224
229 virtual std::string shortID(const std::string& val = "val") const;
230
235 virtual std::string longID(const std::string& val = "val") const;
236
237 virtual void reset() ;
238
239private:
243 ValueArg<T>(const ValueArg<T>& rhs);
244 ValueArg<T>& operator=(const ValueArg<T>& rhs);
245};
246
247
251template<class T>
252ValueArg<T>::ValueArg(const std::string& flag,
253 const std::string& name,
254 const std::string& desc,
255 bool req,
256 T val,
257 const std::string& typeDesc,
258 Visitor* v)
259: Arg(flag, name, desc, req, true, v),
260 _value( val ),
261 _default( val ),
262 _typeDesc( typeDesc ),
263 _constraint( NULL )
264{ }
265
266template<class T>
267ValueArg<T>::ValueArg(const std::string& flag,
268 const std::string& name,
269 const std::string& desc,
270 bool req,
271 T val,
272 const std::string& typeDesc,
273 CmdLineInterface& parser,
274 Visitor* v)
275: Arg(flag, name, desc, req, true, v),
276 _value( val ),
277 _default( val ),
278 _typeDesc( typeDesc ),
279 _constraint( NULL )
280{
281 parser.add( this );
282}
283
284template<class T>
285ValueArg<T>::ValueArg(const std::string& flag,
286 const std::string& name,
287 const std::string& desc,
288 bool req,
289 T val,
290 Constraint<T>* constraint,
291 Visitor* v)
292: Arg(flag, name, desc, req, true, v),
293 _value( val ),
294 _default( val ),
295 _typeDesc( constraint->shortID() ),
296 _constraint( constraint )
297{ }
298
299template<class T>
300ValueArg<T>::ValueArg(const std::string& flag,
301 const std::string& name,
302 const std::string& desc,
303 bool req,
304 T val,
305 Constraint<T>* constraint,
306 CmdLineInterface& parser,
307 Visitor* v)
308: Arg(flag, name, desc, req, true, v),
309 _value( val ),
310 _default( val ),
311 _typeDesc( constraint->shortID() ),
312 _constraint( constraint )
313{
314 parser.add( this );
315}
316
317
321template<class T>
323
327template<class T>
328bool ValueArg<T>::processArg(int *i, std::vector<std::string>& args)
329{
330 if ( _ignoreable && Arg::ignoreRest() )
331 return false;
332
333 if ( _hasBlanks( args[*i] ) )
334 return false;
335
336 std::string flag = args[*i];
337
338 std::string value = "";
339 trimFlag( flag, value );
340
341 if ( argMatches( flag ) )
342 {
343 if ( _alreadySet )
344 {
345 if ( _xorSet )
347 "Mutually exclusive argument already set!",
348 toString()) );
349 else
350 throw( CmdLineParseException("Argument already set!",
351 toString()) );
352 }
353
354 if ( Arg::delimiter() != ' ' && value == "" )
355 throw( ArgParseException(
356 "Couldn't find delimiter for this argument!",
357 toString() ) );
358
359 if ( value == "" )
360 {
361 (*i)++;
362 if ( static_cast<unsigned int>(*i) < args.size() )
363 _extractValue( args[*i] );
364 else
365 throw( ArgParseException("Missing a value for this argument!",
366 toString() ) );
367 }
368 else
369 _extractValue( value );
370
371 _alreadySet = true;
373 return true;
374 }
375 else
376 return false;
377}
378
382template<class T>
383std::string ValueArg<T>::shortID(const std::string& val) const
384{
385 static_cast<void>(val); // Ignore input, don't warn
386 return Arg::shortID( _typeDesc );
387}
388
392template<class T>
393std::string ValueArg<T>::longID(const std::string& val) const
394{
395 static_cast<void>(val); // Ignore input, don't warn
396 return Arg::longID( _typeDesc );
397}
398
399template<class T>
400void ValueArg<T>::_extractValue( const std::string& val )
401{
402 try {
404 } catch( ArgParseException &e) {
405 throw ArgParseException(e.error(), toString());
406 }
407
408 if ( _constraint != NULL )
409 if ( ! _constraint->check( _value ) )
410 throw( CmdLineParseException( "Value '" + val +
411 + "' does not meet constraint: "
412 + _constraint->description(),
413 toString() ) );
414}
415
416template<class T>
418{
419 Arg::reset();
421}
422
423} // namespace TCLAP
424
425#endif
std::string error() const
Returns the error text.
Thrown from within the child Arg classes when it fails to properly parse the argument it has been pas...
void _checkWithVisitor() const
Performs the special handling described by the Visitor.
Definition Arg.h:612
virtual std::string longID(const std::string &valueId="val") const
Returns a long ID for the usage.
Definition Arg.h:524
bool _hasBlanks(const std::string &s) const
Checks whether a given string has blank chars, indicating that it is a combined SwitchArg.
Definition Arg.h:642
static bool ignoreRest()
Whether to ignore the rest.
Definition Arg.h:206
bool _alreadySet
Indicates whether the argument has been set.
Definition Arg.h:138
bool _ignoreable
Whether this argument can be ignored, if desired.
Definition Arg.h:151
static char delimiter()
The delimiter that separates an argument flag/name from the value.
Definition Arg.h:212
bool _xorSet
Indicates that the arg was set as part of an XOR and not on the command line.
Definition Arg.h:157
virtual void reset()
Clears the Arg object and allows it to be reused by new command lines.
Definition Arg.h:680
virtual bool argMatches(const std::string &s) const
A method that tests whether a string matches this argument.
Definition Arg.h:591
virtual void trimFlag(std::string &flag, std::string &value) const
Trims a value off of the flag.
Definition Arg.h:621
virtual std::string toString() const
Returns a simple string representation of the argument.
Definition Arg.h:600
virtual std::string shortID(const std::string &valueId="val") const
Returns a short ID for the usage.
Definition Arg.h:506
The base class that manages the command line definition and passes along the parsing to the appropria...
virtual void add(Arg &a)=0
Adds an argument to the list of arguments to be parsed.
Thrown from CmdLine when the arguments on the command line are not properly specified,...
The interface that defines the interaction between the Arg and Constraint.
Definition Constraint.h:39
virtual std::string longID(const std::string &val="val") const
Specialization of longID.
Definition ValueArg.h:393
T _default
Used to support the reset() method so that ValueArg can be reset to their constructed value.
Definition ValueArg.h:58
virtual void reset()
Clears the Arg object and allows it to be reused by new command lines.
Definition ValueArg.h:417
T _value
The value parsed from the command line.
Definition ValueArg.h:52
T & getValue()
Returns the value of the argument.
Definition ValueArg.h:322
virtual bool processArg(int *i, std::vector< std::string > &args)
Handles the processing of the argument.
Definition ValueArg.h:328
std::string _typeDesc
A human readable description of the type to be parsed.
Definition ValueArg.h:67
Constraint< T > * _constraint
A Constraint this Arg must conform to.
Definition ValueArg.h:72
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.
Definition ValueArg.h:252
void _extractValue(const std::string &val)
Extracts the value from the string.
Definition ValueArg.h:400
virtual std::string shortID(const std::string &val="val") const
Specialization of shortID.
Definition ValueArg.h:383
A base class that defines the interface for visitors.
Definition Visitor.h:32
Definition Arg.h:58
void ExtractValue(T &destVal, const std::string &strVal, ValueLike vl)
Definition Arg.h:416
T::ValueCategory ValueCategory
Definition ArgTraits.h:80