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 diameter {
  24
  25 namespace codec {
  26
  27 class Engine;
  28
  29 typedef std::map<anna::diameter::ApplicationId, Engine*> appid_codec_engines_t;
  30 typedef std::map<anna::diameter::ApplicationId, Engine*>::const_iterator appid_codec_engines_it;
  31 typedef std::map<anna::diameter::ApplicationId, Engine*>::iterator appid_codec_engines_nc_it;
  32
  33 /**
  34  * Helper class to centralize application codec engines and ease the automatic codec engine selection from
  35  * codec resources (mainly Message class, but also Avp).
  36  *
  37  * This is useful if you enable the auto selection from messages application id, avoiding to pre-initialize
  38  * such codec messages with a specific engine before interpreting the data sources or building.
  39  * At multithread application, it is recommended to specialize the message codec for each stack without using
  40  * this engine manager.
  41  */
  42 class EngineManager : public anna::Singleton <EngineManager> {
  43
  44 private:
  45
  46   bool a_autoSelectFromApplicationId;
  47   appid_codec_engines_t a_appid_codec_engines;
  48
  49   // private constructor
  50   EngineManager() : a_autoSelectFromApplicationId(true) {};
  51
  52 public:
  53
  54   /**
  55    * First element iterator
  56    */
  57   appid_codec_engines_it begin() const throw() { return a_appid_codec_engines.begin(); }
  58
  59   /**
  60    * Last element iterator
  61    */
  62   appid_codec_engines_it end() const throw() { return a_appid_codec_engines.end(); }
  63
  64   /**
  65    * Number of registered engines
  66    */
  67   int size() const throw() { return a_appid_codec_engines.size(); }
  68
  69   /**
  70    * Registers a new codec engine (externally allocated) associated to an application id.
  71    * If the application id exists, the new engine pointer will replace the existing one.
  72    *
  73    * @param appid Application-Id
  74    * @param engine Associated codec engine
  75    */
  76   void registerCodecEngine(const ApplicationId &appid, Engine* engine) throw();
  77
  78   /**
  79    * Get the associated codec engine for a provided Application-Id.
  80    *
  81    * @param appid Application-Id
  82    *
  83    * @return Found codec engine, NULL if not found
  84    */
  85   Engine *getCodecEngine(const ApplicationId &appid) const throw();
  86
  87   /**
  88    * If only one codec engine is registered (mono-stack application), it will be returned
  89    * (NULL in other case). This is because mono-stack applications could merge compatible
  90    * stacks into one unique dictionary, using a global value for stack id with no relation
  91    * regarding application-id concept.
  92    *
  93    * @return Unique codec engine, NULL if not unique (empty manager or more than one)
  94    */
  95   Engine *getMonoStackCodecEngine() const throw() {
  96     return ((size() != 1) ? NULL : begin()->second);
  97   }
  98
  99   /**
 100    * The user could select the appropriate codec engine depending on the context, but some applications could
 101    * consider interesting automatic codec engine selection from managed messages (decoded from any source,
 102    * or built from scratch). Then, this engine manager will be used registering all the supported stacks
 103    * with their corresponding codec engines, and automatic selection will be done during decoding of any
 104    * supported source of data (hexadecimal buffers, xml documents) or build operations.
 105    *
 106    * If the user pre-initializes the codec engine for a #Message or #Avp element, this selection is ignored
 107    * even if enabled: the codec engine only can be established one time, for security reasons.
 108    *
 109    * @param enable Activates/deactivates the codec engine selection from the Application-Id value. True by default
 110    * and applicable when this manager store is not empty.
 111    */
 112   void selectFromApplicationId (bool enable) throw() { a_autoSelectFromApplicationId = enable; }
 113
 114   /**
 115     Gets the currently configured behaviour regarding codec engine selection.
 116
 117     @return True if selection is done with the Application-Id (default behaviour). False to disable (the manager
 118     could be used for some other things which could be also interesting).
 119    */
 120   bool selectFromApplicationId (void) throw() { return a_autoSelectFromApplicationId; }
 121
 122
 123   friend class anna::Singleton <EngineManager>;
 124 };
 125
 126 }
 127 }
 128 }
 129
 130 #endif
 131