Public Member Functions | Public Attributes | Private Member Functions | Private Attributes | Friends

ap_Argument Class Reference
[Parser for config files; validation]

#include <ap.h>

List of all members.

Public Member Functions

 ap_Argument ()
 default constructor prepare object for exclusive command group
 ap_Argument (ap_ArgType_e a_argType, ap_Presence_e a_presence=pr_OPTIONAL, const char *a_long="", const char *a_short="", bool a_exclusive=false)
 constructor for parameters, non eclusive groups, any other argument
 ap_Argument (ivd_CliCommand_e a_cliCommand, const char *a_long, const char *a_short, bool a_exclusive=false)
 constructor for cli command
 ap_Argument (const char *a_long)
 constructor for cli
 ap_Argument (const string &a_long)
 ap_Argument (const ap_Argument &a_arg)
void Parse (UInt32_t a_argc, char *a_argv[], pf_ValueList &a_parsed) const
 owner name is passed by groupParse method if group has exclusive attribut set.
void GroupDump (ostream &a_os) const
void GroupList (ostream &a_os) const
ap_Argumentoperator<< (const ap_Argument &a_arg_p) const
ap_Argumentoperator= (const ap_Argument &a_arg)
ap_Argumentoperator<< (bool a_hidden) const

Public Attributes

string m_long
const char * m_short
ivd_CliCommand_e m_cliCommand

Private Member Functions

bool ArgParse (UInt32_t &a_idx, UInt32_t a_argc, char *a_argv[], pf_ValueList &a_parsed, int &a_shortOptIdx, bool a_necessary, const char *a_ownerName="", bool a_allHasShort=false) const
bool GroupParse (UInt32_t &a_idx, UInt32_t a_argc, char *a_argv[], pf_ValueList &a_parsed, bool a_necessary) const

Private Attributes

ap_ArgType_e m_argType
 argument type
ap_Presence_e m_presence
bool m_exclusive
bool m_allHasShort
ap_Argument_p_v_t m_group_v
vector< UInt8_tm_mandatoryEl_v
bool m_hidden

Friends

IVD_PARSER_DECL_d ostream & operator<< (ostream &a_os, const ap_Argument &a_grp)

Detailed Description

Definition at line 75 of file ap.h.


Constructor & Destructor Documentation

ap_Argument::ap_Argument (  ) 

default constructor prepare object for exclusive command group

Definition at line 61 of file ap.cpp.

        :
        m_argType(at_GROUP),
        m_presence(pr_MANDATORY),
        m_long(ap_valCmdName),
        m_short(""),
        m_cliCommand(cc_SENTINEL),
        m_exclusive(true),
        m_allHasShort(true), // when passed arg that hasn't short opt became false
        m_hidden(false)
{
    // empty
}

ap_Argument::ap_Argument ( ap_ArgType_e  a_argType,
ap_Presence_e  a_presence = pr_OPTIONAL,
const char *  a_long = "",
const char *  a_short = "",
bool  a_exclusive = false 
)

constructor for parameters, non eclusive groups, any other argument

Parameters:
a_short long command/option name
a_exclusive short command/option name

Definition at line 77 of file ap.cpp.

        :
        m_argType(a_argType),
        m_presence(a_presence),
        m_long(a_long),
        m_short(a_short),
        m_cliCommand(cc_SENTINEL),
        m_exclusive(a_exclusive),
        m_allHasShort(true), // when passed arg that hasn't short opt became false
        m_hidden(false)
{
    // empty
}

ap_Argument::ap_Argument ( ivd_CliCommand_e  a_cliCommand,
const char *  a_long,
const char *  a_short,
bool  a_exclusive = false 
)

constructor for cli command

Parameters:
a_short long command/option name
a_exclusive short command/option name

Definition at line 98 of file ap.cpp.

        :
        m_argType(at_COMMAND),
        m_presence(pr_MANDATORY),
        m_long(a_long),
        m_short(a_short),
        m_cliCommand(a_cliCommand),
        m_exclusive(a_exclusive),
        m_allHasShort(true), // when passed arg that hasn't short opt became false
        m_hidden(false)
{
    // empty
}

ap_Argument::ap_Argument ( const char *  a_long  ) 

constructor for cli

Definition at line 118 of file ap.cpp.

        :
        m_argType(at_CLI),
        m_presence(pr_ELEMENTSPEC),
        m_long(a_long),
        m_short(""),
        m_cliCommand(cc_SENTINEL),
        m_exclusive(false),
        m_allHasShort(true), // when passed arg that hasn't short opt became false
        m_hidden(false)
{
    // empty
}

