include/anna/diameter/codec/EngineManager.hpp

   1 // ANNA - Anna is Not Nothingness Anymore                                                         //
   2 //                                                                                                //
   3 // (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
   4 //                                                                                                //
   5 // See project site at http://redmine.teslayout.com/projects/anna-suite                           //
   6 // See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
   7
   8
   9 #ifndef anna_diameter_codec_EngineManager_hpp
  10 #define anna_diameter_codec_EngineManager_hpp
  11
  12
  13 // Project
  14 #include <anna/core/Singleton.hpp>
  15 #include <anna/diameter/defines.hpp>
  16
  17 // Standard
  18 #include <map>
  19
  20
  21 namespace anna {
  22
  23 namespace xml {
  24   class Node;
  25
  26 }
  27 namespace diameter {
  28
  29 namespace codec {
  30
  31 class Engine;
  32
  33 typedef std::map<anna::diameter::ApplicationId, Engine*> appid_codec_engines_t;
  34 typedef std::map<anna::diameter::ApplicationId, Engine*>::const_iterator appid_codec_engines_it;
  35 typedef std::map<anna::diameter::ApplicationId, Engine*>::iterator appid_codec_engines_nc_it;
  36
  37 /**
  38  * Helper class to centralize application codec engines and ease the automatic codec engine selection from
  39  * codec resources (mainly Message class, but also Avp).
  40  *
  41  * This is useful if you enable the auto selection from messages application id, avoiding to pre-initialize
  42  * such codec messages with a specific engine before interpreting the data sources or building.
  43  * At multithread application, it is recommended to specialize the message codec for each stack without using
  44  * this engine manager.
  45  */
  46 class EngineManager : public anna::Singleton <EngineManager> {
  47
  48 private:
  49
  50   bool a_autoSelectFromApplicationId;
  51   appid_codec_engines_t a_appid_codec_engines;
  52
  53   // private constructor
  54   EngineManager() : a_autoSelectFromApplicationId(true) {};
  55
  56 public:
  57
  58   virtual ~EngineManager() {;}
  59
  60   /**
  61    * First element iterator
  62    */
  63   appid_codec_engines_it begin() const throw() { return a_appid_codec_engines.begin(); }
  64
  65   /**
  66    * Last element iterator
  67    */
  68   appid_codec_engines_it end() const throw() { return a_appid_codec_engines.end(); }
  69
  70   /**
  71    * Number of registered engines
  72    */
  73   int size() const throw() { return a_appid_codec_engines.size(); }
  74
  75   /**
  76    * Registers a new codec engine (externally allocated) associated to an application id.
  77    * If the application id exists, the new engine pointer will replace the existing one.
  78    *
  79    * @param appid Application-Id
  80    * @param engine Associated codec engine
  81    */
  82   void registerCodecEngine(const ApplicationId &appid, Engine* engine) throw();
  83
  84   /**
  85    * Get the associated codec engine for a provided Application-Id.
  86    *
  87    * @param appid Application-Id
  88    *
  89    * @return Found codec engine, NULL if not found
  90    */
  91   Engine *getCodecEngine(const ApplicationId &appid) const throw();
  92
  93   /**
  94    * If only one codec engine is registered (mono-stack application), it will be returned
  95    * (NULL in other case). This is because mono-stack applications could merge compatible
  96    * stacks into one unique dictionary, using a global value for stack id with no relation
  97    * regarding application-id concept.
  98    *
  99    * @return Unique codec engine, NULL if not unique (empty manager or more than one)
 100    */
 101   Engine *getMonoStackCodecEngine() const throw() {
 102     return ((size() != 1) ? NULL : begin()->second);
 103   }
 104
 105   /**
 106    * The user could select the appropriate codec engine depending on the context, but some applications could
 107    * consider interesting automatic codec engine selection from managed messages (decoded from any source,
 108    * or built from scratch). Then, this engine manager will be used registering all the supported stacks
 109    * with their corresponding codec engines, and automatic selection will be done during decoding of any
 110    * supported source of data (hexadecimal buffers, xml documents) or build operations.
 111    *
 112    * If the user pre-initializes the codec engine for a #Message or #Avp element, this selection is ignored
 113    * even if enabled: the codec engine only can be established one time, for security reasons.
 114    *
 115    * @param enable Activates/deactivates the codec engine selection from the Application-Id value. True by default
 116    * and applicable when this manager store is not empty.
 117    */
 118   void selectFromApplicationId (bool enable) throw() { a_autoSelectFromApplicationId = enable; }
 119
 120   /**
 121     Gets the currently configured behaviour regarding codec engine selection.
 122
 123     @return True if selection is done with the Application-Id (default behaviour). False to disable (the manager
 124     could be used for some other things which could be also interesting).
 125    */
 126   bool selectFromApplicationId (void) throw() { return a_autoSelectFromApplicationId; }
 127
 128   /**
 129      Class XML representation.
 130      \param parent XML node over which we will put instance information.
 131      \return XML documentcon with class content.
 132   */
 133   virtual anna::xml::Node* asXML(anna::xml::Node* parent) const throw();
 134
 135
 136   friend class anna::Singleton <EngineManager>;
 137 };
 138
 139 }
 140 }
 141 }
 142
 143 #endif
 144