include/anna/diameter/stack/Avp.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_Avp_hpp
  10 #define anna_diameter_stack_Avp_hpp
  11
  12
  13 // Local
  14 #include <anna/diameter/defines.hpp>
  15 #include <anna/diameter/stack/AvpRule.hpp>
  16 #include <anna/core/util/MultiRangeExpression.hpp>
  17
  18 #include <anna/core/RuntimeException.hpp>
  19 #include <anna/config/defines.hpp>
  20
  21 // STL
  22 #include <string>
  23 #include <map>
  24
  25
  26
  27 namespace anna {
  28 namespace xml {
  29 class Node;
  30 }
  31 }
  32
  33
  34
  35
  36 namespace anna {
  37
  38 namespace diameter {
  39
  40 namespace stack {
  41
  42
  43 //typedef std::map<AvpId, AvpRule> avprule_container;
  44 typedef std::map < int /*position*/, AvpRule > avprule_container;
  45 typedef avprule_container::iterator avprule_iterator;
  46 typedef avprule_container::const_iterator const_avprule_iterator;
  47
  48
  49 class Format;
  50 class Dictionary;
  51
  52 //------------------------------------------------------------------------------
  53 //-------------------------------------------------------------------- class Avp
  54 //------------------------------------------------------------------------------
  55 /**
  56 * Avp Reference information
  57 */
  58 class Avp {
  59
  60 public:
  61
  62   struct lessLabel {
  63     bool operator()(const std::string &d1, const std::string &d2) const {
  64       return (atoi(d1.c_str()) < atoi(d2.c_str()));
  65     }
  66   };
  67   typedef std::map < std::string /* data */, std::string /* alias */, lessLabel > label_container;
  68   typedef label_container::iterator label_iterator;
  69   typedef label_container::const_iterator const_label_iterator;
  70
  71
  72
  73   struct FlagRule {
  74     enum _v {
  75       None = -1, // Initialized
  76       must,
  77       may,
  78       shouldnot,
  79       mustnot
  80     };
  81
  82     anna_declare_enum(FlagRule);
  83
  84     /**
  85     * FlagRule description
  86     * @param v FlagRule type
  87     * @return FlagRule description
  88     */
  89     static const char* asText(const FlagRule::_v v) throw(anna::RuntimeException) {
  90       return asCString(v);
  91     }
  92   };
  93
  94
  95 private:
  96
  97   const Dictionary *a_dictionary;
  98   AvpId a_id;
  99   std::string a_name;
 100   std::string a_formatName;
 101   std::string a_vendorName;
 102
 103   // Flag Rules:
 104   FlagRule::_v a_vBit, a_mBit, a_pBit;
 105   bool a_mayEncrypt;
 106
 107   MultiRangeExpression a_enums;
 108   label_container a_labels;
 109
 110   // Grouped:
 111   avprule_container a_avprules;
 112   bool a_allowFixedRule;
 113   int a_avprulePosition;
 114
 115   void _initializeEnumsLabelsAndRules() throw() {
 116     a_enums.setLiteral("");
 117     a_labels.clear();
 118     a_avprules.clear();
 119     a_allowFixedRule = true;
 120     a_avprulePosition = 0;
 121   }
 122
 123   void _initialize(const Dictionary *d) throw() {
 124     a_dictionary = d;
 125     a_name = "";
 126     a_formatName = "";
 127     a_vendorName = "";
 128     a_vBit = FlagRule::mustnot;
 129     a_mBit = FlagRule::must;
 130     a_pBit = FlagRule::may;
 131     a_mayEncrypt = true;
 132     _initializeEnumsLabelsAndRules();
 133   }
 134
 135 public:
 136
 137   Avp(const Dictionary *d = NULL) { _initialize(d); }
 138   ~Avp();
 139
 140
 141   // get
 142   const AvpId & getId(void) const throw() { return a_id; }
 143   const std::string & getName(void) const throw() { return a_name; }
 144   const std::string & getFormatName(void) const throw() { return a_formatName; }
 145
 146   const FlagRule::_v & getVbit(void) const throw() { return a_vBit; }
 147   const FlagRule::_v & getMbit(void) const throw() { return a_mBit; }
 148   const FlagRule::_v & getPbit(void) const throw() { return a_pBit; }
 149   bool mayEncrypt(void) const throw() { return a_mayEncrypt; }
 150
 151   const char * getEnums(void) const throw() { return a_enums.getLiteral(); }
 152   const char * getAlias(const std::string data) const throw() {
 153     std::map<std::string, std::string>::const_iterator it = a_labels.find(data);
 154     return ((it != a_labels.end()) ? ((*it).second.c_str()) : NULL);
 155   }
 156
 157   // containers
 158   const_avprule_iterator avprule_begin() const throw() { return a_avprules.begin(); }
 159   const_avprule_iterator avprule_end() const throw() { return a_avprules.end(); }
 160   int avprule_size() const throw() { return a_avprules.size(); }
 161
 162   const_label_iterator label_begin() const throw() { return a_labels.begin(); }
 163   const_label_iterator label_end() const throw() { return a_labels.end(); }
 164   int label_size() const throw() { return a_labels.size(); }
 165
 166
 167   // helpers
 168   bool allowEnum(int value) const throw() { return a_enums.contain(value); }
 169   bool hasAliases(void) const throw() { return (a_labels.size() != 0); }
 170   bool isChild(const AvpId & avp) const throw();
 171   std::string getFlagsDescription(void) const throw();
 172   std::string getFlagRulesDescription(void) const throw();
 173   const Format * getFormat() const throw();
 174
 175   std::string asString(void) const throw();
 176   anna::xml::Node* asXML(anna::xml::Node* parent) const throw();
 177
 178   // operators
 179
 180   // set
 181   void setCode(const S32 & c) throw(anna::RuntimeException) {
 182     if(c < 0) throw anna::RuntimeException("Negative avp-code not allowed", ANNA_FILE_LOCATION);
 183
 184     a_id.first = c;
 185   }
 186
 187   void setVendorId(const S32 & v) throw(anna::RuntimeException) {
 188     if(v < 0) throw anna::RuntimeException("Negative vendor-id not allowed", ANNA_FILE_LOCATION);
 189
 190     a_id.second = v;
 191   }
 192
 193   void setName(const std::string & n) throw(anna::RuntimeException) {
 194     if(n == "") throw anna::RuntimeException("Empty avp-name string not allowed", ANNA_FILE_LOCATION);
 195
 196     a_name = n;
 197   }
 198
 199   void initialize(const Dictionary *d = NULL) throw() { _initialize(d); }
 200   void setVendorName(const std::string & vn) throw() { a_vendorName = vn; }
 201   void setFormatName(const std::string & fn) throw() { a_formatName = fn; }
 202   void setVbit(const FlagRule::_v &v) throw() { a_vBit = v; }
 203   void setMbit(const FlagRule::_v &m) throw() { a_mBit = m; }
 204   void setPbit(const FlagRule::_v &p) throw() { a_pBit = p; } // deprecated flag ...
 205   void setMayEncrypt(bool me) throw() { a_mayEncrypt = me; }
 206
 207   void setEnums(const char * e) throw() { a_enums.setLiteral(e); }
 208   void addEnums(const char * e) throw() { a_enums.addLiteral(e); a_enums.simplifyLiteral(); }
 209
 210   // After format configuration:
 211   void addLabel(const std::string & data,  const std::string & alias) throw(anna::RuntimeException);
 212   void addAvpRule(const AvpRule & avpRule) throw(anna::RuntimeException);
 213 };
 214
 215
 216 }
 217 }
 218 }
 219
 220
 221 #endif