Code refactor for UERadioCapabilityInfoIndication

src/ngap/ngapIEs/UERadioCapabilityForPaging.cpp

@@ -25,29 +25,29 @@ namespace ngap {
 
 //------------------------------------------------------------------------------
 UERadioCapabilityForPaging::UERadioCapabilityForPaging() {
-  ueRadioCapabilityForPagingOfNR    = NULL;
-  ueRadioCapabilityForPagingOfEUTRA = NULL;
+  ueRadioCapabilityForPagingOfNR    = std::nullopt;
+  ueRadioCapabilityForPagingOfEUTRA = std::nullopt;
 }
 
 //------------------------------------------------------------------------------
 UERadioCapabilityForPaging::~UERadioCapabilityForPaging() {}
 
 //------------------------------------------------------------------------------
-bool UERadioCapabilityForPaging::encode2UERadioCapabilityForPaging(
+bool UERadioCapabilityForPaging::encode(
     Ngap_UERadioCapabilityForPaging_t* ueRadioCapabilityForPaging) {
-  if (ueRadioCapabilityForPagingOfNR) {
+  if (ueRadioCapabilityForPagingOfNR.has_value()) {
     ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR =
         (Ngap_UERadioCapabilityForPagingOfNR_t*) calloc(
             1, sizeof(Ngap_UERadioCapabilityForPagingOfNR_t));
-    if (!ueRadioCapabilityForPagingOfNR->encode(
+    if (!ueRadioCapabilityForPagingOfNR.value().encode(
             ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR))
       return false;
   }
-  if (ueRadioCapabilityForPagingOfEUTRA) {
+  if (ueRadioCapabilityForPagingOfEUTRA.has_value()) {
     ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA =
         (Ngap_UERadioCapabilityForPagingOfEUTRA_t*) calloc(
             1, sizeof(Ngap_UERadioCapabilityForPagingOfEUTRA_t));
-    if (!ueRadioCapabilityForPagingOfEUTRA->encode(
+    if (!ueRadioCapabilityForPagingOfEUTRA.value().encode(
             ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA))
       return false;
   }
@@ -56,39 +56,59 @@ bool UERadioCapabilityForPaging::encode2UERadioCapabilityForPaging(
 }
 
 //------------------------------------------------------------------------------
-bool UERadioCapabilityForPaging::decodefromUERadioCapabilityForPaging(
+bool UERadioCapabilityForPaging::decode(
     Ngap_UERadioCapabilityForPaging_t* ueRadioCapabilityForPaging) {
   if (ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR) {
-    ueRadioCapabilityForPagingOfNR = new UERadioCapabilityForPagingOfNR();
-    if (!ueRadioCapabilityForPagingOfNR->decode(
-            ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR))
+    UERadioCapabilityForPagingOfNR tmp = {};
+    if (!tmp.decode(ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR))
       return false;
+    ueRadioCapabilityForPagingOfNR =
+        std::optional<UERadioCapabilityForPagingOfNR>(tmp);
   }
   if (ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA) {
-    ueRadioCapabilityForPagingOfEUTRA = new UERadioCapabilityForPagingOfEUTRA();
-    if (!ueRadioCapabilityForPagingOfEUTRA->decode(
+    UERadioCapabilityForPagingOfEUTRA tmp = {};
+    if (!tmp.decode(
             ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA))
       return false;
+    ueRadioCapabilityForPagingOfEUTRA =
+        std::optional<UERadioCapabilityForPagingOfEUTRA>(tmp);
   }
 
   return true;
 }
 
 //------------------------------------------------------------------------------
-bool UERadioCapabilityForPaging::getUERadioCapabilityForPaging(
-    UERadioCapabilityForPagingOfNR*& m_ueRadioCapabilityForPagingOfNR,
-    UERadioCapabilityForPagingOfEUTRA*& m_ueRadioCapabilityForPagingOfEUTRA) {
-  m_ueRadioCapabilityForPagingOfNR    = ueRadioCapabilityForPagingOfNR;
-  m_ueRadioCapabilityForPagingOfEUTRA = ueRadioCapabilityForPagingOfEUTRA;
+bool UERadioCapabilityForPaging::setUERadioCapabilityForPagingOfNR(
+    const OCTET_STRING_t& capability) {
+  UERadioCapabilityForPagingOfNR tmp = {};
+  tmp.set(capability);
+  ueRadioCapabilityForPagingOfNR =
+      std::optional<UERadioCapabilityForPagingOfNR>(tmp);
+  return true;
+}
+
+//------------------------------------------------------------------------------
+bool UERadioCapabilityForPaging::getUERadioCapabilityForPagingOfNR(
+    OCTET_STRING_t& capability) {
+  if (!ueRadioCapabilityForPagingOfNR.has_value()) return false;
+  return ueRadioCapabilityForPagingOfNR.value().get(capability);
+}
 
+//------------------------------------------------------------------------------
+bool UERadioCapabilityForPaging::setUERadioCapabilityForPagingOfEUTRA(
+    const OCTET_STRING_t& capability) {
+  UERadioCapabilityForPagingOfEUTRA tmp = {};
+  tmp.set(capability);
+  ueRadioCapabilityForPagingOfEUTRA =
+      std::optional<UERadioCapabilityForPagingOfEUTRA>(tmp);
   return true;
 }
 
 //------------------------------------------------------------------------------
-void UERadioCapabilityForPaging::setUERadioCapabilityForPaging(
-    UERadioCapabilityForPagingOfNR* m_ueRadioCapabilityForPagingOfNR,
-    UERadioCapabilityForPagingOfEUTRA* m_ueRadioCapabilityForPagingOfEUTRA) {
-  ueRadioCapabilityForPagingOfNR    = m_ueRadioCapabilityForPagingOfNR;
-  ueRadioCapabilityForPagingOfEUTRA = m_ueRadioCapabilityForPagingOfEUTRA;
+bool UERadioCapabilityForPaging::getUERadioCapabilityForPagingOfEUTRA(
+    OCTET_STRING_t& capability) {
+  if (!ueRadioCapabilityForPagingOfEUTRA.has_value()) return false;
+  return ueRadioCapabilityForPagingOfEUTRA.value().get(capability);
 }
+
 }  // namespace ngap

src/ngap/ngapIEs/UERadioCapabilityForPaging.hpp

@@ -19,12 +19,14 @@
  *      contact@openairinterface.org
  */
 
-#ifndef _UERADIOCAPABILITYFORPAGING_H_
-#define _UERADIOCAPABILITYFORPAGING_H_
+#ifndef _UE_RADIO_CAPABILITY_FOR_PAGING_H_
+#define _UE_RADIO_CAPABILITY_FOR_PAGING_H_
 
 #include "UERadioCapabilityForPagingOfEUTRA.hpp"
 #include "UERadioCapabilityForPagingOfNR.hpp"
 
+#include <optional>
+
 extern "C" {
 #include "Ngap_UERadioCapabilityForPaging.h"
 }
@@ -36,20 +38,19 @@ class UERadioCapabilityForPaging {
   UERadioCapabilityForPaging();
   virtual ~UERadioCapabilityForPaging();
 
-  bool encode2UERadioCapabilityForPaging(
-      Ngap_UERadioCapabilityForPaging_t* ueRadioCapabilityForPaging);
-  bool decodefromUERadioCapabilityForPaging(
-      Ngap_UERadioCapabilityForPaging_t* ueRadioCapabilityForPaging);
-  bool getUERadioCapabilityForPaging(
-      UERadioCapabilityForPagingOfNR*& m_ueRadioCapabilityForPagingOfNR,
-      UERadioCapabilityForPagingOfEUTRA*& m_ueRadioCapabilityForPagingOfEUTRA);
-  void setUERadioCapabilityForPaging(
-      UERadioCapabilityForPagingOfNR* m_ueRadioCapabilityForPagingOfNR,
-      UERadioCapabilityForPagingOfEUTRA* m_ueRadioCapabilityForPagingOfEUTRA);
+  bool encode(Ngap_UERadioCapabilityForPaging_t* ueRadioCapabilityForPaging);
+  bool decode(Ngap_UERadioCapabilityForPaging_t* ueRadioCapabilityForPaging);
+
+  bool setUERadioCapabilityForPagingOfNR(const OCTET_STRING_t& capability);
+  bool getUERadioCapabilityForPagingOfNR(OCTET_STRING_t& capability);
+
+  bool setUERadioCapabilityForPagingOfEUTRA(const OCTET_STRING_t& capability);
+  bool getUERadioCapabilityForPagingOfEUTRA(OCTET_STRING_t& capability);
 
  private:
-  UERadioCapabilityForPagingOfNR* ueRadioCapabilityForPagingOfNR;  // Optional
-  UERadioCapabilityForPagingOfEUTRA*
+  std::optional<UERadioCapabilityForPagingOfNR>
+      ueRadioCapabilityForPagingOfNR;  // Optional
+  std::optional<UERadioCapabilityForPagingOfEUTRA>
       ueRadioCapabilityForPagingOfEUTRA;  // Optional
 };
 

src/ngap/ngapMsgs/UERadioCapabilityInfoIndication.cpp

@@ -34,7 +34,7 @@ namespace ngap {
 UeRadioCapabilityInfoIndicationMsg::UeRadioCapabilityInfoIndicationMsg()
     : NgapUEMessage() {
   ueRadioCapabilityInfoIndicationIEs = nullptr;
-  ueRadioCapabilityForPaging         = nullptr;
+  ueRadioCapabilityForPaging         = std::nullopt;
   setMessageType(NgapMessageType::UE_RADIO_CAPABILITY_INFO_INDICATION);
   initialize();
 }
@@ -133,23 +133,20 @@ void UeRadioCapabilityInfoIndicationMsg::getUERadioCapability(
 void UeRadioCapabilityInfoIndicationMsg::setUERadioCapabilityForPaging(
     const OCTET_STRING_t& ue_radio_capability_for_paging_of_nr,
     const OCTET_STRING_t& ue_radio_capability_for_paging_of_eutra) {
-  if (!ueRadioCapabilityForPaging)
-    ueRadioCapabilityForPaging = new UERadioCapabilityForPaging();
-  UERadioCapabilityForPagingOfNR* m_ueRadioCapabilityForPagingOfNR = nullptr;
-  UERadioCapabilityForPagingOfEUTRA* m_ueRadioCapabilityForPagingOfEUTRA =
-      nullptr;
+  if (!(conv::check_octet_string(ue_radio_capability_for_paging_of_nr) or
+        conv::check_octet_string(ue_radio_capability_for_paging_of_eutra))) {
+    return;
+  }
+  UERadioCapabilityForPaging tmp = {};
+
   if (conv::check_octet_string(ue_radio_capability_for_paging_of_nr)) {
-    m_ueRadioCapabilityForPagingOfNR = new UERadioCapabilityForPagingOfNR();
-    m_ueRadioCapabilityForPagingOfNR->set(ue_radio_capability_for_paging_of_nr);
+    tmp.setUERadioCapabilityForPagingOfNR(ue_radio_capability_for_paging_of_nr);
   }
   if (conv::check_octet_string(ue_radio_capability_for_paging_of_eutra)) {
-    m_ueRadioCapabilityForPagingOfEUTRA =
-        new UERadioCapabilityForPagingOfEUTRA();
-    m_ueRadioCapabilityForPagingOfEUTRA->set(
+    tmp.setUERadioCapabilityForPagingOfEUTRA(
         ue_radio_capability_for_paging_of_eutra);
   }
-  ueRadioCapabilityForPaging->setUERadioCapabilityForPaging(
-      m_ueRadioCapabilityForPagingOfNR, m_ueRadioCapabilityForPagingOfEUTRA);
+  ueRadioCapabilityForPaging = std::optional<UERadioCapabilityForPaging>(tmp);
 
   Ngap_UERadioCapabilityInfoIndicationIEs_t* ie =
       (Ngap_UERadioCapabilityInfoIndicationIEs_t*) calloc(
@@ -159,7 +156,7 @@ void UeRadioCapabilityInfoIndicationMsg::setUERadioCapabilityForPaging(
   ie->value.present =
       Ngap_UERadioCapabilityInfoIndicationIEs__value_PR_UERadioCapabilityForPaging;
 
-  int ret = ueRadioCapabilityForPaging->encode2UERadioCapabilityForPaging(
+  int ret = ueRadioCapabilityForPaging.value().encode(
       &ie->value.choice.UERadioCapabilityForPaging);
   if (!ret) {
     Logger::ngap().error("Encode NGAP UERadioCapabilityForPaging IE error");
@@ -177,25 +174,11 @@ void UeRadioCapabilityInfoIndicationMsg::setUERadioCapabilityForPaging(
 bool UeRadioCapabilityInfoIndicationMsg::getUERadioCapabilityForPaging(
     OCTET_STRING_t& ue_radio_capability_for_paging_of_nr,
     OCTET_STRING_t& ue_radio_capability_for_paging_of_eutra) {
-  if (!ueRadioCapabilityForPaging) return false;
-  UERadioCapabilityForPagingOfNR* m_ueRadioCapabilityForPagingOfNR;
-  UERadioCapabilityForPagingOfEUTRA* m_ueRadioCapabilityForPagingOfEUTRA;
-  if (!ueRadioCapabilityForPaging->getUERadioCapabilityForPaging(
-          m_ueRadioCapabilityForPagingOfNR,
-          m_ueRadioCapabilityForPagingOfEUTRA))
-    return false;
-
-  if (m_ueRadioCapabilityForPagingOfNR) {
-    if (!m_ueRadioCapabilityForPagingOfNR->get(
-            ue_radio_capability_for_paging_of_nr))
-      return false;
-  }
-  if (m_ueRadioCapabilityForPagingOfEUTRA) {
-    if (!m_ueRadioCapabilityForPagingOfEUTRA->get(
-            ue_radio_capability_for_paging_of_eutra))
-      return false;
-  }
-
+  if (!ueRadioCapabilityForPaging.has_value()) return false;
+  ueRadioCapabilityForPaging.value().getUERadioCapabilityForPagingOfNR(
+      ue_radio_capability_for_paging_of_nr);
+  ueRadioCapabilityForPaging.value().getUERadioCapabilityForPagingOfEUTRA(
+      ue_radio_capability_for_paging_of_eutra);
   return true;
 }
 
@@ -281,15 +264,16 @@ bool UeRadioCapabilityInfoIndicationMsg::decodeFromPdu(
             ueRadioCapabilityInfoIndicationIEs->protocolIEs.list.array[i]
                     ->value.present ==
                 Ngap_UERadioCapabilityInfoIndicationIEs__value_PR_UERadioCapabilityForPaging) {
-          ueRadioCapabilityForPaging = new UERadioCapabilityForPaging();
-          if (!ueRadioCapabilityForPaging->decodefromUERadioCapabilityForPaging(
-                  &ueRadioCapabilityInfoIndicationIEs->protocolIEs.list
-                       .array[i]
-                       ->value.choice.UERadioCapabilityForPaging)) {
+          UERadioCapabilityForPaging tmp = {};
+          if (!tmp.decode(&ueRadioCapabilityInfoIndicationIEs->protocolIEs.list
+                               .array[i]
+                               ->value.choice.UERadioCapabilityForPaging)) {
             Logger::ngap().error(
                 "Decoded NGAP UERadioCapabilityForPaging IE error");
             return false;
           }
+          ueRadioCapabilityForPaging =
+              std::optional<UERadioCapabilityForPaging>(tmp);
         } else {
           Logger::ngap().error(
               "Decoded NGAP UERadioCapabilityForPaging IE error");

src/ngap/ngapMsgs/UERadioCapabilityInfoIndication.hpp

@@ -43,9 +43,6 @@ class UeRadioCapabilityInfoIndicationMsg : public NgapUEMessage {
   void setRanUeNgapId(const uint32_t& id) override;
   bool decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) override;
 
-  void setUERadioCapability(uint8_t* buf, size_t size);
-  bool getUERadioCapability(uint8_t*& buf, size_t& size);
-
   void setUERadioCapability(const OCTET_STRING_t& capability);
   void getUERadioCapability(OCTET_STRING_t& capability);
 
@@ -60,8 +57,9 @@ class UeRadioCapabilityInfoIndicationMsg : public NgapUEMessage {
   Ngap_UERadioCapabilityInfoIndication_t* ueRadioCapabilityInfoIndicationIEs;
   // AMF_UE_NGAP_ID //Mandatory
   // RAN_UE_NGAP_ID //Mandatory
-  UERadioCapability ueRadioCapability;                     // Mandatory
-  UERadioCapabilityForPaging* ueRadioCapabilityForPaging;  // Optional
+  UERadioCapability ueRadioCapability;  // Mandatory
+  std::optional<UERadioCapabilityForPaging>
+      ueRadioCapabilityForPaging;  // Optional
 };
 
 }  // namespace ngap