Code refactoring for InitialContextSetupResponse

src/ngap/ngapIEs/PDUSessionResourceFailedToSetupItemCxtRes.cpp

@@ -21,9 +21,6 @@
 
 #include "PDUSessionResourceFailedToSetupItemCxtRes.hpp"
 
-#include <iostream>
-using namespace std;
-
 namespace ngap {
 
 //------------------------------------------------------------------------------
@@ -35,49 +32,45 @@ PDUSessionResourceFailedToSetupItemCxtRes::
     ~PDUSessionResourceFailedToSetupItemCxtRes() {}
 
 //------------------------------------------------------------------------------
-void PDUSessionResourceFailedToSetupItemCxtRes::
-    setPDUSessionResourceFailedToSetupItemCxtRes(
-        const PDUSessionID& m_pDUSessionID,
-        const OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer) {
-  pDUSessionID = m_pDUSessionID;
-  pDUSessionResourceSetupUnsuccessfulTransfer =
-      m_pDUSessionResourceSetupUnsuccessfulTransfer;
+void PDUSessionResourceFailedToSetupItemCxtRes::set(
+    const PDUSessionID& pdu_session_id,
+    const OCTET_STRING_t& pdu_session_resource_setup_unsuccessful_transfer) {
+  pdu_session_id_ = pdu_session_id;
+  pdu_session_resource_setup_unsuccessful_transfer_ =
+      pdu_session_resource_setup_unsuccessful_transfer;
 }
 
 //------------------------------------------------------------------------------
-void PDUSessionResourceFailedToSetupItemCxtRes::
-    getPDUSessionResourceFailedToSetupItemCxtRes(
-        PDUSessionID& m_pDUSessionID,
-        OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer) {
-  m_pDUSessionID = pDUSessionID;
-  pDUSessionResourceSetupUnsuccessfulTransfer =
-      pDUSessionResourceSetupUnsuccessfulTransfer;
+void PDUSessionResourceFailedToSetupItemCxtRes::get(
+    PDUSessionID& pdu_session_id,
+    OCTET_STRING_t& pdu_session_resource_setup_unsuccessful_transfer) {
+  pdu_session_id = pdu_session_id_;
+  pdu_session_resource_setup_unsuccessful_transfer =
+      pdu_session_resource_setup_unsuccessful_transfer_;
 }
 
 //------------------------------------------------------------------------------
-bool PDUSessionResourceFailedToSetupItemCxtRes::
-    encode2PDUSessionResourceFailedToSetupItemCxtRes(
+bool PDUSessionResourceFailedToSetupItemCxtRes::encode(
     Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t*
         pduSessionResourceFailedToSetupItemCxtRes) {
-  if (!pDUSessionID.encode(
+  if (!pdu_session_id_.encode(
           pduSessionResourceFailedToSetupItemCxtRes->pDUSessionID))
     return false;
   pduSessionResourceFailedToSetupItemCxtRes
       ->pDUSessionResourceSetupUnsuccessfulTransfer =
-      pDUSessionResourceSetupUnsuccessfulTransfer;
+      pdu_session_resource_setup_unsuccessful_transfer_;
 
   return true;
 }
 
 //------------------------------------------------------------------------------
-bool PDUSessionResourceFailedToSetupItemCxtRes::
-    decodefromPDUSessionResourceFailedToSetupItemCxtRes(
+bool PDUSessionResourceFailedToSetupItemCxtRes::decode(
     Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t*
         pduSessionResourceFailedToSetupItemCxtRes) {
-  if (!pDUSessionID.decode(
+  if (!pdu_session_id_.decode(
           pduSessionResourceFailedToSetupItemCxtRes->pDUSessionID))
     return false;
-  pDUSessionResourceSetupUnsuccessfulTransfer =
+  pdu_session_resource_setup_unsuccessful_transfer_ =
       pduSessionResourceFailedToSetupItemCxtRes
           ->pDUSessionResourceSetupUnsuccessfulTransfer;
 

src/ngap/ngapIEs/PDUSessionResourceFailedToSetupItemCxtRes.hpp

@@ -35,23 +35,22 @@ class PDUSessionResourceFailedToSetupItemCxtRes {
   PDUSessionResourceFailedToSetupItemCxtRes();
   virtual ~PDUSessionResourceFailedToSetupItemCxtRes();
 
-  void setPDUSessionResourceFailedToSetupItemCxtRes(
+  void set(
       const PDUSessionID& m_pDUSessionID,
       const OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer);
-  void getPDUSessionResourceFailedToSetupItemCxtRes(
+  void get(
       PDUSessionID& m_pDUSessionID,
       OCTET_STRING_t& m_pDUSessionResourceSetupUnsuccessfulTransfer);
 
-  bool encode2PDUSessionResourceFailedToSetupItemCxtRes(
-      Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t*
+  bool encode(Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t*
                   pduSessionResourceFailedToSetupItemCxtRes);
-  bool decodefromPDUSessionResourceFailedToSetupItemCxtRes(
-      Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t*
+  bool decode(Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t*
                   pduSessionResourceFailedToSetupItemCxtRes);
 
  private:
-  PDUSessionID pDUSessionID;                                   // Mandatory
-  OCTET_STRING_t pDUSessionResourceSetupUnsuccessfulTransfer;  // Mandatory
+  PDUSessionID pdu_session_id_;  // Mandatory
+  OCTET_STRING_t
+      pdu_session_resource_setup_unsuccessful_transfer_;  // Mandatory
 };
 
 }  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceFailedToSetupListCxtRes.cpp

@@ -35,34 +35,30 @@ PDUSessionResourceFailedToSetupListCxtRes::
     ~PDUSessionResourceFailedToSetupListCxtRes() {}
 
 //------------------------------------------------------------------------------
-void PDUSessionResourceFailedToSetupListCxtRes::
-    setPDUSessionResourceFailedToSetupListCxtRes(
+void PDUSessionResourceFailedToSetupListCxtRes::set(
     const std::vector<PDUSessionResourceFailedToSetupItemCxtRes>& list) {
-  itemList = list;
+  item_list_ = list;
 }
 
 //------------------------------------------------------------------------------
-void PDUSessionResourceFailedToSetupListCxtRes::
-    getPDUSessionResourceFailedToSetupListCxtRes(
+void PDUSessionResourceFailedToSetupListCxtRes::get(
     std::vector<PDUSessionResourceFailedToSetupItemCxtRes>& list) {
-  list = itemList;
+  list = item_list_;
 }
 
 //------------------------------------------------------------------------------
-bool PDUSessionResourceFailedToSetupListCxtRes::
-    encode2PDUSessionResourceFailedToSetupListCxtRes(
+bool PDUSessionResourceFailedToSetupListCxtRes::encode(
     Ngap_PDUSessionResourceFailedToSetupListCxtRes_t*
         pduSessionResourceFailedToSetupListCxtRes) {
   for (std::vector<PDUSessionResourceFailedToSetupItemCxtRes>::iterator it =
-           std::begin(itemList);
-       it < std::end(itemList); ++it) {
+           std::begin(item_list_);
+       it < std::end(item_list_); ++it) {
     Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t* failedToResponse =
         (Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t*) calloc(
             1, sizeof(Ngap_PDUSessionResourceFailedToSetupItemCxtRes_t));
     if (!failedToResponse) return false;
 
-    if (!it->encode2PDUSessionResourceFailedToSetupItemCxtRes(failedToResponse))
-      return false;
+    if (!it->encode(failedToResponse)) return false;
     if (ASN_SEQUENCE_ADD(
             &pduSessionResourceFailedToSetupListCxtRes->list,
             failedToResponse) != 0)
@@ -73,18 +69,16 @@ bool PDUSessionResourceFailedToSetupListCxtRes::
 }
 
 //------------------------------------------------------------------------------
-bool PDUSessionResourceFailedToSetupListCxtRes::
-    decodefromPDUSessionResourceFailedToSetupListCxtRes(
+bool PDUSessionResourceFailedToSetupListCxtRes::decode(
     Ngap_PDUSessionResourceFailedToSetupListCxtRes_t*
         pduSessionResourceFailedToSetupListCxtRes) {
-  itemList.reserve(pduSessionResourceFailedToSetupListCxtRes->list.count);
+  item_list_.reserve(pduSessionResourceFailedToSetupListCxtRes->list.count);
   for (int i = 0; i < pduSessionResourceFailedToSetupListCxtRes->list.count;
        i++) {
     PDUSessionResourceFailedToSetupItemCxtRes item = {};
-    if (!item.decodefromPDUSessionResourceFailedToSetupItemCxtRes(
-            pduSessionResourceFailedToSetupListCxtRes->list.array[i]))
+    if (!item.decode(pduSessionResourceFailedToSetupListCxtRes->list.array[i]))
       return false;
-    itemList.push_back(item);
+    item_list_.push_back(item);
   }
 
   return true;

src/ngap/ngapIEs/PDUSessionResourceFailedToSetupListCxtRes.hpp

@@ -36,20 +36,16 @@ class PDUSessionResourceFailedToSetupListCxtRes {
   PDUSessionResourceFailedToSetupListCxtRes();
   virtual ~PDUSessionResourceFailedToSetupListCxtRes();
 
-  void setPDUSessionResourceFailedToSetupListCxtRes(
-      const std::vector<PDUSessionResourceFailedToSetupItemCxtRes>& list);
-  void getPDUSessionResourceFailedToSetupListCxtRes(
-      std::vector<PDUSessionResourceFailedToSetupItemCxtRes>& list);
+  void set(const std::vector<PDUSessionResourceFailedToSetupItemCxtRes>& list);
+  void get(std::vector<PDUSessionResourceFailedToSetupItemCxtRes>& list);
 
-  bool encode2PDUSessionResourceFailedToSetupListCxtRes(
-      Ngap_PDUSessionResourceFailedToSetupListCxtRes_t*
+  bool encode(Ngap_PDUSessionResourceFailedToSetupListCxtRes_t*
                   pduSessionResourceFailedToSetupListCxtRes);
-  bool decodefromPDUSessionResourceFailedToSetupListCxtRes(
-      Ngap_PDUSessionResourceFailedToSetupListCxtRes_t*
+  bool decode(Ngap_PDUSessionResourceFailedToSetupListCxtRes_t*
                   pduSessionResourceFailedToSetupListCxtRes);
 
  private:
-  std::vector<PDUSessionResourceFailedToSetupItemCxtRes> itemList;
+  std::vector<PDUSessionResourceFailedToSetupItemCxtRes> item_list_;
 };
 
 }  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceSetupItemCxtRes.cpp

@@ -30,45 +30,46 @@ PDUSessionResourceSetupItemCxtRes::PDUSessionResourceSetupItemCxtRes() {}
 PDUSessionResourceSetupItemCxtRes::~PDUSessionResourceSetupItemCxtRes() {}
 
 //------------------------------------------------------------------------------
-void PDUSessionResourceSetupItemCxtRes::setPDUSessionResourceSetupItemCxtRes(
-    const PDUSessionID& m_pDUSessionID,
-    const OCTET_STRING_t& m_pDUSessionResourceSetupResponseTransfer) {
-  pDUSessionID = m_pDUSessionID;
-  pDUSessionResourceSetupResponseTransfer =
-      m_pDUSessionResourceSetupResponseTransfer;
+void PDUSessionResourceSetupItemCxtRes::set(
+    const PDUSessionID& pdu_session_id,
+    const OCTET_STRING_t& pdu_session_resource_setup_response_transfer) {
+  pdu_session_id_ = pdu_session_id;
+  pdu_session_resource_setup_response_transfer_ =
+      pdu_session_resource_setup_response_transfer;
 }
 
 //------------------------------------------------------------------------------
-void PDUSessionResourceSetupItemCxtRes::getPDUSessionResourceSetupItemCxtRes(
-    PDUSessionID& m_pDUSessionID,
-    OCTET_STRING_t& m_pDUSessionResourceSetupResponseTransfer) {
-  m_pDUSessionID = pDUSessionID;
-  m_pDUSessionResourceSetupResponseTransfer =
-      pDUSessionResourceSetupResponseTransfer;
+void PDUSessionResourceSetupItemCxtRes::get(
+    PDUSessionID& pdu_session_id,
+    OCTET_STRING_t& pdu_session_resource_setup_response_transfer) const {
+  pdu_session_id = pdu_session_id_;
+  pdu_session_resource_setup_response_transfer =
+      pdu_session_resource_setup_response_transfer_;
 }
 
 //------------------------------------------------------------------------------
-bool PDUSessionResourceSetupItemCxtRes::
-    encode2PDUSessionResourceSetupItemCxtRes(
+bool PDUSessionResourceSetupItemCxtRes::encode(
     Ngap_PDUSessionResourceSetupItemCxtRes_t*
-            pduSessionResourceSetupItemCxtRes) {
-  if (!pDUSessionID.encode(pduSessionResourceSetupItemCxtRes->pDUSessionID))
+        pdu_session_resource_setup_item_cxt_res) {
+  if (!pdu_session_id_.encode(
+          pdu_session_resource_setup_item_cxt_res->pDUSessionID))
     return false;
-  pduSessionResourceSetupItemCxtRes->pDUSessionResourceSetupResponseTransfer =
-      pDUSessionResourceSetupResponseTransfer;
+  pdu_session_resource_setup_item_cxt_res
+      ->pDUSessionResourceSetupResponseTransfer =
+      pdu_session_resource_setup_response_transfer_;
 
   return true;
 }
 
 //------------------------------------------------------------------------------
-bool PDUSessionResourceSetupItemCxtRes::
-    decodefromPDUSessionResourceSetupItemCxtRes(
+bool PDUSessionResourceSetupItemCxtRes::decode(
     Ngap_PDUSessionResourceSetupItemCxtRes_t*
-            pduSessionResourceSetupItemCxtRes) {
-  if (!pDUSessionID.decode(pduSessionResourceSetupItemCxtRes->pDUSessionID))
+        pdu_session_resource_setup_item_cxt_res) {
+  if (!pdu_session_id_.decode(
+          pdu_session_resource_setup_item_cxt_res->pDUSessionID))
     return false;
-  pDUSessionResourceSetupResponseTransfer =
-      pduSessionResourceSetupItemCxtRes
+  pdu_session_resource_setup_response_transfer_ =
+      pdu_session_resource_setup_item_cxt_res
           ->pDUSessionResourceSetupResponseTransfer;
 
   return true;

src/ngap/ngapIEs/PDUSessionResourceSetupItemCxtRes.hpp

@@ -35,23 +35,21 @@ class PDUSessionResourceSetupItemCxtRes {
   PDUSessionResourceSetupItemCxtRes();
   virtual ~PDUSessionResourceSetupItemCxtRes();
 
-  void setPDUSessionResourceSetupItemCxtRes(
-      const PDUSessionID& m_pDUSessionID,
-      const OCTET_STRING_t& m_pDUSessionResourceSetupResponseTransfer);
-  void getPDUSessionResourceSetupItemCxtRes(
-      PDUSessionID& m_pDUSessionID,
-      OCTET_STRING_t& m_pDUSessionResourceSetupResponseTransfer);
-
-  bool encode2PDUSessionResourceSetupItemCxtRes(
-      Ngap_PDUSessionResourceSetupItemCxtRes_t*
-          pduSessionResourceSetupItemCxtRes);
-  bool decodefromPDUSessionResourceSetupItemCxtRes(
-      Ngap_PDUSessionResourceSetupItemCxtRes_t*
-          pduSessionResourceSetupItemCxtRes);
+  void set(
+      const PDUSessionID& pdu_session_id,
+      const OCTET_STRING_t& pdu_session_resource_setup_response_transfer);
+  void get(
+      PDUSessionID& pdu_session_id,
+      OCTET_STRING_t& pdu_session_resource_setup_response_transfer) const;
+
+  bool encode(Ngap_PDUSessionResourceSetupItemCxtRes_t*
+                  pdu_session_resource_setup_item_cxt_res);
+  bool decode(Ngap_PDUSessionResourceSetupItemCxtRes_t*
+                  pdu_session_resource_setup_item_cxt_res);
 
  private:
-  PDUSessionID pDUSessionID;                               // Mandatory
-  OCTET_STRING_t pDUSessionResourceSetupResponseTransfer;  // Mandatory
+  PDUSessionID pdu_session_id_;                                  // Mandatory
+  OCTET_STRING_t pdu_session_resource_setup_response_transfer_;  // Mandatory
 };
 
 }  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceSetupListCxtRes.cpp

@@ -30,30 +30,29 @@ PDUSessionResourceSetupListCxtRes::PDUSessionResourceSetupListCxtRes() {}
 PDUSessionResourceSetupListCxtRes::~PDUSessionResourceSetupListCxtRes() {}
 
 //------------------------------------------------------------------------------
-void PDUSessionResourceSetupListCxtRes::setPDUSessionResourceSetupListCxtRes(
+void PDUSessionResourceSetupListCxtRes::set(
     const std::vector<PDUSessionResourceSetupItemCxtRes>& list) {
-  itemList = list;
+  item_list_ = list;
 }
 
 //------------------------------------------------------------------------------
-void PDUSessionResourceSetupListCxtRes::getPDUSessionResourceSetupListCxtRes(
+void PDUSessionResourceSetupListCxtRes::get(
     std::vector<PDUSessionResourceSetupItemCxtRes>& list) {
-  list = itemList;
+  list = item_list_;
 }
 
 //------------------------------------------------------------------------------
-bool PDUSessionResourceSetupListCxtRes::
-    encode2PDUSessionResourceSetupListCxtRes(
+bool PDUSessionResourceSetupListCxtRes::encode(
     Ngap_PDUSessionResourceSetupListCxtRes_t*
         pduSessionResourceSetupListCxtRes) {
   for (std::vector<PDUSessionResourceSetupItemCxtRes>::iterator it =
-           std::begin(itemList);
-       it < std::end(itemList); ++it) {
+           std::begin(item_list_);
+       it < std::end(item_list_); ++it) {
     Ngap_PDUSessionResourceSetupItemCxtRes_t* response =
         (Ngap_PDUSessionResourceSetupItemCxtRes_t*) calloc(
             1, sizeof(Ngap_PDUSessionResourceSetupItemCxtRes_t));
     if (!response) return false;
-    if (!it->encode2PDUSessionResourceSetupItemCxtRes(response)) return false;
+    if (!it->encode(response)) return false;
     if (ASN_SEQUENCE_ADD(&pduSessionResourceSetupListCxtRes->list, response) !=
         0)
       return false;
@@ -63,17 +62,15 @@ bool PDUSessionResourceSetupListCxtRes::
 }
 
 //------------------------------------------------------------------------------
-bool PDUSessionResourceSetupListCxtRes::
-    decodefromPDUSessionResourceSetupListCxtRes(
+bool PDUSessionResourceSetupListCxtRes::decode(
     Ngap_PDUSessionResourceSetupListCxtRes_t*
         pduSessionResourceSetupListCxtRes) {
-  itemList.reserve(pduSessionResourceSetupListCxtRes->list.count);
+  item_list_.reserve(pduSessionResourceSetupListCxtRes->list.count);
   for (int i = 0; i < pduSessionResourceSetupListCxtRes->list.count; i++) {
     PDUSessionResourceSetupItemCxtRes item = {};
-    if (!item.decodefromPDUSessionResourceSetupItemCxtRes(
-            pduSessionResourceSetupListCxtRes->list.array[i]))
+    if (!item.decode(pduSessionResourceSetupListCxtRes->list.array[i]))
       return false;
-    itemList.push_back(item);
+    item_list_.push_back(item);
   }
 
   return true;

src/ngap/ngapIEs/PDUSessionResourceSetupListCxtRes.hpp

@@ -36,20 +36,16 @@ class PDUSessionResourceSetupListCxtRes {
   PDUSessionResourceSetupListCxtRes();
   virtual ~PDUSessionResourceSetupListCxtRes();
 
-  void setPDUSessionResourceSetupListCxtRes(
-      const std::vector<PDUSessionResourceSetupItemCxtRes>& list);
-  void getPDUSessionResourceSetupListCxtRes(
-      std::vector<PDUSessionResourceSetupItemCxtRes>& list);
+  void set(const std::vector<PDUSessionResourceSetupItemCxtRes>& list);
+  void get(std::vector<PDUSessionResourceSetupItemCxtRes>& list);
 
-  bool encode2PDUSessionResourceSetupListCxtRes(
-      Ngap_PDUSessionResourceSetupListCxtRes_t*
+  bool encode(Ngap_PDUSessionResourceSetupListCxtRes_t*
                   pduSessionResourceSetupListCxtRes);
-  bool decodefromPDUSessionResourceSetupListCxtRes(
-      Ngap_PDUSessionResourceSetupListCxtRes_t*
+  bool decode(Ngap_PDUSessionResourceSetupListCxtRes_t*
                   pduSessionResourceSetupListCxtRes);
 
  private:
-  std::vector<PDUSessionResourceSetupItemCxtRes> itemList;
+  std::vector<PDUSessionResourceSetupItemCxtRes> item_list_;
 };
 
 }  // namespace ngap

src/ngap/ngapMsgs/InitialContextSetupResponse.cpp

@@ -32,8 +32,8 @@ namespace ngap {
 InitialContextSetupResponseMsg::InitialContextSetupResponseMsg()
     : NgapUEMessage() {
   initialContextSetupResponseIEs              = nullptr;
-  pduSessionResourceSetupResponseList         = nullptr;
-  pduSessionResourceFailedToSetupResponseList = nullptr;
+  pduSessionResourceSetupResponseList         = std::nullopt;
+  pduSessionResourceFailedToSetupResponseList = std::nullopt;
 
   setMessageType(NgapMessageType::INITIAL_CONTEXT_SETUP_RESPONSE);
   initialize();
@@ -98,22 +98,21 @@ void InitialContextSetupResponseMsg::setRanUeNgapId(
 //------------------------------------------------------------------------------
 void InitialContextSetupResponseMsg::setPduSessionResourceSetupResponseList(
     const std::vector<PDUSessionResourceSetupResponseItem_t>& list) {
-  if (!pduSessionResourceSetupResponseList)
-    pduSessionResourceSetupResponseList =
-        new PDUSessionResourceSetupListCxtRes();
+  PDUSessionResourceSetupListCxtRes tmp = {};
 
-  std::vector<PDUSessionResourceSetupItemCxtRes> itemCxtResList;
+  std::vector<PDUSessionResourceSetupItemCxtRes> item_cxt_res_list;
   for (int i = 0; i < list.size(); i++) {
-    PDUSessionID m_pDUSessionID = {};
-    m_pDUSessionID.set(list[i].pduSessionId);
-    PDUSessionResourceSetupItemCxtRes itemCxtRes = {};
-    itemCxtRes.setPDUSessionResourceSetupItemCxtRes(
-        m_pDUSessionID, list[i].pduSessionResourceSetupResponseTransfer);
-    itemCxtResList.push_back(itemCxtRes);
+    PDUSessionID pdu_session_id = {};
+    pdu_session_id.set(list[i].pduSessionId);
+    PDUSessionResourceSetupItemCxtRes item_cxt_res = {};
+    item_cxt_res.set(
+        pdu_session_id, list[i].pduSessionResourceSetupResponseTransfer);
+    item_cxt_res_list.push_back(item_cxt_res);
   }
 
-  pduSessionResourceSetupResponseList->setPDUSessionResourceSetupListCxtRes(
-      itemCxtResList);
+  tmp.set(item_cxt_res_list);
+  pduSessionResourceSetupResponseList =
+      std::optional<PDUSessionResourceSetupListCxtRes>(tmp);
 
   Ngap_InitialContextSetupResponseIEs_t* ie =
       (Ngap_InitialContextSetupResponseIEs_t*) calloc(
@@ -123,8 +122,7 @@ void InitialContextSetupResponseMsg::setPduSessionResourceSetupResponseList(
   ie->value.present =
       Ngap_InitialContextSetupResponseIEs__value_PR_PDUSessionResourceSetupListCxtRes;
 
-  int ret = pduSessionResourceSetupResponseList
-                ->encode2PDUSessionResourceSetupListCxtRes(
+  int ret = pduSessionResourceSetupResponseList.value().encode(
       &ie->value.choice.PDUSessionResourceSetupListCxtRes);
   if (!ret) {
     Logger::ngap().error("Encode PDUSessionResourceSetupListCxtRes IE error");
@@ -140,24 +138,23 @@ void InitialContextSetupResponseMsg::setPduSessionResourceSetupResponseList(
 //------------------------------------------------------------------------------
 void InitialContextSetupResponseMsg::setPduSessionResourceFailedToSetupList(
     const std::vector<PDUSessionResourceFailedToSetupItem_t>& list) {
-  if (!pduSessionResourceFailedToSetupResponseList)
-    pduSessionResourceFailedToSetupResponseList =
-        new PDUSessionResourceFailedToSetupListCxtRes();
+  PDUSessionResourceFailedToSetupListCxtRes tmp = {};
 
-  std::vector<PDUSessionResourceFailedToSetupItemCxtRes> itemCxtResList;
-  itemCxtResList.reserve(list.size());
+  std::vector<PDUSessionResourceFailedToSetupItemCxtRes> item_cxt_res_list;
+  item_cxt_res_list.reserve(list.size());
 
   for (int i = 0; i < list.size(); i++) {
-    PDUSessionID pDUSessionID = {};
-    pDUSessionID.set(list[i].pduSessionId);
-    PDUSessionResourceFailedToSetupItemCxtRes itemCxtRes = {};
-    itemCxtRes.setPDUSessionResourceFailedToSetupItemCxtRes(
-        pDUSessionID, list[i].pduSessionResourceSetupUnsuccessfulTransfer);
-    itemCxtResList.push_back(itemCxtRes);
+    PDUSessionID pdu_session_id = {};
+    pdu_session_id.set(list[i].pduSessionId);
+    PDUSessionResourceFailedToSetupItemCxtRes item_cxt_res = {};
+    item_cxt_res.set(
+        pdu_session_id, list[i].pduSessionResourceSetupUnsuccessfulTransfer);
+    item_cxt_res_list.push_back(item_cxt_res);
   }
 
-  pduSessionResourceFailedToSetupResponseList
-      ->setPDUSessionResourceFailedToSetupListCxtRes(itemCxtResList);
+  tmp.set(item_cxt_res_list);
+  pduSessionResourceFailedToSetupResponseList =
+      std::optional<PDUSessionResourceFailedToSetupListCxtRes>(tmp);
 
   Ngap_InitialContextSetupResponseIEs_t* ie =
       (Ngap_InitialContextSetupResponseIEs_t*) calloc(
@@ -167,9 +164,7 @@ void InitialContextSetupResponseMsg::setPduSessionResourceFailedToSetupList(
   ie->value.present =
       Ngap_InitialContextSetupResponseIEs__value_PR_PDUSessionResourceFailedToSetupListCxtRes;
 
-  int ret =
-      pduSessionResourceFailedToSetupResponseList
-          ->encode2PDUSessionResourceFailedToSetupListCxtRes(
+  int ret = pduSessionResourceFailedToSetupResponseList.value().encode(
       &ie->value.choice.PDUSessionResourceFailedToSetupListCxtRes);
   if (!ret) {
     Logger::ngap().error(
@@ -253,18 +248,17 @@ bool InitialContextSetupResponseMsg::decodeFromPdu(
             initialContextSetupResponseIEs->protocolIEs.list.array[i]
                     ->value.present ==
                 Ngap_InitialContextSetupResponseIEs__value_PR_PDUSessionResourceSetupListCxtRes) {
-          pduSessionResourceSetupResponseList =
-              new PDUSessionResourceSetupListCxtRes();
-          if (!pduSessionResourceSetupResponseList
-                   ->decodefromPDUSessionResourceSetupListCxtRes(
-                       &initialContextSetupResponseIEs->protocolIEs.list
-                            .array[i]
+          PDUSessionResourceSetupListCxtRes tmp = {};
+          if (!tmp.decode(
+                  &initialContextSetupResponseIEs->protocolIEs.list.array[i]
                        ->value.choice.PDUSessionResourceSetupListCxtRes)) {
             Logger::ngap().error(
                 "Decoded NGAP PDUSessionResourceSetupListCxtRes IE error");
 
             return false;
           }
+          pduSessionResourceSetupResponseList =
+              std::optional<PDUSessionResourceSetupListCxtRes>(tmp);
         } else {
           Logger::ngap().error(
               "Decoded NGAP PDUSessionResourceSetupListCxtRes IE error");
@@ -278,12 +272,9 @@ bool InitialContextSetupResponseMsg::decodeFromPdu(
             initialContextSetupResponseIEs->protocolIEs.list.array[i]
                     ->value.present ==
                 Ngap_InitialContextSetupResponseIEs__value_PR_PDUSessionResourceFailedToSetupListCxtRes) {
-          pduSessionResourceFailedToSetupResponseList =
-              new PDUSessionResourceFailedToSetupListCxtRes();
-          if (!pduSessionResourceFailedToSetupResponseList
-                   ->decodefromPDUSessionResourceFailedToSetupListCxtRes(
-                       &initialContextSetupResponseIEs->protocolIEs.list
-                            .array[i]
+          PDUSessionResourceFailedToSetupListCxtRes tmp = {};
+          if (!tmp.decode(
+                  &initialContextSetupResponseIEs->protocolIEs.list.array[i]
                        ->value.choice
                        .PDUSessionResourceFailedToSetupListCxtRes)) {
             Logger::ngap().error(
@@ -292,6 +283,8 @@ bool InitialContextSetupResponseMsg::decodeFromPdu(
 
             return false;
           }
+          pduSessionResourceFailedToSetupResponseList =
+              std::optional<PDUSessionResourceFailedToSetupListCxtRes>(tmp);
         } else {
           Logger::ngap().error(
               "Decoded NGAP PDUSessionResourceFailedToSetupListCxtRes IE "
@@ -315,21 +308,19 @@ bool InitialContextSetupResponseMsg::decodeFromPdu(
 //------------------------------------------------------------------------------
 bool InitialContextSetupResponseMsg::getPduSessionResourceSetupResponseList(
     std::vector<PDUSessionResourceSetupResponseItem_t>& list) {
-  if (!pduSessionResourceSetupResponseList) return false;
+  if (!pduSessionResourceSetupResponseList.has_value()) return false;
 
-  std::vector<PDUSessionResourceSetupItemCxtRes> itemCxtResList;
-  pduSessionResourceSetupResponseList->getPDUSessionResourceSetupListCxtRes(
-      itemCxtResList);
+  std::vector<PDUSessionResourceSetupItemCxtRes> item_cxt_res_list;
+  pduSessionResourceSetupResponseList.value().get(item_cxt_res_list);
 
   for (std::vector<PDUSessionResourceSetupItemCxtRes>::iterator it =
-           std::begin(itemCxtResList);
-       it < std::end(itemCxtResList); ++it) {
+           std::begin(item_cxt_res_list);
+       it < std::end(item_cxt_res_list); ++it) {
     PDUSessionResourceSetupResponseItem_t response = {};
 
-    PDUSessionID m_pDUSessionID = {};
-    it->getPDUSessionResourceSetupItemCxtRes(
-        m_pDUSessionID, response.pduSessionResourceSetupResponseTransfer);
-    m_pDUSessionID.get(response.pduSessionId);
+    PDUSessionID pdu_session_id = {};
+    it->get(pdu_session_id, response.pduSessionResourceSetupResponseTransfer);
+    pdu_session_id.get(response.pduSessionId);
     list.push_back(response);
   }
 
@@ -339,22 +330,21 @@ bool InitialContextSetupResponseMsg::getPduSessionResourceSetupResponseList(
 //------------------------------------------------------------------------------
 bool InitialContextSetupResponseMsg::getPduSessionResourceFailedToSetupList(
     std::vector<PDUSessionResourceFailedToSetupItem_t>& list) {
-  if (!pduSessionResourceFailedToSetupResponseList) return false;
+  if (!pduSessionResourceFailedToSetupResponseList.has_value()) return false;
 
-  std::vector<PDUSessionResourceFailedToSetupItemCxtRes> itemCxtResList;
-  pduSessionResourceFailedToSetupResponseList
-      ->getPDUSessionResourceFailedToSetupListCxtRes(itemCxtResList);
+  std::vector<PDUSessionResourceFailedToSetupItemCxtRes> item_cxt_res_list;
+  pduSessionResourceFailedToSetupResponseList.value().get(item_cxt_res_list);
 
   for (std::vector<PDUSessionResourceFailedToSetupItemCxtRes>::iterator it =
-           std::begin(itemCxtResList);
-       it < std::end(itemCxtResList); ++it) {
+           std::begin(item_cxt_res_list);
+       it < std::end(item_cxt_res_list); ++it) {
     PDUSessionResourceFailedToSetupItem_t failedToResponse = {};
 
-    PDUSessionID pDUSessionID = {};
-    it->getPDUSessionResourceFailedToSetupItemCxtRes(
-        pDUSessionID,
+    PDUSessionID pdu_session_id = {};
+    it->get(
+        pdu_session_id,
         failedToResponse.pduSessionResourceSetupUnsuccessfulTransfer);
-    pDUSessionID.get(failedToResponse.pduSessionId);
+    pdu_session_id.get(failedToResponse.pduSessionId);
 
     list.push_back(failedToResponse);
   }

src/ngap/ngapMsgs/InitialContextSetupResponse.hpp

@@ -26,6 +26,8 @@
 #include "PDUSessionResourceSetupListCxtRes.hpp"
 #include "NgapUEMessage.hpp"
 
+#include <optional>
+
 extern "C" {
 #include "Ngap_InitialContextSetupResponse.h"
 }
@@ -57,9 +59,9 @@ class InitialContextSetupResponseMsg : public NgapUEMessage {
   Ngap_InitialContextSetupResponse_t* initialContextSetupResponseIEs;
   // AMF_UE_NGAP_ID //Mandatory
   // RAN_UE_NGAP_ID //Mandatory
-  PDUSessionResourceSetupListCxtRes*
+  std::optional<PDUSessionResourceSetupListCxtRes>
       pduSessionResourceSetupResponseList;  // Optional
-  PDUSessionResourceFailedToSetupListCxtRes*
+  std::optional<PDUSessionResourceFailedToSetupListCxtRes>
       pduSessionResourceFailedToSetupResponseList;  // Optional
   // TODO: Criticality Diagnostics (Optional)
 };