Remove dynamic exceptions

[anna.git] / source / diameter / codec / Avp.cpp

diff --git a/source/diameter/codec/Avp.cpp b/source/diameter/codec/Avp.cpp
index 2338111..14d5aa7 100644 (file)
--- a/source/diameter/codec/Avp.cpp
+++ b/source/diameter/codec/Avp.cpp
@@ -77,7 +77,7 @@ Avp::~Avp() {
 //------------------------------------------------------------------------------
 //------------------------------------------------------------- Avp::setEngine()
 //------------------------------------------------------------------------------
-void Avp::setEngine(Engine *engine) throw() {
+void Avp::setEngine(Engine *engine) {
   if (a_engine && engine != a_engine) {
     LOGWARNING(anna::Logger::warning("Ignored: it is not a good practice to change the codec engine once assigned. Clear the avp first to set the engine again.", ANNA_FILE_LOCATION));
     return;
@@ -89,7 +89,7 @@ void Avp::setEngine(Engine *engine) throw() {
 //------------------------------------------------------------------------------
 //------------------------------------------------------------- Avp::getEngine()
 //------------------------------------------------------------------------------
-Engine * Avp::getEngine() const throw(anna::RuntimeException) {
+Engine * Avp::getEngine() const noexcept(false) {
   if(!a_engine)
     throw anna::RuntimeException("Invalid codec engine reference (NULL). Use setEngine() to set the corresponding codec engine", ANNA_FILE_LOCATION);
 
@@ -100,7 +100,7 @@ Engine * Avp::getEngine() const throw(anna::RuntimeException) {
 //------------------------------------------------------------------------------
 //------------------------------------------------------------ Avp::initialize()
 //------------------------------------------------------------------------------
-void Avp::initialize() throw() {
+void Avp::initialize() {
   a_id = helpers::AVPID__AVP; // (0,0)
   a_flags = 0x00;
   a_insertionPositionForChilds = 0;
@@ -132,7 +132,7 @@ void Avp::initialize() throw() {
 //------------------------------------------------------------------------------
 //----------------------------------------------------------------- Avp::clear()
 //------------------------------------------------------------------------------
-void Avp::clear() throw(anna::RuntimeException) {
+void Avp::clear() noexcept(false) {
   delete a_OctetString;
   delete a_Integer32;
   delete a_Integer64;
@@ -167,7 +167,7 @@ void Avp::clear() throw(anna::RuntimeException) {
 //------------------------------------------------------------------------------
 //-------------------------------------------------------------- Avp::avp_find()
 //------------------------------------------------------------------------------
-avp_iterator Avp::avp_find(avp_container &avps, AvpId id, unsigned int position) throw() {
+avp_iterator Avp::avp_find(avp_container &avps, AvpId id, unsigned int position) {
   int match = 0;
   Avp *aux;
 
@@ -188,7 +188,7 @@ avp_iterator Avp::avp_find(avp_container &avps, AvpId id, unsigned int position)
 //------------------------------------------------------------------------------
 //---------------------------------------------------------------- Avp::addAvp()
 //------------------------------------------------------------------------------
-Avp * Avp::addAvp(avp_container &avps, int &insertionPositionForChilds, AvpId id, Engine *engine) throw() {
+Avp * Avp::addAvp(avp_container &avps, int &insertionPositionForChilds, AvpId id, Engine *engine) {
   Avp * result = engine->createAvp(NULL);
   result->setId(id);
   addChild(avps, insertionPositionForChilds, result);
@@ -199,7 +199,7 @@ Avp * Avp::addAvp(avp_container &avps, int &insertionPositionForChilds, AvpId id
 //------------------------------------------------------------------------------
 //---------------------------------------------------------------- Avp::addAvp()
 //------------------------------------------------------------------------------
-Avp * Avp::addAvp(Avp * avp) throw(anna::RuntimeException) {
+Avp * Avp::addAvp(Avp * avp) noexcept(false) {
   if(!avp) return NULL;
   if (avp->getEngine() != getEngine()) return NULL;
   addChild(avp);
@@ -210,7 +210,7 @@ Avp * Avp::addAvp(Avp * avp) throw(anna::RuntimeException) {
 //------------------------------------------------------------------------------
 //------------------------------------------------------------- Avp::removeAvp()
 //------------------------------------------------------------------------------
-bool Avp::removeAvp(avp_container &avps, find_container &finds, AvpId id, int ocurrence, Engine *engine) throw() {
+bool Avp::removeAvp(avp_container &avps, find_container &finds, AvpId id, int ocurrence, Engine *engine) {
   bool removed = false;
   bool do_remove = true;
   int position = ocurrence;
@@ -263,7 +263,7 @@ bool Avp::removeAvp(avp_container &avps, find_container &finds, AvpId id, int oc
 //------------------------------------------------------------------------------
 //-------------------------------------------------------------- Avp::countAvp()
 //------------------------------------------------------------------------------
-int Avp::countAvp(const avp_container &avps, AvpId id) throw() {
+int Avp::countAvp(const avp_container &avps, AvpId id) {
   int result = 0;
   const_avp_iterator it;
 
@@ -276,7 +276,7 @@ int Avp::countAvp(const avp_container &avps, AvpId id) throw() {
 //------------------------------------------------------------------------------
 //-------------------------------------------------------------- Avp::firstAvp()
 //------------------------------------------------------------------------------
-const Avp* Avp::firstAvp(const avp_container &avps, AvpId id) throw() {
+const Avp* Avp::firstAvp(const avp_container &avps, AvpId id) {
   const_avp_iterator it = avp_find(avps, id, 1);
 
   if(it != avps.end())
@@ -289,7 +289,7 @@ const Avp* Avp::firstAvp(const avp_container &avps, AvpId id) throw() {
 //------------------------------------------------------------------------------
 //----------------------------------------------------------- Avp::countChilds()
 //------------------------------------------------------------------------------
-int Avp::countChilds(const avp_container &avps) throw() {
+int Avp::countChilds(const avp_container &avps) {
   return avps.size();
 }
 
@@ -297,7 +297,7 @@ int Avp::countChilds(const avp_container &avps) throw() {
 //------------------------------------------------------------------------------
 //---------------------------------------------------------------- Avp::getAvp()
 //------------------------------------------------------------------------------
-const Avp *Avp::getAvp(const avp_container &avps, find_container &finds, AvpId id, int ocurrence, Engine *engine, anna::Exception::Mode::_v emode) throw(anna::RuntimeException) {
+const Avp *Avp::getAvp(const avp_container &avps, find_container &finds, AvpId id, int ocurrence, Engine *engine, anna::Exception::Mode::_v emode) noexcept(false) {
   if(ocurrence == 0) {
     LOGDEBUG(anna::Logger::debug("Ocurrence number zero has no sense. NULL returned.", ANNA_FILE_LOCATION));
     return NULL;
@@ -386,7 +386,7 @@ const Avp *Avp::getAvp(const avp_container &avps, find_container &finds, AvpId i
 //------------------------------------------------------------------------------
 //--------------------------------------------------------------- Avp::_getAvp()
 //------------------------------------------------------------------------------
-const Avp *Avp::_getAvp(AvpId id, int ocurrence, anna::Exception::Mode::_v emode) const throw(anna::RuntimeException) {
+const Avp *Avp::_getAvp(AvpId id, int ocurrence, anna::Exception::Mode::_v emode) const noexcept(false) {
   // Dictionary stack avp and format (this):
   const stack::Avp *stackAvp = getStackAvp();
   const stack::Format *stackFormat = stackAvp ? (stackAvp->getFormat()) : NULL /*Unknown*/;
@@ -401,7 +401,7 @@ const Avp *Avp::_getAvp(AvpId id, int ocurrence, anna::Exception::Mode::_v emode
 //------------------------------------------------------------------------------
 //---------------------------------------------------------- Avp::assertFormat()
 //------------------------------------------------------------------------------
-void Avp::assertFormat(const std::string &name) const throw(anna::RuntimeException) {
+void Avp::assertFormat(const std::string &name) const noexcept(false) {
   // Dictionary stack avp and format:
   const stack::Avp *stackAvp = getStackAvp();
   const stack::Format *stackFormat = stackAvp ? (stackAvp->getFormat()) : NULL /*Unknown*/;
@@ -423,7 +423,7 @@ void Avp::assertFormat(const std::string &name) const throw(anna::RuntimeExcepti
 //------------------------------------------------------------------------------
 //--------------------------------------------------------------- Avp::flagsOK()
 //------------------------------------------------------------------------------
-bool Avp::flagsOK() const throw() {
+bool Avp::flagsOK() const {
   // Dictionary stack avp:
   const stack::Avp *stackAvp = getStackAvp();
 
@@ -495,7 +495,7 @@ bool Avp::flagsOK() const throw() {
 //------------------------------------------------------------------------------
 //----------------------------------------------------------------- Avp::setId()
 //------------------------------------------------------------------------------
-void Avp::setId(AvpId id) throw(anna::RuntimeException) {
+void Avp::setId(AvpId id) noexcept(false) {
   // Generic AVP assignment has no sense
   if(id == helpers::AVPID__AVP) return;
 
@@ -557,7 +557,7 @@ void Avp::setId(AvpId id) throw(anna::RuntimeException) {
 //------------------------------------------------------------------------------
 //----------------------------------------------------------------- Avp::setId()
 //------------------------------------------------------------------------------
-void Avp::setId(const char *name) throw(anna::RuntimeException) {
+void Avp::setId(const char *name) noexcept(false) {
   setId(getEngine()->avpIdForName(name));
 }
 
@@ -565,7 +565,7 @@ void Avp::setId(const char *name) throw(anna::RuntimeException) {
 //------------------------------------------------------------------------------
 //---------------------------------------------------------------- Avp::addAvp()
 //------------------------------------------------------------------------------
-Avp * Avp::addAvp(const char *name) throw(anna::RuntimeException) {
+Avp * Avp::addAvp(const char *name) noexcept(false) {
   return addAvp(getEngine()->avpIdForName(name));
 }
 
@@ -573,7 +573,7 @@ Avp * Avp::addAvp(const char *name) throw(anna::RuntimeException) {
 //------------------------------------------------------------------------------
 //------------------------------------------------------------- Avp::removeAvp()
 //------------------------------------------------------------------------------
-bool Avp::removeAvp(const char *name, int ocurrence) throw(anna::RuntimeException) {
+bool Avp::removeAvp(const char *name, int ocurrence) noexcept(false) {
   return removeAvp(getEngine()->avpIdForName(name), ocurrence);
 }
 
@@ -581,7 +581,7 @@ bool Avp::removeAvp(const char *name, int ocurrence) throw(anna::RuntimeExceptio
 //------------------------------------------------------------------------------
 //--------------------------------------------------------------- Avp::_getAvp()
 //------------------------------------------------------------------------------
-const Avp *Avp::_getAvp(const char *name, int ocurrence, anna::Exception::Mode::_v emode) const throw(anna::RuntimeException) {
+const Avp *Avp::_getAvp(const char *name, int ocurrence, anna::Exception::Mode::_v emode) const noexcept(false) {
   return getAvp(getEngine()->avpIdForName(name), ocurrence, emode);
 }
 
@@ -589,14 +589,14 @@ const Avp *Avp::_getAvp(const char *name, int ocurrence, anna::Exception::Mode::
 //------------------------------------------------------------------------------
 //-------------------------------------------------------------- Avp::countAvp()
 //------------------------------------------------------------------------------
-int Avp::countAvp(const char *name) const throw(anna::RuntimeException) {
+int Avp::countAvp(const char *name) const noexcept(false) {
   return countAvp(getEngine()->avpIdForName(name));
 }
 
 //------------------------------------------------------------------------------
 //------------------------------------------------------------- Avp::getLength()
 //------------------------------------------------------------------------------
-U24 Avp::getLength() const throw() {
+U24 Avp::getLength() const {
   U24 result;
   // Avp format:
   const stack::Avp *stackAvp = getStackAvp();
@@ -637,7 +637,7 @@ U24 Avp::getLength() const throw() {
 //------------------------------------------------------------------------------
 //-------------------------------------------- Avp::unknownAvpWithMandatoryBit()
 //------------------------------------------------------------------------------
-void Avp::unknownAvpWithMandatoryBit() const throw(anna::RuntimeException) {
+void Avp::unknownAvpWithMandatoryBit() const noexcept(false) {
   OamModule &oamModule = OamModule::instantiate();
   const char *c_aid = STRING_WITH_QUOTATION_MARKS__C_STR(anna::diameter::functions::avpIdAsPairString(a_id));
   oamModule.activateAlarm(OamModule::Alarm::AvpDecode__UnknownAvp__s__WithMandatoryBit, c_aid);
@@ -651,7 +651,7 @@ void Avp::unknownAvpWithMandatoryBit() const throw(anna::RuntimeException) {
 //------------------------------------------------------------------------------
 //-------------------------------------------------------- Avp::decodeDataPart()
 //------------------------------------------------------------------------------
-void Avp::decodeDataPart(const char * buffer, int size, const parent_t & parent, Message *answer) throw(anna::RuntimeException) {
+void Avp::decodeDataPart(const char * buffer, int size, const parent_t & parent, Message *answer) noexcept(false) {
   // OAM
   OamModule &oamModule = OamModule::instantiate();
   // Dictionary stack avp and format:
@@ -726,7 +726,7 @@ void Avp::decodeDataPart(const char * buffer, int size, const parent_t & parent,
 //------------------------------------------------------------------------------
 //---------------------------------------------------------------- Avp::decode()
 //------------------------------------------------------------------------------
-void Avp::decode(const anna::DataBlock &db, const parent_t & parent, Message *answer) throw(anna::RuntimeException) {
+void Avp::decode(const anna::DataBlock &db, const parent_t & parent, Message *answer) noexcept(false) {
   // OAM
   OamModule &oamModule = OamModule::instantiate();
 
@@ -835,7 +835,7 @@ void Avp::decode(const anna::DataBlock &db, const parent_t & parent, Message *an
 //------------------------------------------------------------------------------
 //----------------------------------------------------------- Avp::getStackAvp()
 //------------------------------------------------------------------------------
-const anna::diameter::stack::Avp *Avp::getStackAvp(AvpId id, Engine *engine) throw() {
+const anna::diameter::stack::Avp *Avp::getStackAvp(AvpId id, Engine *engine) {
   const stack::Dictionary * dictionary = engine->getDictionary();
   return (dictionary ? (dictionary->getAvp(id)) : NULL);
 }
@@ -844,7 +844,7 @@ const anna::diameter::stack::Avp *Avp::getStackAvp(AvpId id, Engine *engine) thr
 //------------------------------------------------------------------------------
 //------------------------------------------------------------------- Avp::fix()
 //------------------------------------------------------------------------------
-void Avp::fix(avp_container &avps, find_container &finds, int &insertionPositionForChilds, anna::diameter::stack::const_avprule_iterator ruleBegin, anna::diameter::stack::const_avprule_iterator ruleEnd) throw() {
+void Avp::fix(avp_container &avps, find_container &finds, int &insertionPositionForChilds, anna::diameter::stack::const_avprule_iterator ruleBegin, anna::diameter::stack::const_avprule_iterator ruleEnd) {
   // Exit cases
   if(avps.size() == 0) return;  // empty content, nothing to fix
 
@@ -890,7 +890,7 @@ void Avp::fix(avp_container &avps, find_container &finds, int &insertionPosition
 //------------------------------------------------------------------------------
 //------------------------------------------------------------------- Avp::fix()
 //------------------------------------------------------------------------------
-void Avp::fix() throw() {
+void Avp::fix() {
   // Dictionary stack avp:
   const stack::Avp *stackAvp = getStackAvp();
   const stack::Format *stackFormat = stackAvp ? (stackAvp->getFormat()) : NULL /*Unknown*/;
@@ -912,7 +912,7 @@ void Avp::fix() throw() {
 //------------------------------------------------------------------------------
 //------------------------------------------------------------ Avp::validLevel()
 //------------------------------------------------------------------------------
-bool Avp::validLevel(const avp_container &avps, anna::diameter::stack::const_avprule_iterator ruleBegin, anna::diameter::stack::const_avprule_iterator ruleEnd, Engine * engine, const parent_t & parent, Message *answer) throw(anna::RuntimeException) {
+bool Avp::validLevel(const avp_container &avps, anna::diameter::stack::const_avprule_iterator ruleBegin, anna::diameter::stack::const_avprule_iterator ruleEnd, Engine * engine, const parent_t & parent, Message *answer) noexcept(false) {
   bool result = true;
   // OAM
   OamModule &oamModule = OamModule::instantiate();
@@ -1085,7 +1085,7 @@ bool Avp::validLevel(const avp_container &avps, anna::diameter::stack::const_avp
 //------------------------------------------------------------------------------
 //----------------------------------------------------------------- Avp::valid()
 //------------------------------------------------------------------------------
-bool Avp::valid(const parent_t & parent, Message *answer) const throw(anna::RuntimeException) {
+bool Avp::valid(const parent_t & parent, Message *answer) const noexcept(false) {
   // OAM
   OamModule &oamModule = OamModule::instantiate();
   // Dictionary stack avp:
@@ -1163,7 +1163,7 @@ bool Avp::valid(const parent_t & parent, Message *answer) const throw(anna::Runt
 //------------------------------------------------------------------------------
 //------------------------------------------------------------------ Avp::code()
 //------------------------------------------------------------------------------
-void Avp::code(char* buffer, int &size) const throw(anna::RuntimeException) {
+void Avp::code(char* buffer, int &size) const noexcept(false) {
   // Code
   buffer[0] = (S8)(a_id.first >> 24);
   buffer[1] = (S8)(a_id.first >> 16);
@@ -1242,7 +1242,7 @@ void Avp::code(char* buffer, int &size) const throw(anna::RuntimeException) {
 //------------------------------------------------------------------------------
 //------------------------------------------------------------ Avp::getXMLdata()
 //------------------------------------------------------------------------------
-std::string Avp::getXMLdata(bool & isHex, const stack::Format *stackFormat) const throw() {
+std::string Avp::getXMLdata(bool & isHex, const stack::Format *stackFormat) const {
   std::string result = "";
   isHex = false;
   // Unknown
@@ -1329,7 +1329,7 @@ std::string Avp::getXMLdata(bool & isHex, const stack::Format *stackFormat) cons
 //------------------------------------------------------------------------------
 //---------------------------------------------------------------- Avp::decode()
 //------------------------------------------------------------------------------
-void Avp::decode(const anna::DataBlock &db) throw(anna::RuntimeException) {
+void Avp::decode(const anna::DataBlock &db) noexcept(false) {
   parent_t parent;
   parent.setMessage(CommandId(0, false), "No-Parent");
   decode(db, parent, NULL);
@@ -1339,7 +1339,7 @@ void Avp::decode(const anna::DataBlock &db) throw(anna::RuntimeException) {
 //------------------------------------------------------------------------------
 //--------------------------------------------------------------- Avp::fromXML()
 //------------------------------------------------------------------------------
-void Avp::fromXML(const anna::xml::Node* avpNode) throw(anna::RuntimeException) {
+void Avp::fromXML(const anna::xml::Node* avpNode) noexcept(false) {
   // <!ATTLIST avp id CDATA #IMPLIED code CDATA #IMPLIED vendor-code CDATA #IMPLIED flags CDATA #IMPLIED data CDATA #IMPLIED hex-data CDATA #IMPLIED>
   const anna::xml::Attribute *name, *code, *vendorCode, *flags, *data, *hexData;
   name = avpNode->getAttribute("name", false /* no exception */);
@@ -1599,7 +1599,7 @@ void Avp::fromXML(const anna::xml::Node* avpNode) throw(anna::RuntimeException)
 //------------------------------------------------------------------------------
 //----------------------------------------------------------------- Avp::asXML()
 //------------------------------------------------------------------------------
-anna::xml::Node* Avp::asXML(anna::xml::Node* parent) const throw() {
+anna::xml::Node* Avp::asXML(anna::xml::Node* parent) const {
   // <!ATTLIST avp id CDATA #IMPLIED code CDATA #IMPLIED vendor-code CDATA #IMPLIED flags CDATA #IMPLIED data CDATA #IMPLIED hex-data CDATA #IMPLIED>
   anna::xml::Node* result = parent->createChild("avp");
   // Dictionary stack avp and format:
@@ -1648,7 +1648,7 @@ anna::xml::Node* Avp::asXML(anna::xml::Node* parent) const throw() {
 //------------------------------------------------------------------------------
 //----------------------------------------------------------- Avp::asXMLString()
 //------------------------------------------------------------------------------
-std::string Avp::asXMLString(bool normalize) const throw() {
+std::string Avp::asXMLString(bool normalize) const {
   anna::xml::Node root("root");
 
   anna::xml::Compiler::Mode::_v mode = normalize ? anna::xml::Compiler::Mode::Sort : anna::xml::Compiler::Mode::Visual;
@@ -1664,7 +1664,7 @@ std::string Avp::asXMLString(bool normalize) const throw() {
 //------------------------------------------------------------------------------
 //---------------------------------------------------------------- Avp::isLike()
 //------------------------------------------------------------------------------
-bool Avp::isLike(const std::string &pattern) const throw() {
+bool Avp::isLike(const std::string &pattern) const {
   anna::RegularExpression re(pattern);
   return re.isLike(asXMLString(true /* normalize by mean sorting attribute names and removing new lines */));
 }