cmdArg.h

Go to the documentation of this file.

/****************************************************************************** 
 * 
 *  file:  Arg.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_ARGUMENT_H
#define DtCmdLine_ARGUMENT_H

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

#include "cmdArgException.h"
#include "cmdVisitor.h"
#include "cmdLineInterface.h"

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

namespace DtCmdLine {

   class Arg
   {
   private: 

      static bool& ignoreRestRef() { static bool ign = false; return ign; }

      static char& delimiterRef() { static char delim = ' '; return delim; } 

   protected:

      std::string _flag;

      std::string _name;

      std::string _description;

      bool _required;

      std::string _requireLabel;

      bool _valueRequired;

      bool _alreadySet;

      Visitor* _visitor;

      bool _ignoreable;

      bool _xorSet;

      void _checkWithVisitor() const;

      Arg( const std::string& flag, 
           const std::string& name, 
           const std::string& desc, 
           bool req, 
           bool valreq,
           Visitor* v = NULL );

   public:
      virtual ~Arg();

      virtual void addToList( std::list<Arg*>& argList ) const;

      static void beginIgnoring() { ignoreRestRef() = true; }

      static bool ignoreRest() { return ignoreRestRef(); }

      static char delimiter() { return delimiterRef(); } 

      static const char blankChar() { return '*'; }

      static const char flagStartChar() { return '-'; }

      static const std::string flagStartString() { return "-"; }

      static const std::string nameStartString() { return "--"; }

      static const std::string ignoreNameString() { return "ignore_rest"; }

      static void setDelimiter( char c ) { delimiterRef() = c; }

      virtual bool processArg(int *i, std::vector<std::string>& args) = 0; 

      virtual bool operator==(const Arg& a);

      const std::string& getFlag() const;

      const std::string& getName() const;

      std::string getDescription() const;

      virtual bool isRequired() const;

      void forceRequired();

      void xorSet();

      bool isValueRequired() const;

      bool isSet() const;

      bool isIgnoreable() const;

      virtual bool argMatches( const std::string& s ) const;

      virtual std::string toString() const;

      virtual std::string shortID( const std::string& valueId = "val" ) const;

      virtual std::string longID( const std::string& valueId = "val" ) const;

      virtual void trimFlag( std::string& flag, std::string& value ) const;

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

      void setRequireLabel( const std::string& s );

   };

   typedef std::list<Arg*>::iterator ArgListIterator;

   typedef std::vector<Arg*>::iterator ArgVectorIterator;

   typedef std::list<Visitor*>::iterator VisitorListIterator;


   //BEGIN Arg.cpp

   inline Arg::Arg(const std::string& flag, 
                   const std::string& name, 
                   const std::string& desc, 
                   bool req, 
                   bool valreq,
                   Visitor* v) :
      _flag(flag),
      _name(name),
      _description(desc),
      _required(req),
      _requireLabel("required"),
      _valueRequired(valreq),
      _alreadySet(false),
      _visitor( v ),
      _ignoreable(true),
      _xorSet(false)
   {
      if ( _flag.length() > 1 ) 
         throw(SpecificationException(
                                      "Argument flag can only be one character long", toString() ) );

      if ( _name != ignoreNameString() &&  
           ( _flag == Arg::flagStartString() || 
             _flag == Arg::nameStartString() || 
             _flag == " " ) )
         throw(SpecificationException("Argument flag cannot be either '" + 
                                      Arg::flagStartString() + "' or '" + 
                                      Arg::nameStartString() + "' or a space.",
                                      toString() ) );

      if ( ( _name.find( Arg::flagStartString(), 0 ) != std::string::npos ) || 
           ( _name.find( Arg::nameStartString(), 0 ) != std::string::npos ) ||
           ( _name.find( " ", 0 ) != std::string::npos ) )
         throw(SpecificationException("Argument name cannot contain either '" + 
                                      Arg::flagStartString() + "' or '" + 
                                      Arg::nameStartString() + "' or space.",
                                      toString() ) );

   }

   inline Arg::~Arg() { }

   inline std::string Arg::shortID( const std::string& valueId ) const
   {
      std::string id = "";

      if ( _flag != "" )
         id = Arg::flagStartString() + _flag;
      else
         id = Arg::nameStartString() + _name;

      std::string delim = " "; 
      delim[0] = Arg::delimiter(); 

      if ( _valueRequired )
         id += delim + "<" + valueId  + ">";

      if ( !_required )
         id = "[" + id + "]";

      return id;
   }

   inline std::string Arg::longID( const std::string& valueId ) const
   {
      std::string id = "";

      if ( _flag != "" )
      {
         id += Arg::flagStartString() + _flag;

         if ( _valueRequired )
            id += " <" + valueId + ">";

         id += ",  ";
      }

      id += Arg::nameStartString() + _name;

      if ( _valueRequired )
         id += " <" + valueId + ">";

      return id;

   }

   inline bool Arg::operator==(const Arg& a)
   {
      if ( ( _flag != "" && _flag == a._flag ) || 
           (_name == a._name))
      {
         return true;
      }
      else
      {
         return false;
      }
   }

   inline std::string Arg::getDescription() const 
   {
      std::string desc = "";
      if ( _required )
         desc = "(" + _requireLabel + ")  ";

      //if ( _valueRequired )

      desc += _description;
      return desc; 
   }

   inline const std::string& Arg::getFlag() const { return _flag; }

   inline const std::string& Arg::getName() const { return _name; } 

   inline bool Arg::isRequired() const { return _required; }

   inline bool Arg::isValueRequired() const { return _valueRequired; }

   inline bool Arg::isSet() const 
   { 
      if ( _alreadySet && !_xorSet )
         return true;
      else
         return false;
   }

   inline bool Arg::isIgnoreable() const { return _ignoreable; }

   inline void Arg::setRequireLabel( const std::string& s) 
   { 
      _requireLabel = s;
   }

   inline bool Arg::argMatches( const std::string& argFlag ) const
   {
      if ( ( argFlag == Arg::flagStartString() + _flag && _flag != "" ) ||
           argFlag == Arg::nameStartString() + _name )
         return true;
      else
         return false;
   }

   inline std::string Arg::toString() const
   {
      std::string s = "";

      if ( _flag != "" )
         s += Arg::flagStartString() + _flag + " ";

   s += "(" + Arg::nameStartString() + _name + ")";

   return s;
}

inline void Arg::_checkWithVisitor() const
{
   if ( _visitor != NULL )
      _visitor->visit();
}

inline void Arg::trimFlag(std::string& flag, std::string& value) const
{
   int stop = 0;
   for ( int i = 0; (unsigned int)i < flag.length(); i++ )
      if ( flag[i] == Arg::delimiter() )
      {
         stop = i;
         break;
      }

   if ( stop > 1 )
   {
      value = flag.substr(stop+1);
      flag = flag.substr(0,stop);
   }

}

inline bool Arg::_hasBlanks( const std::string& s ) const
{
   for ( int i = 1; (unsigned int)i < s.length(); i++ )
      if ( s[i] == Arg::blankChar() )
         return true;

   return false;
}

inline void Arg::forceRequired()
{
   _required = true;
}

inline void Arg::xorSet()
{
   _alreadySet = true;
   _xorSet = true;
}

inline void Arg::addToList( std::list<Arg*>& argList ) const
{
   argList.push_front( (Arg*)this );
}

//END Arg.cpp

} //namespace DtCmdLine

#ifdef DtUSE_UTILITIES_NAMESPACE
}     
#endif

#endif