Avp.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_diameter_stack_Avp_hpp
#define anna_diameter_stack_Avp_hpp


// Local
#include <anna/diameter/defines.hpp>
#include <anna/diameter/stack/AvpRule.hpp>
#include <anna/core/util/MultiRangeExpression.hpp>

#include <anna/core/RuntimeException.hpp>
#include <anna/config/defines.hpp>

// STL
#include <string>
#include <map>



namespace anna {
namespace xml {
class Node;
}
}




namespace anna {

namespace diameter {

namespace stack {


//typedef std::map<AvpId, AvpRule> avprule_container;
typedef std::map < int /*position*/, AvpRule > avprule_container;
typedef avprule_container::iterator avprule_iterator;
typedef avprule_container::const_iterator const_avprule_iterator;


class Format;
class Dictionary;

//------------------------------------------------------------------------------
//-------------------------------------------------------------------- class Avp
//------------------------------------------------------------------------------
class Avp {

public:

  struct lessLabel {
    bool operator()(const std::string &d1, const std::string &d2) const {
      return (atoi(d1.c_str()) < atoi(d2.c_str()));
    }
  };
  typedef std::map < std::string /* data */, std::string /* alias */, lessLabel > label_container;
  typedef label_container::iterator label_iterator;
  typedef label_container::const_iterator const_label_iterator;



  struct FlagRule {
    enum _v {
      None = -1, // Initialized
      must,
      may,
      shouldnot,
      mustnot
    };

    anna_declare_enum(FlagRule);

    static const char* asText(const FlagRule::_v v) noexcept(false) {
      return asCString(v);
    }
  };


private:

  const Dictionary *a_dictionary;
  AvpId a_id;
  std::string a_name;
  std::string a_formatName;
  std::string a_vendorName;

  // Flag Rules:
  FlagRule::_v a_vBit, a_mBit, a_pBit;
  bool a_mayEncrypt;

  MultiRangeExpression a_enums;
  label_container a_labels;

  // Grouped:
  avprule_container a_avprules;
  bool a_allowFixedRule;
  int a_avprulePosition;

  void _initializeEnumsLabelsAndRules() {
    a_enums.setLiteral("");
    a_labels.clear();
    a_avprules.clear();
    a_allowFixedRule = true;
    a_avprulePosition = 0;
  }

  void _initialize(const Dictionary *d) {
    a_dictionary = d;
    a_name = "";
    a_formatName = "";
    a_vendorName = "";
    a_vBit = FlagRule::mustnot;
    a_mBit = FlagRule::must;
    a_pBit = FlagRule::may;
    a_mayEncrypt = true;
    _initializeEnumsLabelsAndRules();
  }

public:

  Avp(const Dictionary *d = NULL) { _initialize(d); }
  ~Avp();


  // get
  const AvpId & getId(void) const { return a_id; }
  const std::string & getName(void) const { return a_name; }
  const std::string & getFormatName(void) const { return a_formatName; }

  const FlagRule::_v & getVbit(void) const { return a_vBit; }
  const FlagRule::_v & getMbit(void) const { return a_mBit; }
  const FlagRule::_v & getPbit(void) const { return a_pBit; }
  bool mayEncrypt(void) const { return a_mayEncrypt; }

  const char * getEnums(void) const { return a_enums.getLiteral(); }
  const char * getAlias(const std::string data) const {
    std::map<std::string, std::string>::const_iterator it = a_labels.find(data);
    return ((it != a_labels.end()) ? ((*it).second.c_str()) : NULL);
  }

  // containers
  const_avprule_iterator avprule_begin() const { return a_avprules.begin(); }
  const_avprule_iterator avprule_end() const { return a_avprules.end(); }
  int avprule_size() const { return a_avprules.size(); }

  const_label_iterator label_begin() const { return a_labels.begin(); }
  const_label_iterator label_end() const { return a_labels.end(); }
  int label_size() const { return a_labels.size(); }


  // helpers
  bool allowEnum(int value) const { return a_enums.contain(value); }
  bool hasAliases(void) const { return (a_labels.size() != 0); }
  bool isChild(const AvpId & avp) const ;
  std::string getFlagsDescription(void) const ;
  std::string getFlagRulesDescription(void) const ;
  const Format * getFormat() const ;

  std::string asString(void) const ;
  anna::xml::Node* asXML(anna::xml::Node* parent) const ;

  // operators

  // set
  void setCode(const S32 & c) noexcept(false) {
    if(c < 0) throw anna::RuntimeException("Negative avp-code not allowed", ANNA_FILE_LOCATION);

    a_id.first = c;
  }

  void setVendorId(const S32 & v) noexcept(false) {
    if(v < 0) throw anna::RuntimeException("Negative vendor-id not allowed", ANNA_FILE_LOCATION);

    a_id.second = v;
  }

  void setName(const std::string & n) noexcept(false) {
    if(n == "") throw anna::RuntimeException("Empty avp-name string not allowed", ANNA_FILE_LOCATION);

    a_name = n;
  }

  void initialize(const Dictionary *d = NULL) { _initialize(d); }
  void setVendorName(const std::string & vn) { a_vendorName = vn; }
  void setFormatName(const std::string & fn) { a_formatName = fn; }
  void setVbit(const FlagRule::_v &v) { a_vBit = v; }
  void setMbit(const FlagRule::_v &m) { a_mBit = m; }
  void setPbit(const FlagRule::_v &p) { a_pBit = p; } // deprecated flag ...
  void setMayEncrypt(bool me) { a_mayEncrypt = me; }

  void setEnums(const char * e) { a_enums.setLiteral(e); }
  void addEnums(const char * e) { a_enums.addLiteral(e); a_enums.simplifyLiteral(); }

  // After format configuration:
  void addLabel(const std::string & data,  const std::string & alias) noexcept(false);
  void addAvpRule(const AvpRule & avpRule) noexcept(false);
};


}
}
}


#endif