Command.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_Command_hpp
#define anna_diameter_stack_Command_hpp


// Local
#include <anna/diameter/defines.hpp>
#include <anna/diameter/stack/AvpRule.hpp>
#include <anna/diameter/codec/Format.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 {

class Dictionary;

//------------------------------------------------------------------------------
//---------------------------------------------------------------- class Command
//------------------------------------------------------------------------------
class Command {

public:

  //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;


private:

  const Dictionary *a_dictionary;
  CommandId a_id;
  std::string a_name;

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

  void _initializeRules() {
    a_avprules.clear();
    a_allowFixedRule = true;
    a_avprulePosition = 0;
  }

  void _initialize(const Dictionary *d) {
    a_dictionary = d;
    _initializeRules();
  }

public:

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


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


  // 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(); }


  // helpers
  bool isEmpty(void) const { return (!a_avprules.size()); }
  bool isRequest(void) const { return (a_id.second); }
  bool isAnswer(void) const { return (!a_id.second); }
  bool isChild(const AvpId & avp) const ;

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

  // operators

  // set
  void initialize(const Dictionary *d = NULL) { _initialize(d); }
  void setCode(const U24 & c) noexcept(false) {

    a_id.first = c;
  }
  void setRequest(bool r = true) { a_id.second = r; }
  void setAnswer(bool a = true) { a_id.second = a; }
  void setName(const std::string & n) noexcept(false) {
    if(n == "") throw anna::RuntimeException("Empty command-name string not allowed", ANNA_FILE_LOCATION);

    a_name = n;
  }
  void addAvpRule(const AvpRule & avpRule) noexcept(false);
};


}
}
}


#endif