Refactor NGSetupFailure and its IEs

src/ngap/ngapIEs/Cause.cpp

@@ -20,56 +20,55 @@
  */
 
 #include "Cause.hpp"
-
-#include <iostream>
-using namespace std;
+#include "logger.hpp"
 
 namespace ngap {
 
 //------------------------------------------------------------------------------
 Cause::Cause() {
-  causeValue = -1;
+  cause_present_ = Ngap_Cause_PR_NOTHING;
+  cause_value_   = -1;
 }
 
 //------------------------------------------------------------------------------
 Cause::~Cause() {}
 
 //------------------------------------------------------------------------------
-void Cause::setChoiceOfCause(Ngap_Cause_PR m_causePresent) {
-  causePresent = m_causePresent;
+void Cause::setChoiceOfCause(const Ngap_Cause_PR& cause_present) {
+  cause_present_ = cause_present;
 }
 
 //------------------------------------------------------------------------------
-void Cause::setValue(long m_causeValue) {
-  causeValue = m_causeValue;
+void Cause::setValue(const long& cause_value) {
+  cause_value_ = cause_value;
 }
 
 //------------------------------------------------------------------------------
-bool Cause::encode2Cause(Ngap_Cause_t* cause) {
-  cause->present = causePresent;
-  switch (causePresent) {
+bool Cause::encode(Ngap_Cause_t& cause) const {
+  cause.present = cause_present_;
+  switch (cause_present_) {
     case Ngap_Cause_PR_radioNetwork: {
-      cause->choice.radioNetwork = causeValue;
+      cause.choice.radioNetwork = cause_value_;
       break;
     }
     case Ngap_Cause_PR_transport: {
-      cause->choice.transport = causeValue;
+      cause.choice.transport = cause_value_;
       break;
     }
     case Ngap_Cause_PR_nas: {
-      cause->choice.nas = causeValue;
+      cause.choice.nas = cause_value_;
       break;
     }
     case Ngap_Cause_PR_protocol: {
-      cause->choice.protocol = causeValue;
+      cause.choice.protocol = cause_value_;
       break;
     }
     case Ngap_Cause_PR_misc: {
-      cause->choice.misc = causeValue;
+      cause.choice.misc = cause_value_;
       break;
     }
     default: {
-      cout << "[Warning] Cause Present error!" << endl;
+      Logger::ngap().warn("Cause Present error!");
       return false;
       break;
     }
@@ -78,26 +77,26 @@ bool Cause::encode2Cause(Ngap_Cause_t* cause) {
 }
 
 //------------------------------------------------------------------------------
-bool Cause::decodefromCause(Ngap_Cause_t* pdu) {
-  causePresent = pdu->present;
-  switch (causePresent) {
+bool Cause::decode(const Ngap_Cause_t& cause) {
+  cause_present_ = cause.present;
+  switch (cause_present_) {
     case Ngap_Cause_PR_radioNetwork: {
-      causeValue = pdu->choice.radioNetwork;
+      cause_value_ = cause.choice.radioNetwork;
     } break;
     case Ngap_Cause_PR_transport: {
-      causeValue = pdu->choice.transport;
+      cause_value_ = cause.choice.transport;
     } break;
     case Ngap_Cause_PR_nas: {
-      causeValue = pdu->choice.nas;
+      cause_value_ = cause.choice.nas;
     } break;
     case Ngap_Cause_PR_protocol: {
-      causeValue = pdu->choice.protocol;
+      cause_value_ = cause.choice.protocol;
     } break;
     case Ngap_Cause_PR_misc: {
-      causeValue = pdu->choice.misc;
+      cause_value_ = cause.choice.misc;
     } break;
     default: {
-      cout << "[Warning] Cause Present error!" << endl;
+      Logger::ngap().warn("Cause Present error!");
       return false;
     }
   }
@@ -105,12 +104,12 @@ bool Cause::decodefromCause(Ngap_Cause_t* pdu) {
 }
 
 //------------------------------------------------------------------------------
-Ngap_Cause_PR Cause::getChoiceOfCause() {
-  return causePresent;
+Ngap_Cause_PR Cause::getChoiceOfCause() const {
+  return cause_present_;
 }
 
 //------------------------------------------------------------------------------
-long Cause::getValue() {
-  return causeValue;
+long Cause::getValue() const {
+  return cause_value_;
 }
 }  // namespace ngap

src/ngap/ngapIEs/Cause.hpp

@@ -33,16 +33,16 @@ class Cause {
   Cause();
   virtual ~Cause();
 
-  bool encode2Cause(Ngap_Cause_t* cause);
-  bool decodefromCause(Ngap_Cause_t* pdu);
-  void setChoiceOfCause(Ngap_Cause_PR m_causePresent);
-  Ngap_Cause_PR getChoiceOfCause();
-  void setValue(long);
-  long getValue();
+  bool encode(Ngap_Cause_t& cause) const;
+  bool decode(const Ngap_Cause_t& cause);
+  void setChoiceOfCause(const Ngap_Cause_PR& cause_present);
+  Ngap_Cause_PR getChoiceOfCause() const;
+  void setValue(const long& value);
+  long getValue() const;
 
  private:
-  long causeValue;
-  Ngap_Cause_PR causePresent;
+  long cause_value_;
+  Ngap_Cause_PR cause_present_;
 };
 }  // namespace ngap
 

src/ngap/ngapIEs/PDUSessionResourceReleaseCommandTransfer.cpp

@@ -56,8 +56,8 @@ void PDUSessionResourceReleaseCommandTransfer::setCauseRadioNetwork(
   causeValue->setChoiceOfCause(Ngap_Cause_PR_radioNetwork);
   causeValue->setValue(cause_value);
 
-  int ret = causeValue->encode2Cause(
-      &pduSessionResourceReleaseCommandTransferIEs->cause);
+  int ret =
+      causeValue->encode(pduSessionResourceReleaseCommandTransferIEs->cause);
   if (!ret) {
     cout << "encode CauseRadioNetwork IE error" << endl;
     return;
@@ -70,8 +70,8 @@ void PDUSessionResourceReleaseCommandTransfer::setCauseTransport(
   causeValue->setChoiceOfCause(Ngap_Cause_PR_transport);
   causeValue->setValue(cause_value);
 
-  int ret = causeValue->encode2Cause(
-      &pduSessionResourceReleaseCommandTransferIEs->cause);
+  int ret =
+      causeValue->encode(pduSessionResourceReleaseCommandTransferIEs->cause);
   if (!ret) {
     cout << "encode CauseTransport IE error" << endl;
     return;
@@ -84,8 +84,8 @@ void PDUSessionResourceReleaseCommandTransfer::setCauseNas(
   causeValue->setChoiceOfCause(Ngap_Cause_PR_nas);
   causeValue->setValue(cause_value);
 
-  int ret = causeValue->encode2Cause(
-      &pduSessionResourceReleaseCommandTransferIEs->cause);
+  int ret =
+      causeValue->encode(pduSessionResourceReleaseCommandTransferIEs->cause);
   if (!ret) {
     cout << "encode CauseNas IE error" << endl;
     return;
@@ -98,8 +98,8 @@ void PDUSessionResourceReleaseCommandTransfer::setCauseProtocol(
   causeValue->setChoiceOfCause(Ngap_Cause_PR_protocol);
   causeValue->setValue(cause_value);
 
-  int ret = causeValue->encode2Cause(
-      &pduSessionResourceReleaseCommandTransferIEs->cause);
+  int ret =
+      causeValue->encode(pduSessionResourceReleaseCommandTransferIEs->cause);
   if (!ret) {
     cout << "encode CauseProtocol IE error" << endl;
     return;
@@ -112,8 +112,8 @@ void PDUSessionResourceReleaseCommandTransfer::setCauseMisc(
   causeValue->setChoiceOfCause(Ngap_Cause_PR_misc);
   causeValue->setValue(cause_value);
 
-  int ret = causeValue->encode2Cause(
-      &pduSessionResourceReleaseCommandTransferIEs->cause);
+  int ret =
+      causeValue->encode(pduSessionResourceReleaseCommandTransferIEs->cause);
   if (!ret) {
     cout << "encode CauseMisc IE error" << endl;
     return;
@@ -155,8 +155,7 @@ bool PDUSessionResourceReleaseCommandTransfer::decodefromIE(
   // pduSessionResourceSetupUnsuccessfulTransferIEs);
 
   causeValue = new Cause();
-  if (!causeValue->decodefromCause(
-          &pduSessionResourceReleaseCommandTransferIEs->cause)) {
+  if (!causeValue->decode(pduSessionResourceReleaseCommandTransferIEs->cause)) {
     cout << "decoded ngap Cause IE error" << endl;
     return false;
   }

src/ngap/ngapIEs/PDUSessionResourceSetupUnsuccessfulTransfer.cpp

@@ -55,8 +55,8 @@ void PduSessionResourceSetupUnSuccessfulTransferIE::setCauseRadioNetwork(
   causeValue->setChoiceOfCause(Ngap_Cause_PR_radioNetwork);
   causeValue->setValue(cause_value);
 
-  int ret = causeValue->encode2Cause(
-      &pduSessionResourceSetupUnsuccessfulTransferIEs->cause);
+  int ret =
+      causeValue->encode(pduSessionResourceSetupUnsuccessfulTransferIEs->cause);
   if (!ret) {
     cout << "encode CauseRadioNetwork IE error" << endl;
     return;
@@ -71,8 +71,8 @@ void PduSessionResourceSetupUnSuccessfulTransferIE::setCauseTransport(
   causeValue->setChoiceOfCause(Ngap_Cause_PR_transport);
   causeValue->setValue(cause_value);
 
-  int ret = causeValue->encode2Cause(
-      &pduSessionResourceSetupUnsuccessfulTransferIEs->cause);
+  int ret =
+      causeValue->encode(pduSessionResourceSetupUnsuccessfulTransferIEs->cause);
   if (!ret) {
     cout << "encode CauseTransport IE error" << endl;
     return;
@@ -87,8 +87,8 @@ void PduSessionResourceSetupUnSuccessfulTransferIE::setCauseNas(
   causeValue->setChoiceOfCause(Ngap_Cause_PR_nas);
   causeValue->setValue(cause_value);
 
-  int ret = causeValue->encode2Cause(
-      &pduSessionResourceSetupUnsuccessfulTransferIEs->cause);
+  int ret =
+      causeValue->encode(pduSessionResourceSetupUnsuccessfulTransferIEs->cause);
   if (!ret) {
     cout << "encode CauseNas IE error" << endl;
     return;
@@ -103,8 +103,8 @@ void PduSessionResourceSetupUnSuccessfulTransferIE::setCauseProtocol(
   causeValue->setChoiceOfCause(Ngap_Cause_PR_protocol);
   causeValue->setValue(cause_value);
 
-  int ret = causeValue->encode2Cause(
-      &pduSessionResourceSetupUnsuccessfulTransferIEs->cause);
+  int ret =
+      causeValue->encode(pduSessionResourceSetupUnsuccessfulTransferIEs->cause);
   if (!ret) {
     cout << "encode CauseProtocol IE error" << endl;
     return;
@@ -119,8 +119,8 @@ void PduSessionResourceSetupUnSuccessfulTransferIE::setCauseMisc(
   causeValue->setChoiceOfCause(Ngap_Cause_PR_misc);
   causeValue->setValue(cause_value);
 
-  int ret = causeValue->encode2Cause(
-      &pduSessionResourceSetupUnsuccessfulTransferIEs->cause);
+  int ret =
+      causeValue->encode(pduSessionResourceSetupUnsuccessfulTransferIEs->cause);
   if (!ret) {
     cout << "encode CauseMisc IE error" << endl;
     return;
@@ -165,8 +165,8 @@ bool PduSessionResourceSetupUnSuccessfulTransferIE::decodefromIE(
   // pduSessionResourceSetupUnsuccessfulTransferIEs);
 
   causeValue = new Cause();
-  if (!causeValue->decodefromCause(
-          &pduSessionResourceSetupUnsuccessfulTransferIEs->cause)) {
+  if (!causeValue->decode(
+          pduSessionResourceSetupUnsuccessfulTransferIEs->cause)) {
     cout << "decoded ngap Cause IE error" << endl;
     return false;
   }

src/ngap/ngapIEs/TimeToWait.cpp

@@ -21,38 +21,40 @@
 
 #include "TimeToWait.hpp"
 
-#include <iostream>
-using namespace std;
-
 namespace ngap {
 
 //------------------------------------------------------------------------------
 TimeToWait::TimeToWait() {
-  timeValue = -1;
+  time_ = -1;
+}
+
+//------------------------------------------------------------------------------
+TimeToWait::TimeToWait(e_Ngap_TimeToWait time) {
+  time_ = time;
 }
 
 //------------------------------------------------------------------------------
 TimeToWait::~TimeToWait() {}
 
 //------------------------------------------------------------------------------
-void TimeToWait::setValue(e_Ngap_TimeToWait m_timeToWait) {
-  timeValue = m_timeToWait;
+void TimeToWait::setValue(e_Ngap_TimeToWait time) {
+  time_ = time;
 }
 
 //------------------------------------------------------------------------------
-bool TimeToWait::encode2TimeToWait(Ngap_TimeToWait_t* timeToWait) {
-  *timeToWait = timeValue;
+bool TimeToWait::encode(Ngap_TimeToWait_t& time) {
+  time_ = time;
   return true;
 }
 
 //------------------------------------------------------------------------------
-bool TimeToWait::decodefromTimeToWait(Ngap_TimeToWait_t* pdu) {
-  timeValue = *pdu;
+bool TimeToWait::decode(Ngap_TimeToWait_t& time) {
+  time_ = time;
   return true;
 }
 
 //------------------------------------------------------------------------------
 long TimeToWait::getValue() {
-  return timeValue;
+  return time_;
 }
 }  // namespace ngap

src/ngap/ngapIEs/TimeToWait.hpp

@@ -33,15 +33,16 @@ namespace ngap {
 class TimeToWait {
  public:
   TimeToWait();
+  TimeToWait(e_Ngap_TimeToWait);
   virtual ~TimeToWait();
 
-  bool encode2TimeToWait(Ngap_TimeToWait_t*);
-  bool decodefromTimeToWait(Ngap_TimeToWait_t*);
+  bool encode(Ngap_TimeToWait_t&);
+  bool decode(Ngap_TimeToWait_t&);
   void setValue(e_Ngap_TimeToWait);
   long getValue();
 
  private:
-  long timeValue;
+  long time_;
 };
 }  // namespace ngap
 

src/ngap/ngapMsgs/HandoverPreparationFailure.cpp

@@ -108,7 +108,7 @@ void HandoverPreparationFailure::setCause(
 
   cause.setChoiceOfCause(causePresent);
   if (causePresent != Ngap_Cause_PR_NOTHING) cause.setValue(value);
-  cause.encode2Cause(&(ie->value.choice.Cause));
+  cause.encode(ie->value.choice.Cause);
   int ret = ASN_SEQUENCE_ADD(&hoPreparationFailureIEs->protocolIEs.list, ie);
   if (ret != 0) Logger::ngap().error("Encode Cause IE error");
 }
@@ -181,9 +181,8 @@ bool HandoverPreparationFailure::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
                 Ngap_Criticality_ignore &&
             hoPreparationFailureIEs->protocolIEs.list.array[i]->value.present ==
                 Ngap_HandoverPreparationFailureIEs__value_PR_Cause) {
-          if (!cause.decodefromCause(
-                  &hoPreparationFailureIEs->protocolIEs.list.array[i]
-                       ->value.choice.Cause)) {
+          if (!cause.decode(hoPreparationFailureIEs->protocolIEs.list.array[i]
+                                ->value.choice.Cause)) {
             Logger::ngap().error("Decoded NGAP Cause IE error");
             return false;
           }

src/ngap/ngapMsgs/HandoverRequest.cpp

@@ -159,7 +159,7 @@ void HandoverRequest::setCause(
 
   cause.setChoiceOfCause(causePresent);
   cause.setValue(value);
-  cause.encode2Cause(&(ie->value.choice.Cause));
+  cause.encode(ie->value.choice.Cause);
   int ret = ASN_SEQUENCE_ADD(&handoverRequestIEs->protocolIEs.list, ie);
   if (ret != 0) Logger::ngap().error("Encode Cause IE error");
 }

src/ngap/ngapMsgs/HandoverRequiredMsg.cpp

@@ -209,9 +209,8 @@ bool HandoverRequiredMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
                 Ngap_Criticality_ignore &&
             handoverRequiredIEs->protocolIEs.list.array[i]->value.present ==
                 Ngap_HandoverRequiredIEs__value_PR_Cause) {
-          if (!cause.decodefromCause(
-                  &handoverRequiredIEs->protocolIEs.list.array[i]
-                       ->value.choice.Cause)) {
+          if (!cause.decode(handoverRequiredIEs->protocolIEs.list.array[i]
+                                ->value.choice.Cause)) {
             Logger::ngap().error("Decoded NGAP Cause IE error");
             return false;
           }

src/ngap/ngapMsgs/NGReset.cpp

@@ -54,7 +54,7 @@ void NGResetMsg::setCause(const Cause& c) {
   ie->criticality   = Ngap_Criticality_ignore;
   ie->value.present = Ngap_NGResetIEs__value_PR_Cause;
 
-  if (!cause.encode2Cause(&ie->value.choice.Cause)) {
+  if (!cause.encode(ie->value.choice.Cause)) {
     Logger::ngap().error("Encode NGAP Cause IE error");
     free_wrapper((void**) &ie);
     return;
@@ -121,8 +121,8 @@ bool NGResetMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
                     Ngap_Criticality_ignore &&
                 ngResetIEs->protocolIEs.list.array[i]->value.present ==
                     Ngap_NGResetIEs__value_PR_Cause) {
-              if (!cause.decodefromCause(&ngResetIEs->protocolIEs.list.array[i]
-                                              ->value.choice.Cause)) {
+              if (!cause.decode(ngResetIEs->protocolIEs.list.array[i]
+                                    ->value.choice.Cause)) {
                 Logger::ngap().error("Decoded NGAP Cause IE error");
                 return false;
               }

src/ngap/ngapMsgs/NGSetupFailure.cpp

@@ -32,6 +32,7 @@ namespace ngap {
 NGSetupFailureMsg::NGSetupFailureMsg() : NgapMessage() {
   ngSetupFailureIEs = nullptr;
   // criticalityDiagnostics = NULL;
+  timeToWait = std::nullopt;
   NgapMessage::setMessageType(NgapMessageType::NG_SETUP_FAILURE);
   initialize();
 }
@@ -53,7 +54,7 @@ void NGSetupFailureMsg::addCauseIE() {
   ie->criticality   = Ngap_Criticality_ignore;
   ie->value.present = Ngap_NGSetupFailureIEs__value_PR_Cause;
 
-  if (!cause.encode2Cause(&ie->value.choice.Cause)) {
+  if (!cause.encode(ie->value.choice.Cause)) {
     Logger::ngap().error("Encode NGAP Cause IE error");
     free_wrapper((void**) &ie);
     return;
@@ -65,13 +66,15 @@ void NGSetupFailureMsg::addCauseIE() {
 
 //------------------------------------------------------------------------------
 void NGSetupFailureMsg::addTimeToWaitIE() {
+  if (!timeToWait.has_value()) return;
+
   Ngap_NGSetupFailureIEs_t* ie =
       (Ngap_NGSetupFailureIEs_t*) calloc(1, sizeof(Ngap_NGSetupFailureIEs_t));
   ie->id            = Ngap_ProtocolIE_ID_id_TimeToWait;
   ie->criticality   = Ngap_Criticality_ignore;
   ie->value.present = Ngap_NGSetupFailureIEs__value_PR_TimeToWait;
 
-  if (!timeToWait.encode2TimeToWait(&ie->value.choice.TimeToWait)) {
+  if (!timeToWait.value().encode(ie->value.choice.TimeToWait)) {
     Logger::ngap().error("Encode NGAP Cause IE error");
     free_wrapper((void**) &ie);
     return;
@@ -89,26 +92,27 @@ void NGSetupFailureMsg::set(
   cause.setValue(cause_value);
   addCauseIE();
 
-  timeToWait.setValue(time_to_wait);
+  timeToWait = std::make_optional<TimeToWait>(time_to_wait);
   addTimeToWaitIE();
 }
 
 //------------------------------------------------------------------------------
-void NGSetupFailureMsg::set(const e_Ngap_CauseRadioNetwork& cause_value) {
+void NGSetupFailureMsg::setCauseRadioNetwork(
+    const e_Ngap_CauseRadioNetwork& cause_value) {
   cause.setChoiceOfCause(Ngap_Cause_PR_radioNetwork);
   cause.setValue(cause_value);
   addCauseIE();
 }
 
 //------------------------------------------------------------------------------
-void NGSetupFailureMsg::setCauseTransport(
+void NGSetupFailureMsg::set(
     const e_Ngap_CauseTransport& cause_value,
     const e_Ngap_TimeToWait& time_to_wait) {
   cause.setChoiceOfCause(Ngap_Cause_PR_transport);
   cause.setValue(cause_value);
   addCauseIE();
 
-  timeToWait.setValue(time_to_wait);
+  timeToWait = std::make_optional<TimeToWait>(time_to_wait);
   addTimeToWaitIE();
 }
 
@@ -121,13 +125,13 @@ void NGSetupFailureMsg::setCauseTransport(
 }
 
 //------------------------------------------------------------------------------
-void NGSetupFailureMsg::setCauseNas(
+void NGSetupFailureMsg::set(
     const e_Ngap_CauseNas& cause_value, const e_Ngap_TimeToWait& time_to_wait) {
   cause.setChoiceOfCause(Ngap_Cause_PR_nas);
   cause.setValue(cause_value);
   addCauseIE();
 
-  timeToWait.setValue(time_to_wait);
+  timeToWait = std::make_optional<TimeToWait>(time_to_wait);
   addTimeToWaitIE();
 }
 
@@ -139,14 +143,14 @@ void NGSetupFailureMsg::setCauseNas(const e_Ngap_CauseNas& cause_value) {
 }
 
 //------------------------------------------------------------------------------
-void NGSetupFailureMsg::setCauseProtocol(
+void NGSetupFailureMsg::set(
     const e_Ngap_CauseProtocol& cause_value,
     const e_Ngap_TimeToWait& time_to_wait) {
   cause.setChoiceOfCause(Ngap_Cause_PR_protocol);
   cause.setValue(cause_value);
   addCauseIE();
 
-  timeToWait.setValue(time_to_wait);
+  timeToWait = std::make_optional<TimeToWait>(time_to_wait);
   addTimeToWaitIE();
 }
 
@@ -159,14 +163,14 @@ void NGSetupFailureMsg::setCauseProtocol(
 }
 
 //------------------------------------------------------------------------------
-void NGSetupFailureMsg::setCauseMisc(
+void NGSetupFailureMsg::set(
     const e_Ngap_CauseMisc& cause_value,
     const e_Ngap_TimeToWait& time_to_wait) {
   cause.setChoiceOfCause(Ngap_Cause_PR_misc);
   cause.setValue(cause_value);
   addCauseIE();
 
-  timeToWait.setValue(time_to_wait);
+  timeToWait = std::make_optional<TimeToWait>(time_to_wait);
   addTimeToWaitIE();
 }
 
@@ -205,9 +209,8 @@ bool NGSetupFailureMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
                 Ngap_Criticality_ignore &&
             ngSetupFailureIEs->protocolIEs.list.array[i]->value.present ==
                 Ngap_NGSetupFailureIEs__value_PR_Cause) {
-          if (!cause.decodefromCause(
-                  &ngSetupFailureIEs->protocolIEs.list.array[i]
-                       ->value.choice.Cause)) {
+          if (!cause.decode(ngSetupFailureIEs->protocolIEs.list.array[i]
+                                ->value.choice.Cause)) {
             Logger::ngap().error("Decoded NGAP Cause IE error");
             return false;
           }
@@ -221,12 +224,13 @@ bool NGSetupFailureMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
                 Ngap_Criticality_ignore &&
             ngSetupFailureIEs->protocolIEs.list.array[i]->value.present ==
                 Ngap_NGSetupFailureIEs__value_PR_TimeToWait) {
-          if (!timeToWait.decodefromTimeToWait(
-                  &ngSetupFailureIEs->protocolIEs.list.array[i]
-                       ->value.choice.TimeToWait)) {
+          TimeToWait tmp = {};
+          if (!tmp.decode(ngSetupFailureIEs->protocolIEs.list.array[i]
+                              ->value.choice.TimeToWait)) {
             Logger::ngap().error("Decoded NGAP TimeToWait IE error");
             return false;
           }
+          timeToWait = std::optional<TimeToWait>(tmp);
         } else {
           Logger::ngap().error("Decoded NGAP TimeToWait IE error");
           return false;
@@ -302,11 +306,16 @@ bool NGSetupFailureMsg::getCauseMisc(e_Ngap_CauseMisc& causeMisc) {
 }
 
 //------------------------------------------------------------------------------
-bool NGSetupFailureMsg::getTime2Wait(e_Ngap_TimeToWait& time) {
-  if (timeToWait.getValue() < 0) {
+void NGSetupFailureMsg::setTimeToWait(const e_Ngap_TimeToWait& time) {
+  timeToWait = std::make_optional<TimeToWait>(time);
+}
+
+//------------------------------------------------------------------------------
+bool NGSetupFailureMsg::getTimeToWait(e_Ngap_TimeToWait& time) {
+  if (timeToWait.has_value()) {
     return false;
   }
-  time = (e_Ngap_TimeToWait) timeToWait.getValue();
+  time = (e_Ngap_TimeToWait) timeToWait.value().getValue();
   return true;
 }
 

src/ngap/ngapMsgs/NGSetupFailure.hpp

@@ -27,6 +27,8 @@
 #include "TimeToWait.hpp"
 #include "NgapMessage.hpp"
 
+#include <optional>
+
 namespace ngap {
 
 class NGSetupFailureMsg : public NgapMessage {
@@ -39,47 +41,49 @@ class NGSetupFailureMsg : public NgapMessage {
   void set(
       const e_Ngap_CauseRadioNetwork& cause_value,
       const e_Ngap_TimeToWait& time_to_wait);
-  void set(const e_Ngap_CauseRadioNetwork& cause_value);
-  bool getCauseRadioNetwork(e_Ngap_CauseRadioNetwork&);
-
-  void setCauseTransport(
+  void set(
       const e_Ngap_CauseTransport& cause_value,
       const e_Ngap_TimeToWait& time_to_wait);
+  void set(
+      const e_Ngap_CauseNas& cause_value,
+      const e_Ngap_TimeToWait& time_to_wait);
+  void set(
+      const e_Ngap_CauseProtocol& cause_value,
+      const e_Ngap_TimeToWait& time_to_wait);
+  void set(
+      const e_Ngap_CauseMisc& cause_value,
+      const e_Ngap_TimeToWait& time_to_wait);
+
+  void setCauseRadioNetwork(const e_Ngap_CauseRadioNetwork& cause_value);
+  bool getCauseRadioNetwork(e_Ngap_CauseRadioNetwork&);
+
   void setCauseTransport(const e_Ngap_CauseTransport& cause_value);
   bool getCauseTransport(e_Ngap_CauseTransport&);
 
-  void setCauseNas(
-      const e_Ngap_CauseNas& cause_value,
-      const e_Ngap_TimeToWait& time_to_wait);
   void setCauseNas(const e_Ngap_CauseNas& cause_value);
   bool getCauseNas(e_Ngap_CauseNas&);
 
-  void setCauseProtocol(
-      const e_Ngap_CauseProtocol& cause_value,
-      const e_Ngap_TimeToWait& time_to_wait);
   void setCauseProtocol(const e_Ngap_CauseProtocol& cause_value);
   bool getCauseProtocol(e_Ngap_CauseProtocol&);
 
-  void setCauseMisc(
-      const e_Ngap_CauseMisc& cause_value,
-      const e_Ngap_TimeToWait& time_to_wait);
   void setCauseMisc(const e_Ngap_CauseMisc& cause_value);
   bool getCauseMisc(e_Ngap_CauseMisc&);
 
   bool getCauseType(Ngap_Cause_PR&);
-  bool getTime2Wait(e_Ngap_TimeToWait&);
 
-  bool decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) override;
+  bool getTimeToWait(e_Ngap_TimeToWait&);
+  void setTimeToWait(const e_Ngap_TimeToWait&);
 
-  void addCauseIE();
-  void addTimeToWaitIE();
+  bool decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) override;
 
  private:
   Ngap_NGSetupFailure_t* ngSetupFailureIEs;
-
-  Cause cause;            // Mandatory
-  TimeToWait timeToWait;  // Mandatory
+  Cause cause;                           // Mandatory
+  std::optional<TimeToWait> timeToWait;  // Optional
   // TODO: CriticalityDiagnostics *criticalityDiagnostics; //Optional
+
+  void addCauseIE();
+  void addTimeToWaitIE();
 };
 }  // namespace ngap
 #endif

src/ngap/ngapMsgs/UEContextReleaseCommand.cpp

@@ -144,7 +144,7 @@ void UEContextReleaseCommandMsg::addCauseIE() {
   ie->id            = Ngap_ProtocolIE_ID_id_Cause;
   ie->criticality   = Ngap_Criticality_ignore;
   ie->value.present = Ngap_UEContextReleaseCommand_IEs__value_PR_Cause;
-  causeValue.encode2Cause(&ie->value.choice.Cause);
+  causeValue.encode(ie->value.choice.Cause);
   int ret = ASN_SEQUENCE_ADD(&ies->protocolIEs.list, ie);
   if (ret != 0) Logger::ngap().error("Encode NGAP Cause IE error");
 }
@@ -214,8 +214,8 @@ bool UEContextReleaseCommandMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
                 Ngap_Criticality_ignore &&
             ies->protocolIEs.list.array[i]->value.present ==
                 Ngap_UEContextReleaseCommand_IEs__value_PR_Cause) {
-          if (!causeValue.decodefromCause(
-                  &ies->protocolIEs.list.array[i]->value.choice.Cause)) {
+          if (!causeValue.decode(
+                  ies->protocolIEs.list.array[i]->value.choice.Cause)) {
             Logger::ngap().error("Decoded NGAP Cause IE error");
             return false;
           }

src/ngap/ngapMsgs/UEContextReleaseRequest.cpp

@@ -109,7 +109,7 @@ void UEContextReleaseRequestMsg::addCauseIE() {
   ie->id            = Ngap_ProtocolIE_ID_id_Cause;
   ie->criticality   = Ngap_Criticality_ignore;
   ie->value.present = Ngap_UEContextReleaseRequest_IEs__value_PR_Cause;
-  causeValue.encode2Cause(&ie->value.choice.Cause);
+  causeValue.encode(ie->value.choice.Cause);
   int ret = ASN_SEQUENCE_ADD(&ies->protocolIEs.list, ie);
   if (ret != 0) Logger::ngap().error("Encode Cause IE error");
 }
@@ -176,8 +176,8 @@ bool UEContextReleaseRequestMsg::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
                 Ngap_Criticality_ignore &&
             ies->protocolIEs.list.array[i]->value.present ==
                 Ngap_UEContextReleaseRequest_IEs__value_PR_Cause) {
-          if (!causeValue.decodefromCause(
-                  &ies->protocolIEs.list.array[i]->value.choice.Cause)) {
+          if (!causeValue.decode(
+                  ies->protocolIEs.list.array[i]->value.choice.Cause)) {
             Logger::ngap().error("Decode NGAP Cause IE error");
             return false;
           }