cmdLine.h

Go to the documentation of this file.

/****************************************************************************** 
 * 
 *  file:  CmdLine.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_CMDLINE_H
#define DtCmdLine_CMDLINE_H
 

#include "cmdSwitchArg.h"
#include "cmdUnlabeledValueArg.h"
#include "cmdUnlabeledMultiArg.h"

#include "cmdXorHandler.h"
#include "cmdHelpVisitor.h"
#include "cmdVersionVisitor.h"
#include "cmdIgnoreRestVisitor.h"

#include "cmdLineOutput.h"
#include "cmdStdOutput.h"

#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <iomanip>
#include <algorithm>

#include <vlutil/vlProcessControl.h>
#include <vlutil/vlKeyboard.h>
#include <vlutil/vlPrint.h>

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

namespace DtCmdLine {


   class CmdLine : public CmdLineInterface
   {
   protected:

      std::list<Arg*> _argList;

      std::string _progName;

      std::string _message;

      std::string _version;

      int _numRequired;

      char _delimiter;

      XorHandler _xorHandler;

      std::list<Arg*> _argDeleteOnExitList;

      std::list<Visitor*> _visitorDeleteOnExitList;

      CmdLineOutput* _output;

      bool _emptyCombined(const std::string& s);

      bool myPressAnyKey;

   private:

      void _constructor();

      void deleteOnExit(Arg* ptr);

      void deleteOnExit(Visitor* ptr);

      bool _userSetOutput;

   public:

      CmdLine(const std::string& name, 
              const std::string& message,
              const std::string& version = "none",
#ifdef _WIN32
              bool pressAnyKey = true);
#else
              bool pressAnyKey = false);
#endif

      CmdLine(const std::string& message, 
              const char delimiter = ' ',
              const std::string& version = "none",
#ifdef _WIN32
              bool pressAnyKey = true);
#else
              bool pressAnyKey = false);
#endif

      virtual ~CmdLine();

      void add( Arg& a );

      void add( Arg* a );

      void xorAdd( Arg& a, Arg& b );

      void xorAdd( std::vector<Arg*>& xors );

      void parse(int argc, char** argv, bool printOnError = true)
      throw(CmdLineParseException);

       char** checkHelpOption( int & argc, char** argv, bool & result, bool removeFromArgs = true );

      CmdLineOutput* getOutput();

      void setOutput(CmdLineOutput* co);

      std::string& getVersion();

      std::string& getProgramName();

      std::list<Arg*>& getArgList();

      XorHandler& getXorHandler();

      char getDelimiter();

      std::string& getMessage();
   };


   //Begin CmdLine.cpp

   inline CmdLine::CmdLine(const std::string& n, 
                           const std::string& m, 
                           const std::string& v,
                           bool pressAnyKey)
      : _progName(n),
      _message(m),
      _version(v),
      _numRequired(0),
      _delimiter(' '),
      myPressAnyKey(pressAnyKey),
      _userSetOutput(false)
      { 
         _constructor();
      }

   inline CmdLine::CmdLine(const std::string& m, 
                           char delim, 
                           const std::string& v,
                           bool pressAnyKey)
      : _progName("not_set_yet"),
      _message(m),
      _version(v),
      _numRequired(0),
      _delimiter(delim),
      myPressAnyKey(pressAnyKey),
      _userSetOutput(false)
      {
         _constructor();
      }

   inline CmdLine::~CmdLine()
   {
      ArgListIterator argIter;
      VisitorListIterator visIter;

      for( argIter = _argDeleteOnExitList.begin(); 
           argIter != _argDeleteOnExitList.end(); 
           ++argIter)
         delete *argIter;

      for( visIter = _visitorDeleteOnExitList.begin(); 
           visIter != _visitorDeleteOnExitList.end(); 
           ++visIter) 
         delete *visIter;

      if ( !_userSetOutput )
         delete _output;
   }

   inline void CmdLine::_constructor()
   { 
      _output = new StdOutput;

      Visitor *v;

      Arg::setDelimiter( _delimiter );

      v = new HelpVisitor( this, &_output, myPressAnyKey );
      SwitchArg* help = new SwitchArg("h","help", 
                                      "Displays usage information and exits.", 
                                      false, v);
      add( help );
      deleteOnExit(help);
      deleteOnExit(v);

      v = new VersionVisitor( this, &_output, myPressAnyKey );
      SwitchArg* vers = new SwitchArg("v","version", 
                                      "Displays version information and exits.", 
                                      false, v);
      add( vers );
      deleteOnExit(vers);
      deleteOnExit(v);

      v = new IgnoreRestVisitor();
      SwitchArg* ignore  = new SwitchArg(Arg::flagStartString(), 
                                         Arg::ignoreNameString(),
                                         "Ignores the rest of the labeled arguments following this flag.",
                                         false, v);
      add( ignore );
      deleteOnExit(ignore);
      deleteOnExit(v);
   }

   inline void CmdLine::xorAdd( std::vector<Arg*>& ors )
   {
      _xorHandler.add( ors );

      for (ArgVectorIterator it = ors.begin(); it != ors.end(); it++)
      {
         (*it)->forceRequired();
         (*it)->setRequireLabel( "OR required" );

         add( *it );
      }
   }

   inline void CmdLine::xorAdd( Arg& a, Arg& b ) 
   {
      std::vector<Arg*> ors;
      ors.push_back( &a );
      ors.push_back( &b );
      xorAdd( ors );
   }

   inline void CmdLine::add( Arg& a ) 
   { 
      add( &a );
   }

   inline void CmdLine::add( Arg* a ) 
   { 
      for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ ) 
         if ( *a == *(*it) ) 
            throw( SpecificationException( "Argument with same flag/name already exists!", 
                   a->longID() ) );

      a->addToList( _argList );

      if ( a->isRequired() ) 
         _numRequired++;   
   }

   inline char** CmdLine::checkHelpOption( int & argc, char** argv, bool & result, bool removeFromArgs )
   {
      // cache the old argument count
      int oldArgc = argc;

      // vector of command line arguments
      std::vector<std::string> args;
      for (int i = 1; i < argc; i++)
         args.push_back(argv[i]);

      std::vector<std::string>::iterator prev;
      std::vector<std::string>::iterator cur;
      std::vector<std::string>::iterator end = args.end();

      // get the beginning
      cur = args.begin();

      // finished early? 
      bool finished = false;

      while( ( cur != end && finished == false ) )
      {
         if( (*cur) == "--help" )
         {
            if( removeFromArgs )
            {
               // subtract an argument
               argc--;

               // erase it
               args.erase(cur);
            }

            // set back to the previous
            cur = prev;

            // we've finished
            finished = true;

            // break out 
            break;
         }
         else
         {
            prev = cur; 
            ++cur;
         }
      }

      // set the result
      result = finished;

      if( ( removeFromArgs == true ) && ( finished == true ) )
      {
         // ok so we found help, and removed it which means we 
         // altered the argv's, we need to reconstruct and give back
         // otherwise return what we had
         char ** new_argv = new char * [ args.size() ];
         for( unsigned int i = 0; i < args.size(); ++i )
         {
            new_argv[i] = new char[ args[i].length() + 1 ];
            memcpy( new_argv[i], args[i].c_str(), args[i].length() );
         }

         return new_argv;
      }
      
      // restore the old argc 
      argc = oldArgc;
      return argv;      
   }

   inline void CmdLine::parse(int argc, char** argv, bool printOnError)
   throw(CmdLineParseException)
   {
      try {

         _progName = argv[0]; 

         std::vector<std::string> args;
         int i;
         for (i = 1; i < argc; i++)
            args.push_back(argv[i]);

         int requiredCount = 0;

         for (i = 0; (unsigned int)i < args.size(); i++)
         {
            bool matched = false;
            for (ArgListIterator it = _argList.begin(); it != _argList.end(); it++)
            {
               if ( (*it)->processArg( &i, args ) )
               {
                  requiredCount += _xorHandler.check( *it );
                  matched = true;
                  break;
               }
            }

            if ( !matched && _emptyCombined( args[i] ) )
               matched = true;

            if ( !matched && !Arg::ignoreRest() )
               throw(CmdLineParseException("Couldn't find match for argument",
                                           args[i]));
         }

         if ( requiredCount < _numRequired )
            throw(CmdLineParseException("One or more required arguments missing!"));

         if ( requiredCount > _numRequired )
            throw(CmdLineParseException("Too many arguments!"));

      } catch ( ArgException e ) { 
     
         if( printOnError == false )
         {
            throw(CmdLineParseException(e.error()));
            return;
         }
           _output->failure(*this,e); 

           int oldNotifyLevel = DtNotifyLevel;
           DtNotifyLevel = 3;

           if (myPressAnyKey)
           {
              DtInfo << "Press any key to continue" << std::endl;

              while (DtPollBlockingInputChar() == '\0')
              {
                 DtSleep(0.1);
              }
           }
           
           DtNotifyLevel = oldNotifyLevel;
           
           exit(1); 
        }
   }

   inline bool CmdLine::_emptyCombined(const std::string& s)
   {
      if ( s[0] != Arg::flagStartChar() )
         return false;

      for ( int i = 1; (unsigned int)i < s.length(); i++ )
         if ( s[i] != Arg::blankChar() )
            return false;

      return true;
   }

   inline void CmdLine::deleteOnExit(Arg* ptr)
   {
      _argDeleteOnExitList.push_back(ptr);
   }

   inline void CmdLine::deleteOnExit(Visitor* ptr)
   {
      _visitorDeleteOnExitList.push_back(ptr);
   }

   inline CmdLineOutput* CmdLine::getOutput()
   {
      return _output;
   }

   inline void CmdLine::setOutput(CmdLineOutput* co)
   {
      _userSetOutput = true;
      _output = co;
   }

   inline std::string& CmdLine::getVersion()
   {
      return _version;
   }

   inline std::string& CmdLine::getProgramName()
   {
      return _progName;
   }

   inline std::list<Arg*>& CmdLine::getArgList()
   {
      return _argList;
   }

   inline XorHandler& CmdLine::getXorHandler()
   {
      return _xorHandler;
   }

   inline char CmdLine::getDelimiter()
   {
      return _delimiter;
   }

   inline std::string& CmdLine::getMessage()
   {
      return _message;
   }

   //End CmdLine.cpp



} //namespace DtCmdLine

#ifdef DtUSE_UTILITIES_NAMESPACE
}     
#endif

#endif