Program Listing for File switch_arg.hpp

↰ Return to documentation for file (/tmp/ws/src/ecl_core/ecl_command_line/include/ecl/command_line/switch_arg.hpp)

/*****************************************************************************
** 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