00001 #ifndef WIBBLE_COMMANDLINE_ENGINE_H
00002 #define WIBBLE_COMMANDLINE_ENGINE_H
00003
00004 #include <wibble/commandline/options.h>
00005 #include <string>
00006 #include <vector>
00007 #include <map>
00008 #include <iosfwd>
00009
00010 namespace wibble {
00011 namespace commandline {
00012
00013 #if 0
00014 -- This help is left around to be reintegrated when I found something
00015 appropriate. It documents the general behavior of functions in the form
00016 ArgList::iterator parse(ArgList& list, ArgList::iterator begin);
00017
00027 #endif
00028
00038 class Engine : public Managed
00039 {
00040 MemoryManager* m_manager;
00041 std::string m_name;
00042
00043 protected:
00044
00045 std::vector<OptionGroup*> m_groups;
00046 std::vector<Option*> m_options;
00047 std::vector<Engine*> m_commands;
00048
00049
00050 std::map<char, Option*> m_short;
00051 std::map<std::string, Option*> m_long;
00052 std::map<std::string, Engine*> m_aliases;
00053
00054
00055
00056 Engine* m_found_command;
00057
00058 void addWithoutAna(Option* o);
00059 void addWithoutAna(const std::vector<Option*>& o);
00060 void add(const std::string& alias, Engine* o);
00061
00062
00063 void rebuild();
00064
00072 std::pair<ArgList::iterator, bool> parseFirstIfKnown(ArgList& list, ArgList::iterator begin);
00073
00074 #if 0
00076 ArgList::iterator parseConsecutiveSwitches(ArgList& list, ArgList::iterator begin);
00077 #endif
00078
00080 ArgList::iterator parseKnownSwitches(ArgList& list, ArgList::iterator begin);
00081
00089 ArgList::iterator parseList(ArgList& list) { return parse(list, list.begin()); }
00090
00095 ArgList::iterator parse(ArgList& list, ArgList::iterator begin);
00096
00097
00098 Engine(MemoryManager* mman = 0, const std::string& name = std::string(),
00099 const std::string& usage = std::string(),
00100 const std::string& description = std::string(),
00101 const std::string& longDescription = std::string())
00102 : m_manager(mman), m_name(name), m_found_command(0), primaryAlias(name),
00103 usage(usage), description(description), longDescription(longDescription) {}
00104
00105 public:
00106 const std::string& name() const { return m_name; }
00107
00109 Option* add(Option* o);
00110
00112 OptionGroup* add(OptionGroup* group);
00113
00115 Engine* add(Engine* o);
00116
00120 template<typename T>
00121 T* create(const std::string& name,
00122 char shortName,
00123 const std::string& longName,
00124 const std::string& usage = std::string(),
00125 const std::string& description = std::string())
00126 {
00127 T* item = new T(name, shortName, longName, usage, description);
00128 if (m_manager) m_manager->add(item);
00129 return item;
00130 }
00131
00135 template<typename T>
00136 T* add(const std::string& name,
00137 char shortName,
00138 const std::string& longName,
00139 const std::string& usage = std::string(),
00140 const std::string& description = std::string())
00141 {
00142 T* res = create<T>(name, shortName, longName, usage, description);
00143 add(res);
00144 return res;
00145 }
00146
00150 OptionGroup* createGroup(const std::string& description)
00151 {
00152 OptionGroup* g = new OptionGroup(m_manager, description);
00153 if (m_manager) m_manager->add(g);
00154 return g;
00155 }
00156
00160 OptionGroup* addGroup(const std::string& description)
00161 {
00162 return add(createGroup(description));
00163 }
00164
00168 Engine* createEngine(const std::string& name,
00169 const std::string& usage = std::string(),
00170 const std::string& description = std::string(),
00171 const std::string& longDescription = std::string())
00172 {
00173 Engine* item = new Engine(m_manager, name, usage, description, longDescription);
00174 if (m_manager) m_manager->add(item);
00175 return item;
00176 }
00177
00181 Engine* addEngine(const std::string& name,
00182 const std::string& usage = std::string(),
00183 const std::string& description = std::string(),
00184 const std::string& longDescription = std::string())
00185 {
00186 return add(createEngine(name, usage, description, longDescription));
00187 }
00188
00190 const std::vector<OptionGroup*>& groups() const { return m_groups; }
00191
00193 const std::vector<Option*>& options() const { return m_options; }
00194
00196 const std::vector<Engine*>& commands() const { return m_commands; }
00197
00198 Engine* command(const std::string& name) const
00199 {
00200 std::map<std::string, Engine*>::const_iterator i = m_aliases.find(name);
00201 if (i == m_aliases.end())
00202 return 0;
00203 else
00204 return i->second;
00205 }
00206
00208 bool hasOptions() const { return !m_groups.empty() || !m_options.empty(); }
00209
00214 Engine* foundCommand() const { return m_found_command; }
00215
00216
00217 void dump(std::ostream& out, const std::string& prefix = std::string());
00218
00219 std::string primaryAlias;
00220 std::vector<std::string> aliases;
00221 std::string usage;
00222 std::string description;
00223 std::string longDescription;
00224 std::string examples;
00225
00226 friend class Parser;
00227 };
00228
00229 }
00230 }
00231
00232
00233 #endif