c10a36e664b916bf13538a39bce2baf731d353d9
[anna.git] / include / anna / core / util / CommandLine.hpp
1 // ANNA - Anna is Not 'N' Anymore
2 //
3 // (c) Copyright 2005-2014 Eduardo Ramos Testillano & Francisco Ruiz Rayo
4 //
5 // https://bitbucket.org/testillano/anna
6 //
7 // Redistribution and use in source and binary forms, with or without
8 // modification, are permitted provided that the following conditions
9 // are met:
10 //
11 //     * Redistributions of source code must retain the above copyright
12 // notice, this list of conditions and the following disclaimer.
13 //     * Redistributions in binary form must reproduce the above
14 // copyright notice, this list of conditions and the following disclaimer
15 // in the documentation and/or other materials provided with the
16 // distribution.
17 //     * Neither the name of Google Inc. nor the names of its
18 // contributors may be used to endorse or promote products derived from
19 // this software without specific prior written permission.
20 //
21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 //
33 // Authors: eduardo.ramos.testillano@gmail.com
34 //          cisco.tierra@gmail.com
35
36
37 #ifndef anna_core_util_CommandLine_hpp
38 #define anna_core_util_CommandLine_hpp
39
40 #include <stdlib.h>
41
42 #include <vector>
43
44 #include <anna/core/functions.hpp>
45 #include <anna/core/Singleton.hpp>
46
47 namespace anna {
48
49 class RuntimeException;
50
51 namespace xml {
52 class Node;
53 }
54
55
56 /**
57    Facilita la recogida de parametros desde la linea de comandos. Tambien
58    verifica que todos los parametros necesarios han sido indicados por el
59    usuario.
60 */
61 class CommandLine : public Singleton <CommandLine> {
62 public:
63   /**
64      Define los tipos de argumento
65
66   */
67   struct Argument { enum Type { Mandatory = 0, Optional};  };
68
69   // Accesores
70   /**
71      @return la lista de cadenas indicadas en la linea de comandos al ejecutar este programa.
72      Mientras que no invoquemos al metodo #initialize devolvera NULL.
73   */
74   const char** getArgv() const throw() { return a_argv; }
75
76   /**
77      @return El numero de parametros indicados en la linea de comandos al ejecutar este programa.
78   */
79   int getArgc() const throw() { return a_argc; }
80
81   //
82   // Metodos
83   //
84   /**
85      Establece la informacion necesaria para analizar la linea de comandos
86      indicada por el usuario. Debe invocarse antes que cualquier otro metodo
87      relacionado con la obtencion/comprobacion de valor de la linea de comandos.
88
89      Recibe una copia de los parametros que los recibidos por el metodo 'main'.
90
91      @param argv Conjunto de cadenas que se reciben de la linea de comandos.
92      @param argc Numero de cadenas recibidas.
93   */
94   void initialize(const char** argv, const int argc) throw() {
95     a_argv = argv;
96     a_argc = argc;
97     a_wasParsed = false;
98   }
99
100   /**
101      Registra un argumentName que sera recocido por nuestra aplicacion.
102
103      Se pueden indicar tantos argumentNames como sea necesario.
104
105      @param argumentName Nombre del argumento.
106      @param type Tipo de argumento. Ver  Variable#Type.
107      @param comment Explicacion acerca de cometido de este argumento.
108      @param needValue Indica si el parametro que estamos definido debe tener un
109      valor adicional. Por ejemplo un parametro "usuario" deberia tener un valor adicional
110      que sea el valor que toma.
111    */
112   void add(const char* argumentName, Argument::Type type, const char* comment, const bool needValue = true) throw();
113
114   /**
115      Obtiene el valor asociado al argumento recibido como parametro.
116      El valor devuelto puede ser NULL en caso de que el argumento no sea
117      obligatorio y no este en la linea de comandos.
118      Si el argumento es obligatorio y no este en la linea de comandos o
119      no tiene valor asociado la ejecucion del programa TERMINA inmediatamente.
120
121      @param argumentName Nombre del argumento del que deseamos obtener el valor.
122      @param exitOnFault Indica el funcionamiento del metodo en caso de que el
123      argumento solicitado no halla sido indicado. Si el parametro no existe
124      si vale @em true la aplicacion terminara, si vale @em false devolvera NULL.
125
126      @return Valor asociadoal argumento recibido como parametro. Puede ser NULL.
127   */
128   const char* getValue(const char* argumentName, const bool exitOnFault = true) throw();
129
130   /**
131      Obtiene el valor asociado al argumento recibido, pero convirtiendo a
132      numero el valor obtenido por #getValue.
133
134      @param argumentName Nombre del argumento del que deseamos obtener el valor.
135
136      @return Valor numerico del valor devuelto por #getValue.
137   */
138   int getIntegerValue(const char* argumentName) throw() { return atoi(getValue(argumentName)); }
139
140   /**
141      Comprueba si el argumento recibido como parametro estña presente en la linea de
142      comandos.
143
144      @param argumentName Nombre del argumento del que deseamos obtener el valor.
145
146      @return true si el argumento esta en la linea de comandos y false en otro caso.
147    */
148   bool exists(const char* argumentName) throw() { return (getValue(argumentName, false) != NULL) ? true : false; }
149
150   /**
151     Comprueba la linea de comandos del programa para verificar que coincide con los argumentos
152     registrados por nuestra aplicacion:
153
154     @li Verifica que los parametros obligatorios estan en la linea de comandos.
155     @li Verifica que los valores de los argumento son correctos de forma que si un parametro
156     debe llevar un valor asociado este esta presente y que si no debe llevarlo no esta.
157     El orden en que aparezcan los argumento en la linea de comandos es indiferente a la hora de
158     hacer las comprobacion.
159
160     Si hay algun fallo en la linea de comandos establecida al ejecutar el programa visualiza un
161     resumen con los parametros soportados y la ejecucion del programa finaliza.
162   */
163   void verify() throw(RuntimeException);
164
165
166   /**
167      Class string representation
168      \return String with relevant information for this instance.
169   */
170   std::string asString() const throw();
171
172   /**
173      Class xml representation
174      \param parent Parent XML node on which hold this instance information.
175      \return XML document with relevant information for this instance.
176   */
177   xml::Node* asXML(xml::Node* parent) const throw();
178
179
180 private:
181   Mutex a_mutex;
182
183   class Variable {
184   public:
185     // Constructores
186     Variable(const char* name, const Argument::Type type, const char* comment, const bool needValue = true) :
187       a_name(name), a_type(type), a_comment(comment), a_needValue(needValue),
188       a_isOn(false), a_value(NULL) {
189     }
190     virtual ~Variable() { if(a_value) free(a_value); }
191
192     // Accesores
193     const std::string& getName() const throw() { return a_name; }
194     const char* getValue() const throw() { return a_value; }
195     const char* getComment() const throw() { return a_comment; }
196     bool getNeedValue() const throw() { return a_needValue; }
197     bool getIsOn() const throw() { return a_isOn; }
198     Argument::Type getType() const throw() { return a_type; }
199
200     // Modificadores
201     void setValue(const char* value) throw() { a_value = (value == NULL) ? NULL : strdup(value); }
202     void setIsOn(const bool isOn) throw() { a_isOn = isOn; }
203
204     // Metodos
205     std::string asString() const throw();
206
207   protected:
208     std::string a_name;
209     const char* a_comment;
210     char* a_value;
211     Argument::Type a_type;
212     bool a_needValue;
213     bool a_isOn;
214   };
215
216   const char **a_argv;
217   int a_argc;
218   bool a_wasParsed;
219   std::vector <Variable*> a_arguments;
220
221   CommandLine() : a_argv(NULL), a_argc(0)  {;}
222
223   bool analize() throw();
224   const Variable* search(const char *argumentName) const throw();
225   void printUsage() const throw();
226
227   friend class Singleton <CommandLine>;
228 };
229
230 }
231
232 #endif
233