---

cmdline.h

Go to the documentation of this file.

/*=========================================================================*
                  cmdline.h  -  handle command line arguments
                             -------------------
    begin                : Sun Mar 17 2002
    copyright            : (C) 2002 by Christian Neise
    email                : C.Neise at users.sourceforge.net
 *=========================================================================*/

/*=========================================================================*
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as       *
 *   published by the Free Software Foundation; either version 2 of        *
 *   the License, or (at your option) any later version.                   *
 *                                                                         *
 *=========================================================================*/

#include <string>
#include <vector>
#include <sstream>

/* If you use gcc 3.2 or higher you may want to remove the comment below */
// #define USE_GCC_NEW_VERSION

#ifdef USE_GCC_NEW_VERSION
#include <ext/functional>
#else
#include <functional>
// if the compiler complains here, read the comment above
#endif

namespace cmdl {


class CmdLineException : public std::exception
{
   public:
      enum error_t
      {
         unknown_option = 0,
         invalid_argument = 1,
         too_many_arguments = 2,
         no_multiple_use = 3,
         argument_expected = 4,
         option_expected = 5
      };

      CmdLineException(const std::string& strOption, error_t nError)
            : m_strOption(strOption),  m_nError(nError) { /*empty*/}


       virtual ~CmdLineException() throw();
            
      error_t get_error_code() const { return m_nError; }

      const std::string& get_option(){ return m_strOption; }

      virtual const char *what() const throw();

   private:
      std::string m_strOption;
      error_t m_nError;
      mutable std::string m_strError;
};








class CmdLine
{
   public:
      enum option_t
      {  cmdLineDefault = 0,
         cmdMultiple = 1
      };

      CmdLine( char c_option_char = '-' );

      void Init(int argc, char *argv[]);

      void Done();

      //
      // Retrieving single arguments given to command line options
      //

      template <class T>
      bool GetSingleValue( const char* pszOpt, T& tDest)
      {
         const char *arg = getSingleArgForOption( pszOpt );
         if (arg)
         {
            transform( arg, tDest, pszOpt );
            return true;
         }
         else
            return false;
      }

      bool GetSingleValue( const char* pszOpt, bool &bDest)
      {
         bool bOptionSet = OptionSetNoArgs( pszOpt );

         if ( OptionSetNoArgs( pszOpt ) )
             throw CmdLineException(pszOpt, CmdLineException::no_multiple_use);

         if (bOptionSet) bDest = true;

         return bOptionSet;
      }

      //
      // Calls a function if a option was given
      //

      unsigned short Call( const char* pszOpt, void (*function)(), char options = cmdLineDefault)
      {
         unsigned short argc = 0;
         while (OptionSetNoArgs( pszOpt ))
         {
            function();
            ++argc;
            if ( !( options & cmdMultiple ) && OptionSetNoArgs( pszOpt ) )
                throw CmdLineException(pszOpt, CmdLineException::no_multiple_use);
         }
         return argc;
      }

      template <class T>
      unsigned short Call( const char *pszOpt, void (*function)(const T& strDest), char options = cmdLineDefault)
      {
         unsigned short argc=0;
         CharPtrList_t::iterator found = m_CharPtrList.begin();
         const char *arg=GetNextArgForOption(pszOpt, found);
         while ( arg )
         {
            T targ;
            transform<T>( arg, targ, pszOpt);
            function( targ );

            arg=GetNextArgForOption(pszOpt, found);
            ++argc;

            if ( arg && !( options & cmdMultiple ))
                throw CmdLineException(pszOpt, CmdLineException::too_many_arguments);
         }
         return argc;
      }

      template <class C, class T>
      unsigned short Call( const char *pszOpt, C& object, void (C::*function)(const T& strDest), char options = cmdLineDefault)
      {
         unsigned short argc=0;
         CharPtrList_t::iterator found = m_CharPtrList.begin();
         const char *arg=GetNextArgForOption(pszOpt, found);
         while ( arg )
         {
            T targ;
            transform<T>( arg, targ, pszOpt);

#ifdef USE_GCC_NEW_VERSION
            __gnu_cxx::mem_fun1_ref( function )( object, targ );
#else                        
            mem_fun1_ref( function )( object, targ );
            // if the compiler complains here, read the comment at the top of this file
#endif            

            arg=GetNextArgForOption(pszOpt, found);
            ++argc;

            if ( arg && !( options & cmdMultiple ))
                throw CmdLineException(pszOpt, CmdLineException::too_many_arguments);
         }
         return argc;
      }


   private:
      typedef std::vector <const char*> CharPtrList_t;

      CharPtrList_t m_CharPtrList;

      char m_c_option_char;

      void transform( const char * from, std::string& to, const char * )
      {
          to = from;
      }

      template <class T>
      void transform( const char * from, T& to, const char * pszOpt)
      {
         std::string strValue( from );
         std::istringstream in(strValue);
         in >> to;
         if ( in.fail() || in.bad() || in.peek() > 0)
                throw CmdLineException(pszOpt, CmdLineException::invalid_argument);
      }

      bool IsOption( CharPtrList_t::iterator it ){ return !*it || **it == m_c_option_char; }

      const char *FindFirstArgForOption( const char *pszOpt, CharPtrList_t::iterator &);

      const char* GetNextArgForOption (const char *pszOpt, CharPtrList_t::iterator &);

      bool OptionSetNoArgs(const char *pszOpt );

      const char *getSingleArgForOption( const char *pszOpt );
};




}; // namespace cmdl

---