ap_Argument::ap_Argument ( const string &  a_long  ) 

Definition at line 134 of file ap.cpp.

        :
        m_argType(at_CLI),
        m_presence(pr_ELEMENTSPEC),
        m_long(a_long),
        m_short(""),
        m_cliCommand(cc_SENTINEL),
        m_exclusive(false),
        m_allHasShort(true), // when passed arg that hasn't short opt became false
        m_hidden(false)
{
    // empty
}

ap_Argument::ap_Argument ( const ap_Argument a_arg  )  [inline]

Definition at line 99 of file ap.h.

                                          {
        *this = a_arg;
    };


Member Function Documentation

bool ap_Argument::ArgParse ( UInt32_t a_idx,
UInt32_t  a_argc,
char *  a_argv[],
pf_ValueList a_parsed,
int &  a_shortOptIdx,
bool  a_necessary,
const char *  a_ownerName = "",
bool  a_allHasShort = false 
) const [private]

Definition at line 202 of file ap.cpp.

References pf_List::Add(), pf_ValueList::Add(), at_COMMAND, at_GROUP, at_MULTIPAR, at_OPTION, at_PARAMETER, cc_DEFAULT, cmn_Num2Str(), GroupParse(), ie_AP_INVARGTYPE, ie_AP_SYNERR, ivd_Error, m_argType, m_cliCommand, m_long, and m_short.

{
    if (a_idx >= a_argc) { // no more arguments
        return false;
    }
    const char *arg = a_argv[a_idx];
//    cout << " parse arg " << arg
//         << " check with " << m_long
//         << " presence = " << m_presence
//         << endl;

    if (   m_argType    == at_GROUP
        || m_cliCommand == cc_DEFAULT) { // it's a group go directly there
        // if group parsed some argument then return true
        return GroupParse(a_idx, a_argc, a_argv, a_parsed, a_necessary);
    }

    if (*arg == '-') {
        if (arg[1] == '-') { // long command/option
           if (strcmp((const char*)(&arg[2]), (const char*)(m_long.c_str()) ) != 0) {
               return false;
           }
           a_idx++; // next arg to parse
        }
        else if (arg[1] != '\0') { // short command/option
           if (arg[a_shortOptIdx] != *m_short) {
               return false;
           }
           a_shortOptIdx++;
           if (arg[a_shortOptIdx] == '\0') { // no more short option in arg
               a_idx++; // next arg to parse
               a_shortOptIdx = 1;
           }
        }
        else { //
            throw ivd_Error(ie_AP_SYNERR, "single '-' option not supported.");
        }
        // Use a_ownername instead ap_valCmdName only for command.
        // Every exclusive group is evaluate by its name
        // and it is used short opt if all have it.
        if (m_argType == at_COMMAND) { // always long for command
            a_parsed.Add(pf_Value(a_ownerName, cmn_Num2Str(m_cliCommand), 0));
        }
        else if (*a_ownerName != '\0') {
            if (   a_allHasShort ) {
                a_parsed.Add(pf_Value(a_ownerName, m_short, 0));
            }
            else {
                a_parsed.Add(pf_Value(a_ownerName, m_long, 0));
            }
        }
        else if (m_argType == at_OPTION) {
            a_parsed.Add(pf_Value(m_long, "true", 0));
        }
        else { // this should not happened at customer
               // whong argument parameters in ap.cpp file
            throw ivd_Error(ie_AP_INVARGTYPE, string(m_long));
        }
    }
    else { // if (*arg = '-')
        if (m_argType == at_PARAMETER ) {
            a_parsed.Add(pf_Value(m_long, arg, 0));
            a_idx++; // next arg to parse
        }
        else if (m_argType == at_MULTIPAR) {
            pf_List list(0);

            do {
                list.Add(pf_Elem(arg, 0));
                a_idx++;
                if (a_idx >= a_argc) {
                    break;
                }
                arg = a_argv[a_idx];
            } while (*arg != '-');

            a_parsed.Add(pf_Value(m_long, list, 0));
        }
        else { // nothing match, so skip group parse too
//            cout << "Nothing match, so skip group parse too. arg " << arg
//                 << "  group " << m_long << endl;
            return false;
        }
    } // if (*arg = '-')

    // merged short options can't have group
    if (a_shortOptIdx == 1) {
        // necessary argument is allways passed as true
        // argument is parsed, so its options need to be parsed too
        GroupParse(a_idx, a_argc, a_argv, a_parsed, true);
    }
//    cout << "return from group " << m_long << endl;
    return true;
}

