/common/common.hpp

  1#ifndef COMMON_HPP
  2#define COMMON_HPP
  3#include <string>
  4#include <global.hpp>
  5#include <map>
  6#include <memory>
  7#include <algorithm>
  8#include <cctype>
  9
 10/*! \file common.hpp
 11  \brief %Common utilities
 12
 13  File contains declaration for various classes and functions commonly used. Template functions
 14  and small class methods are implemented inline
 15*/
 16
 17/*! \namespace Common
 18  \brief %Common functions/classes
 19
 20  This module contains functions, classes, etc. which are common to the whole program (frequently used).
 21*/
 22
 23namespace Common {
 24
 25  //! Error codes for the common namespace
 26
 27  enum {
 28    E_CONFIG_LOAD, //!< Error while loading configuration file
 29    E_CONFIG_PARAM_NOT_FOUND, //!< Configuration parameter not found \sa Config::operator[]
 30    E_REGISTRY_ITEM_NOT_FOUND, //!< Registry item not found \sa Registry::getItem
 31  };
 32
 33
 34  /*! \brief Global %Exception class
 35
 36    An instance of this class will be thrown whenever an exception/error occurs in the program code. This does not apply to
 37    exceptions thrown by STL.
 38    -Converting/casting this class to const char* will return the message
 39    -Converting/casting this class to int will return the code
 40    
 41   %Exception class won't be used very frequently, in the sense, it will be thrown only in case of error,
 42   and errors obviously must occur rarely. Hence, functions of this class aren't inlined to keep the binary size small
 43   in case the compiler inlines the code after requesition by the inline statement (or definition in the class itself).
 44
 45   \todo Global exception handler
 46   \coder{Nilesh G,nileshgr}
 47   */
 48
 49  class Exception {
 50  private:
 51    std::string message; //!< Message of the exception
 52    int code; //!< Error code of the exception
 53    unsigned int line; //!< Line number in the file where the exception was thrown
 54    std::string file; //!< File name in which exception was thrown
 55    
 56  public:
 57
 58    /*! \brief Constructor
 59      \param[in] _message std::string - The message
 60      \param[in] _code int - Error code
 61      \param[in] _line unsigned int - Line number in file where exception was thrown
 62      \param[in] _file const char* - File name where exception was thrown
 63    */
 64
 65    Exception(std::string _message, int _code = 0, unsigned int _line = 0, const char* _file = NULL);
 66
 67    /*! \brief Object to const char* casting operator
 68
 69      When object of Exception is casted to const char*, it returns the message value from #getCMessage
 70
 71      \return const char* #getCMessage
 72    */
 73    
 74    operator const char*() const;
 75
 76    /*! \brief Object to int casting operator
 77
 78      When object of Exception is casted to int, it returns #code value from #getCode
 79
 80      \return int #getCode
 81    */
 82    
 83    operator int() const;
 84
 85    /*! \return The exception message excluding line number & file name (#message)
 86      \sa getCMessage
 87    */
 88    
 89    const char* getMessage() const;
 90
 91    //! \return Error/Exception code from #code
 92    
 93    int getCode() const;
 94
 95    //! \return Line number where exception occured from #line
 96    
 97    unsigned int getLineNo() const;
 98
 99    //! \return File name in which exception occurred from #file
100    
101    const char* getFileName() const;
102
103    //! \return Complete exception message in the format: [Error X] on line \#L of file F
104    
105    const char* getCMessage() const;
106  };
107
108  /*! \brief Configuration reader class
109
110    The applications configuration will be stored in a XML file which will be parsed using pugixml into a #Dict_t.
111    #operator[] gives access (read only) to each parameter.
112  */
113
114  class Config {
115  private:
116
117    //! Dicitonary to store parsed XML data
118    Dict_t data;
119    
120  public:
121
122    /*! \brief Constructor - the main function which does the parsing.
123
124      The whole parsing/processing occurs in the constructor (by calling pugixml's functions).
125
126      \remark The following structure is assumed in the XML file:
127      \verbatim
128      <config>
129        <moduleName>
130          <moduleParameter1>value1</moduleParameter1>
131          <moduleParameter2>value2</moduleParameter2>
132	  .
133	  .
134	  .
135        </moduleName>
136      </config>
137      \endverbatim
138      The configuration in #data will be stored as data[moduleName_moduleParameter1] = value1
139
140      \param[in] filename Path to the XML file containing configuration
141     */
142    
143    Config(std::string filename);
144
145    /*! \brief Element access to parsed \<keys,values\> stored in #data
146
147      We don't need write access to configuration, hence the function returns a const std::string and not a reference or pointer
148
149      \param[in] key Element name (xml) or key name in the configuration
150      \return Value of the respective key in #data
151      \throw Common::Exception with #E_CONFIG_PARAM_NOT_FOUND if key is not found in #data
152    */
153    
154    const std::string operator[](std::string key) {
155      if(data.find(key) == data.end())
156	throw Common::Exception("Configuration parameter " + key + " not found", E_CONFIG_PARAM_NOT_FOUND, __LINE__, __FILE__);
157      return data[key];
158    }
159
160    //! \sa #operator[]
161    
162    const std::string getParam(std::string key) {
163      return data[key];
164    }
165  };
166
167  /*! \brief Registry class
168
169    A class to store pointers to various types of objects etc with key name.
170    The class supports two interfaces- singleton and the usual, multiple instances. \n
171    In singleton method, once an instance is created, it will be persisted till the method to destroy the instance is called.
172
173    \coder{Nilesh G,nileshgr}
174  */
175
176  class Registry {
177  private:
178    typedef std::map<std::string, void*> items_t; //!< Define items_t dictionary type
179    typedef std::pair<std::string, void*> item_t; //!< Define item_t, one single item type
180    items_t items; //!< Dictionary to store pointers to objects
181    static std::unique_ptr<Registry> instance; //!< Unique_ptr to store pointer to singleton instance
182
183  public:
184    //! Static method to obtain instance
185
186    static Registry& getInstance();
187    
188    //! Static method to destroy instance
189
190    static void destroyInstance();
191
192    /*! \brief Method to add item
193      \param name Name of item to be added
194      \param ptr Pointer to item to be stored
195      \return Registry& for cascading operations
196    */
197
198    Registry& addItem(std::string name, void* ptr) {
199      std::transform(name.begin(), name.end(), name.begin(), (int (*)(int))std::tolower);
200      items[name] = ptr;
201      return *this;
202    }
203
204    /*! \brief Templated function to retrieve item
205      \param name Name of item to be returned
206      \tparam objtype Type of the object required as return type. dynamic_cast will be used.
207      \return Reference to dynamic_cast of objtype
208      \throw Common::Exception if name is not found in items
209    */
210      
211    template<typename objtype>
212    objtype& getItem(std::string name) {
213      std::transform(name.begin(), name.end(), name.begin(), (int (*)(int)) std::tolower);
214      items_t::iterator i;
215      if((i = items.find(name)) == items.end())
216	throw Common::Exception("Item: " + name + " not found in registry", E_REGISTRY_ITEM_NOT_FOUND, __LINE__, __FILE__);
217      return *(reinterpret_cast <objtype*> (i->second));
218    }
219
220    /*! \brief Method to delete item
221      \param name Name of the item to be deleted
222      \return Registry& for cascading operations
223    */
224      
225    Registry& deleteItem(std::string name) {
226      items.erase(name);
227      return *this;
228    }
229  };
230}
231#endif