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;

        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();
                
                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::getValue() { return _value; }

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;

        // if the whole string matches the flag or name string
        if ( argMatches( args[*i] ) )
        {
                commonProcessing();

                return true;
        }
        // if a substring matches the flag as part of a combination
        else if ( combinedSwitchesMatch( args[*i] ) )
        {
                // check again to ensure we don't misinterpret 
                // this as a MultiSwitchArg 
                if ( combinedSwitchesMatch( args[*i] ) )
                        throw(CmdLineParseException("Argument already set!", 
                                                    toString()));

                commonProcessing();

                // We only want to return true if we've found the last combined
                // match in the string, otherwise we return true so that other 
                // switches in the combination will have a chance to match.
                return lastCombined( args[*i] );
        }
        else
                return false;
}

inline void SwitchArg::reset()
{
        Arg::reset();
        _value = _default;  
}
//End SwitchArg.cpp

} //namespace TCLAP

#endif