include/anna/diameter/stack/Format.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_Format_hpp
  10 #define anna_diameter_stack_Format_hpp
  11
  12 // Local
  13 #include <anna/diameter/codec/Format.hpp>
  14
  15 #include <anna/config/defines.hpp>
  16 #include <anna/core/RuntimeException.hpp>
  17
  18 // STL
  19 #include <string>
  20
  21
  22
  23 namespace anna {
  24 namespace xml {
  25 class Node;
  26 }
  27 }
  28
  29
  30
  31 namespace anna {
  32
  33 namespace diameter {
  34
  35 namespace stack {
  36
  37 class Dictionary;
  38
  39 //------------------------------------------------------------------------------
  40 //----------------------------------------------------------------- class Format
  41 //------------------------------------------------------------------------------
  42 /**
  43 * Format data container
  44 */
  45 class Format {
  46   const Dictionary *a_dictionary;
  47   std::string a_name;
  48   std::string a_parentName;
  49
  50   void _initialize(const Dictionary *d) throw() {
  51     a_dictionary = d;
  52     a_name = "";
  53     a_parentName = "";
  54   }
  55
  56 public:
  57
  58   Format(const Dictionary *d = NULL) { _initialize(d); }
  59   ~Format() {};
  60
  61
  62   // get
  63
  64   /**
  65   * Gets the format type name
  66   *
  67   * @return Format type name
  68   */
  69   const std::string & getName(void) const throw() { return a_name; }
  70
  71   /**
  72   * Gets the format parent type name
  73   *
  74   * @return Format parent type name, empty string for diameter basic format types (and reserved like 'Any, Unknown')
  75   */
  76   const std::string & getParentName(void) const throw() { return a_parentName; }
  77
  78   // helpers
  79
  80   /**
  81   * Gets the diameter parent type reference
  82   *
  83   * @return Diameter parent type reference, NULL for diameter basic format types (and reserved like 'Any, Unknown')
  84   */
  85   const Format * getParent(void) const throw();
  86
  87   /**
  88   * The diameter format is a derived type
  89   *
  90   * @return The format is derived
  91   */
  92   bool isDerived(void) const throw() { return (a_parentName != ""); }
  93
  94   /**
  95   * The diameter format is a basic type:
  96   *  (OctetString, Integer32, Integer64, Unsigned32, Unsigned64, Float32, Float64, Grouped)
  97   *
  98   * @return The format is basic
  99   */
 100   bool isBasic(void) const throw() { return (!isDerived() && !isReserved()); }
 101
 102   /**
 103   * Gets the diameter basic format type from which a derived type inherit, or basic type itself for non-derived
 104   *
 105   * @return Diameter basic format type
 106   */
 107   codec::Format::_v getBasicType(void) const throw(anna::RuntimeException);
 108
 109   /**
 110   * The diameter format belongs to RFC3588 diameter format family:
 111   *  (OctetString, Integer32, Integer64, Unsigned32, Unsigned64, Float32, Float64, Grouped, Address, Time, UTF8String, DiameterIdentity, DiameterURI, Enumerated, IPFilterRule, QoSFilterRule)
 112   *
 113   * @return The format belongs to RFC3588
 114   */
 115   bool isRFC3588(void) const throw() { return (codec::Format::isRFC3588(a_name)); }
 116
 117   // Reserved
 118   /** @return The format is 'Any' (generic AVP) */
 119   bool isAny() const throw() { return (a_name == codec::Format::asText(codec::Format::Any)); }
 120 //   /** @return The format is 'Unknown' */
 121 //   bool isUnknown() const throw() { return (a_name == codec::Format::asText(codec::Format::Unknown)); }
 122
 123   // RFC 3588
 124   /** @return The format is 'OctetString' */
 125   bool isOctetString() const throw() { return (a_name == codec::Format::asText(codec::Format::OctetString)); }
 126   /** @return The format is 'Integer32' */
 127   bool isInteger32() const throw() { return (a_name == codec::Format::asText(codec::Format::Integer32)); }
 128   /** @return The format is 'Integer64' */
 129   bool isInteger64() const throw() { return (a_name == codec::Format::asText(codec::Format::Integer64)); }
 130   /** @return The format is 'Unsigned32' */
 131   bool isUnsigned32() const throw() { return (a_name == codec::Format::asText(codec::Format::Unsigned32)); }
 132   /** @return The format is 'Unsigned64' */
 133   bool isUnsigned64() const throw() { return (a_name == codec::Format::asText(codec::Format::Unsigned64)); }
 134   /** @return The format is 'Float32' */
 135   bool isFloat32() const throw() { return (a_name == codec::Format::asText(codec::Format::Float32)); }
 136   /** @return The format is 'Float64' */
 137   bool isFloat64() const throw() { return (a_name == codec::Format::asText(codec::Format::Float64)); }
 138   /** @return The format is 'Grouped' */
 139   bool isGrouped() const throw() { return (a_name == codec::Format::asText(codec::Format::Grouped)); }
 140   /** @return The format is 'Address' */
 141   bool isAddress() const throw() { return (a_name == codec::Format::asText(codec::Format::Address)); }
 142   /** @return The format is 'Time' */
 143   bool isTime() const throw() { return (a_name == codec::Format::asText(codec::Format::Time)); }
 144   /** @return The format is 'UTF8String' */
 145   bool isUTF8String() const throw() { return (a_name == codec::Format::asText(codec::Format::UTF8String)); }
 146   /** @return The format is 'DiameterIdentity' */
 147   bool isDiameterIdentity() const throw() { return (a_name == codec::Format::asText(codec::Format::DiameterIdentity)); }
 148   /** @return The format is 'DiameterURI' */
 149   bool isDiameterURI() const throw() { return (a_name == codec::Format::asText(codec::Format::DiameterURI)); }
 150   /** @return The format is 'Enumerated' */
 151   bool isEnumerated() const throw() { return (a_name == codec::Format::asText(codec::Format::Enumerated)); }
 152   /** @return The format is 'IPFilterRule' */
 153   bool isIPFilterRule() const throw() { return (a_name == codec::Format::asText(codec::Format::IPFilterRule)); }
 154   /** @return The format is 'QoSFilterRule' */
 155   bool isQoSFilterRule() const throw() { return (a_name == codec::Format::asText(codec::Format::QoSFilterRule)); }
 156
 157   /**
 158   * The diameter format is application-specific or a format type name not registered on dictionary
 159   *
 160   * @return The format is application-specific
 161   */
 162   bool isApplicationSpecific(void) const throw() { return (!isRFC3588() && !isReserved()); }
 163
 164   /**
 165   * The diameter format is reserved ('Any' for generic AVP, 'Unknown' for not registered avps)
 166   *
 167   * @return The format is reserved
 168   */
 169   bool isReserved(void) const throw() { return (codec::Format::isReserved(a_name)); }
 170
 171   /**
 172   * Class string representation
 173   *
 174   * @return String with class content
 175   */
 176   std::string asString(void) const throw();
 177
 178   /**
 179   * Class xml representation
 180   *
 181   * @return XML document with relevant information for this instance.
 182   */
 183   anna::xml::Node* asXML(anna::xml::Node* parent) const throw();
 184
 185   // operators
 186
 187   /**
 188   * @return Equality between two class instances
 189   */
 190   friend bool operator == (const Format & f1, const Format & f2) { return ((f1.getName() == f2.getName())); }
 191
 192   /**
 193   * @return Difference between two class instances
 194   */
 195   friend bool operator != (const Format & f1, const Format & f2) { return !(f1 == f2); }
 196
 197   // set
 198
 199   /**
 200   * Initializes the class content
 201   */
 202   void initialize(const Dictionary *d = NULL) throw() { _initialize(d); }
 203
 204   /**
 205   * Sets Avp format type name
 206   *
 207   * @param type Avp format type name
 208   */
 209   void setName(const char * name) throw(anna::RuntimeException) {
 210     if(name == NULL) throw anna::RuntimeException("Null Format-name not allowed", ANNA_FILE_LOCATION);
 211
 212     a_name = name;
 213
 214     if(a_name == "") throw anna::RuntimeException("Empty Format-name not allowed", ANNA_FILE_LOCATION);
 215   }
 216
 217   /**
 218   * Sets RFC3588 Avp format type name
 219   *
 220   * @param rfc3588Format RFC3588 format type
 221   */
 222   void setRFC3588(codec::Format::_v rfc3588Format) throw() {
 223     setName(codec::Format::asText(rfc3588Format));
 224   }
 225
 226   /**
 227   * Sets Diameter-basic avp format parent
 228   *
 229   * @param parent Diameter-basic avp format parent
 230   */
 231   void setParentName(const std::string & parentName) throw(anna::RuntimeException);
 232 };
 233
 234
 235 }
 236 }
 237 }
 238
 239
 240 #endif
 241
 242