Dictionary.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_Dictionary_hpp
#define anna_diameter_stack_Dictionary_hpp


// Local
#include <anna/diameter/defines.hpp>
#include <anna/diameter/stack/Format.hpp>
#include <anna/diameter/stack/Vendor.hpp>
#include <anna/diameter/stack/Avp.hpp>
#include <anna/diameter/stack/Command.hpp>

#include <anna/core/RuntimeException.hpp>

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

namespace anna {
namespace xml {
class Node;
class DTDMemory;
}
}




namespace anna {

namespace diameter {

namespace stack {



//------------------------------------------------------------------------------
//------------------------------------------------------------- class Dictionary
//------------------------------------------------------------------------------
class Dictionary {

public:

  typedef std::map<std::string, Format> format_container;
  typedef format_container::const_iterator const_format_iterator;

  typedef std::map<S32, Vendor> vendor_container;
  typedef vendor_container::const_iterator const_vendor_iterator;

  struct lessAvp { // order by vendor id
    bool operator()(AvpId id1, AvpId id2) const {
      if(id1.second == id2.second) return (id1.first < id2.first);

      return (id1.second < id2.second);
    }
  };
  typedef std::map<AvpId, Avp, lessAvp> avp_container;
  typedef avp_container::const_iterator const_avp_iterator;


  struct lessCommand {
    bool operator()(CommandId id1, CommandId id2) const {
      if(id1.first == id2.first) {
        if(id1.second != id2.second) return (id1.second);  // request -> answer

        return (false);
      }

      return (id1.first < id2.first);
    }
  };
  typedef std::map<CommandId, Command, lessCommand> command_container;
  typedef command_container::const_iterator const_command_iterator;

protected:
  std::string a_name;

private:

  bool a_allowUpdates;
  format_container a_formats;
  vendor_container a_vendors;
  avp_container a_avps;
  command_container a_commands;

  // Auxiliary
  const anna::xml::DTDMemory * a_dtd;

  // Name identifiers:
  typedef std::map<std::string, const Vendor *> vendorNames_container;
  typedef vendorNames_container::const_iterator const_vendorNames_iterator;

  typedef std::map<std::string, const Avp *> avpNames_container;
  typedef avpNames_container::const_iterator const_avpNames_iterator;

  typedef std::map<std::string, const Command *> commandNames_container;
  typedef commandNames_container::const_iterator const_commandNames_iterator;

  vendorNames_container a_vendorNames;
  avpNames_container a_avpNames;
  commandNames_container a_commandNames;


  // init
  void initialize() ;

  // check & addings
  //void checkUniqueIdentifiers(const anna::xml::Node *rootNode) const noexcept(false);
  void extractFormats(const anna::xml::Node *rootNode) noexcept(false);
  void extractVendors(const anna::xml::Node *rootNode) noexcept(false);
  void extractAvps(const anna::xml::Node *rootNode) noexcept(false);
  void extractCommands(const anna::xml::Node *rootNode) noexcept(false);

public:

  Dictionary();
  ~Dictionary() {};

  // get
  const std::string & getName() const { return a_name; }
  const Format * getFormat(const std::string & formatName) const ;
  const Vendor * getVendor(S32 vendorId) const ;
  const Vendor * getVendor(const std::string & vendorName) const ;
  const Avp * getAvp(const AvpId & avpId) const ;
  const Avp * getAvp(const std::string & avpName) const ;
  const Command * getCommand(const CommandId & commandId) const ;
  const Command * getCommand(const std::string & commandName) const ;

  // set
  void allowUpdates(bool allow = true) { a_allowUpdates = allow; }
  void addFormat(const Format &, bool reserved = false) noexcept(false);
  void addVendor(const Vendor &) noexcept(false);
  void addAvp(const Avp &) noexcept(false);
  void addCommand(const Command &) noexcept(false);

  // containers
  const_format_iterator format_begin() const { return a_formats.begin(); }
  const_format_iterator format_end() const { return a_formats.end(); }
  int format_size() const { return a_formats.size(); }

  const_vendor_iterator vendor_begin() const { return a_vendors.begin(); }
  const_vendor_iterator vendor_end() const { return a_vendors.end(); }
  int vendor_size() const { return a_vendors.size(); }

  const_avp_iterator avp_begin() const { return a_avps.begin(); }
  const_avp_iterator avp_end() const { return a_avps.end(); }
  int avp_size() const { return a_avps.size(); }

  const_command_iterator command_begin() const { return a_commands.begin(); }
  const_command_iterator command_end() const { return a_commands.end(); }
  int command_size() const { return a_commands.size(); }


  // helpers
  std::string asString(void) const ;

  anna::xml::Node* asXML(anna::xml::Node* parent) const ;

  std::string asXMLString() const ;

  // operators

  virtual void load(const std::string & pathFile) noexcept(false);

  void clear(void) { initialize(); } // initialize and prepares the dictionary
};


}
}
}


#endif