MultiArg.h

Go to the documentation of this file.

/****************************************************************************** 
 * 
 *  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>

#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 {

template<class T> class MultiArg;

namespace MULTI_ARG_HELPER {

enum Error_e { EXTRACT_FAILURE = 1000, EXTRACT_TOO_MANY };

template<class T>
class ValueExtractor 
{
     friend class MultiArg<T>;
  
     private:

          std::vector<T> &_values;
  
          ValueExtractor(std::vector<T> &values) : _values(values) {}
  
          int extractValue( const std::string& val ) 
          {
               T temp;

#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 >> temp; 
                    else
                         break;
      
                    valuesRead++;
               }         
    
               if ( is.fail() )
                    return EXTRACT_FAILURE;
    
               if ( valuesRead > 1 )
                    return EXTRACT_TOO_MANY;
    
               _values.push_back(temp);
    
               return 0;
          } 
};

template<>
class ValueExtractor<std::string> 
{
     friend class MultiArg<std::string>;

     private:

        std::vector<std::string> &_values;
  
        ValueExtractor(std::vector<std::string> &values) : _values(values) {}

        int extractValue( const std::string& val ) 
          {
            _values.push_back( val );
            return 0;
        }
};

} //namespace MULTI_ARG_HELPER

template<class T>
class MultiArg : public Arg
{
     protected:

          std::vector<T> _values;

          std::vector<T> _allowed;

          std::string _typeDesc;

          void _extractValue( const std::string& val );

          void _checkAllowed( const std::string& val );

     public:

          MultiArg( const std::string& flag,
                  const std::string& name,
                  const std::string& desc,
                  bool req,
                  const std::string& typeDesc,
                  Visitor* v = NULL);

          MultiArg( const std::string& flag, 
                  const std::string& name,
                  const std::string& desc,
                  bool req,
                  const std::string& typeDesc,
                  CmdLineInterface& parser,
                  Visitor* v = NULL );

          MultiArg( const std::string& flag,
                  const std::string& name,
                  const std::string& desc,
                  bool req,
                  const std::vector<T>& allowed,
                  Visitor* v = NULL );
            
          MultiArg( const std::string& flag, 
                  const std::string& name,
                  const std::string& desc,
                  bool req,
                  const std::vector<T>& allowed,
                  CmdLineInterface& parser,
                  Visitor* v = NULL );
            
          virtual bool processArg(int* i, std::vector<std::string>& args); 

          const std::vector<T>& getValue();

          virtual std::string shortID(const std::string& val="val") const;

          virtual std::string longID(const std::string& val="val") const;

          virtual bool isRequired() const;

     private:

          void allowedInit();
};

template<class T>
void MultiArg<T>::allowedInit()
{
     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>
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 )
{ }

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 )
{ 
     parser.add( this );
}

template<class T>
MultiArg<T>::MultiArg(const std::string& flag, 
                      const std::string& name,
                      const std::string& desc,
                      bool req,
                      const std::vector<T>& allowed,
                      Visitor* v)
: Arg( flag, name, desc, req, true, v ),
  _allowed( allowed )
{ 
     allowedInit();
}

template<class T>
MultiArg<T>::MultiArg(const std::string& flag, 
                      const std::string& name,
                      const std::string& desc,
                      bool req,
                      const std::vector<T>& allowed,
                      CmdLineInterface& parser,
                      Visitor* v)
: Arg( flag, name, desc, req, true, v ),
  _allowed( allowed )
{ 
     allowedInit();
     parser.add( this );
}

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() ) );

          if ( value == "" )
          {
               (*i)++;
               if ( (unsigned int)*i < args.size() )
                    _extractValue( args[*i] );
               else
                    throw( ArgParseException("Missing a value for this argument!",
                                         toString() ) );
          }
          else
               _extractValue( value );

          _checkWithVisitor();

          return true;
     }
     else
          return false;
}

template<class T>
void MultiArg<T>::_checkAllowed( const std::string& val )
{
     if ( _allowed.size() > 0 )
          if ( find(_allowed.begin(),_allowed.end(),_values.back()) 
                 == _allowed.end() )
               throw( CmdLineParseException( "Couldn't find '" + val +
                                          "' in allowed list.", toString() ) );
}

template<class T>
std::string MultiArg<T>::shortID(const std::string& val) const
{
     std::string id = Arg::shortID(_typeDesc) + " ... ";

     return id;
}

template<class T>
std::string MultiArg<T>::longID(const std::string& val) const
{
     std::string id = Arg::longID(_typeDesc) + "  (accepted multiple times)";

     return id;
}

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 ) 
{
     MULTI_ARG_HELPER::ValueExtractor<T> ve(_values);
            
     int err = ve.extractValue(val);

     if ( err == MULTI_ARG_HELPER::EXTRACT_FAILURE )
          throw( ArgParseException("Couldn't read argument value "
                                 "from string '" + val + "'", toString() ) );

     if(err == MULTI_ARG_HELPER::EXTRACT_TOO_MANY)
         throw( ArgParseException("More than one valid value "
                                 "parsed from string '" + val + "'", 
                                         toString() ) );             
     _checkAllowed( val );
}
          

} // namespace TCLAP

#endif

---