Arg.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 TCLAP_ARGUMENT_H
#define TCLAP_ARGUMENT_H

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

#include <tclap/ArgException.h>
#include <tclap/Visitor.h>
#include <tclap/CmdLineInterface.h>

namespace TCLAP {

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;

  bool _acceptsMultipleValues;

  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;

  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 );

  virtual bool allowMore();
  virtual bool acceptsMultipleValues();
  
  virtual std::string getValueAsString()const = 0; 
};

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),
  _acceptsMultipleValues(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(); // ugly!!!
  
  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) const
{
  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 += "(value required)  ";

  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
{
  // allow matching for patterns like --load-dicom with --load_dicom 
  // (more standard and user friendly)
  // only change dashes to underscores if the string starts with --
  std::string fixedFlag(argFlag);
  if ( argFlag.find_first_of(Arg::nameStartString()) == 0 )
    {
    const std::string::size_type nameStartLen = Arg::nameStartString().length(); 
    std::string::size_type dashIndex; 
    while ( (dashIndex = fixedFlag.find_first_of("-", nameStartLen)) != std::string::npos )
      {
      fixedFlag[dashIndex] = '_';
      }
    }

  if ( ( fixedFlag == Arg::flagStartString() + _flag && _flag != "" ) ||
       fixedFlag == 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; static_cast<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; static_cast<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( const_cast<Arg*>(this) );
}

inline bool Arg::allowMore()
{
  return false;
}

inline bool Arg::acceptsMultipleValues()
{
  return _acceptsMultipleValues;
}

//END Arg.cpp

} //namespace TCLAP

#endif