value_arg.hpp

Go to the documentation of this file.

 
/*****************************************************************************
** Ifdefs
*****************************************************************************/
 
#ifndef TCLAP_VALUE_ARGUMENT_H
#define TCLAP_VALUE_ARGUMENT_H
 
#include <string>
#include <vector>
#include <cstdio>
#include "arg.hpp"
#include "constraint.hpp"
 
#define HAVE_SSTREAM
 
#if defined(HAVE_SSTREAM)
#include <sstream>
#elif defined(HAVE_STRSTREAM)
#include <strstream>
#else
#error "Need a stringstream (sstream or strstream) to compile!"
#endif
 
namespace ecl {
 
template<class T> class ValueArg;
 
namespace ValueArgHelper {
 
enum Error_e { EXTRACT_FAILURE = 1000, EXTRACT_TOO_MANY };
 
template<class T> class ValueExtractor
{
        friend class ValueArg<T>;
 
        private:
 
        T &_value;
 
        ValueExtractor(T &value) : _value(value) { }
 
        int extractValue( const std::string& val )
                {
 
#if defined(HAVE_SSTREAM)
                        std::istringstream is(val);
#elif defined(HAVE_STRSTREAM)
                        std::istrstream is(val.c_str());
#else
#error "Need a stringstream (sstream or strstream) to compile!"
#endif
 
            int valuesRead = 0;
            while ( is.good() )
                        {
                if ( is.peek() != EOF )
                    is >> _value;
                else
                    break;
 
                valuesRead++;
            }
 
            if ( is.fail() )
                return EXTRACT_FAILURE;
 
            if ( valuesRead > 1 )
                return EXTRACT_TOO_MANY;
 
            return 0;
        }
};
 
template<> class ValueExtractor<std::string>
{
    friend class ValueArg<std::string>;
 
    private:
 
        std::string &_value;
 
        ValueExtractor(std::string &value) : _value(value) {}
 
        int extractValue( const std::string& val )
                {
            _value = val;
            return 0;
        }
};
 
} //namespace ValueArgHelper
 
template<class T>
class ValueArg : public Arg
{
    protected:
 
        T _value;
 
        std::string _typeDesc;
 
        Constraint<T>* _constraint;
 
        void _extractValue( const std::string& val );
 
        public:
 
        ValueArg( const std::string& flag,
                  const std::string& name,
                  const std::string& desc,
                  bool req,
                  T value,
                  const std::string& typeDesc,
                  Visitor* v = NULL);
 
 
        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 );
 
        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 );
 
        ValueArg( const std::string& flag,
                  const std::string& name,
                  const std::string& desc,
                  bool req,
                  T value,
                  Constraint<T>* constraint,
                  Visitor* v = NULL );
 
        virtual bool processArg(int* i, std::vector<std::string>& args);
 
        T& getValue() ;
 
        virtual std::string shortID(const std::string& val = "val") const;
 
        virtual std::string longID(const std::string& val = "val") const;
 
};
 
 
template<class T>
ValueArg<T>::ValueArg(const std::string& flag,
                      const std::string& name,
                      const std::string& desc,
                      bool req,
                      T value,
                      const std::string& typeDesc,
                      Visitor* v)
: Arg(flag, name, desc, req, true, v),
  _value( value ),
  _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 ),
  _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 ),
  _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 ),
  _typeDesc( constraint->shortID() ),
  _constraint( constraint )
{
    parser.add( this );
}
 
 
template<class T>
T& ValueArg<T>::getValue() { return _value; }
 
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 )
                        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;
}
 
template<class T>
std::string ValueArg<T>::shortID(const std::string& val) const
{
    std::string stop_warnings = val; // Only to stop annoying warning messages, I dont think it slows things down
    return Arg::shortID( _typeDesc );
}
 
template<class T>
std::string ValueArg<T>::longID(const std::string& val) const
{
    std::string stop_warnings = val; // Only to stop annoying warning messages, I dont think it slows things down
    return Arg::longID( _typeDesc );
}
 
template<class T> // Just to stop the warnings.
void ValueArg<T>::_extractValue( const std::string& val )
{
        ValueArgHelper::ValueExtractor<T> ve(_value);
 
        int err = ve.extractValue(val);
 
        if ( err == ValueArgHelper::EXTRACT_FAILURE )
                throw( ArgParseException("Couldn't read argument value from string '" +
                                     val + "'", toString() ) );
 
        if ( err == ValueArgHelper::EXTRACT_TOO_MANY )
                throw( ArgParseException(
                                        "More than one valid value parsed from string '" +
                                    val + "'", toString() ) );
 
        if ( _constraint != NULL )
                if ( ! _constraint->check( _value ) )
                        throw( CmdLineParseException( "Value '" + val +
                                                                              "' does not meet constraint: " +
                                                                                  _constraint->description(),
                                                                                  toString() ) );
}
 
}; // namespace ecl
 
#endif