SwitchArg.h

Go to the documentation of this file.

/****************************************************************************** 
 * 
 *  file:  SwitchArg.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_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;


     public:

          SwitchArg(const std::string& flag, 
                     const std::string& name, 
                     const std::string& desc,
                     bool def,
                      Visitor* v = NULL);

                      
          SwitchArg(const std::string& flag, 
                     const std::string& name, 
                     const std::string& desc,
                     bool def,
                      CmdLineInterface& parser,
                      Visitor* v = NULL);
                      
                      
          virtual bool processArg(int* i, std::vector<std::string>& args); 

          bool combinedSwitchesMatch(std::string& combined);

          bool getValue();
};

//BEGIN SwitchArg.cpp
inline SwitchArg::SwitchArg(const std::string& flag, 
                        const std::string& name, 
                          const std::string& desc, 
                     bool _default,
                          Visitor* v )
: Arg(flag, name, desc, false, false, v),
  _value( _default )
{ }

inline SwitchArg::SwitchArg(const std::string& flag, 
                         const std::string& name, 
                         const std::string& desc, 
                         bool _default,
                         CmdLineInterface& parser,
                         Visitor* v )
: Arg(flag, name, desc, false, false, v),
  _value( _default )
{ 
     parser.add( this );
}

inline bool SwitchArg::getValue() { return _value; }

inline bool SwitchArg::combinedSwitchesMatch(std::string& combinedSwitches )
{
     // make sure this is actually a combined switch
     if ( 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;

     // 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 ( combinedSwitches[i] == _flag[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 bool SwitchArg::processArg(int *i, std::vector<std::string>& args)
{
     if ( _ignoreable && Arg::ignoreRest() )
          return false;

     if ( argMatches( args[*i] ) || combinedSwitchesMatch( args[*i] ) )
     {
          // If we match on a combined switch, then we want to return false
          // so that other switches in the combination will also have a
          // chance to match.
          bool ret = false;
          if ( argMatches( args[*i] ) )
               ret = true;

          if ( _alreadySet )
               throw(CmdLineParseException("Argument already set!", toString()));    

          _alreadySet = true;

          if ( _value == true )
               _value = false;
          else
               _value = true;

          _checkWithVisitor();

          return ret;
     }
     else
          return false;
}

//End SwitchArg.cpp

} //namespace TCLAP

#endif

---