wibble::commandline::Engine Class Reference

Parse commandline options. More...

`#include <engine.h>`

Inheritance diagram for wibble::commandline::Engine:
[legend]
Collaboration diagram for wibble::commandline::Engine:
[legend]

## Public Member Functions

const std::string & | name () const
Option * | add (Option *o)
| Add an Option to this engine. More...
OptionGroup * | add (OptionGroup *group)
| Add an OptionGroup to this engine. More...
Engine * | add (Engine *o)
| Add a Engine to this engine. More...
template<typename T >
T * | create (const std::string &name, char shortName, const std::string &longName, const std::string &usage=std::string(), const std::string &description=std::string())
| Create an option. More...
template<typename T >
T * | add (const std::string &name, char shortName, const std::string &longName, const std::string &usage=std::string(), const std::string &description=std::string())
| Create an option and add to this engine. More...
OptionGroup * | createGroup (const std::string &description)
| Create an OptionGroup. More...
OptionGroup * | addGroup (const std::string &description)
| Create an OptionGroup and add it to this engine. More...
Engine * | createEngine (const std::string &name, const std::string &usage=std::string(), const std::string &description=std::string(), const std::string &longDescription=std::string())
| Create a Engine. More...
Engine * | addEngine (const std::string &name, const std::string &usage=std::string(), const std::string &description=std::string(), const std::string &longDescription=std::string())
| Create a Engine and add it to this engine as a command. More...
const std::vector< OptionGroup * > & | groups () const
| Get the OptionGroups that have been added to this engine. More...
const std::vector< Option * > & | options () const
| Get the Options that have been added to this engine. More...
const std::vector< Engine * > & | commands () const
| Get the Engines that have been added to this engine. More...
Engine * | command (const std::string &name) const
bool | hasOptions () const
| Returns true if this Engine has options to parse. More...
Engine * | foundCommand () const
| Return the command that has been found in the commandline, or NULL if none have been found. More...
void | dump (std::ostream &out, const std::string &prefix=std::string())
Public Member Functions inherited from wibble::commandline::Managed
virtual | ~Managed ()

## Public Attributes

std::string | primaryAlias
std::vector< std::string > | aliases
std::string | usage
std::string | description
std::string | longDescription
std::string | examples
bool | hidden
bool | no_switches_after_first_arg

## Protected Member Functions

void | addWithoutAna (Option *o)
void | addWithoutAna (const std::vector< Option * > &o)
void | add (const std::string &alias, Engine *o)
void | rebuild ()
std::pair< ArgList::iterator, bool > | parseFirstIfKnown (ArgList &list, ArgList::iterator begin)
| Handle the commandline switch at 'begin'. More...
ArgList::iterator | parseKnownSwitches (ArgList &list, ArgList::iterator begin)
| Parse all known Options and leave the rest in list. More...
ArgList::iterator | parseList (ArgList &list)
| Parse the list of arguments, starting at the beginning and removing the arguments it successfully parses. More...
ArgList::iterator | parse (ArgList &list, ArgList::iterator begin)
| Parse all the switches in list, leaving only the non-switch arguments or the arguments following "--". More...
| Engine (MemoryManager *mman=0, const std::string &name=std::string(), const std::string &usage=std::string(), const std::string &description=std::string(), const std::string &longDescription=std::string())

## Protected Attributes

std::vector< OptionGroup * > | m_groups
std::vector< Option * > | m_options
std::vector< Engine * > | m_commands
std::map< char, Option * > | m_short
std::map< std::string, Option * > | m_long
std::map< std::string, Engine * > | m_aliases
Engine * | m_found_command

## Friends

class | Parser

## Detailed Description

Parse commandline options.

Normally it parses short or long switches all starting with '-'

If other engines are added, then looks in the commandline for a non-switch command to select the operation mode. This allow to have a custom set of commandline options for every non-switch command.

## Constructor & Destructor Documentation

