CmdLineParser.h

Go to the documentation of this file.

// ---------------------------------------------------------------------------
// $Id: CmdLineParser.h 232 2008-08-15 18:19:35Z daaugusto $
//
//   CmdLineParser.h (created on Tue Aug 8 11:01:58 BRT 2006)
// 
//   Command-line Parser
//
//   Copyright (C) 2006-2008 Douglas Adriano Augusto (daaugusto)
// 
// Command-line Parser 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 3 of the License, or (at
// your option) any later version.
// 
// Command-line Parser is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
// Public License for more details.
// 
// You should have received a copy of the GNU General Public License along
// with Command-line Parser; if not, see <http://www.gnu.org/licenses/>.
//
// ------------------------------------------------------------------------

#ifndef cmd_line_parser_h
#define cmd_line_parser_h

#include <string>
#include <sstream>
#include <list>
#include <limits>
#include <map>
#include <cstring>

#include "CmdLineException.h"

// ---------------------------------------------------------------------
namespace CmdLine {

typedef long double FLOAT;

typedef long INT;

enum { NONE = 0,         
       SILENT = 1,       
       OUT_OF_RANGE = 2, 
       NO_VALUE = 4,     
       DUPLICATE = 8,    
       FIRSTONLY = 16    
};

// ---------------------------------------------------------------------
template<class T> class Option {
public:
   Option( T def, T min, T max ) 
      : m_value( def ), m_min( min ), m_max( max ),
        m_found( false ), m_has_alias( false ), m_flags( 0 ) {}

public:
   T m_value, 
     m_min, 
     m_max; 
   bool m_found; 
public:
   bool IsSet( unsigned flag ) const { return m_flags & flag; }

   Option<T>& Set( unsigned flag ) { return m_flags |= flag, *this; }
   
   Option<T>& UnSet( unsigned flag ) { return m_flags &= ~flag, *this; }

   Option<T>& Flags( unsigned flag ) { return m_flags = flag, *this; }

public:
   bool m_has_alias;
private:
   unsigned m_flags; 
};

// ---------------------------------------------------------------------
template <class T> class OptionsType {
public:
   OptionsType( const class Parser& parser ): m_parser( parser ) {}

   typedef typename std::map<std::string, void*>::const_iterator CI;

   Option<T>& Add(const std::string& name, const std::string& alias="", 
                          T def=T(), T min=T(), T max=T() )
   {
      CheckOption( name, alias );

      void* tmp = new Option<T>( def, min, max );
      m_opts[name] = tmp;

      if( alias.size() > 0 ) // was provided an alias?
      {
         m_opts[alias] = tmp;
         static_cast<Option<T>*>( tmp )->m_has_alias = true;
      }

      return *static_cast<Option<T>*>( tmp );
   }

   T Get( const std::string& s ) const
   {
      const Option<T>* p = Find( s ); if( p ) return p->m_value;

      throw E_Exception("","Option "+s+" does not exist");
   }

   bool Get( const std::string& s, T& value ) const
   {
      const Option<T>* p = Find( s ); 

      if( p ) {
         value = p->m_value;
         return p->m_found;
      }

      throw E_Exception("","Option "+s+" does not exist");
   }

   template<class C> C Get( const std::string& s ) const
   {
      return static_cast<C>( Get( s ) );
   }

   template<class C> bool Get( const std::string& s, C& value ) const
   {
      const Option<T>* p = Find( s ); 

      if( p ) {
         value = static_cast<C>( p->m_value );
         return p->m_found;
      }

      throw E_Exception("","Option "+s+" does not exist");
   }

   bool Found( const std::string& s ) const
   {
      const Option<T>* p = Find( s ); if( p ) return p->m_found;

      throw E_Exception("","Option "+s+" does not exist");
   }

public:
   const class Parser& m_parser;

protected:
   virtual ~OptionsType()
   {
      for( CI p = m_opts.begin(); p != m_opts.end(); ++p )
      {
         if( Cast(p)->m_has_alias ) { Cast(p)->m_has_alias = false; continue; }

         delete Cast(p);
      }
   }

   void CheckOption( const std::string& name, const std::string& alias ) const
   {
      if( name[0] != '-' )
         throw E_Exception( "","Invalid option name: '"+name+"'" );

      if( alias.size() > 0 && alias[0] != '-' )
         throw E_Exception( "","Invalid option alias: '"+alias+"'" );
   }

   Option<T>* Cast( CI p ) const { return static_cast<Option<T>*>(p->second); }

   Option<T>* Find( const std::string& s ) const
   { 
      CI p = m_opts.find(s); return p != m_opts.end() ? Cast(p) : 0;
   }

   bool CheckDuplicate( const Option<T>* p, const std::string opt ) const
   {
      if( p->m_found ) // already declared before?
      {
         if( p->IsSet( DUPLICATE ) ) throw E_Duplicate( opt );

         if( !p->IsSet( SILENT ) )
            std::cerr << "> Option '" << opt 
                      << "' was declared more than once.\n";

         return !p->IsSet( FIRSTONLY );
      }

      return true; // ok, not declared before
   }

private:
   std::map<std::string, void*> m_opts;
};

class Parser;

// ---------------------------------------------------------------------
class OptionsINT: public OptionsType<INT> {
public:
   OptionsINT( const Parser& parser ): OptionsType<INT>( parser ) {}
   
