switch_arg.hpp

Go to the documentation of this file.

 
/*****************************************************************************
** Ifdefs
*****************************************************************************/
 
#ifndef TCLAP_SWITCH_ARG_H
#define TCLAP_SWITCH_ARG_H
 
#include <string>
#include <vector>
 
#include "arg.hpp"
 
namespace ecl {
 
 
class SwitchArg : public Arg
{
        protected:
 
                bool _value;
 
        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();
 
};
 
//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,
                                        CmdLineInterface& parser,
                                        bool _default,
                                        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 || ( !ret && combinedSwitchesMatch( args[*i] ) ) )
                        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 ecl
 
 
#endif