SwitchArg.h

Go to the documentation of this file.

// -*- Mode: c++; c-basic-offset: 4; tab-width: 4; -*-
 
/****************************************************************************** 
 * 
 *  file:  SwitchArg.h
 * 
 *  Copyright (c) 2003, Michael E. Smoot .
 *  Copyright (c) 2004, Michael E. Smoot, Daniel Aarno.
 *  Copyright (c) 2017, Google LLC
 *  All rights reserved.
 * 
 *  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_SWITCH_ARG_H
#define TCLAP_SWITCH_ARG_H
 
#include <string>
#include <vector>
 
#include <tclap/Arg.h>
 
namespace TCLAP {
 
class SwitchArg : public Arg
{
protected:
 
  bool _value;
 
  bool _default;
 
public:
 
  SwitchArg(const std::string& flag, 
        const std::string& name, 
        const std::string& desc,
        bool def = false,
        Visitor* v = NULL);
 
                                  
  SwitchArg(const std::string& flag, 
        const std::string& name, 
        const std::string& desc,
        CmdLineInterface& parser,
        bool def = false,
        Visitor* v = NULL);
                                  
                                  
  virtual bool processArg(int* i, std::vector<std::string>& args); 
 
  bool combinedSwitchesMatch(std::string& combined);
 
  bool getValue() const { return _value; }
 
  operator bool() const { return _value; }
                
  virtual void reset();
 
private:
  bool lastCombined(std::string& combined);
 
  void commonProcessing();
};
 
//BEGIN SwitchArg.cpp
inline SwitchArg::SwitchArg(const std::string& flag, 
                const std::string& name, 
                const std::string& desc, 
                bool default_val,
                Visitor* v )
  : Arg(flag, name, desc, false, false, v),
    _value( default_val ),
    _default( default_val )
{ }
 
inline SwitchArg::SwitchArg(const std::string& flag, 
                const std::string& name, 
                const std::string& desc, 
                CmdLineInterface& parser,
                bool default_val,
                Visitor* v )
  : Arg(flag, name, desc, false, false, v),
    _value( default_val ),
    _default(default_val)
{ 
  parser.add( this );
}
 
inline bool SwitchArg::lastCombined(std::string& combinedSwitches ) 
{
  for ( unsigned int i = 1; i < combinedSwitches.length(); i++ )
    if ( combinedSwitches[i] != Arg::blankChar() )
      return false;
        
  return true;
}
 
inline bool SwitchArg::combinedSwitchesMatch(std::string& combinedSwitches )
{
  // make sure this is actually a combined switch
  if ( combinedSwitches.length() > 0 &&
       combinedSwitches[0] != Arg::flagStartString()[0] )
    return false;
 
  // make sure it isn't a long name 
  if ( combinedSwitches.substr( 0, Arg::nameStartString().length() ) == 
       Arg::nameStartString() )
    return false;
 
  // make sure the delimiter isn't in the string 
  if ( combinedSwitches.find_first_of(Arg::delimiter()) != std::string::npos)
    return false;
 
  // ok, we're not specifying a ValueArg, so we know that we have
  // a combined switch list.  
  for ( unsigned int i = 1; i < combinedSwitches.length(); i++ )
    if ( _flag.length() > 0 && 
     combinedSwitches[i] == _flag[0] &&
     _flag[0] != Arg::flagStartString()[0] ) 
      {
    // update the combined switches so this one is no longer present
    // this is necessary so that no unlabeled args are matched
    // later in the processing.
    //combinedSwitches.erase(i,1);
    combinedSwitches[i] = Arg::blankChar(); 
    return true;
      }
 
  // none of the switches passed in the list match. 
  return false;   
}
 
inline void SwitchArg::commonProcessing()
{
  if ( _xorSet )
    throw(CmdLineParseException(
                "Mutually exclusive argument already set!", toString()));
 
  if ( _alreadySet ) 
    throw(CmdLineParseException("Argument already set!", toString()));
 
  _alreadySet = true;
 
  if ( _value == true )
    _value = false;
  else
    _value = true;
 
  _checkWithVisitor();
}
 
inline bool SwitchArg::processArg(int *i, std::vector<std::string>& args)
{
  if ( _ignoreable && Arg::ignoreRest() )
    return false;