   Option<INT>& Add( const std::string&, const std::string& = "", 
                     INT = 0, INT = std::numeric_limits<INT>::min(), 
                     INT = std::numeric_limits<INT>::max() );
   bool Match( int&, char**, int );

};

// ---------------------------------------------------------------------
class OptionsFLOAT: public OptionsType<FLOAT> {
public:
   OptionsFLOAT( const Parser& parser ): OptionsType<FLOAT>( parser ) {}

   Option<FLOAT>& Add( const std::string&, const std::string& = "", 
                       FLOAT = 0.0, FLOAT = std::numeric_limits<FLOAT>::min(), 
                       FLOAT = std::numeric_limits<FLOAT>::max() );

   bool Match( int&, char**, int );

   friend bool OptionsINT::Match( int&, char**, int );
};

// ---------------------------------------------------------------------
class OptionsBOOL: public OptionsType<bool> {
public:
   OptionsBOOL( const Parser& parser ): OptionsType<bool>( parser ) {}
   bool Match( int&, char**, int );
};

// ---------------------------------------------------------------------
class OptionsCHAR: public OptionsType<char> {
public:
   OptionsCHAR( const Parser& parser ): OptionsType<char>( parser ) {}

   Option<char>& Add( const std::string&, const std::string& = "", char =
                           '\0', const char* = 0, bool = false );

   bool Match( int&, char**, int );

private:
   std::map<std::string, std::pair<const char*, bool> > m_ranges;
};

// ---------------------------------------------------------------------
class OptionsSTRING: public OptionsType<std::string> {
public:
   OptionsSTRING( const Parser& parser ): OptionsType<std::string>( parser ) {}

   Option<std::string>& Add( const std::string&, const std::string& = "", 
                             std::string = "", const char* first = 0, ... );

   bool Match( int&, char**, int );

private:
   std::map<std::string, std::list<std::string> > m_ranges;
};

// ---------------------------------------------------------------------
class Parser {
public:
   Parser( int argc, char** argv, unsigned flags = 0 ): 
           Int( *this ), Float( *this ), Bool( *this ), Char( *this ), 
           String( *this ), m_argc( argc ), m_argv( argv ), m_flags( flags ) 
   { }

   int Process();

   template<class T> int Process( T& );

   bool IsSet( unsigned flag ) const { return m_flags & flag; }

   Parser& Set( unsigned flag ) { return m_flags |= flag, *this; }
   
   Parser& UnSet( unsigned flag ) { return m_flags &= ~flag, *this; }

   Parser& Flags( unsigned flag ) { return m_flags = flag, *this; }

public:
   class OptionsINT Int; 
   class OptionsFLOAT Float; 
   class OptionsBOOL Bool; 
   class OptionsCHAR Char; 
   class OptionsSTRING String; 
   friend class OptionsINT;
   friend class OptionsFLOAT;
   friend class OptionsBOOL;
   friend class OptionsCHAR;
   friend class OptionsSTRING;
private:
   int m_argc; 
   char** m_argv; 
   unsigned m_flags; 
};

// ---------------------------------------------------------------------
template<class T> int Parser::Process( T& remains )
{
   remains.clear(); int i = 1, matched = 0;

   while( i < m_argc )
   {
      if( !strcmp( m_argv[i], "--" ) ) break; // "--" stops the option processing

      if( m_argv[i][0] == '-' && ( Int.Match( i, m_argv, m_argc ) || 
          Float.Match( i, m_argv, m_argc ) || Bool.Match( i, m_argv, m_argc ) || 
          Char.Match( i, m_argv, m_argc ) || String.Match( i, m_argv, m_argc )) )
      {
         ++matched;
      }
      else remains.push_back( m_argv[i] ); // not a valid option

      ++i;
   }

   // only if encountered "--": do not process the remaining
   while( ++i < m_argc ) { remains.push_back( m_argv[i] ); }

   return matched;
}

// ---------------------------------------------------------------------
} // end namespace CmdLine
// ---------------------------------------------------------------------
#endif