wibble::commandline::Engine::Engine | ( | MemoryManager * | mman = `0`,
|  | const std::string & | name = `std::string()`,
|  | const std::string & | usage = `std::string()`,
|  | const std::string & | description = `std::string()`,
|  | const std::string & | longDescription = `std::string()`
| ) |  |

inline protected

Referenced by createEngine().

## Member Function Documentation

void Engine::add | ( | const std::string & | alias,
|  | Engine * | o
| ) |  |

protected

References wibble::iterator().

Referenced by add(), addEngine(), addGroup(), and withCommands().

Option * Engine::add | ( | Option * | o | ) |

Add an Option to this engine.

OptionGroup * Engine::add | ( | OptionGroup * | group | ) |

Add an OptionGroup to this engine.

Engine * Engine::add | ( | Engine * | o | ) |

Add a Engine to this engine.

template<typename T >

T* wibble::commandline::Engine::add | ( | const std::string & | name,
|  | char | shortName,
|  | const std::string & | longName,
|  | const std::string & | usage = `std::string()`,
|  | const std::string & | description = `std::string()`
| ) |  |

inline

Create an option and add to this engine.

References add(), description, name(), and usage.

Engine* wibble::commandline::Engine::addEngine | ( | const std::string & | name,
|  | const std::string & | usage = `std::string()`,
|  | const std::string & | description = `std::string()`,
|  | const std::string & | longDescription = `std::string()`
| ) |  |

inline

Create a Engine and add it to this engine as a command.

References add(), createEngine(), description, longDescription, and usage.

Referenced by TestCommandlineDoc::basic(), wibble::commandline::StandardParserWithMandatoryCommand::StandardParserWithMandatoryCommand(), and withCommands().

OptionGroup* wibble::commandline::Engine::addGroup | ( | const std::string & | description | ) |

inline

Create an OptionGroup and add it to this engine.

References add(), and createGroup().

Referenced by TestCommandlineDoc::basic(), and wibble::commandline::StandardParser::StandardParser().

void Engine::addWithoutAna | ( | Option * | o | ) |

protected

References wibble::iterator(), wibble::commandline::Option::longNames, and wibble::commandline::Option::shortNames.

void Engine::addWithoutAna | ( | const std::vector< Option * > & | o | ) |

protected

Engine* wibble::commandline::Engine::command | ( | const std::string & | name | ) | const

inline

const std::vector<Engine*>& wibble::commandline::Engine::commands | ( |  | ) | const

inline

Get the Engines that have been added to this engine.

References m_commands.

Referenced by wibble::commandline::Manpage::output(), and wibble::commandline::Help::outputHelp().

template<typename T >

T* wibble::commandline::Engine::create | ( | const std::string & | name,
|  | char | shortName,
|  | const std::string & | longName,
|  | const std::string & | usage = `std::string()`,
|  | const std::string & | description = `std::string()`
| ) |  |

inline

Create an option.

References wibble::commandline::MemoryManager::add(), description, and usage.

Engine* wibble::commandline::Engine::createEngine | ( | const std::string & | name,
|  | const std::string & | usage = `std::string()`,
|  | const std::string & | description = `std::string()`,
|  | const std::string & | longDescription = `std::string()`
| ) |  |

inline

Create a Engine.

References wibble::commandline::MemoryManager::add(), description, Engine(), longDescription, and usage.

Referenced by addEngine().

OptionGroup* wibble::commandline::Engine::createGroup | ( | const std::string & | description | ) |

inline

Create an OptionGroup.

References wibble::commandline::MemoryManager::add().

Referenced by addGroup().

void Engine::dump | ( | std::ostream & | out,
|  | const std::string & | prefix = `std::string()`
| ) |  |

Engine* wibble::commandline::Engine::foundCommand | ( |  | ) | const

inline

Return the command that has been found in the commandline, or NULL if none have been found.

References m_found_command.

Referenced by withCommands().

const std::vector<OptionGroup*>& wibble::commandline::Engine::groups | ( |  | ) | const