Here is the call graph for this function:

void ap_Argument::GroupDump ( ostream &  a_os  )  const

Definition at line 562 of file ap.cpp.

References ap_argLevel_g, ap_cmdName, ap_sizeUpTo3rdLevel_g, ap_valCmdName, at_COMMAND, m_exclusive, m_group_v, m_long, and m_presence.

Referenced by operator<<().

                                               {
    if (m_group_v.size() == 0) {
        return;
    }
    ap_argLevel_g++;

    bool excl = m_exclusive;
    bool opt  = m_presence == pr_OPTIONAL;

    int leve3WriteOffset = 0;
    if (excl && !opt && m_long != ap_valCmdName) {
        a_os << '{';
        if (ap_argLevel_g < 3) {
            ap_sizeUpTo3rdLevel_g += 1;
        }
        else if(ap_argLevel_g == 3) {
            leve3WriteOffset = ap_sizeUpTo3rdLevel_g;
        }
    }

    ap_Argument_p_v_i iter          = m_group_v.begin();
    ap_Argument_p_v_i oneBeforeLast = m_group_v.end();
    oneBeforeLast--;

    for (; iter != oneBeforeLast; ++iter) {
        if (ap_argLevel_g == 2) {
            ap_sizeUpTo3rdLevel_g = 0;
//            a_os << " R ";
        }
//        a_os << "L:" << ap_argLevel_g << " S: " << ap_sizeUpTo3rdLevel_g << " ";
        if ((**iter).m_argType == at_COMMAND) {
            a_os << "  " << ap_cmdName << " ";
            if (ap_argLevel_g < 3) {
                ap_sizeUpTo3rdLevel_g += 3 + string(ap_cmdName).length();
//                a_os << "S: " << ap_sizeUpTo3rdLevel_g << " ";
            }
        }
        a_os << **iter;
        if ((**iter).m_argType == at_COMMAND) { // new line after command
            a_os << endl;
        }
        else {
            a_os << " ";
            if (ap_argLevel_g < 3) {
                ap_sizeUpTo3rdLevel_g += 1;
//                a_os << "S: " << ap_sizeUpTo3rdLevel_g << " ";
            }

            if (excl) {
                if (ap_argLevel_g == 3) {
                    a_os << endl << string(leve3WriteOffset, ' ');
                }
                a_os << "| ";
                if (ap_argLevel_g < 3) {
                    ap_sizeUpTo3rdLevel_g += 1;
//                    a_os << "S: " << ap_sizeUpTo3rdLevel_g << " ";
                }
            }
        }

    }
    if ((**oneBeforeLast).m_argType == at_COMMAND) {
        a_os << "  " << ap_cmdName << " ";
    }
    a_os << **oneBeforeLast;
    if ((**oneBeforeLast).m_argType == at_COMMAND) {
        a_os << endl << endl << "Common options:" << endl;
    }

    if (excl && !opt && m_long != ap_valCmdName) {
        a_os << '}';
        if (ap_argLevel_g < 3) {
            ap_sizeUpTo3rdLevel_g += 1;
//            a_os << "S: " << ap_sizeUpTo3rdLevel_g << " ";
        }
    }
    ap_argLevel_g--;
}

Here is the caller graph for this function:

void ap_Argument::GroupList ( ostream &  a_os  )  const

Definition at line 643 of file ap.cpp.

References m_group_v.

                                               {
    ap_Argument_p_v_i iter          = m_group_v.begin();
    ap_Argument_p_v_i oneBeforeLast = m_group_v.end();
    oneBeforeLast--;
    for (; iter != oneBeforeLast; ++iter) {
        a_os << (**iter).m_long << ", ";
    }
    a_os << (**oneBeforeLast).m_long;
}

bool ap_Argument::GroupParse ( UInt32_t a_idx,
UInt32_t  a_argc,
char *  a_argv[],
pf_ValueList a_parsed,
bool  a_necessary 
) const [private]

Definition at line 306 of file ap.cpp.

