cmdMultiArg.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 DtCmdLine_MULTIPLE_ARGUMENT_H
#define DtCmdLine_MULTIPLE_ARGUMENT_H


#include <cstdio>

#include <string>
#include <vector>

#include "cmdArg.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

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

namespace DtCmdLine {

   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;
            }
         };

         template<>
         class ValueExtractor<DtString>
         {
            friend class MultiArg<DtString>;

         private:

            std::vector<DtString>& _values;

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

            int extractValue(const DtString& 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() const;

         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() const { 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 ( std::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 );
      }


} 

#ifdef DtUSE_UTILITIES_NAMESPACE
}     
#endif

#endif