include/anna/diameter/stack/Dictionary.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_stack_Dictionary_hpp
  10 #define anna_diameter_stack_Dictionary_hpp
  11
  12
  13 // Local
  14 #include <anna/diameter/defines.hpp>
  15 #include <anna/diameter/stack/Format.hpp>
  16 #include <anna/diameter/stack/Vendor.hpp>
  17 #include <anna/diameter/stack/Avp.hpp>
  18 #include <anna/diameter/stack/Command.hpp>
  19
  20 #include <anna/core/RuntimeException.hpp>
  21
  22 // STL
  23 #include <string>
  24 #include <map>
  25
  26 namespace anna {
  27 namespace xml {
  28 class Node;
  29 class DTDMemory;
  30 }
  31 }
  32
  33
  34
  35
  36 namespace anna {
  37
  38 namespace diameter {
  39
  40 namespace stack {
  41
  42
  43
  44 //------------------------------------------------------------------------------
  45 //------------------------------------------------------------- class Dictionary
  46 //------------------------------------------------------------------------------
  47 /**
  48 * Dictionary information
  49 */
  50 class Dictionary {
  51
  52 public:
  53
  54   typedef std::map<std::string, Format> format_container;
  55   typedef format_container::const_iterator const_format_iterator;
  56
  57   typedef std::map<S32, Vendor> vendor_container;
  58   typedef vendor_container::const_iterator const_vendor_iterator;
  59
  60   struct lessAvp { // order by vendor id
  61     bool operator()(AvpId id1, AvpId id2) const {
  62       if(id1.second == id2.second) return (id1.first < id2.first);
  63
  64       return (id1.second < id2.second);
  65     }
  66   };
  67   typedef std::map<AvpId, Avp, lessAvp> avp_container;
  68   typedef avp_container::const_iterator const_avp_iterator;
  69
  70
  71   struct lessCommand {
  72     bool operator()(CommandId id1, CommandId id2) const {
  73       if(id1.first == id2.first) {
  74         if(id1.second != id2.second) return (id1.second);  // request -> answer
  75
  76         return (false);
  77       }
  78
  79       return (id1.first < id2.first);
  80     }
  81   };
  82   typedef std::map<CommandId, Command, lessCommand> command_container;
  83   typedef command_container::const_iterator const_command_iterator;
  84
  85 protected:
  86   std::string a_name;
  87
  88 private:
  89
  90   bool a_allowUpdates;
  91   format_container a_formats;
  92   vendor_container a_vendors;
  93   avp_container a_avps;
  94   command_container a_commands;
  95
  96   // Auxiliary
  97   const anna::xml::DTDMemory * a_dtd;
  98
  99   // Name identifiers:
 100   typedef std::map<std::string, const Vendor *> vendorNames_container;
 101   typedef vendorNames_container::const_iterator const_vendorNames_iterator;
 102
 103   typedef std::map<std::string, const Avp *> avpNames_container;
 104   typedef avpNames_container::const_iterator const_avpNames_iterator;
 105
 106   typedef std::map<std::string, const Command *> commandNames_container;
 107   typedef commandNames_container::const_iterator const_commandNames_iterator;
 108
 109   vendorNames_container a_vendorNames;
 110   avpNames_container a_avpNames;
 111   commandNames_container a_commandNames;
 112
 113
 114   // init
 115   void initialize() throw();
 116
 117   // check & addings
 118   //void checkUniqueIdentifiers(const anna::xml::Node *rootNode) const throw(anna::RuntimeException);
 119   void extractFormats(const anna::xml::Node *rootNode) throw(anna::RuntimeException);
 120   void extractVendors(const anna::xml::Node *rootNode) throw(anna::RuntimeException);
 121   void extractAvps(const anna::xml::Node *rootNode) throw(anna::RuntimeException);
 122   void extractCommands(const anna::xml::Node *rootNode) throw(anna::RuntimeException);
 123
 124 public:
 125
 126   Dictionary();
 127   ~Dictionary() {};
 128
 129   // get
 130   const std::string & getName() const throw() { return a_name; }
 131   const Format * getFormat(const std::string & formatName) const throw();
 132   const Vendor * getVendor(S32 vendorId) const throw();
 133   const Vendor * getVendor(const std::string & vendorName) const throw();
 134   const Avp * getAvp(const AvpId & avpId) const throw();
 135   const Avp * getAvp(const std::string & avpName) const throw();
 136   const Command * getCommand(const CommandId & commandId) const throw();
 137   const Command * getCommand(const std::string & commandName) const throw();
 138
 139   // set
 140   void allowUpdates(bool allow = true) throw() { a_allowUpdates = allow; }
 141   void addFormat(const Format &, bool reserved = false) throw(anna::RuntimeException);
 142   void addVendor(const Vendor &) throw(anna::RuntimeException);
 143   void addAvp(const Avp &) throw(anna::RuntimeException);
 144   void addCommand(const Command &) throw(anna::RuntimeException);
 145
 146   // containers
 147   const_format_iterator format_begin() const throw() { return a_formats.begin(); }
 148   const_format_iterator format_end() const throw() { return a_formats.end(); }
 149   int format_size() const throw() { return a_formats.size(); }
 150
 151   const_vendor_iterator vendor_begin() const throw() { return a_vendors.begin(); }
 152   const_vendor_iterator vendor_end() const throw() { return a_vendors.end(); }
 153   int vendor_size() const throw() { return a_vendors.size(); }
 154
 155   const_avp_iterator avp_begin() const throw() { return a_avps.begin(); }
 156   const_avp_iterator avp_end() const throw() { return a_avps.end(); }
 157   int avp_size() const throw() { return a_avps.size(); }
 158
 159   const_command_iterator command_begin() const throw() { return a_commands.begin(); }
 160   const_command_iterator command_end() const throw() { return a_commands.end(); }
 161   int command_size() const throw() { return a_commands.size(); }
 162
 163
 164   // helpers
 165   /**
 166   * Class string representation
 167   *
 168   * @return String with class content
 169   */
 170   std::string asString(void) const throw();
 171
 172   /**
 173      Class XML representation.
 174      \param parent XML node over which we will put instance information.
 175      \return XML documentcon with class content.
 176   */
 177   anna::xml::Node* asXML(anna::xml::Node* parent) const throw();
 178
 179   /**
 180      Class XML string representation
 181      \return XML string representation with class content.
 182   */
 183   std::string asXMLString() const throw();
 184
 185   // operators
 186
 187   /**
 188   * Loads an XML dictionary document over the diameter dictionary.
 189   *
 190   * Successive loadings will imply data accumulation, and the behaviour for redefinitions could be configured
 191   * in two ways: allow updating for dictionary items, or launch exception when any collision is found. This
 192   * could be set at #allowUpdates, and default value deny such redefinitions. It could be interesting, in order
 193   * to keep a more compact multi-stack configuration, allow updates sharing out the whole stack dictionaries as
 194   * many parts as possible to get centralized definitions. I.e. common vendors and avps used at a unique xml file,
 195   * and stack-specific commands in other set of xml files. Application only would have to load common part for all
 196   * the created dictionaries with this method and specific one for each final dictionary:
 197   *
 198   * @param pathFile Path file to the xml document which represents the diameter dictionary.
 199   *
 200   * <pre>
 201   * Dictionary *nokiaStack = stackEngine.createDictionary("/var/tmp/vendors_and_avps.xml", NOKIA_STACK_ID);
 202   * Dictionary *huaweiStack = stackEngine.createDictionary("/var/tmp/vendors_and_avps.xml", HUAWEI_STACK_ID);
 203   * nokiaStack->load("/var/tmp/nokia_commands.xml");
 204   * huaweiStack->load("/var/tmp/huawei_commands.xml");
 205   * </pre>
 206   */
 207   virtual void load(const std::string & pathFile) throw(anna::RuntimeException);
 208
 209   /**
 210   * Clears dictionary content
 211   */
 212   void clear(void) throw() { initialize(); } // initialize and prepares the dictionary
 213 };
 214
 215
 216 }
 217 }
 218 }
 219
 220
 221 #endif