AvpRule.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_AvpRule_hpp
#define anna_diameter_stack_AvpRule_hpp


// Local
#include <anna/diameter/defines.hpp>

#include <anna/core/RuntimeException.hpp>
#include <anna/core/define.autoenum.hpp>

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


// Five spaces:
#define DICTIONARY_AVPRULE_TAB      "     "



namespace anna {
namespace xml {
class Node;
}
}



namespace anna {

namespace diameter {

namespace stack {

class Dictionary;

//------------------------------------------------------------------------------
//---------------------------------------------------------------- class AvpRule
//------------------------------------------------------------------------------
class AvpRule {

public:

  struct Presence {
    enum _v {
      None = -1,
      Fixed,
      Mandatory,
      Optional
    };

    anna_declare_enum(Presence);

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

private:

  const Dictionary *a_dictionary;
  AvpId a_avpId; // reference
  Presence::_v a_presence;
  std::string a_qual;

  void _initialize(const Dictionary *d) {
    a_dictionary = d;
    a_presence = Presence::None;
    a_qual = "";
  }

public:


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


  // get
  std::string getAvpName(void) const ;
  const Presence::_v & getPresence(void) const { return a_presence; }
  const std::string & getQual(void) const { return a_qual; }

  // helpers
  AvpId getId(void) const { return a_avpId; }
  bool isAny(void) const ; // generic Avp
  bool isFixed(void) const { return (a_presence == Presence::Fixed); }
  bool isMandatory(void) const { return (a_presence == Presence::Mandatory); }
  bool isOptional(void) const { return (a_presence == Presence::Optional); }
  int getQualMin(void) const ;
  int getQualMax(void) const ; // -1 is infinite

  std::string asString(bool showPair = true) const ;
  anna::xml::Node* asXML(anna::xml::Node* parent) const ;

  // operators

  // set
  void initialize(const Dictionary *d = NULL) { _initialize(d); }
  void setAvpId(const AvpId & ai) { a_avpId = ai; }
  void setPresence(const Presence::_v & p) { a_presence = p; }
  void setQual(const std::string & q) noexcept(false);
};


}
}
}


#endif