inline

Get the OptionGroups that have been added to this engine.

References m_groups.

Referenced by wibble::commandline::Help::outputOptions().

bool wibble::commandline::Engine::hasOptions | ( |  | ) | const

inline

Returns true if this Engine has options to parse.

Referenced by wibble::commandline::Help::outputHelp().

const std::string& wibble::commandline::Engine::name | ( |  | ) | const

inline

Referenced by add(), wibble::commandline::Manpage::output(), wibble::commandline::StandardParserWithManpage::StandardParserWithManpage(), and withCommands().

const std::vector<Option*>& wibble::commandline::Engine::options | ( |  | ) | const

inline

Get the Options that have been added to this engine.

References m_options.

Referenced by wibble::commandline::Help::outputOptions().

ArgList::iterator Engine::parse | ( | ArgList & | list,
|  | ArgList::iterator | begin
| ) |  |

protected

Parse all the switches in list, leaving only the non-switch arguments or the arguments following "--".

References wibble::list::begin(), wibble::commandline::ArgList::isSwitch(), and wibble::iterator().

Referenced by parseList().

std::pair< ArgList::iterator, bool > Engine::parseFirstIfKnown | ( | ArgList & | list,
|  | ArgList::iterator | begin
| ) |  |

protected

Handle the commandline switch at 'begin'.

If the switch at 'begin' cannot be handled, the list is untouched and 'begin',false is returned. Else, the switch is removed and the new begin is returned.

References wibble::list::begin(), wibble::commandline::ArgList::eraseAndAdvance(), and wibble::iterator().

ArgList::iterator Engine::parseKnownSwitches | ( | ArgList & | list,
|  | ArgList::iterator | begin
| ) |  |

protected

Parse all known Options and leave the rest in list.

References wibble::list::begin(), wibble::commandline::ArgList::isSwitch(), and wibble::iterator().

ArgList::iterator wibble::commandline::Engine::parseList | ( | ArgList & | list | ) |

inline protected

Parse the list of arguments, starting at the beginning and removing the arguments it successfully parses.

Returns
  An iterator to the first unparsed argument (can be list.end())

References parse().

Referenced by wibble::commandline::Parser::parse().

void Engine::rebuild | ( |  | ) |

protected

## Friends And Related Function Documentation

friend class Parser

friend

## Member Data Documentation

std::vector<std::string> wibble::commandline::Engine::aliases

Referenced by wibble::commandline::Help::outputHelp().

std::string wibble::commandline::Engine::description

Referenced by add(), addEngine(), create(), createEngine(), wibble::commandline::Manpage::output(), wibble::commandline::Help::outputHelp(), and withCommands().

std::string wibble::commandline::Engine::examples

bool wibble::commandline::Engine::hidden

std::string wibble::commandline::Engine::longDescription

Referenced by addEngine(), createEngine(), wibble::commandline::Manpage::output(), and withCommands().

std::map<std::string, Engine*> wibble::commandline::Engine::m_aliases

protected

std::vector<Engine*> wibble::commandline::Engine::m_commands

protected

Referenced by commands().

Engine* wibble::commandline::Engine::m_found_command

protected

Referenced by foundCommand().

std::vector<OptionGroup*> wibble::commandline::Engine::m_groups

protected

Referenced by groups().

std::map<std::string, Option*> wibble::commandline::Engine::m_long

protected

std::vector<Option*> wibble::commandline::Engine::m_options

protected

Referenced by options().

std::map<char, Option*> wibble::commandline::Engine::m_short

protected

bool wibble::commandline::Engine::no_switches_after_first_arg

std::string wibble::commandline::Engine::primaryAlias

Referenced by wibble::commandline::Help::outputHelp().

std::string wibble::commandline::Engine::usage

Referenced by add(), addEngine(), create(), createEngine(), wibble::commandline::Manpage::output(), wibble::commandline::Help::outputHelp(), and withCommands().

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

- engine.h
- engine.cpp