DtVrvCommandLineParser.h

Go to the documentation of this file.

/****************************************************************************** 
 * 
 *  file:  DtVrvCommandLineParser.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.  
 *  
 *****************************************************************************/ 

#pragma once


#include <cmdLine/cmdLineInterface.h>

#include <vrvUtil/DtVrvCmdSwitchArg.h>
#include <cmdLine/cmdUnlabeledValueArg.h>
#include <cmdLine/cmdUnlabeledMultiArg.h>

#include <cmdLine/cmdXorHandler.h>
#include <cmdLine/cmdHelpVisitor.h>
#include <cmdLine/cmdVersionVisitor.h>
#include <cmdLine/cmdIgnoreRestVisitor.h>

#include <cmdLine/cmdLineOutput.h>
#include <cmdLine/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>

namespace makVrv {
   class CmdLine : public DtCmdLine::CmdLineInterface
   {
   protected:

      std::list<DtCmdLine::Arg*> _argList;

      std::string _progName;

      std::string _message;

      std::string _version;

      int _numRequired;

      char _delimiter;

      DtCmdLine::XorHandler _xorHandler;

      std::list<DtCmdLine::Arg*> _argDeleteOnExitList;

      std::list<DtCmdLine::Visitor*> _visitorDeleteOnExitList;

      DtCmdLine::CmdLineOutput* _output;

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

      bool myPressAnyKey;

   private:

      void _constructor();

      void deleteOnExit(DtCmdLine::Arg* ptr);

      void deleteOnExit(DtCmdLine::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( DtCmdLine::Arg& a );

      void add( DtCmdLine::Arg* a );

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

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

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

      DtCmdLine::CmdLineOutput* getOutput();

      void setOutput(DtCmdLine::CmdLineOutput* co);

      std::string& getVersion();

      std::string& getProgramName();

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

      DtCmdLine::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()
   {
      DtCmdLine::ArgListIterator argIter;
      DtCmdLine::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 DtCmdLine::StdOutput;

      DtCmdLine::Visitor *v;

      DtCmdLine::Arg::setDelimiter( _delimiter );

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

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

      v = new DtCmdLine::IgnoreRestVisitor();
      makVrv::SwitchArg* ignore  = new makVrv::SwitchArg(DtCmdLine::Arg::flagStartString(), 
                                         DtCmdLine::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<DtCmdLine::Arg*>& ors )
   {
      _xorHandler.add( ors );

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

         add( *it );
      }
   }

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

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

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

      a->addToList( _argList );

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

   inline void CmdLine::parse(int argc, char** argv, bool /*printOnError*/)
   {
      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 (DtCmdLine::ArgListIterator it = _argList.begin(); it != _argList.end(); ++it)
            {
               //This line changes the behavior of unlabeled multi args so that 
               // they are only included if they are before the ignore rest parameter
               if(!(*it)->isIgnoreable() || !DtCmdLine::Arg::ignoreRest())
               {
                  if ( (*it)->processArg( &i, args ) )
                  {
                     requiredCount += _xorHandler.check( *it );
                     matched = true;
                     break;
                  }
               }
               
            }

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

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

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

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

      } catch ( DtCmdLine::ArgException& e ) { 
           _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] != DtCmdLine::Arg::flagStartChar() )
         return false;

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

      return true;
   }

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

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

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

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

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

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

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

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

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

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

   //End CmdLine.cpp
}