References alloca(), cc_DEFAULT, ie_AP_NOOPTION, ie_AP_NOTENOUGH, ie_AP_SYNERR, ivd_Error, m_allHasShort, m_exclusive, m_group_v, m_long, m_mandatoryEl_v, m_presence, pr_MANDATORY, pr_OPTIONAL, and size.

Referenced by ArgParse(), and Parse().

                                            {

    int size = m_group_v.size();
    if (size == 0) {// return if group is empty
//        cout << " group of " << m_long << " is empty" << endl;
        return false;
    }
//    cout << " parse group of " << m_long
//         << " exclusive = " << m_exclusive
//         << endl;

    char * groupNameArg = a_argv[a_idx-1];

    // nothing is parsed yet
    bool *parsed = (bool*)alloca(size * sizeof(bool));
    bool *p = parsed;
    for (int j = 0; j < size; ++j, ++p) {
        *p = false;
    }

    // need when parse merged short options
    int shortOptIdx = 1;
    bool someParsed = false;
    bool someParsedPerPass;
    int defaultCmdIdx = -1;
    ap_Argument_p_v_i defCmdIter;
    do {
        someParsedPerPass = false;
        ap_Argument_p_v_i iter = m_group_v.begin();
        for (int i = 0; i < size; ++i, ++iter) {
            if (!parsed[i]) { // not parsed yet
                if ((*iter)->m_cliCommand == cc_DEFAULT)  {
                    defaultCmdIdx = i; // default command mest be parsed as last
                    defCmdIter = iter;
                }
                else if ((*iter)->ArgParse(a_idx, a_argc, a_argv, a_parsed,
                                        shortOptIdx,
                                        // if argument is mandatory and contain not exclusive group
                                        // then its next level arguments are mandatory to parse
                                        m_presence == pr_MANDATORY && !m_exclusive,
                                        m_exclusive
                                        ? m_long.c_str()  // if exclusive pass group name
                                        : "",    // to evaluate it by choiced opt
                                        m_allHasShort)) {
                    parsed[i] = someParsed = someParsedPerPass = true;
                    if (m_exclusive) {
                        goto foundExclusive; // got one;
                    }
                }
            }
        }
    } while (someParsedPerPass);
    if (defaultCmdIdx != -1) { // default command parsed as last
        if ((*defCmdIter)->ArgParse(a_idx, a_argc, a_argv, a_parsed,
                            shortOptIdx,
                            m_presence != pr_OPTIONAL,
                            m_exclusive
                            ? m_long.c_str()  // if exclusive pass group name
                            : "",    // to evaluate it by choiced opt
                            m_allHasShort)) {
            parsed[defaultCmdIdx] = someParsed = true;
            if (m_exclusive) {
                goto foundExclusive; // got one;
            }
        }
    }

    //cout << " "
    //     << " presence = " << m_presence
    //     << " some parsed = " << someParsed
    //     << " grupName = " << m_long
    //     << " needed " << a_necessary
    //     << endl;

    if (    m_presence != pr_OPTIONAL
        &&  a_necessary) {
        if (m_exclusive) {
            // fix bug 677  check if group is optional
            if (!someParsed) {
//                char * lastArg = a_argv[a_idx-1];
// TODO: Windows workaround for "Unknown exception" (bugs 1249 & 3136)
// NOTE! Do not use ostringstream. It does not work on Windows.
                string msg("No argument(s) specified for '");
                msg += groupNameArg;
                msg += "'";
                throw ivd_Error(ie_AP_NOOPTION, msg);
            }
        }
        else {
            // check if all mandatory arguments are parsed
            for (int n = 0; n < size; ++n) {
                if (    m_mandatoryEl_v[n]
                    && !parsed[n] ) {

//                    char * lastArg = a_argv[a_idx-1];
// TODO: Windows workaround for "Unknown exception" (bug 1249)
// NOTE! Do not use ostringstream. It does not work on Windows.
                    string msg("No argument(s) specified for '");
                    msg += groupNameArg;
                    msg += "'";
                    throw ivd_Error(ie_AP_NOTENOUGH, msg);
                }
            }
        }
    }

foundExclusive:
    if (shortOptIdx != 1) {
        char * stopArg = a_argv[a_idx];
        string message;
        { //NOTE NOTE NOTE!!! Strange, but Windows thrown an error if use throw
          // in same bloc as ostring stream. See bug 5335.
         // ostring stream destructor must not be in same block as throw ivd_Error
            ostringstream msg;
            msg << "'" << stopArg
                << "' on char '" << stopArg[shortOptIdx]
                << "' index " << shortOptIdx
                << ". Maybe long option without -- prefix.";
            message = msg.str();
        }
        throw ivd_Error(ie_AP_SYNERR, message );
    }
    return someParsed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ap_Argument & ap_Argument::operator<< ( const ap_Argument a_arg_p  )  const

Definition at line 438 of file ap.cpp.

References ie_AP_ALREADYEXIST, ivd_Error, m_allHasShort, m_exclusive, m_group_v, m_long, m_mandatoryEl_v, m_presence, m_short, and pr_MANDATORY.

                                                                   {
    if (m_allHasShort && m_exclusive) {
        if (*a_arg.m_short == '\0') {
            m_allHasShort = false;
        }
        else { // check if arg short opt isn't already in group
            ap_Argument_p_v_i iter = m_group_v.begin();
            for (; iter != m_group_v.end(); ++iter) {
                if ((**iter).m_short ==  a_arg.m_short) {
                    throw ivd_Error(ie_AP_ALREADYEXIST, string(m_long));
                }
            }
        }
    }
    m_group_v.push_back(const_cast<ap_Argument*>(&a_arg));
    m_mandatoryEl_v.push_back((a_arg.m_presence == pr_MANDATORY));
    return *const_cast<ap_Argument*>(this);
}

ap_Argument & ap_Argument::operator<< ( bool  a_hidden  )  const

Definition at line 458 of file ap.cpp.

References m_hidden.

                                                        {
    m_hidden = true;
    return *const_cast<ap_Argument*>(this);
}

ap_Argument & ap_Argument::operator= ( const ap_Argument a_arg  ) 

Definition at line 150 of file ap.cpp.

References m_allHasShort, m_argType, m_cliCommand, m_exclusive, m_group_v, m_hidden, m_long, m_mandatoryEl_v, m_presence, and m_short.

                                                            {

    if (this == const_cast<ap_Argument*>(&a_arg)) {
        return *this;
    }

        m_argType       = a_arg.m_argType ;
        m_presence      = a_arg.m_presence;
        m_long          = a_arg.m_long    ;
        m_short         = a_arg.m_short   ;
        m_cliCommand    = a_arg.m_cliCommand;
        m_exclusive     = a_arg.m_exclusive;
        m_allHasShort   = a_arg.m_allHasShort;
        m_group_v       = a_arg.m_group_v;
        m_mandatoryEl_v = a_arg.m_mandatoryEl_v;
        m_hidden        = a_arg.m_hidden;
        return *this;
}

void ap_Argument::Parse ( UInt32_t  a_argc,
char *  a_argv[],
pf_ValueList a_parsed 
) const

owner name is passed by groupParse method if group has exclusive attribut set.

This name is used to evaluate it with choised option

Definition at line 171 of file ap.cpp.

References pf_ValueList::Add(), ap_valArg0Name, at_CLI, ivd_BaseException::GetContext(), ivd_BaseException::GetError(), GroupParse(), ie_AP_INVGROUPTYPE, ie_AP_SYNERR, ivd_Error, m_argType, m_long, and pr_MANDATORY.

Referenced by cfg_Cli_fsc::cfg_Cli_fsc(), cfg_Cli_hsm::cfg_Cli_hsm(), cfg_CliBak::cfg_CliBak(), cfg_CliCheck::cfg_CliCheck(), cfg_CliCreateFile::cfg_CliCreateFile(), cfg_CliDD::cfg_CliDD(), cfg_CliDrive::cfg_CliDrive(), cfg_CliFile::cfg_CliFile(), cfg_CliFsTest::cfg_CliFsTest(), cfg_CliJob::cfg_CliJob(), cfg_CliLibrary::cfg_CliLibrary(), cfg_CliMedium::cfg_CliMedium(), cfg_CliPartition::cfg_CliPartition(), cfg_CliPool::cfg_CliPool(), cfg_CliRecover::cfg_CliRecover(), cfg_CliSystem::cfg_CliSystem(), and cfg_ivddbg::cfg_ivddbg().

                                                      {

    UInt32_t argIdx = 1;

    if (m_argType == at_CLI) {
        a_parsed.Add(pf_Value(ap_valArg0Name, a_argv[0], 0));
        pf_ValueList parsed;
        try {
            GroupParse(argIdx, a_argc, a_argv, a_parsed, pr_MANDATORY);
            // all argument must be parsed before exit
            if (argIdx < a_argc) {
                throw ivd_Error(ie_AP_SYNERR, string(a_argv[argIdx]));
            }
        }
        catch (ivd_Error &e) {
            ostringstream msg;
            msg << e.GetContext() << endl
                << "Run '" << m_long << " --help' for more information.";
            throw ivd_Error(e.GetError(), msg.str());
        }
    }
    else {
        throw ivd_Error(ie_AP_INVGROUPTYPE,
                        "Initial argument must be at_CLI type.");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:


Friends And Related Function Documentation

IVD_PARSER_DECL_d ostream& operator<< ( ostream &  a_os,
const ap_Argument a_grp 
) [friend]

Definition at line 471 of file ap.cpp.

                                                              {

    if (  !ap_showHidden
       && a_arg.m_hidden) {
        return a_os;
    }

    bool opt         = a_arg.m_presence == pr_OPTIONAL;
    bool hasElements = a_arg.m_group_v.size() > 0;
    if (opt) {
        a_os << '[';
        if (ap_argLevel_g < 4) {
            ap_sizeUpTo3rdLevel_g++;
        }
    }
    switch (a_arg.m_argType) {
    case at_COMMAND :
        if (a_arg.m_cliCommand == cc_DEFAULT) { // default command has not name
            break;
        }
        // break intentionally left out - fall through
    case at_OPTION : {
        bool srt = *a_arg.m_short != '\0';
        if (srt) {
            if (!opt || hasElements) {
                a_os << "{";
                if (ap_argLevel_g < 4) {
                    ap_sizeUpTo3rdLevel_g++;
                }
            }
            a_os  << "-" << a_arg.m_short << " | ";
            if (ap_argLevel_g < 4) {
                ap_sizeUpTo3rdLevel_g += 5;
            }
        }
        a_os << "--" << a_arg.m_long;
        if (ap_argLevel_g < 4) {
            ap_sizeUpTo3rdLevel_g += 2 + string(a_arg.m_long).length();
        }
        if (srt && (!opt || hasElements)) {
            a_os << '}';
            if (ap_argLevel_g < 4) {
                ap_sizeUpTo3rdLevel_g += 1;
            }
        }
        if (hasElements) {
            a_os << " ";
            if (ap_argLevel_g < 4) {
                ap_sizeUpTo3rdLevel_g += 1;
            }
        }
        break;
    }
    case at_PARAMETER :
    case at_MULTIPAR :
        a_os << a_arg.m_long;
        if (hasElements) {
            a_os << " ";
            if (ap_argLevel_g < 4) {
                ap_sizeUpTo3rdLevel_g += 1;
            }
        }
        break;

    case at_GROUP :
        break;
    case at_CLI :
        a_os << "Usage: " << endl;

        // ugly: hat to store in global
        ap_cmdName = a_arg.m_long.c_str();
        break;

    default : ;
    }

    if (hasElements) {
        a_arg.GroupDump(a_os);
    }

    if (opt) {
        a_os << ']';
        if (ap_argLevel_g < 4) {
            ap_sizeUpTo3rdLevel_g += 1;
        }
    }
    return a_os;
}


Member Data Documentation

bool ap_Argument::m_allHasShort [mutable, private]

Definition at line 155 of file ap.h.

Referenced by GroupParse(), operator<<(), and operator=().

argument type

Definition at line 145 of file ap.h.

Referenced by ArgParse(), operator<<(), operator=(), and Parse().

Definition at line 151 of file ap.h.

Referenced by ArgParse(), operator<<(), and operator=().

bool ap_Argument::m_exclusive [private]

Definition at line 154 of file ap.h.

Referenced by GroupDump(), GroupParse(), operator<<(), and operator=().

Definition at line 157 of file ap.h.

Referenced by GroupDump(), GroupList(), GroupParse(), operator<<(), operator<<(), and operator=().

bool ap_Argument::m_hidden [mutable, private]

Definition at line 159 of file ap.h.

Referenced by operator<<(), operator<<(), and operator=().

Definition at line 158 of file ap.h.

Referenced by GroupParse(), operator<<(), and operator=().

Definition at line 147 of file ap.h.

Referenced by GroupDump(), GroupParse(), operator<<(), operator<<(), and operator=().

const char* ap_Argument::m_short

Definition at line 150 of file ap.h.

Referenced by ArgParse(), operator<<(), operator<<(), and operator=().


The documentation for this class was generated from the following files: