Apply google style format for new code

src/itti/msgs/itti_msg_n2.hpp

@@ -98,11 +98,17 @@ class itti_dl_nas_transport : public itti_msg_n2 {
   bstring nas;
 };
 
-class itti_initial_context_setup_request : public itti_msg_n2
-{
-public:
-  itti_initial_context_setup_request(const task_id_t origin, const task_id_t destination) : itti_msg_n2(INITIAL_CONTEXT_SETUP_REQUEST, origin, destination) {}
-  itti_initial_context_setup_request(const itti_initial_context_setup_request &i) : itti_msg_n2(i) {
+class itti_initial_context_setup_request : public itti_msg_n2 {
+ public:
+  itti_initial_context_setup_request(const task_id_t origin,
+                                     const task_id_t destination)
+      :
+      itti_msg_n2(INITIAL_CONTEXT_SETUP_REQUEST, origin, destination) {
+  }
+  itti_initial_context_setup_request(
+      const itti_initial_context_setup_request &i)
+      :
+      itti_msg_n2(i) {
     is_pdu_exist = false;
     isn2sm_avaliable = false;
 
@@ -156,7 +162,6 @@ class itti_pdu_session_resource_release_command : public itti_msg_n2 {
   uint8_t pdu_session_id;
 };
 
-
 class itti_ue_context_release_request : public itti_msg_n2 {
  public:
   itti_ue_context_release_request(const task_id_t origin,
@@ -171,55 +176,89 @@ class itti_ue_context_release_request : public itti_msg_n2 {
   UEContextReleaseRequestMsg *ueCtxRel;
 };
 
-class itti_ue_context_release_command : public itti_msg_n2
-{
-public:
-  itti_ue_context_release_command(const task_id_t origin, const task_id_t destination) : itti_msg_n2(UE_CONTEXT_RELEASE_COMMAND, origin, destination) {}
-  itti_ue_context_release_command(const itti_dl_nas_transport &i) : itti_msg_n2(i) {}
+class itti_ue_context_release_command : public itti_msg_n2 {
+ public:
+  itti_ue_context_release_command(const task_id_t origin,
+                                  const task_id_t destination)
+      :
+      itti_msg_n2(UE_CONTEXT_RELEASE_COMMAND, origin, destination) {
+  }
+  itti_ue_context_release_command(const itti_dl_nas_transport &i)
+      :
+      itti_msg_n2(i) {
+  }
 
-public:
+ public:
   uint32_t ran_ue_ngap_id;
   long amf_ue_ngap_id;
   Cause cause;
 };
 
-class itti_ue_radio_capability_indication : public itti_msg_n2
-{
-public:
-  itti_ue_radio_capability_indication(const task_id_t origin, const task_id_t destination) : itti_msg_n2(UE_RADIO_CAP_IND, origin, destination) {}
-  itti_ue_radio_capability_indication(const itti_ue_radio_capability_indication &i) : itti_msg_n2(i) {}
+class itti_ue_radio_capability_indication : public itti_msg_n2 {
+ public:
+  itti_ue_radio_capability_indication(const task_id_t origin,
+                                      const task_id_t destination)
+      :
+      itti_msg_n2(UE_RADIO_CAP_IND, origin, destination) {
+  }
+  itti_ue_radio_capability_indication(
+      const itti_ue_radio_capability_indication &i)
+      :
+      itti_msg_n2(i) {
+  }
   UeRadioCapabilityInfoIndicationMsg *ueRadioCap;
 };
 
-class itti_handover_required : public itti_msg_n2
-{
-public:
-  itti_handover_required(const task_id_t origin, const task_id_t destination) : itti_msg_n2(HANDOVER_REQUIRED, origin, destination) {}
-  itti_handover_required(const itti_handover_required &i) : itti_msg_n2(i) {}
+class itti_handover_required : public itti_msg_n2 {
+ public:
+  itti_handover_required(const task_id_t origin, const task_id_t destination)
+      :
+      itti_msg_n2(HANDOVER_REQUIRED, origin, destination) {
+  }
+  itti_handover_required(const itti_handover_required &i)
+      :
+      itti_msg_n2(i) {
+  }
   HandoverRequiredMsg *handvoerRequ;
 };
 
-class itti_handover_request_Ack : public itti_msg_n2
-{
-public:
-  itti_handover_request_Ack(const task_id_t origin, const task_id_t destination) : itti_msg_n2(HANDOVER_REQUEST_ACK, origin, destination) {}
-  itti_handover_request_Ack(const itti_handover_request_Ack &i) : itti_msg_n2(i) {}
+class itti_handover_request_Ack : public itti_msg_n2 {
+ public:
+  itti_handover_request_Ack(const task_id_t origin, const task_id_t destination)
+      :
+      itti_msg_n2(HANDOVER_REQUEST_ACK, origin, destination) {
+  }
+  itti_handover_request_Ack(const itti_handover_request_Ack &i)
+      :
+      itti_msg_n2(i) {
+  }
   HandoverRequestAck *handoverrequestAck;
 };
 
-class itti_handover_notify : public itti_msg_n2
-{
-public:
-  itti_handover_notify(const task_id_t origin, const task_id_t destination) : itti_msg_n2(HANDOVER_NOTIFY, origin, destination) {}
-  itti_handover_notify(const itti_handover_notify &i) : itti_msg_n2(i) {}
+class itti_handover_notify : public itti_msg_n2 {
+ public:
+  itti_handover_notify(const task_id_t origin, const task_id_t destination)
+      :
+      itti_msg_n2(HANDOVER_NOTIFY, origin, destination) {
+  }
+  itti_handover_notify(const itti_handover_notify &i)
+      :
+      itti_msg_n2(i) {
+  }
   HandoverNotifyMsg *handovernotify;
 };
 
-class itti_uplinkranstatsutransfer : public itti_msg_n2
-{
-public:
-  itti_uplinkranstatsutransfer(const task_id_t origin, const task_id_t destination) : itti_msg_n2(UPLINKRANSTATUSTRANSFER, origin, destination) {}
-  itti_uplinkranstatsutransfer(const itti_uplinkranstatsutransfer &i) : itti_msg_n2(i) {}
+class itti_uplinkranstatsutransfer : public itti_msg_n2 {
+ public:
+  itti_uplinkranstatsutransfer(const task_id_t origin,
+                               const task_id_t destination)
+      :
+      itti_msg_n2(UPLINKRANSTATUSTRANSFER, origin, destination) {
+  }
+  itti_uplinkranstatsutransfer(const itti_uplinkranstatsutransfer &i)
+      :
+      itti_msg_n2(i) {
+  }
   UplinkRANStatusTransfer *uplinkrantransfer;
 };
 

src/ngap/ngapIEs/COUNTValueForPDCP_SN18.cpp

@@ -30,38 +30,35 @@
 #include <vector>
 
 using namespace std;
-namespace ngap
-{
-    COUNTValueForPDCP_SN18::COUNTValueForPDCP_SN18()
-    {
+namespace ngap {
+COUNTValueForPDCP_SN18::COUNTValueForPDCP_SN18() {
   pdcp = 0;
   hfn_pdcp = 0;
-    }
-    COUNTValueForPDCP_SN18::~COUNTValueForPDCP_SN18() {}
-    void COUNTValueForPDCP_SN18::setvalue(long pDCP, long hfn_PDCP)
-    {
+}
+COUNTValueForPDCP_SN18::~COUNTValueForPDCP_SN18() {
+}
+void COUNTValueForPDCP_SN18::setvalue(long pDCP, long hfn_PDCP) {
   pdcp = pDCP;
   hfn_pdcp = hfn_PDCP;
-    }
-    void COUNTValueForPDCP_SN18::getvalue(long &pDCP, long &hFN_PDCP)
-    {
+}
+void COUNTValueForPDCP_SN18::getvalue(long &pDCP, long &hFN_PDCP) {
   pDCP = pdcp;
   hFN_PDCP = hfn_pdcp;
-    }
-    bool COUNTValueForPDCP_SN18::encodedCOUNTValueForPDCP_SN18(Ngap_COUNTValueForPDCP_SN18_t &countvalue)
-    {
+}
+bool COUNTValueForPDCP_SN18::encodedCOUNTValueForPDCP_SN18(
+    Ngap_COUNTValueForPDCP_SN18_t &countvalue) {
   countvalue.pDCP_SN18 = pdcp;
   countvalue.hFN_PDCP_SN18 = hfn_pdcp;
   cout << "the encode pdcp_sn18 is" << countvalue.pDCP_SN18 << endl;
   cout << "the encode hfn_pdcp_sn18 is" << countvalue.hFN_PDCP_SN18 << endl;
   return true;
-    }
-    bool COUNTValueForPDCP_SN18::decodedCOUNTValueForPDCP_SN18(Ngap_COUNTValueForPDCP_SN18_t &countValue)
-    {
+}
+bool COUNTValueForPDCP_SN18::decodedCOUNTValueForPDCP_SN18(
+    Ngap_COUNTValueForPDCP_SN18_t &countValue) {
   pdcp = countValue.pDCP_SN18;
   hfn_pdcp = countValue.hFN_PDCP_SN18;
   cout << "the decode pdcp_sn18 is" << countValue.pDCP_SN18 << endl;
   cout << "the decode hfn_pdcp_sn18 is" << countValue.hFN_PDCP_SN18 << endl;
   return true;
-    }
+}
 }  // namespace ngap

src/ngap/ngapIEs/COUNTValueForPDCP_SN18.hpp

@@ -27,14 +27,11 @@
  */
 #ifndef _COUNTVALUEFORPDCP_SN18_H_
 #define _COUNTVALUEFORPDCP_SN18_H_
-extern "C"
-{
+extern "C" {
 #include "Ngap_COUNTValueForPDCP-SN18.h"
 }
-namespace ngap
-{
-    class COUNTValueForPDCP_SN18
-    {
+namespace ngap {
+class COUNTValueForPDCP_SN18 {
  private:
   /* data */
   long pdcp;
@@ -47,7 +44,7 @@ namespace ngap
   void setvalue(long pDCP, long hfn_PDCP);
   bool encodedCOUNTValueForPDCP_SN18(Ngap_COUNTValueForPDCP_SN18_t &countvalue);
   bool decodedCOUNTValueForPDCP_SN18(Ngap_COUNTValueForPDCP_SN18_t &countValue);
-    };
+};
 
 }  // namespace ngap
 #endif

src/ngap/ngapIEs/PDUSessionResourceAdmittedItem.cpp

@@ -30,43 +30,48 @@
 #include <iostream>
 using namespace std;
 
-namespace ngap{
-	PDUSessionResourceAdmittedItem::PDUSessionResourceAdmittedItem()
-	{
+namespace ngap {
+PDUSessionResourceAdmittedItem::PDUSessionResourceAdmittedItem() {
   pDUSessionID = NULL;
-	}
-	PDUSessionResourceAdmittedItem::~PDUSessionResourceAdmittedItem(){}
+}
+PDUSessionResourceAdmittedItem::~PDUSessionResourceAdmittedItem() {
+}
 
-	void PDUSessionResourceAdmittedItem::setPDUSessionResourceAdmittedItem(PDUSessionID *m_pDUSessionID, OCTET_STRING_t m_handoverrequestAcktransfer)
-	{
+void PDUSessionResourceAdmittedItem::setPDUSessionResourceAdmittedItem(
+    PDUSessionID *m_pDUSessionID, OCTET_STRING_t m_handoverrequestAcktransfer) {
   pDUSessionID = m_pDUSessionID;
   handoverrequestAcktransfer = m_handoverrequestAcktransfer;
-	}
-	bool PDUSessionResourceAdmittedItem::encode2PDUSessionResourceAdmittedItem(Ngap_PDUSessionResourceAdmittedItem_t *pdUSessionResourceAdmittedItem)
-	{
-		if(!pDUSessionID) return false;
-		if(!pDUSessionID->encode2PDUSessionID(pdUSessionResourceAdmittedItem->pDUSessionID)) return false;
-		pdUSessionResourceAdmittedItem->handoverRequestAcknowledgeTransfer = handoverrequestAcktransfer;
+}
+bool PDUSessionResourceAdmittedItem::encode2PDUSessionResourceAdmittedItem(
+    Ngap_PDUSessionResourceAdmittedItem_t *pdUSessionResourceAdmittedItem) {
+  if (!pDUSessionID)
+    return false;
+  if (!pDUSessionID->encode2PDUSessionID(
+      pdUSessionResourceAdmittedItem->pDUSessionID))
+    return false;
+  pdUSessionResourceAdmittedItem->handoverRequestAcknowledgeTransfer =
+      handoverrequestAcktransfer;
 
   return true;
-	}
-	//......
-	bool PDUSessionResourceAdmittedItem::decodefromPDUSessionResourceAdmittedItem(Ngap_PDUSessionResourceAdmittedItem_t *pdUSessionResourceAdmittedItem)
-	{
+}
+//�����......
+bool PDUSessionResourceAdmittedItem::decodefromPDUSessionResourceAdmittedItem(
+    Ngap_PDUSessionResourceAdmittedItem_t *pdUSessionResourceAdmittedItem) {
   pDUSessionID = new PDUSessionID();
-		if(!pDUSessionID->decodefromPDUSessionID(pdUSessionResourceAdmittedItem->pDUSessionID)) return false;
-		handoverrequestAcktransfer = pdUSessionResourceAdmittedItem->handoverRequestAcknowledgeTransfer;
+  if (!pDUSessionID->decodefromPDUSessionID(
+      pdUSessionResourceAdmittedItem->pDUSessionID))
+    return false;
+  handoverrequestAcktransfer = pdUSessionResourceAdmittedItem
+      ->handoverRequestAcknowledgeTransfer;
 
   return true;
-	}
-	void PDUSessionResourceAdmittedItem::getPDUSessionResourceAdmittedItem(PDUSessionID *&m_pDUSessionID, OCTET_STRING_t&m_handoverrequestAcktransfer)
-	{
+}
+void PDUSessionResourceAdmittedItem::getPDUSessionResourceAdmittedItem(
+    PDUSessionID *&m_pDUSessionID,
+    OCTET_STRING_t &m_handoverrequestAcktransfer) {
   m_pDUSessionID = pDUSessionID;
   m_handoverrequestAcktransfer = handoverrequestAcktransfer;
-	}
-
 }
 
-
-
+}
 

src/ngap/ngapIEs/PDUSessionResourceAdmittedItem.hpp

@@ -30,32 +30,34 @@
 
 #include "PDUSessionID.hpp"
 #include "PDUSessionResourceHandoverRequestAckTransfer.hpp"
-extern "C"{
-  #include "Ngap_PDUSessionResourceAdmittedItem.h"
+extern "C" {
+#include "Ngap_PDUSessionResourceAdmittedItem.h"
 }
 
-namespace ngap{
+namespace ngap {
 
-	class PDUSessionResourceAdmittedItem {
+class PDUSessionResourceAdmittedItem {
  public:
   PDUSessionResourceAdmittedItem();
   virtual ~PDUSessionResourceAdmittedItem();
 
-		void setPDUSessionResourceAdmittedItem(PDUSessionID *m_pDUSessionID, OCTET_STRING_t m_handoverrequestAcktransfer);
-		void getPDUSessionResourceAdmittedItem(PDUSessionID *&m_pDUSessionID, OCTET_STRING_t&m_handoverrequestAcktransfer);
-		
-		bool encode2PDUSessionResourceAdmittedItem(Ngap_PDUSessionResourceAdmittedItem_t *pdUSessionResourceAdmittedItem);
-		bool decodefromPDUSessionResourceAdmittedItem(Ngap_PDUSessionResourceAdmittedItem_t *pdUSessionResourceAdmittedItem);
+  void setPDUSessionResourceAdmittedItem(
+      PDUSessionID *m_pDUSessionID,
+      OCTET_STRING_t m_handoverrequestAcktransfer);
+  void getPDUSessionResourceAdmittedItem(
+      PDUSessionID *&m_pDUSessionID,
+      OCTET_STRING_t &m_handoverrequestAcktransfer);
+
+  bool encode2PDUSessionResourceAdmittedItem(
+      Ngap_PDUSessionResourceAdmittedItem_t *pdUSessionResourceAdmittedItem);
+  bool decodefromPDUSessionResourceAdmittedItem(
+      Ngap_PDUSessionResourceAdmittedItem_t *pdUSessionResourceAdmittedItem);
  private:
   PDUSessionID *pDUSessionID;
   OCTET_STRING_t handoverrequestAcktransfer;
-	};
+};
 
 }
 
 #endif
 
-
-
-
-

src/ngap/ngapIEs/PDUSessionResourceAdmittedList.cpp

@@ -3,50 +3,56 @@
 #include <iostream>
 using namespace std;
 
-namespace ngap{
-	PDUSessionResourceAdmittedList::PDUSessionResourceAdmittedList()
-	{
+namespace ngap {
+PDUSessionResourceAdmittedList::PDUSessionResourceAdmittedList() {
   pduSessionResourceAdmittedItem = NULL;
   numofSessionResourceAdmittedItem = 0;
-	}
-	PDUSessionResourceAdmittedList::~PDUSessionResourceAdmittedList(){}
+}
+PDUSessionResourceAdmittedList::~PDUSessionResourceAdmittedList() {
+}
 
-	void PDUSessionResourceAdmittedList::setPDUSessionResourceAdmittedList(PDUSessionResourceAdmittedItem *m_pduSessionResourceAdmittedItem,int num)
-	{
+void PDUSessionResourceAdmittedList::setPDUSessionResourceAdmittedList(
+    PDUSessionResourceAdmittedItem *m_pduSessionResourceAdmittedItem, int num) {
   pduSessionResourceAdmittedItem = m_pduSessionResourceAdmittedItem;
   numofSessionResourceAdmittedItem = num;
-	}
-	bool PDUSessionResourceAdmittedList::encode2PDUSessionResourceAdmittedList(Ngap_PDUSessionResourceAdmittedList_t *pduSessionResourceAdmittedList)
-	{
-		for(int i=0;i< numofSessionResourceAdmittedItem;i++)
-		{
-			Ngap_PDUSessionResourceAdmittedItem_t *response = (Ngap_PDUSessionResourceAdmittedItem_t *)calloc(1,sizeof(Ngap_PDUSessionResourceAdmittedItem_t));
-			if(!response) return false;
-			if(!pduSessionResourceAdmittedItem[i].encode2PDUSessionResourceAdmittedItem(response)) return false;
-			if(ASN_SEQUENCE_ADD(&pduSessionResourceAdmittedList->list, response) != 0) return false;
+}
+bool PDUSessionResourceAdmittedList::encode2PDUSessionResourceAdmittedList(
+    Ngap_PDUSessionResourceAdmittedList_t *pduSessionResourceAdmittedList) {
+  for (int i = 0; i < numofSessionResourceAdmittedItem; i++) {
+    Ngap_PDUSessionResourceAdmittedItem_t *response =
+        (Ngap_PDUSessionResourceAdmittedItem_t*) calloc(
+            1, sizeof(Ngap_PDUSessionResourceAdmittedItem_t));
+    if (!response)
+      return false;
+    if (!pduSessionResourceAdmittedItem[i].encode2PDUSessionResourceAdmittedItem(
+        response))
+      return false;
+    if (ASN_SEQUENCE_ADD(&pduSessionResourceAdmittedList->list, response) != 0)
+      return false;
   }
 
   return true;
-	}
-	bool PDUSessionResourceAdmittedList::decodefromPDUSessionResourceAdmittedList(Ngap_PDUSessionResourceAdmittedList_t *pduSessionResourceAdmittedList)
-	{
+}
+bool PDUSessionResourceAdmittedList::decodefromPDUSessionResourceAdmittedList(
+    Ngap_PDUSessionResourceAdmittedList_t *pduSessionResourceAdmittedList) {
   numofSessionResourceAdmittedItem = pduSessionResourceAdmittedList->list.count;
-		pduSessionResourceAdmittedItem = new PDUSessionResourceAdmittedItem[numofSessionResourceAdmittedItem]();
-		for(int i=0;i< numofSessionResourceAdmittedItem;i++)
-		{
-			if(!pduSessionResourceAdmittedItem[i].decodefromPDUSessionResourceAdmittedItem(pduSessionResourceAdmittedList->list.array[i])) return false;
+  pduSessionResourceAdmittedItem =
+      new PDUSessionResourceAdmittedItem[numofSessionResourceAdmittedItem]();
+  for (int i = 0; i < numofSessionResourceAdmittedItem; i++) {
+    if (!pduSessionResourceAdmittedItem[i]
+        .decodefromPDUSessionResourceAdmittedItem(
+        pduSessionResourceAdmittedList->list.array[i]))
+      return false;
   }
 
   return true;
-	}
-	void PDUSessionResourceAdmittedList::getPDUSessionResourceAdmittedList(PDUSessionResourceAdmittedItem *&m_pduSessionResourceAdmittedItem,int &num)
-	{
+}
+void PDUSessionResourceAdmittedList::getPDUSessionResourceAdmittedList(
+    PDUSessionResourceAdmittedItem *&m_pduSessionResourceAdmittedItem,
+    int &num) {
   m_pduSessionResourceAdmittedItem = pduSessionResourceAdmittedItem;
   num = numofSessionResourceAdmittedItem;
-	}
-
 }
 
-
-
+}
 

src/ngap/ngapIEs/PDUSessionResourceAdmittedList.hpp

@@ -3,26 +3,32 @@
 
 #include "PDUSessionResourceAdmittedItem.hpp"
 
-extern "C"{
-  #include "Ngap_PDUSessionResourceAdmittedList.h"
+extern "C" {
+#include "Ngap_PDUSessionResourceAdmittedList.h"
 }
 
-namespace ngap{
+namespace ngap {
 
-	class PDUSessionResourceAdmittedList {
+class PDUSessionResourceAdmittedList {
  public:
   PDUSessionResourceAdmittedList();
   virtual ~PDUSessionResourceAdmittedList();
 
-		void setPDUSessionResourceAdmittedList(PDUSessionResourceAdmittedItem *m_pduSessionResourceAdmittedItem,int num);
-		void getPDUSessionResourceAdmittedList(PDUSessionResourceAdmittedItem *&m_pduSessionResourceAdmittedItem,int &num);
-		
-		bool encode2PDUSessionResourceAdmittedList(Ngap_PDUSessionResourceAdmittedList_t *pduSessionResourceAdmittedList);
-		bool decodefromPDUSessionResourceAdmittedList(Ngap_PDUSessionResourceAdmittedList_t *pduSessionResourceAdmittedList);
+  void setPDUSessionResourceAdmittedList(
+      PDUSessionResourceAdmittedItem *m_pduSessionResourceAdmittedItem,
+      int num);
+  void getPDUSessionResourceAdmittedList(
+      PDUSessionResourceAdmittedItem *&m_pduSessionResourceAdmittedItem,
+      int &num);
+
+  bool encode2PDUSessionResourceAdmittedList(
+      Ngap_PDUSessionResourceAdmittedList_t *pduSessionResourceAdmittedList);
+  bool decodefromPDUSessionResourceAdmittedList(
+      Ngap_PDUSessionResourceAdmittedList_t *pduSessionResourceAdmittedList);
  private:
   PDUSessionResourceAdmittedItem *pduSessionResourceAdmittedItem;
   int numofSessionResourceAdmittedItem;
-	};
+};
 
 }
 

src/ngap/ngapIEs/PDUSessionResourceHandoverCommandTransfer.cpp

@@ -26,8 +26,7 @@
  \email: contact@openairinterface.org
  */
 #include "PDUSessionResourceHandoverCommandTransfer.hpp"
-extern "C"
-{
+extern "C" {
 #include "constr_TYPE.h"
 #include "asn_codecs.h"
 #include "per_encoder.h"
@@ -36,78 +35,81 @@ extern "C"
 }
 #include <iostream>
 using namespace std;
-namespace ngap
-{
-    PDUSessionResourceHandoverCommandTransfer::PDUSessionResourceHandoverCommandTransfer()
-    {
-        handovercommandtransferIE = (Ngap_HandoverCommandTransfer_t *)calloc(1, sizeof(Ngap_HandoverCommandTransfer_t));
+namespace ngap {
+PDUSessionResourceHandoverCommandTransfer::PDUSessionResourceHandoverCommandTransfer() {
+  handovercommandtransferIE = (Ngap_HandoverCommandTransfer_t*) calloc(
+      1, sizeof(Ngap_HandoverCommandTransfer_t));
   dLForwardingUP_TNLInformation = NULL;
   qosFlowToBeForwardedList = NULL;
-    }
-    PDUSessionResourceHandoverCommandTransfer::~PDUSessionResourceHandoverCommandTransfer() {}
-    void PDUSessionResourceHandoverCommandTransfer::setQosFlowToBeForwardedList(std::vector<QosFlowToBeForwardedItem_t> list)
-    {
+}
+PDUSessionResourceHandoverCommandTransfer::~PDUSessionResourceHandoverCommandTransfer() {
+}
+void PDUSessionResourceHandoverCommandTransfer::setQosFlowToBeForwardedList(
+    std::vector<QosFlowToBeForwardedItem_t> list) {
   if (!qosFlowToBeForwardedList)
     qosFlowToBeForwardedList = new QosFlowToBeForwardedList();
-        QosFlowToBeForwardedItem *m_item = new QosFlowToBeForwardedItem[list.size()]();
-        for (int i = 0; i < list.size(); i++)
-        {
+  QosFlowToBeForwardedItem *m_item =
+      new QosFlowToBeForwardedItem[list.size()]();
+  for (int i = 0; i < list.size(); i++) {
     QosFlowIdentifier *m_qosFlowIdentifier = new QosFlowIdentifier();
     m_qosFlowIdentifier->setQosFlowIdentifier(list[i].QFI);
     m_item[i].setQosFlowIdentifier(m_qosFlowIdentifier);
   }
   qosFlowToBeForwardedList->setQosFlowToBeForwardedItem(m_item, list.size());
-        int ret = qosFlowToBeForwardedList->encodeQosFlowToBeForwardedList(handovercommandtransferIE->qosFlowToBeForwardedList);
-        cout << "QFI in list " << handovercommandtransferIE->qosFlowToBeForwardedList->list.count << endl;
-        if (handovercommandtransferIE->qosFlowToBeForwardedList->list.array)
-        {
+  int ret = qosFlowToBeForwardedList->encodeQosFlowToBeForwardedList(
+      handovercommandtransferIE->qosFlowToBeForwardedList);
+  cout << "QFI in list "
+      << handovercommandtransferIE->qosFlowToBeForwardedList->list.count
+      << endl;
+  if (handovercommandtransferIE->qosFlowToBeForwardedList->list.array) {
     cout << "array OK" << endl;
-            if (handovercommandtransferIE->qosFlowToBeForwardedList->list.array[0])
-            {
-                cout << "QFI in list " << handovercommandtransferIE->qosFlowToBeForwardedList->list.array[0]->qosFlowIdentifier << endl;
-            }
-            else
-            {
+    if (handovercommandtransferIE->qosFlowToBeForwardedList->list.array[0]) {
+      cout << "QFI in list "
+          << handovercommandtransferIE->qosFlowToBeForwardedList->list.array[0]
+              ->qosFlowIdentifier << endl;
+    } else {
       cout << "error1" << endl;
     }
-        }
-        else
-        {
+  } else {
     cout << "error2" << endl;
   }
 
-        if (!ret)
-        {
+  if (!ret) {
     cout << "encode QosFlowToBeForwardedList IE error" << endl;
     return;
   }
-    }
-    void PDUSessionResourceHandoverCommandTransfer::setUPTransportLayerInformation(GtpTunnel_t uptlinfo)
-    {
-        if (!dLForwardingUP_TNLInformation)
-        {
+}
+void PDUSessionResourceHandoverCommandTransfer::setUPTransportLayerInformation(
+    GtpTunnel_t uptlinfo) {
+  if (!dLForwardingUP_TNLInformation) {
     dLForwardingUP_TNLInformation = new UpTransportLayerInformation();
   }
   TransportLayerAddress *m_transportLayerAddress = new TransportLayerAddress();
   GtpTeid *m_gtpTeid = new GtpTeid();
   m_transportLayerAddress->setTransportLayerAddress(uptlinfo.ip_address);
   m_gtpTeid->setGtpTeid(uptlinfo.gtp_teid);
-        dLForwardingUP_TNLInformation->setUpTransportLayerInformation(m_transportLayerAddress, m_gtpTeid);
-        Ngap_UPTransportLayerInformation *test = (Ngap_UPTransportLayerInformation *)calloc(1, sizeof(Ngap_UPTransportLayerInformation));
+  dLForwardingUP_TNLInformation->setUpTransportLayerInformation(
+      m_transportLayerAddress, m_gtpTeid);
+  Ngap_UPTransportLayerInformation *test =
+      (Ngap_UPTransportLayerInformation*) calloc(
+          1, sizeof(Ngap_UPTransportLayerInformation));
   handovercommandtransferIE->dLForwardingUP_TNLInformation = test;
-        int ret = dLForwardingUP_TNLInformation->encode2UpTransportLayerInformation(*test);
-        if (!ret)
-        {
+  int ret = dLForwardingUP_TNLInformation->encode2UpTransportLayerInformation(
+      *test);
+  if (!ret) {
     cout << "encode dLForwardingUP_TNLInformation IE error";
     return;
   }
-    }
-    int PDUSessionResourceHandoverCommandTransfer::encodePDUSessionResourceHandoverCommandTransfer(uint8_t *buf, int buf_size)
-    {
-        asn_fprint(stderr, &asn_DEF_Ngap_HandoverCommandTransfer, handovercommandtransferIE);
-        asn_enc_rval_t er = aper_encode_to_buffer(&asn_DEF_Ngap_HandoverCommandTransfer, NULL, handovercommandtransferIE, buf, buf_size);
+}
+int PDUSessionResourceHandoverCommandTransfer::encodePDUSessionResourceHandoverCommandTransfer(
+    uint8_t *buf, int buf_size) {
+  asn_fprint(stderr, &asn_DEF_Ngap_HandoverCommandTransfer,
+             handovercommandtransferIE);
+  asn_enc_rval_t er = aper_encode_to_buffer(
+      &asn_DEF_Ngap_HandoverCommandTransfer, NULL, handovercommandtransferIE,
+      buf, buf_size);
   cout << "er.encoded(" << er.encoded << ")" << endl;
   return er.encoded;
-    }
+}
 
 }  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceHandoverCommandTransfer.hpp

@@ -31,15 +31,12 @@
 #include "UPTransportLayerInformation.hpp"
 #include "QosFlowToBeForwardedList.hpp"
 #include "NgapIEsStruct.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_ProtocolIE-Field.h"
 #include "Ngap_HandoverCommandTransfer.h"
 }
-namespace ngap
-{
-    class PDUSessionResourceHandoverCommandTransfer
-    {
+namespace ngap {
+class PDUSessionResourceHandoverCommandTransfer {
  private:
   /* data */
   Ngap_HandoverCommandTransfer_t *handovercommandtransferIE;
@@ -50,9 +47,11 @@ namespace ngap
   PDUSessionResourceHandoverCommandTransfer(/* args */);
   virtual ~PDUSessionResourceHandoverCommandTransfer();
   void setUPTransportLayerInformation(GtpTunnel_t uptlinfo);
-        void setQosFlowToBeForwardedList(std::vector<QosFlowToBeForwardedItem_t> list);
-        int encodePDUSessionResourceHandoverCommandTransfer(uint8_t *buf, int buf_size);
-    };
+  void setQosFlowToBeForwardedList(
+      std::vector<QosFlowToBeForwardedItem_t> list);
+  int encodePDUSessionResourceHandoverCommandTransfer(uint8_t *buf,
+                                                      int buf_size);
+};
 
 }  // namespace ngap
 #endif

src/ngap/ngapIEs/PDUSessionResourceHandoverRequestAckTransfer.cpp

@@ -27,8 +27,7 @@
  */
 #include "PDUSessionResourceHandoverRequestAckTransfer.hpp"
 
-extern "C"
-{
+extern "C" {
 #include "constr_TYPE.h"
 #include "asn_codecs.h"
 #include "per_encoder.h"
@@ -39,78 +38,79 @@ extern "C"
 #include <iostream>
 using namespace std;
 
-namespace ngap
-{
-	PDUSessionResourceHandoverRequestAckTransfer::PDUSessionResourceHandoverRequestAckTransfer()
-	{
-		handoverRequestAcknowledegTransferIEs = (Ngap_HandoverRequestAcknowledgeTransfer_t *)calloc(1, sizeof(Ngap_HandoverRequestAcknowledgeTransfer_t));
+namespace ngap {
+PDUSessionResourceHandoverRequestAckTransfer::PDUSessionResourceHandoverRequestAckTransfer() {
+  handoverRequestAcknowledegTransferIEs =
+      (Ngap_HandoverRequestAcknowledgeTransfer_t*) calloc(
+          1, sizeof(Ngap_HandoverRequestAcknowledgeTransfer_t));
   dLForwardingUP_TNLInformation = NULL;
   QosFlowSetupResponseList = NULL;
-	}
-	PDUSessionResourceHandoverRequestAckTransfer::~PDUSessionResourceHandoverRequestAckTransfer() {}
-	bool PDUSessionResourceHandoverRequestAckTransfer::decodefromHandoverRequestAckTransfer(uint8_t *buf, int buf_size)
-	{
-		asn_dec_rval_t rc = asn_decode(NULL, ATS_ALIGNED_CANONICAL_PER, &asn_DEF_Ngap_HandoverRequestAcknowledgeTransfer, (void **)&handoverRequestAcknowledegTransferIEs, buf, buf_size);
-		if (rc.code == RC_OK)
-		{
+}
+PDUSessionResourceHandoverRequestAckTransfer::~PDUSessionResourceHandoverRequestAckTransfer() {
+}
+bool PDUSessionResourceHandoverRequestAckTransfer::decodefromHandoverRequestAckTransfer(
+    uint8_t *buf, int buf_size) {
+  asn_dec_rval_t rc = asn_decode(
+      NULL, ATS_ALIGNED_CANONICAL_PER,
+      &asn_DEF_Ngap_HandoverRequestAcknowledgeTransfer,
+      (void**) &handoverRequestAcknowledegTransferIEs, buf, buf_size);
+  if (rc.code == RC_OK) {
     cout << "Decoded handoverRequestAcknowledegTransfer successfully" << endl;
-		}
-		else if (rc.code == RC_WMORE)
-		{
+  } else if (rc.code == RC_WMORE) {
     cout << "More data expected, call again" << endl;
     return false;
-		}
-		else
-		{
+  } else {
     cout << "Failure to decode handoverRequestAcknowledegTransfer data" << endl;
     //return false;
   }
   cout << "rc.consumed to decode = " << rc.consumed << endl;
   cout << endl;
   dLForwardingUP_TNLInformation = new UpTransportLayerInformation();
-		if (!dLForwardingUP_TNLInformation->decodefromUpTransportLayerInformation(*handoverRequestAcknowledegTransferIEs->dLForwardingUP_TNLInformation))
-		{
+  if (!dLForwardingUP_TNLInformation->decodefromUpTransportLayerInformation(
+      *handoverRequestAcknowledegTransferIEs->dLForwardingUP_TNLInformation)) {
     cout << "decoded ngap DL_NGU_UP_TNLInformation IE error" << endl;
     return false;
   }
   QosFlowSetupResponseList = new QosFlowListWithDataForwarding();
-		if (!QosFlowSetupResponseList->decodeFormQosFlowListWithDataForwarding(handoverRequestAcknowledegTransferIEs->qosFlowSetupResponseList))
-		{
+  if (!QosFlowSetupResponseList->decodeFormQosFlowListWithDataForwarding(
+      handoverRequestAcknowledegTransferIEs->qosFlowSetupResponseList)) {
     cout << "decoded ngap QosFlowSetupResponseList IE error" << endl;
     return false;
   }
   return true;
-	}
-	bool PDUSessionResourceHandoverRequestAckTransfer::getUpTransportLayerInformation2(GtpTunnel_t *&upTnlInfo)
-	{
-		if (!dLForwardingUP_TNLInformation->decodefromUpTransportLayerInformation(*handoverRequestAcknowledegTransferIEs->dLForwardingUP_TNLInformation))
+}
+bool PDUSessionResourceHandoverRequestAckTransfer::getUpTransportLayerInformation2(
+    GtpTunnel_t *&upTnlInfo) {
+  if (!dLForwardingUP_TNLInformation->decodefromUpTransportLayerInformation(
+      *handoverRequestAcknowledegTransferIEs->dLForwardingUP_TNLInformation))
     return false;
   TransportLayerAddress *m_transportLayerAddress;
   GtpTeid *m_gtpTeid;
-		if (!dLForwardingUP_TNLInformation->getUpTransportLayerInformation(m_transportLayerAddress, m_gtpTeid))
+  if (!dLForwardingUP_TNLInformation->getUpTransportLayerInformation(
+      m_transportLayerAddress, m_gtpTeid))
     return false;
   if (!m_transportLayerAddress->getTransportLayerAddress(upTnlInfo->ip_address))
     return false;
   if (!m_gtpTeid->getGtpTeid(upTnlInfo->gtp_teid))
     return false;
   return true;
-	}
-	bool PDUSessionResourceHandoverRequestAckTransfer::getqosFlowSetupResponseList(std::vector<QosFlowLItemWithDataForwarding_t> &list)
-	{
+}
+bool PDUSessionResourceHandoverRequestAckTransfer::getqosFlowSetupResponseList(
+    std::vector<QosFlowLItemWithDataForwarding_t> &list) {
   if (!QosFlowSetupResponseList)
     return false;
   QosFlowItemWithDataForWarding *m_qosflowitemwithdataforwarding;
   int num = 0;
-		if (QosFlowSetupResponseList->getQosFlowListWithDataForwarding(m_qosflowitemwithdataforwarding, num))
-		{
+  if (QosFlowSetupResponseList->getQosFlowListWithDataForwarding(
+      m_qosflowitemwithdataforwarding, num)) {
     cout << "successful decode QosFlowList" << endl;
   }
-		for (int i = 0; i < num; i++)
-		{
+  for (int i = 0; i < num; i++) {
     QosFlowLItemWithDataForwarding_t response;
-			m_qosflowitemwithdataforwarding[i].getQosFlowItemWithDataForWarding(response.qosFlowIdentifier);
+    m_qosflowitemwithdataforwarding[i].getQosFlowItemWithDataForWarding(
+        response.qosFlowIdentifier);
     list.push_back(response);
   }
   return true;
-	}
+}
 }  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceHandoverRequestAckTransfer.hpp

@@ -33,27 +33,25 @@
 #include "DLQoSFlowPerTNLInformation.hpp"
 #include "SecurityResult.hpp"
 #include "QosFlowListWithDataForwarding.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_ProtocolIE-Field.h"
 #include "Ngap_HandoverRequestAcknowledgeTransfer.h"
 }
-namespace ngap
-{
-	class PDUSessionResourceHandoverRequestAckTransfer
-	{
+namespace ngap {
+class PDUSessionResourceHandoverRequestAckTransfer {
  public:
   PDUSessionResourceHandoverRequestAckTransfer();
   virtual ~PDUSessionResourceHandoverRequestAckTransfer();
   bool decodefromHandoverRequestAckTransfer(uint8_t *buf, int buf_size);
   bool getUpTransportLayerInformation2(GtpTunnel_t *&upTnlInfo);
-		bool getqosFlowSetupResponseList(std::vector<QosFlowLItemWithDataForwarding_t> &list);
+  bool getqosFlowSetupResponseList(
+      std::vector<QosFlowLItemWithDataForwarding_t> &list);
 
  private:
   Ngap_HandoverRequestAcknowledgeTransfer_t *handoverRequestAcknowledegTransferIEs;
   UpTransportLayerInformation *dLForwardingUP_TNLInformation;
   QosFlowListWithDataForwarding *QosFlowSetupResponseList;
-	};
+};
 }  // namespace ngap
 
 #endif

src/ngap/ngapIEs/PDUSessionResourceHandoverRequiredTransfer.cpp

 #include "PDUSessionResourceHandoverRequiredTransfer.hpp"
 
-extern "C"{
-  #include "constr_TYPE.h"
-  #include "asn_codecs.h"
-  #include "per_encoder.h"
-  #include "per_decoder.h"
-  #include "constraints.h"
+extern "C" {
+#include "constr_TYPE.h"
+#include "asn_codecs.h"
+#include "per_encoder.h"
+#include "per_decoder.h"
+#include "constraints.h"
 }
 
 #include <iostream>
 using namespace std;
 
-namespace ngap{
-	PDUSessionResourceHandoverRequiredTransfer::PDUSessionResourceHandoverRequiredTransfer()
-	{
-		handoverrquiredTransferIEs = (Ngap_HandoverRequiredTransfer_t *)calloc(1,sizeof(Ngap_HandoverRequiredTransfer_t));
+namespace ngap {
+PDUSessionResourceHandoverRequiredTransfer::PDUSessionResourceHandoverRequiredTransfer() {
+  handoverrquiredTransferIEs = (Ngap_HandoverRequiredTransfer_t*) calloc(
+      1, sizeof(Ngap_HandoverRequiredTransfer_t));
   DirectForwardingPathAvailability = NULL;
-	}
-	PDUSessionResourceHandoverRequiredTransfer::~PDUSessionResourceHandoverRequiredTransfer(){}
+}
+PDUSessionResourceHandoverRequiredTransfer::~PDUSessionResourceHandoverRequiredTransfer() {
+}
 
-	void PDUSessionResourceHandoverRequiredTransfer::setDirectForwardingPathAvailability(Ngap_DirectForwardingPathAvailability_t directForwardingPathAvailability)
-	{
-		if(!DirectForwardingPathAvailability)
-			DirectForwardingPathAvailability = new Ngap_DirectForwardingPathAvailability_t();
+void PDUSessionResourceHandoverRequiredTransfer::setDirectForwardingPathAvailability(
+    Ngap_DirectForwardingPathAvailability_t directForwardingPathAvailability) {
+  if (!DirectForwardingPathAvailability)
+    DirectForwardingPathAvailability =
+        new Ngap_DirectForwardingPathAvailability_t();
   *DirectForwardingPathAvailability = directForwardingPathAvailability;
-	}
+}
 
-	int  PDUSessionResourceHandoverRequiredTransfer::encode2buffer(uint8_t *buf, int buf_size)
-	{
-		asn_fprint(stderr, &asn_DEF_Ngap_HandoverRequiredTransfer, handoverrquiredTransferIEs);
-		asn_enc_rval_t er = aper_encode_to_buffer(&asn_DEF_Ngap_HandoverRequiredTransfer, NULL, handoverrquiredTransferIEs, buf, buf_size);
-    	cout<<"er.encoded("<<er.encoded<<")"<<endl;
+int PDUSessionResourceHandoverRequiredTransfer::encode2buffer(uint8_t *buf,
+                                                              int buf_size) {
+  asn_fprint(stderr, &asn_DEF_Ngap_HandoverRequiredTransfer,
+             handoverrquiredTransferIEs);
+  asn_enc_rval_t er = aper_encode_to_buffer(
+      &asn_DEF_Ngap_HandoverRequiredTransfer, NULL, handoverrquiredTransferIEs,
+      buf, buf_size);
+  cout << "er.encoded(" << er.encoded << ")" << endl;
   return er.encoded;
-	}
-	//Decapsulation
-	bool PDUSessionResourceHandoverRequiredTransfer::decodefromIE(uint8_t *buf, int buf_size)
-	{
-		asn_dec_rval_t rc = asn_decode(NULL,ATS_ALIGNED_CANONICAL_PER,&asn_DEF_Ngap_HandoverRequiredTransfer,(void**)&handoverrquiredTransferIEs,buf,buf_size);
-		if(rc.code == RC_OK)
-		{
-			cout<<"Decoded successfully"<<endl;
-		}
-		else if(rc.code == RC_WMORE)
-		{
-			cout<<"More data expected, call again"<<endl;
+}
+//Decapsulation
+bool PDUSessionResourceHandoverRequiredTransfer::decodefromIE(uint8_t *buf,
+                                                              int buf_size) {
+  asn_dec_rval_t rc = asn_decode(NULL, ATS_ALIGNED_CANONICAL_PER,
+                                 &asn_DEF_Ngap_HandoverRequiredTransfer,
+                                 (void**) &handoverrquiredTransferIEs, buf,
+                                 buf_size);
+  if (rc.code == RC_OK) {
+    cout << "Decoded successfully" << endl;
+  } else if (rc.code == RC_WMORE) {
+    cout << "More data expected, call again" << endl;
     return false;
-		}
-		else
-		{
-			cout<<"Failure to decode data"<<endl;
+  } else {
+    cout << "Failure to decode data" << endl;
     return false;
   }
-		cout<<"rc.consumed to decode = "<<rc.consumed<<endl;
-		cout<<endl;
+  cout << "rc.consumed to decode = " << rc.consumed << endl;
+  cout << endl;
   //asn_fprint(stderr, &asn_DEF_Ngap_PDUSessionResourceSetupResponseTransfer, pduSessionResourceSetupResponseTransferIEs);
-		if(handoverrquiredTransferIEs->directForwardingPathAvailability)
-		{
-			Ngap_DirectForwardingPathAvailability_t *directForwardingPathAvailability=new Ngap_DirectForwardingPathAvailability_t;
-			directForwardingPathAvailability = handoverrquiredTransferIEs->directForwardingPathAvailability;
+  if (handoverrquiredTransferIEs->directForwardingPathAvailability) {
+    Ngap_DirectForwardingPathAvailability_t *directForwardingPathAvailability =
+        new Ngap_DirectForwardingPathAvailability_t;
+    directForwardingPathAvailability = handoverrquiredTransferIEs
+        ->directForwardingPathAvailability;
   }
 
   return true;
-  	}
+}
 
-	bool PDUSessionResourceHandoverRequiredTransfer::getDirectForwardingPathAvailability(long *directForwardingPathAvailability)
-	{
+bool PDUSessionResourceHandoverRequiredTransfer::getDirectForwardingPathAvailability(
+    long *directForwardingPathAvailability) {
   directForwardingPathAvailability = DirectForwardingPathAvailability;
   return true;
-	}
+}
 
 }
 

src/ngap/ngapIEs/PDUSessionResourceHandoverRequiredTransfer.hpp

@@ -6,30 +6,30 @@
 #include "DLQoSFlowPerTNLInformation.hpp"
 #include "SecurityResult.hpp"
 
-extern "C"{
-	#include "Ngap_ProtocolIE-Field.h"
-	#include "Ngap_HandoverRequiredTransfer.h"
+extern "C" {
+#include "Ngap_ProtocolIE-Field.h"
+#include "Ngap_HandoverRequiredTransfer.h"
 }
 
-namespace ngap{
+namespace ngap {
 
-	class PDUSessionResourceHandoverRequiredTransfer {
+class PDUSessionResourceHandoverRequiredTransfer {
 
  public:
   PDUSessionResourceHandoverRequiredTransfer();
   virtual ~PDUSessionResourceHandoverRequiredTransfer();
-		void setDirectForwardingPathAvailability(Ngap_DirectForwardingPathAvailability_t directForwardingPathAvailability);
+  void setDirectForwardingPathAvailability(
+      Ngap_DirectForwardingPathAvailability_t directForwardingPathAvailability);
   int encode2buffer(uint8_t *buf, int buf_size);
   //Decapsulation
   bool decodefromIE(uint8_t *buf, int buf_size);
-		bool getDirectForwardingPathAvailability(long *directForwardingPathAvailability);
+  bool getDirectForwardingPathAvailability(
+      long *directForwardingPathAvailability);
  private:
   Ngap_HandoverRequiredTransfer_t *handoverrquiredTransferIEs;
   Ngap_DirectForwardingPathAvailability_t *DirectForwardingPathAvailability;
-	};
+};
 
 }
 #endif
 
-
-

src/ngap/ngapIEs/PDUSessionResourceItemHORqd.cpp

@@ -30,42 +30,46 @@
 #include <iostream>
 using namespace std;
 
-namespace ngap{
-	PDUSessionResourceItemHORqd::PDUSessionResourceItemHORqd()
-	{
+namespace ngap {
+PDUSessionResourceItemHORqd::PDUSessionResourceItemHORqd() {
   pDUSessionID = NULL;
-	}
-	PDUSessionResourceItemHORqd::~PDUSessionResourceItemHORqd(){}
+}
+PDUSessionResourceItemHORqd::~PDUSessionResourceItemHORqd() {
+}
 
-	void PDUSessionResourceItemHORqd::setPDUSessionResourceItemHORqd(PDUSessionID *m_pDUSessionID, OCTET_STRING_t m_handoverrequiredtransfer)
-	{
+void PDUSessionResourceItemHORqd::setPDUSessionResourceItemHORqd(
+    PDUSessionID *m_pDUSessionID, OCTET_STRING_t m_handoverrequiredtransfer) {
   pDUSessionID = m_pDUSessionID;
   handoverrequiredtransfer = m_handoverrequiredtransfer;
-	}
-	bool PDUSessionResourceItemHORqd::encode2PDUSessionResourceItemHORqd(Ngap_PDUSessionResourceItemHORqd_t *pdUSessionResourceItemHORqd)
-	{
-		if(!pDUSessionID) return false;
-		if(!pDUSessionID->encode2PDUSessionID(pdUSessionResourceItemHORqd->pDUSessionID)) return false;
-		pdUSessionResourceItemHORqd->handoverRequiredTransfer = handoverrequiredtransfer;
+}
+bool PDUSessionResourceItemHORqd::encode2PDUSessionResourceItemHORqd(
+    Ngap_PDUSessionResourceItemHORqd_t *pdUSessionResourceItemHORqd) {
+  if (!pDUSessionID)
+    return false;
+  if (!pDUSessionID->encode2PDUSessionID(
+      pdUSessionResourceItemHORqd->pDUSessionID))
+    return false;
+  pdUSessionResourceItemHORqd->handoverRequiredTransfer =
+      handoverrequiredtransfer;
 
   return true;
-	}
-	bool PDUSessionResourceItemHORqd::decodefromPDUSessionResourceItemHORqd(Ngap_PDUSessionResourceItemHORqd_t *pdUSessionResourceItemHORqd)
-	{
+}
+bool PDUSessionResourceItemHORqd::decodefromPDUSessionResourceItemHORqd(
+    Ngap_PDUSessionResourceItemHORqd_t *pdUSessionResourceItemHORqd) {
   pDUSessionID = new PDUSessionID();
-		if(!pDUSessionID->decodefromPDUSessionID(pdUSessionResourceItemHORqd->pDUSessionID)) return false;
-		handoverrequiredtransfer = pdUSessionResourceItemHORqd->handoverRequiredTransfer;
+  if (!pDUSessionID->decodefromPDUSessionID(
+      pdUSessionResourceItemHORqd->pDUSessionID))
+    return false;
+  handoverrequiredtransfer = pdUSessionResourceItemHORqd
+      ->handoverRequiredTransfer;
 
   return true;
-	}
-	void PDUSessionResourceItemHORqd::getPDUSessionResourceItemHORqd(PDUSessionID *&m_pDUSessionID, OCTET_STRING_t&m_handoverrequiredtransfer)
-	{
+}
+void PDUSessionResourceItemHORqd::getPDUSessionResourceItemHORqd(
+    PDUSessionID *&m_pDUSessionID, OCTET_STRING_t &m_handoverrequiredtransfer) {
   m_pDUSessionID = pDUSessionID;
   m_handoverrequiredtransfer = handoverrequiredtransfer;
-	}
-
 }
 
-
-
+}
 

src/ngap/ngapIEs/PDUSessionResourceItemHORqd.hpp

@@ -30,32 +30,33 @@
 
 #include "PDUSessionID.hpp"
 #include "PDUSessionResourceHandoverRequestAckTransfer.hpp"
-extern "C"{
-  #include "Ngap_PDUSessionResourceItemHORqd.h"
+extern "C" {
+#include "Ngap_PDUSessionResourceItemHORqd.h"
 }
 
-namespace ngap{
+namespace ngap {
 
-	class PDUSessionResourceItemHORqd{
+class PDUSessionResourceItemHORqd {
  public:
   PDUSessionResourceItemHORqd();
   virtual ~PDUSessionResourceItemHORqd();
 
-		void setPDUSessionResourceItemHORqd(PDUSessionID *m_pDUSessionID, OCTET_STRING_t m_handoverrequiredtransfer);
-		void getPDUSessionResourceItemHORqd(PDUSessionID *&m_pDUSessionID, OCTET_STRING_t&m_handoverrequiredtransfer);
+  void setPDUSessionResourceItemHORqd(
+      PDUSessionID *m_pDUSessionID, OCTET_STRING_t m_handoverrequiredtransfer);
+  void getPDUSessionResourceItemHORqd(
+      PDUSessionID *&m_pDUSessionID,
+      OCTET_STRING_t &m_handoverrequiredtransfer);
 
-		bool encode2PDUSessionResourceItemHORqd(Ngap_PDUSessionResourceItemHORqd_t *pdUSessionResourceItemHORqd);
-		bool decodefromPDUSessionResourceItemHORqd(Ngap_PDUSessionResourceItemHORqd_t *pdUSessionResourceItemHORqd);
+  bool encode2PDUSessionResourceItemHORqd(
+      Ngap_PDUSessionResourceItemHORqd_t *pdUSessionResourceItemHORqd);
+  bool decodefromPDUSessionResourceItemHORqd(
+      Ngap_PDUSessionResourceItemHORqd_t *pdUSessionResourceItemHORqd);
  private:
   PDUSessionID *pDUSessionID;
   OCTET_STRING_t handoverrequiredtransfer;
-	};
+};
 
 }
 
 #endif
 
-
-
-
-

src/ngap/ngapIEs/PDUSessionResourceListHORqd.cpp

@@ -3,50 +3,54 @@
 #include <iostream>
 using namespace std;
 
-namespace ngap{
-	PDUSessionResourceListHORqd::PDUSessionResourceListHORqd()
-	{
+namespace ngap {
+PDUSessionResourceListHORqd::PDUSessionResourceListHORqd() {
   pduSessionResourceItemHORqd = NULL;
   numofpduSessionResourceItemHORqd = 0;
-	}
-	PDUSessionResourceListHORqd::~PDUSessionResourceListHORqd(){}
+}
+PDUSessionResourceListHORqd::~PDUSessionResourceListHORqd() {
+}
 
-	void PDUSessionResourceListHORqd::setPDUSessionResourceListHORqd(PDUSessionResourceItemHORqd *m_pduSessionResourceItemHORqd,int num)
-	{
+void PDUSessionResourceListHORqd::setPDUSessionResourceListHORqd(
+    PDUSessionResourceItemHORqd *m_pduSessionResourceItemHORqd, int num) {
   pduSessionResourceItemHORqd = m_pduSessionResourceItemHORqd;
   numofpduSessionResourceItemHORqd = num;
-	}
-	bool PDUSessionResourceListHORqd::encode2PDUSessionResourceListHORqd(Ngap_PDUSessionResourceListHORqd_t *pduSessionResourceListHORQqd)
-	{
-		for(int i=0;i<numofpduSessionResourceItemHORqd;i++)
-		{
-			Ngap_PDUSessionResourceItemHORqd_t *response = (Ngap_PDUSessionResourceItemHORqd_t *)calloc(1,sizeof(Ngap_PDUSessionResourceItemHORqd_t));
-			if(!response) return false;
-			if(!pduSessionResourceItemHORqd[i].encode2PDUSessionResourceItemHORqd(response)) return false;
-			if(ASN_SEQUENCE_ADD(&pduSessionResourceListHORQqd->list, response) != 0) return false;
+}
+bool PDUSessionResourceListHORqd::encode2PDUSessionResourceListHORqd(
+    Ngap_PDUSessionResourceListHORqd_t *pduSessionResourceListHORQqd) {
+  for (int i = 0; i < numofpduSessionResourceItemHORqd; i++) {
+    Ngap_PDUSessionResourceItemHORqd_t *response =
+        (Ngap_PDUSessionResourceItemHORqd_t*) calloc(
+            1, sizeof(Ngap_PDUSessionResourceItemHORqd_t));
+    if (!response)
+      return false;
+    if (!pduSessionResourceItemHORqd[i].encode2PDUSessionResourceItemHORqd(
+        response))
+      return false;
+    if (ASN_SEQUENCE_ADD(&pduSessionResourceListHORQqd->list, response) != 0)
+      return false;
   }
 
   return true;
-	}
-	bool PDUSessionResourceListHORqd::decodefromPDUSessionResourceListHORqd(Ngap_PDUSessionResourceListHORqd_t *pduSessionResourceListHORQqd)
-	{
+}
+bool PDUSessionResourceListHORqd::decodefromPDUSessionResourceListHORqd(
+    Ngap_PDUSessionResourceListHORqd_t *pduSessionResourceListHORQqd) {
   numofpduSessionResourceItemHORqd = pduSessionResourceListHORQqd->list.count;
-		pduSessionResourceItemHORqd = new PDUSessionResourceItemHORqd[numofpduSessionResourceItemHORqd]();
-		for(int i=0;i< numofpduSessionResourceItemHORqd;i++)
-		{
-			if(!pduSessionResourceItemHORqd[i].decodefromPDUSessionResourceItemHORqd(pduSessionResourceListHORQqd->list.array[i])) return false;
+  pduSessionResourceItemHORqd =
+      new PDUSessionResourceItemHORqd[numofpduSessionResourceItemHORqd]();
+  for (int i = 0; i < numofpduSessionResourceItemHORqd; i++) {
+    if (!pduSessionResourceItemHORqd[i].decodefromPDUSessionResourceItemHORqd(
+        pduSessionResourceListHORQqd->list.array[i]))
+      return false;
   }
 
   return true;
-	}
-	void PDUSessionResourceListHORqd::getPDUSessionResourceListHORqd(PDUSessionResourceItemHORqd *&m_pduSessionResourceItemHORqd,int &num)
-	{
+}
+void PDUSessionResourceListHORqd::getPDUSessionResourceListHORqd(
+    PDUSessionResourceItemHORqd *&m_pduSessionResourceItemHORqd, int &num) {
   m_pduSessionResourceItemHORqd = pduSessionResourceItemHORqd;
   num = numofpduSessionResourceItemHORqd;
-	}
-
 }
 
-
-
+}
 

src/ngap/ngapIEs/PDUSessionResourceListHORqd.hpp

@@ -3,26 +3,30 @@
 
 #include "PDUSessionResourceItemHORqd.hpp"
 
-extern "C"{
-  #include "Ngap_PDUSessionResourceListHORqd.h"
+extern "C" {
+#include "Ngap_PDUSessionResourceListHORqd.h"
 }
 
-namespace ngap{
+namespace ngap {
 
-	class PDUSessionResourceListHORqd {
+class PDUSessionResourceListHORqd {
  public:
   PDUSessionResourceListHORqd();
   virtual ~PDUSessionResourceListHORqd();
 
-		void setPDUSessionResourceListHORqd(PDUSessionResourceItemHORqd *m_pduSessionResourceItemHORqd,int num);
-		void getPDUSessionResourceListHORqd(PDUSessionResourceItemHORqd *&m_pduSessionResourceItemHORqd,int &num);
+  void setPDUSessionResourceListHORqd(
+      PDUSessionResourceItemHORqd *m_pduSessionResourceItemHORqd, int num);
+  void getPDUSessionResourceListHORqd(
+      PDUSessionResourceItemHORqd *&m_pduSessionResourceItemHORqd, int &num);
 
-		bool encode2PDUSessionResourceListHORqd(Ngap_PDUSessionResourceListHORqd_t *pduSessionResourceListHORQqd);
-		bool decodefromPDUSessionResourceListHORqd(Ngap_PDUSessionResourceListHORqd_t *pduSessionResourceListHORQqd);
+  bool encode2PDUSessionResourceListHORqd(
+      Ngap_PDUSessionResourceListHORqd_t *pduSessionResourceListHORQqd);
+  bool decodefromPDUSessionResourceListHORqd(
+      Ngap_PDUSessionResourceListHORqd_t *pduSessionResourceListHORQqd);
  private:
   PDUSessionResourceItemHORqd *pduSessionResourceItemHORqd;
   int numofpduSessionResourceItemHORqd;
-	};
+};
 
 }
 

src/ngap/ngapIEs/PDUSessionResourceReleaseCommandTransfer.cpp

@@ -39,116 +39,119 @@ extern "C" {
 using namespace std;
 
 namespace ngap {
-	PDUSessionResourceReleaseCommandTransfer::PDUSessionResourceReleaseCommandTransfer()
-	{
-		pduSessionResourceReleaseCommandTransferIEs = (Ngap_PDUSessionResourceReleaseCommandTransfer_t *)calloc(1, sizeof(Ngap_PDUSessionResourceReleaseCommandTransfer_t));
+PDUSessionResourceReleaseCommandTransfer::PDUSessionResourceReleaseCommandTransfer() {
+  pduSessionResourceReleaseCommandTransferIEs =
+      (Ngap_PDUSessionResourceReleaseCommandTransfer_t*) calloc(
+          1, sizeof(Ngap_PDUSessionResourceReleaseCommandTransfer_t));
   causeValue = NULL;
-	}
-	PDUSessionResourceReleaseCommandTransfer::~PDUSessionResourceReleaseCommandTransfer() {
+}
+PDUSessionResourceReleaseCommandTransfer::~PDUSessionResourceReleaseCommandTransfer() {
   //if(pduSessionResourceReleaseCommandTransferIEs) ASN_STRUCT_FREE(asn_DEF_Ngap_PDUSessionResourceReleaseCommandTransfer,pduSessionResourceReleaseCommandTransferIEs);
-		if (causeValue) delete causeValue;
+  if (causeValue)
+    delete causeValue;
   //if (pduSessionResourceReleaseCommandTransferIEs) free(pduSessionResourceReleaseCommandTransferIEs);
-	}
+}
 
-	void PDUSessionResourceReleaseCommandTransfer::setCauseRadioNetwork(e_Ngap_CauseRadioNetwork cause_value)
-	{
+void PDUSessionResourceReleaseCommandTransfer::setCauseRadioNetwork(
+    e_Ngap_CauseRadioNetwork cause_value) {
   if (!causeValue)
     causeValue = new Cause();
 
   causeValue->setChoiceOfCause(Ngap_Cause_PR_radioNetwork);
   causeValue->setValue(cause_value);
 
-		int ret = causeValue->encode2Cause(&pduSessionResourceReleaseCommandTransferIEs->cause);
-		if (!ret)
-		{
+  int ret = causeValue->encode2Cause(
+      &pduSessionResourceReleaseCommandTransferIEs->cause);
+  if (!ret) {
     cout << "encode CauseRadioNetwork IE error" << endl;
     return;
   }
-	}
-	void PDUSessionResourceReleaseCommandTransfer::setCauseTransport(e_Ngap_CauseTransport cause_value)
-	{
+}
+void PDUSessionResourceReleaseCommandTransfer::setCauseTransport(
+    e_Ngap_CauseTransport cause_value) {
   if (!causeValue)
     causeValue = new Cause();
 
   causeValue->setChoiceOfCause(Ngap_Cause_PR_transport);
   causeValue->setValue(cause_value);
 
-		int ret = causeValue->encode2Cause(&pduSessionResourceReleaseCommandTransferIEs->cause);
-		if (!ret)
-		{
+  int ret = causeValue->encode2Cause(
+      &pduSessionResourceReleaseCommandTransferIEs->cause);
+  if (!ret) {
     cout << "encode CauseTransport IE error" << endl;
     return;
   }
-	}
-	void PDUSessionResourceReleaseCommandTransfer::setCauseNas(e_Ngap_CauseNas cause_value)
-	{
+}
+void PDUSessionResourceReleaseCommandTransfer::setCauseNas(
+    e_Ngap_CauseNas cause_value) {
   if (!causeValue)
     causeValue = new Cause();
 
   causeValue->setChoiceOfCause(Ngap_Cause_PR_nas);
   causeValue->setValue(cause_value);
 
-		int ret = causeValue->encode2Cause(&pduSessionResourceReleaseCommandTransferIEs->cause);
-		if (!ret)
-		{
+  int ret = causeValue->encode2Cause(
+      &pduSessionResourceReleaseCommandTransferIEs->cause);
+  if (!ret) {
     cout << "encode CauseNas IE error" << endl;
     return;
   }
-	}
-	void PDUSessionResourceReleaseCommandTransfer::setCauseProtocol(e_Ngap_CauseProtocol cause_value)
-	{
+}
+void PDUSessionResourceReleaseCommandTransfer::setCauseProtocol(
+    e_Ngap_CauseProtocol cause_value) {
   if (!causeValue)
     causeValue = new Cause();
 
   causeValue->setChoiceOfCause(Ngap_Cause_PR_protocol);
   causeValue->setValue(cause_value);
 
-		int ret = causeValue->encode2Cause(&pduSessionResourceReleaseCommandTransferIEs->cause);
-		if (!ret)
-		{
+  int ret = causeValue->encode2Cause(
+      &pduSessionResourceReleaseCommandTransferIEs->cause);
+  if (!ret) {
     cout << "encode CauseProtocol IE error" << endl;
     return;
   }
-	}
-	void PDUSessionResourceReleaseCommandTransfer::setCauseMisc(e_Ngap_CauseMisc cause_value)
-	{
+}
+void PDUSessionResourceReleaseCommandTransfer::setCauseMisc(
+    e_Ngap_CauseMisc cause_value) {
   if (!causeValue)
     causeValue = new Cause();
 
   causeValue->setChoiceOfCause(Ngap_Cause_PR_misc);
   causeValue->setValue(cause_value);
 
-		int ret = causeValue->encode2Cause(&pduSessionResourceReleaseCommandTransferIEs->cause);
-		if (!ret)
-		{
+  int ret = causeValue->encode2Cause(
+      &pduSessionResourceReleaseCommandTransferIEs->cause);
+  if (!ret) {
     cout << "encode CauseMisc IE error" << endl;
     return;
   }
-	}
+}
 
-	int  PDUSessionResourceReleaseCommandTransfer::encode2buffer(uint8_t *buf, int buf_size)
-	{
-		asn_fprint(stderr, &asn_DEF_Ngap_PDUSessionResourceReleaseCommandTransfer, pduSessionResourceReleaseCommandTransferIEs);
-		asn_enc_rval_t er = aper_encode_to_buffer(&asn_DEF_Ngap_PDUSessionResourceReleaseCommandTransfer, NULL, pduSessionResourceReleaseCommandTransferIEs, buf, buf_size);
+int PDUSessionResourceReleaseCommandTransfer::encode2buffer(uint8_t *buf,
+                                                            int buf_size) {
+  asn_fprint(stderr, &asn_DEF_Ngap_PDUSessionResourceReleaseCommandTransfer,
+             pduSessionResourceReleaseCommandTransferIEs);
+  asn_enc_rval_t er = aper_encode_to_buffer(
+      &asn_DEF_Ngap_PDUSessionResourceReleaseCommandTransfer, NULL,
+      pduSessionResourceReleaseCommandTransferIEs, buf, buf_size);
   cout << "er.encoded(" << er.encoded << ")" << endl;
   return er.encoded;
-	}
-	//Decapsulation
-	bool PDUSessionResourceReleaseCommandTransfer::decodefromIE(uint8_t *buf, int buf_size)
-	{
-		asn_dec_rval_t rc = asn_decode(NULL, ATS_ALIGNED_CANONICAL_PER, &asn_DEF_Ngap_PDUSessionResourceReleaseCommandTransfer, (void**)&pduSessionResourceReleaseCommandTransferIEs, buf, buf_size);
-
-		if (rc.code == RC_OK)
-		{
+}
+//Decapsulation
+bool PDUSessionResourceReleaseCommandTransfer::decodefromIE(uint8_t *buf,
+                                                            int buf_size) {
+  asn_dec_rval_t rc = asn_decode(
+      NULL, ATS_ALIGNED_CANONICAL_PER,
+      &asn_DEF_Ngap_PDUSessionResourceReleaseCommandTransfer,
+      (void**) &pduSessionResourceReleaseCommandTransferIEs, buf, buf_size);
+
+  if (rc.code == RC_OK) {
     cout << "Decoded successfully" << endl;
-		}
-		else if (rc.code == RC_WMORE)
-		{
+  } else if (rc.code == RC_WMORE) {
     cout << "More data expected, call again" << endl;
     return false;
-		}
-		else
-		{
+  } else {
     cout << "Failure to decode data" << endl;
     return false;
   }
@@ -157,25 +160,25 @@ namespace ngap {
   //asn_fprint(stderr, &asn_DEF_Ngap_PDUSessionResourceSetupUnsuccessfulTransfer, pduSessionResourceSetupUnsuccessfulTransferIEs);
 
   causeValue = new Cause();
-		if (!causeValue->decodefromCause(&pduSessionResourceReleaseCommandTransferIEs->cause))
-		{
+  if (!causeValue->decodefromCause(
+      &pduSessionResourceReleaseCommandTransferIEs->cause)) {
     cout << "decoded ngap Cause IE error" << endl;
     return false;
   }
 
   return true;
-	}
+}
 
-	long PDUSessionResourceReleaseCommandTransfer::getChoiceOfCause()
-	{
-		if (!causeValue) return -1;
+long PDUSessionResourceReleaseCommandTransfer::getChoiceOfCause() {
+  if (!causeValue)
+    return -1;
 
   return causeValue->getChoiceOfCause();
-	}
-	long PDUSessionResourceReleaseCommandTransfer::getCause()
-	{
-		if (!causeValue) return -1;
+}
+long PDUSessionResourceReleaseCommandTransfer::getCause() {
+  if (!causeValue)
+    return -1;
 
   return causeValue->getValue();
-	}
+}
 }

src/ngap/ngapIEs/PDUSessionResourceReleaseCommandTransfer.hpp

@@ -5,15 +5,14 @@
 
 #include "Cause.hpp"
 
-
-extern "C"{
-	#include "Ngap_ProtocolIE-Field.h"
-	#include "Ngap_PDUSessionResourceReleaseCommandTransfer.h"
+extern "C" {
+#include "Ngap_ProtocolIE-Field.h"
+#include "Ngap_PDUSessionResourceReleaseCommandTransfer.h"
 }
 
-namespace ngap{
+namespace ngap {
 
-	class PDUSessionResourceReleaseCommandTransfer {
+class PDUSessionResourceReleaseCommandTransfer {
 
  public:
   PDUSessionResourceReleaseCommandTransfer();
@@ -35,9 +34,8 @@ namespace ngap{
 
   Cause *causeValue;
 
-	};
+};
 
 }
 #endif
 
-

src/ngap/ngapIEs/PDUSessionResourceReleaseItemCmd.cpp

@@ -30,43 +30,52 @@
 #include <iostream>
 using namespace std;
 
-namespace ngap{
-	PDUSessionResourceReleaseItemCmd::PDUSessionResourceReleaseItemCmd()
-	{
+namespace ngap {
+PDUSessionResourceReleaseItemCmd::PDUSessionResourceReleaseItemCmd() {
   pDUSessionID = NULL;
-	}
-	PDUSessionResourceReleaseItemCmd::~PDUSessionResourceReleaseItemCmd(){
-		if (pDUSessionID) delete pDUSessionID;
-	}
+}
+PDUSessionResourceReleaseItemCmd::~PDUSessionResourceReleaseItemCmd() {
+  if (pDUSessionID)
+    delete pDUSessionID;
+}
 
-	void PDUSessionResourceReleaseItemCmd::setPDUSessionResourceReleaseItemCmd(PDUSessionID *m_pDUSessionID,OCTET_STRING_t m_pDUSessionResourceReleaseCommandTransfer)
-	{
+void PDUSessionResourceReleaseItemCmd::setPDUSessionResourceReleaseItemCmd(
+    PDUSessionID *m_pDUSessionID,
+    OCTET_STRING_t m_pDUSessionResourceReleaseCommandTransfer) {
   pDUSessionID = m_pDUSessionID;
-		pDUSessionResourceReleaseCommandTransfer = m_pDUSessionResourceReleaseCommandTransfer;
-	}
-	bool PDUSessionResourceReleaseItemCmd::encode2PDUSessionResourceReleaseItemCmd(Ngap_PDUSessionResourceToReleaseItemRelCmd_t *pduSessionResourceReleaseCommandTransfer)
-	{
-		if(!pDUSessionID->encode2PDUSessionID(pduSessionResourceReleaseCommandTransfer->pDUSessionID)) return false;
-		pduSessionResourceReleaseCommandTransfer->pDUSessionResourceReleaseCommandTransfer = pDUSessionResourceReleaseCommandTransfer;
+  pDUSessionResourceReleaseCommandTransfer =
+      m_pDUSessionResourceReleaseCommandTransfer;
+}
+bool PDUSessionResourceReleaseItemCmd::encode2PDUSessionResourceReleaseItemCmd(
+    Ngap_PDUSessionResourceToReleaseItemRelCmd_t *pduSessionResourceReleaseCommandTransfer) {
+  if (!pDUSessionID->encode2PDUSessionID(
+      pduSessionResourceReleaseCommandTransfer->pDUSessionID))
+    return false;
+  pduSessionResourceReleaseCommandTransfer
+      ->pDUSessionResourceReleaseCommandTransfer =
+      pDUSessionResourceReleaseCommandTransfer;
 
   return true;
-	}
-	bool PDUSessionResourceReleaseItemCmd::decodefromPDUSessionResourceReleaseItemCmd(Ngap_PDUSessionResourceToReleaseItemRelCmd_t *pduSessionResourceReleaseCommandTransfer)
-	{
+}
+bool PDUSessionResourceReleaseItemCmd::decodefromPDUSessionResourceReleaseItemCmd(
+    Ngap_PDUSessionResourceToReleaseItemRelCmd_t *pduSessionResourceReleaseCommandTransfer) {
   pDUSessionID = new PDUSessionID();
-		if(!pDUSessionID->decodefromPDUSessionID(pduSessionResourceReleaseCommandTransfer->pDUSessionID)) return false;
-		pDUSessionResourceReleaseCommandTransfer = pduSessionResourceReleaseCommandTransfer->pDUSessionResourceReleaseCommandTransfer;
+  if (!pDUSessionID->decodefromPDUSessionID(
+      pduSessionResourceReleaseCommandTransfer->pDUSessionID))
+    return false;
+  pDUSessionResourceReleaseCommandTransfer =
+      pduSessionResourceReleaseCommandTransfer
+          ->pDUSessionResourceReleaseCommandTransfer;
 
   return true;
-	}
-	void PDUSessionResourceReleaseItemCmd::getPDUSessionResourceReleaseItemCmd(PDUSessionID *&m_pDUSessionID, OCTET_STRING_t &m_pDUSessionResourceReleaseCommandTransfer)
-	{
+}
+void PDUSessionResourceReleaseItemCmd::getPDUSessionResourceReleaseItemCmd(
+    PDUSessionID *&m_pDUSessionID,
+    OCTET_STRING_t &m_pDUSessionResourceReleaseCommandTransfer) {
   m_pDUSessionID = pDUSessionID;
-		m_pDUSessionResourceReleaseCommandTransfer = pDUSessionResourceReleaseCommandTransfer;
-	}
-
+  m_pDUSessionResourceReleaseCommandTransfer =
+      pDUSessionResourceReleaseCommandTransfer;
 }
 
-
-
+}
 

src/ngap/ngapIEs/PDUSessionResourceReleaseItemCmd.hpp

@@ -33,32 +33,34 @@
 #include "S-NSSAI.hpp"
 #include "PDUSessionResourceReleaseCommandTransfer.hpp"
 
-extern "C"{
-  #include "Ngap_PDUSessionResourceToReleaseItemRelCmd.h"
+extern "C" {
+#include "Ngap_PDUSessionResourceToReleaseItemRelCmd.h"
 }
 
-namespace ngap{
+namespace ngap {
 
-	class PDUSessionResourceReleaseItemCmd {
+class PDUSessionResourceReleaseItemCmd {
  public:
   PDUSessionResourceReleaseItemCmd();
   virtual ~PDUSessionResourceReleaseItemCmd();
 
-		void setPDUSessionResourceReleaseItemCmd(PDUSessionID *m_pDUSessionID, OCTET_STRING_t m_pDUSessionResourceReleaseCommandTransfer);
-		void getPDUSessionResourceReleaseItemCmd(PDUSessionID *&m_pDUSessionID,OCTET_STRING_t &m_pDUSessionResourceReleaseCommandTransfer);
+  void setPDUSessionResourceReleaseItemCmd(
+      PDUSessionID *m_pDUSessionID,
+      OCTET_STRING_t m_pDUSessionResourceReleaseCommandTransfer);
+  void getPDUSessionResourceReleaseItemCmd(
+      PDUSessionID *&m_pDUSessionID,
+      OCTET_STRING_t &m_pDUSessionResourceReleaseCommandTransfer);
 
-		bool encode2PDUSessionResourceReleaseItemCmd(Ngap_PDUSessionResourceToReleaseItemRelCmd_t *pduSessionResourceReleaseCommandTransfer);
-		bool decodefromPDUSessionResourceReleaseItemCmd(Ngap_PDUSessionResourceToReleaseItemRelCmd_t *pduSessionResourceReleaseCommandTransfer);
+  bool encode2PDUSessionResourceReleaseItemCmd(
+      Ngap_PDUSessionResourceToReleaseItemRelCmd_t *pduSessionResourceReleaseCommandTransfer);
+  bool decodefromPDUSessionResourceReleaseItemCmd(
+      Ngap_PDUSessionResourceToReleaseItemRelCmd_t *pduSessionResourceReleaseCommandTransfer);
  private:
   PDUSessionID *pDUSessionID;
   OCTET_STRING_t pDUSessionResourceReleaseCommandTransfer;
-	};
+};
 
 }
 
 #endif
 
-
-
-
-

src/ngap/ngapIEs/PDUSessionResourceReleaseListCmd.cpp

@@ -3,52 +3,61 @@
 #include <iostream>
 using namespace std;
 
-namespace ngap{
-	PDUSessionResourceReleaseListCmd::PDUSessionResourceReleaseListCmd()
-	{
+namespace ngap {
+PDUSessionResourceReleaseListCmd::PDUSessionResourceReleaseListCmd() {
   pduSessionResourceReleaseItemCmd = NULL;
   numofpduSessionResourceReleaseItemCmd = 0;
-	}
-	PDUSessionResourceReleaseListCmd::~PDUSessionResourceReleaseListCmd(){
-		if (pduSessionResourceReleaseItemCmd) delete[] pduSessionResourceReleaseItemCmd;
-	}
+}
+PDUSessionResourceReleaseListCmd::~PDUSessionResourceReleaseListCmd() {
+  if (pduSessionResourceReleaseItemCmd)
+    delete[] pduSessionResourceReleaseItemCmd;
+}
 
-	void PDUSessionResourceReleaseListCmd::setPDUSessionResourceReleaseListCmd(PDUSessionResourceReleaseItemCmd *m_pduSessionResourceReleaseItemCmd,int num)
-	{
+void PDUSessionResourceReleaseListCmd::setPDUSessionResourceReleaseListCmd(
+    PDUSessionResourceReleaseItemCmd *m_pduSessionResourceReleaseItemCmd,
+    int num) {
   pduSessionResourceReleaseItemCmd = m_pduSessionResourceReleaseItemCmd;
   numofpduSessionResourceReleaseItemCmd = num;
-	}
-	bool PDUSessionResourceReleaseListCmd::encode2PDUSessionResourceReleaseListCmd(Ngap_PDUSessionResourceToReleaseListRelCmd_t *pduSessionResourceReleaseListCmd)
-	{
-		for(int i=0;i< numofpduSessionResourceReleaseItemCmd;i++)
-		{
-			Ngap_PDUSessionResourceToReleaseItemRelCmd_t *response = (Ngap_PDUSessionResourceToReleaseItemRelCmd_t *)calloc(1,sizeof(Ngap_PDUSessionResourceToReleaseItemRelCmd_t));
-			if(!response) return false;
-			if(!pduSessionResourceReleaseItemCmd[i].encode2PDUSessionResourceReleaseItemCmd(response)) return false;
-			if(ASN_SEQUENCE_ADD(&pduSessionResourceReleaseListCmd->list, response) != 0) return false;
+}
+bool PDUSessionResourceReleaseListCmd::encode2PDUSessionResourceReleaseListCmd(
+    Ngap_PDUSessionResourceToReleaseListRelCmd_t *pduSessionResourceReleaseListCmd) {
+  for (int i = 0; i < numofpduSessionResourceReleaseItemCmd; i++) {
+    Ngap_PDUSessionResourceToReleaseItemRelCmd_t *response =
+        (Ngap_PDUSessionResourceToReleaseItemRelCmd_t*) calloc(
+            1, sizeof(Ngap_PDUSessionResourceToReleaseItemRelCmd_t));
+    if (!response)
+      return false;
+    if (!pduSessionResourceReleaseItemCmd[i]
+        .encode2PDUSessionResourceReleaseItemCmd(response))
+      return false;
+    if (ASN_SEQUENCE_ADD(&pduSessionResourceReleaseListCmd->list, response)
+        != 0)
+      return false;
   }
 
   return true;
-	}
-	bool PDUSessionResourceReleaseListCmd::decodefromPDUSessionResourceReleaseListCmd(Ngap_PDUSessionResourceToReleaseListRelCmd_t *pduSessionResourceReleaseListCmd)
-	{
-		numofpduSessionResourceReleaseItemCmd = pduSessionResourceReleaseListCmd->list.count;
-		pduSessionResourceReleaseItemCmd = new PDUSessionResourceReleaseItemCmd[numofpduSessionResourceReleaseItemCmd]();
-		for(int i=0;i< numofpduSessionResourceReleaseItemCmd;i++)
-		{
-			if(!pduSessionResourceReleaseItemCmd[i].decodefromPDUSessionResourceReleaseItemCmd(pduSessionResourceReleaseListCmd->list.array[i])) return false;
+}
+bool PDUSessionResourceReleaseListCmd::decodefromPDUSessionResourceReleaseListCmd(
+    Ngap_PDUSessionResourceToReleaseListRelCmd_t *pduSessionResourceReleaseListCmd) {
+  numofpduSessionResourceReleaseItemCmd = pduSessionResourceReleaseListCmd->list
+      .count;
+  pduSessionResourceReleaseItemCmd =
+      new PDUSessionResourceReleaseItemCmd[numofpduSessionResourceReleaseItemCmd]();
+  for (int i = 0; i < numofpduSessionResourceReleaseItemCmd; i++) {
+    if (!pduSessionResourceReleaseItemCmd[i]
+        .decodefromPDUSessionResourceReleaseItemCmd(
+        pduSessionResourceReleaseListCmd->list.array[i]))
+      return false;
   }
 
   return true;
-	}
-	void PDUSessionResourceReleaseListCmd::getPDUSessionResourceReleaseListCmd(PDUSessionResourceReleaseItemCmd *&m_pduSessionResourceReleaseItemCmd,int &num)
-	{
+}
+void PDUSessionResourceReleaseListCmd::getPDUSessionResourceReleaseListCmd(
+    PDUSessionResourceReleaseItemCmd *&m_pduSessionResourceReleaseItemCmd,
+    int &num) {
   m_pduSessionResourceReleaseItemCmd = pduSessionResourceReleaseItemCmd;
   num = numofpduSessionResourceReleaseItemCmd;
-	}
-
 }
 
-
-
+}
 

src/ngap/ngapIEs/PDUSessionResourceReleaseListCmd.hpp

@@ -3,26 +3,32 @@
 
 #include "PDUSessionResourceReleaseItemCmd.hpp"
 
-extern "C"{
-  #include "Ngap_PDUSessionResourceToReleaseListRelCmd.h"
+extern "C" {
+#include "Ngap_PDUSessionResourceToReleaseListRelCmd.h"
 }
 
-namespace ngap{
+namespace ngap {
 
-	class PDUSessionResourceReleaseListCmd {
+class PDUSessionResourceReleaseListCmd {
  public:
   PDUSessionResourceReleaseListCmd();
   virtual ~PDUSessionResourceReleaseListCmd();
 
-		void setPDUSessionResourceReleaseListCmd(PDUSessionResourceReleaseItemCmd *m_pduSessionResourceReleaseItemCmd,int num);
-		void getPDUSessionResourceReleaseListCmd(PDUSessionResourceReleaseItemCmd *&m_pduSessionResourceReleaseItemCmd,int &num);
-		
-		bool encode2PDUSessionResourceReleaseListCmd(Ngap_PDUSessionResourceToReleaseListRelCmd_t *pduSessionResourceReleaseListCmd);
-		bool decodefromPDUSessionResourceReleaseListCmd(Ngap_PDUSessionResourceToReleaseListRelCmd_t *pduSessionResourceReleaseListCmd);
+  void setPDUSessionResourceReleaseListCmd(
+      PDUSessionResourceReleaseItemCmd *m_pduSessionResourceReleaseItemCmd,
+      int num);
+  void getPDUSessionResourceReleaseListCmd(
+      PDUSessionResourceReleaseItemCmd *&m_pduSessionResourceReleaseItemCmd,
+      int &num);
+
+  bool encode2PDUSessionResourceReleaseListCmd(
+      Ngap_PDUSessionResourceToReleaseListRelCmd_t *pduSessionResourceReleaseListCmd);
+  bool decodefromPDUSessionResourceReleaseListCmd(
+      Ngap_PDUSessionResourceToReleaseListRelCmd_t *pduSessionResourceReleaseListCmd);
  private:
   PDUSessionResourceReleaseItemCmd *pduSessionResourceReleaseItemCmd;
   int numofpduSessionResourceReleaseItemCmd;
-	};
+};
 
 }
 

src/ngap/ngapIEs/PDUSessionResourceReleasedItemRelRes.cpp

@@ -53,7 +53,8 @@ void PDUSessionResourceReleasedItemRelRes::getPDUSessionResourceReleasedItemRelR
     PDUSessionID *&m_pDUSessionID,
     OCTET_STRING_t &m_pDUSessionResourceReleaseResponseTransfer) {
   m_pDUSessionID = pDUSessionID;
-  m_pDUSessionResourceReleaseResponseTransfer = pDUSessionResourceReleaseResponseTransfer;
+  m_pDUSessionResourceReleaseResponseTransfer =
+      pDUSessionResourceReleaseResponseTransfer;
 }
 
 //------------------------------------------------------------------------------

src/ngap/ngapIEs/PDUSessionResourceReleasedListRelRes.cpp

@@ -44,8 +44,7 @@ PDUSessionResourceReleasedListRelRes::~PDUSessionResourceReleasedListRelRes() {
 void PDUSessionResourceReleasedListRelRes::setPDUSessionResourceReleasedListRelRes(
     PDUSessionResourceReleasedItemRelRes *m_pduSessionResourceReleasedItemRelRes,
     int num) {
-  pduSessionResourceReleasedItemRelRes =
-      m_pduSessionResourceReleasedItemRelRes;
+  pduSessionResourceReleasedItemRelRes = m_pduSessionResourceReleasedItemRelRes;
   maxnoofPDUSessions = num;
 }
 
@@ -53,8 +52,7 @@ void PDUSessionResourceReleasedListRelRes::setPDUSessionResourceReleasedListRelR
 void PDUSessionResourceReleasedListRelRes::getPDUSessionResourceReleasedListRelRes(
     PDUSessionResourceReleasedItemRelRes *&m_pduSessionResourceReleasedItemRelRes,
     int &num) {
-  m_pduSessionResourceReleasedItemRelRes =
-      pduSessionResourceReleasedItemRelRes;
+  m_pduSessionResourceReleasedItemRelRes = pduSessionResourceReleasedItemRelRes;
   num = maxnoofPDUSessions;
 }
 
@@ -70,8 +68,7 @@ bool PDUSessionResourceReleasedListRelRes::encode2PDUSessionResourceReleasedList
     if (!pduSessionResourceReleasedItemRelRes[i]
         .encode2PDUSessionResourceReleasedItemRelRes(rel))
       return false;
-    if (ASN_SEQUENCE_ADD(&pduSessionResourceReleasedListRelRes->list, rel)
-        != 0)
+    if (ASN_SEQUENCE_ADD(&pduSessionResourceReleasedListRelRes->list, rel) != 0)
       return false;
   }
   return true;

src/ngap/ngapIEs/PDUSessionResourceSetupItemHOReq.cpp

@@ -3,47 +3,56 @@
 #include <iostream>
 using namespace std;
 
-namespace ngap{
-	PDUSessionResourceSetupItemHOReq::PDUSessionResourceSetupItemHOReq()
-	{
+namespace ngap {
+PDUSessionResourceSetupItemHOReq::PDUSessionResourceSetupItemHOReq() {
   pDUSessionID = NULL;
   s_NSSAI = NULL;
-	}
-	PDUSessionResourceSetupItemHOReq::~PDUSessionResourceSetupItemHOReq(){}
+}
+PDUSessionResourceSetupItemHOReq::~PDUSessionResourceSetupItemHOReq() {
+}
 
-	void PDUSessionResourceSetupItemHOReq::setPDUSessionResourceSetupItemHOReq(PDUSessionID *m_pDUSessionID,S_NSSAI	*m_s_NSSAI,OCTET_STRING_t m_pDUSessionResourceSetupRequestTransfer)
-	{
+void PDUSessionResourceSetupItemHOReq::setPDUSessionResourceSetupItemHOReq(
+    PDUSessionID *m_pDUSessionID, S_NSSAI *m_s_NSSAI,
+    OCTET_STRING_t m_pDUSessionResourceSetupRequestTransfer) {
   pDUSessionID = m_pDUSessionID;
   s_NSSAI = m_s_NSSAI;
-		pDUSessionResourceSetupRequestTransfer = m_pDUSessionResourceSetupRequestTransfer;
-	}
-	bool PDUSessionResourceSetupItemHOReq::encode2PDUSessionResourceSetupItemHOReq(Ngap_PDUSessionResourceSetupItemHOReq_t *pduSessionResourceSetupItemHOReq)
-	{
-		if(!pDUSessionID->encode2PDUSessionID(pduSessionResourceSetupItemHOReq->pDUSessionID)) return false;
-		if(!s_NSSAI->encode2S_NSSAI(&pduSessionResourceSetupItemHOReq->s_NSSAI)) return false;
-		pduSessionResourceSetupItemHOReq->handoverRequestTransfer = pDUSessionResourceSetupRequestTransfer;
+  pDUSessionResourceSetupRequestTransfer =
+      m_pDUSessionResourceSetupRequestTransfer;
+}
+bool PDUSessionResourceSetupItemHOReq::encode2PDUSessionResourceSetupItemHOReq(
+    Ngap_PDUSessionResourceSetupItemHOReq_t *pduSessionResourceSetupItemHOReq) {
+  if (!pDUSessionID->encode2PDUSessionID(
+      pduSessionResourceSetupItemHOReq->pDUSessionID))
+    return false;
+  if (!s_NSSAI->encode2S_NSSAI(&pduSessionResourceSetupItemHOReq->s_NSSAI))
+    return false;
+  pduSessionResourceSetupItemHOReq->handoverRequestTransfer =
+      pDUSessionResourceSetupRequestTransfer;
 
   return true;
-	}
-	bool PDUSessionResourceSetupItemHOReq::decodefromPDUSessionResourceSetupItemHOReq(Ngap_PDUSessionResourceSetupItemHOReq_t *pduSessionResourceSetupItemHOReq)
-	{
+}
+bool PDUSessionResourceSetupItemHOReq::decodefromPDUSessionResourceSetupItemHOReq(
+    Ngap_PDUSessionResourceSetupItemHOReq_t *pduSessionResourceSetupItemHOReq) {
   pDUSessionID = new PDUSessionID();
   s_NSSAI = new S_NSSAI();
-		if(!pDUSessionID->decodefromPDUSessionID(pduSessionResourceSetupItemHOReq->pDUSessionID)) return false;
-		if(!s_NSSAI->decodefromS_NSSAI(&pduSessionResourceSetupItemHOReq->s_NSSAI)) return false;
-		pDUSessionResourceSetupRequestTransfer = pduSessionResourceSetupItemHOReq->handoverRequestTransfer;
+  if (!pDUSessionID->decodefromPDUSessionID(
+      pduSessionResourceSetupItemHOReq->pDUSessionID))
+    return false;
+  if (!s_NSSAI->decodefromS_NSSAI(&pduSessionResourceSetupItemHOReq->s_NSSAI))
+    return false;
+  pDUSessionResourceSetupRequestTransfer = pduSessionResourceSetupItemHOReq
+      ->handoverRequestTransfer;
 
   return true;
-	}
-	void PDUSessionResourceSetupItemHOReq::getPDUSessionResourceSetupItemHOReq(PDUSessionID *&m_pDUSessionID, S_NSSAI *&m_s_NSSAI,OCTET_STRING_t &m_pDUSessionResourceSetupRequestTransfer)
-	{
+}
+void PDUSessionResourceSetupItemHOReq::getPDUSessionResourceSetupItemHOReq(
+    PDUSessionID *&m_pDUSessionID, S_NSSAI *&m_s_NSSAI,
+    OCTET_STRING_t &m_pDUSessionResourceSetupRequestTransfer) {
   m_pDUSessionID = pDUSessionID;
   m_s_NSSAI = s_NSSAI;
-		m_pDUSessionResourceSetupRequestTransfer = pDUSessionResourceSetupRequestTransfer;
-	}
-
+  m_pDUSessionResourceSetupRequestTransfer =
+      pDUSessionResourceSetupRequestTransfer;
 }
 
-
-
+}
 

src/ngap/ngapIEs/PDUSessionResourceSetupItemHOReq.hpp

@@ -6,33 +6,35 @@
 #include "S-NSSAI.hpp"
 #include "PDUSessionResourceSetupRequestTransfer.hpp"
 
-extern "C"{
-  #include "Ngap_PDUSessionResourceSetupItemHOReq.h"
+extern "C" {
+#include "Ngap_PDUSessionResourceSetupItemHOReq.h"
 }
 
-namespace ngap{
+namespace ngap {
 
-	class PDUSessionResourceSetupItemHOReq{
+class PDUSessionResourceSetupItemHOReq {
  public:
   PDUSessionResourceSetupItemHOReq();
   virtual ~PDUSessionResourceSetupItemHOReq();
 
-		void setPDUSessionResourceSetupItemHOReq(PDUSessionID *m_pDUSessionID, S_NSSAI	*m_s_NSSAI,OCTET_STRING_t m_pDUSessionResourceSetupRequestTransfer);
-		void getPDUSessionResourceSetupItemHOReq(PDUSessionID *&m_pDUSessionID,S_NSSAI *&m_s_NSSAI,OCTET_STRING_t &m_pDUSessionResourceSetupRequestTransfer);
-		
-		bool encode2PDUSessionResourceSetupItemHOReq(Ngap_PDUSessionResourceSetupItemHOReq_t *pduSessionResourceSetupItemHOReq);
-		bool decodefromPDUSessionResourceSetupItemHOReq(Ngap_PDUSessionResourceSetupItemHOReq_t *pduSessionResourceSetupItemHOReq);
+  void setPDUSessionResourceSetupItemHOReq(
+      PDUSessionID *m_pDUSessionID, S_NSSAI *m_s_NSSAI,
+      OCTET_STRING_t m_pDUSessionResourceSetupRequestTransfer);
+  void getPDUSessionResourceSetupItemHOReq(
+      PDUSessionID *&m_pDUSessionID, S_NSSAI *&m_s_NSSAI,
+      OCTET_STRING_t &m_pDUSessionResourceSetupRequestTransfer);
+
+  bool encode2PDUSessionResourceSetupItemHOReq(
+      Ngap_PDUSessionResourceSetupItemHOReq_t *pduSessionResourceSetupItemHOReq);
+  bool decodefromPDUSessionResourceSetupItemHOReq(
+      Ngap_PDUSessionResourceSetupItemHOReq_t *pduSessionResourceSetupItemHOReq);
  private:
   PDUSessionID *pDUSessionID;
   S_NSSAI *s_NSSAI;
   OCTET_STRING_t pDUSessionResourceSetupRequestTransfer;
-	};
+};
 
 }
 
 #endif
 
-
-
-
-

src/ngap/ngapIEs/PDUSessionResourceSetupListHOReq.cpp

@@ -3,49 +3,58 @@
 #include <iostream>
 using namespace std;
 
-namespace ngap{
-	PDUSessionResourceSetupListHOReq::PDUSessionResourceSetupListHOReq()
-	{
+namespace ngap {
+PDUSessionResourceSetupListHOReq::PDUSessionResourceSetupListHOReq() {
   pduSessionResourceSetupItemHOReq = NULL;
   numofpduSessionResourceSetupItemHOReq = 0;
-	}
-	PDUSessionResourceSetupListHOReq::~PDUSessionResourceSetupListHOReq(){}
+}
+PDUSessionResourceSetupListHOReq::~PDUSessionResourceSetupListHOReq() {
+}
 
-	void PDUSessionResourceSetupListHOReq::setPDUSessionResourceSetupListHOReq(PDUSessionResourceSetupItemHOReq *m_pduSessionResourceSetupItemHOReq,int num)
-	{
+void PDUSessionResourceSetupListHOReq::setPDUSessionResourceSetupListHOReq(
+    PDUSessionResourceSetupItemHOReq *m_pduSessionResourceSetupItemHOReq,
+    int num) {
   pduSessionResourceSetupItemHOReq = m_pduSessionResourceSetupItemHOReq;
   numofpduSessionResourceSetupItemHOReq = num;
-	}
-	bool PDUSessionResourceSetupListHOReq::encode2PDUSessionResourceSetupListHOReq(Ngap_PDUSessionResourceSetupListHOReq_t *pduSessionResourceSetupListHOReq)
-	{
-		for(int i=0;i<numofpduSessionResourceSetupItemHOReq;i++)
-		{
-			Ngap_PDUSessionResourceSetupItemHOReq_t *request = (Ngap_PDUSessionResourceSetupItemHOReq_t *)calloc(1,sizeof(Ngap_PDUSessionResourceSetupItemHOReq_t));
-			if(!request) return false;
-			if(!pduSessionResourceSetupItemHOReq[i].encode2PDUSessionResourceSetupItemHOReq(request)) return false;
-			if(ASN_SEQUENCE_ADD(&pduSessionResourceSetupListHOReq->list, request) != 0) return false;
+}
+bool PDUSessionResourceSetupListHOReq::encode2PDUSessionResourceSetupListHOReq(
+    Ngap_PDUSessionResourceSetupListHOReq_t *pduSessionResourceSetupListHOReq) {
+  for (int i = 0; i < numofpduSessionResourceSetupItemHOReq; i++) {
+    Ngap_PDUSessionResourceSetupItemHOReq_t *request =
+        (Ngap_PDUSessionResourceSetupItemHOReq_t*) calloc(
+            1, sizeof(Ngap_PDUSessionResourceSetupItemHOReq_t));
+    if (!request)
+      return false;
+    if (!pduSessionResourceSetupItemHOReq[i]
+        .encode2PDUSessionResourceSetupItemHOReq(request))
+      return false;
+    if (ASN_SEQUENCE_ADD(&pduSessionResourceSetupListHOReq->list, request) != 0)
+      return false;
   }
 
   return true;
-	}
-	bool PDUSessionResourceSetupListHOReq::decodefromPDUSessionResourceSetupListHOReq(Ngap_PDUSessionResourceSetupListHOReq_t *pduSessionResourceSetupListHOReq)
-	{
-		numofpduSessionResourceSetupItemHOReq = pduSessionResourceSetupListHOReq->list.count;
-		pduSessionResourceSetupItemHOReq = new PDUSessionResourceSetupItemHOReq[numofpduSessionResourceSetupItemHOReq]();
-		for(int i=0;i<numofpduSessionResourceSetupItemHOReq;i++)
-		{
-			if(!pduSessionResourceSetupItemHOReq[i].decodefromPDUSessionResourceSetupItemHOReq(pduSessionResourceSetupListHOReq->list.array[i])) return false;
+}
+bool PDUSessionResourceSetupListHOReq::decodefromPDUSessionResourceSetupListHOReq(
+    Ngap_PDUSessionResourceSetupListHOReq_t *pduSessionResourceSetupListHOReq) {
+  numofpduSessionResourceSetupItemHOReq = pduSessionResourceSetupListHOReq->list
+      .count;
+  pduSessionResourceSetupItemHOReq =
+      new PDUSessionResourceSetupItemHOReq[numofpduSessionResourceSetupItemHOReq]();
+  for (int i = 0; i < numofpduSessionResourceSetupItemHOReq; i++) {
+    if (!pduSessionResourceSetupItemHOReq[i]
+        .decodefromPDUSessionResourceSetupItemHOReq(
+        pduSessionResourceSetupListHOReq->list.array[i]))
+      return false;
   }
 
   return true;
-	}
-	void PDUSessionResourceSetupListHOReq::getPDUSessionResourceSetupListHOReq(PDUSessionResourceSetupItemHOReq *&m_pduSessionResourceSetupItemHOReq,int &num)
-	{
+}
+void PDUSessionResourceSetupListHOReq::getPDUSessionResourceSetupListHOReq(
+    PDUSessionResourceSetupItemHOReq *&m_pduSessionResourceSetupItemHOReq,
+    int &num) {
   m_pduSessionResourceSetupItemHOReq = pduSessionResourceSetupItemHOReq;
   num = numofpduSessionResourceSetupItemHOReq;
-	}
-
 }
 
-
+}
 

src/ngap/ngapIEs/PDUSessionResourceSetupListHOReq.hpp

@@ -3,27 +3,33 @@
 
 #include "PDUSessionResourceSetupItemHOReq.hpp"
 
-extern "C"{
-  #include "Ngap_PDUSessionResourceSetupListHOReq.h"
+extern "C" {
+#include "Ngap_PDUSessionResourceSetupListHOReq.h"
 
 }
 
-namespace ngap{
+namespace ngap {
 
-	class PDUSessionResourceSetupListHOReq{
+class PDUSessionResourceSetupListHOReq {
  public:
   PDUSessionResourceSetupListHOReq();
   virtual ~PDUSessionResourceSetupListHOReq();
 
-		void setPDUSessionResourceSetupListHOReq(PDUSessionResourceSetupItemHOReq *m_pduSessionResourceSetupItemHOReq,int num);
-		void getPDUSessionResourceSetupListHOReq(PDUSessionResourceSetupItemHOReq *&m_pduSessionResourceSetupItemHOReq,int &num);
-		
-		bool encode2PDUSessionResourceSetupListHOReq(Ngap_PDUSessionResourceSetupListHOReq_t *pduSessionResourceSetupListHOReq);
-		bool decodefromPDUSessionResourceSetupListHOReq(Ngap_PDUSessionResourceSetupListHOReq_t *pduSessionResourceSetupListHOReq);
+  void setPDUSessionResourceSetupListHOReq(
+      PDUSessionResourceSetupItemHOReq *m_pduSessionResourceSetupItemHOReq,
+      int num);
+  void getPDUSessionResourceSetupListHOReq(
+      PDUSessionResourceSetupItemHOReq *&m_pduSessionResourceSetupItemHOReq,
+      int &num);
+
+  bool encode2PDUSessionResourceSetupListHOReq(
+      Ngap_PDUSessionResourceSetupListHOReq_t *pduSessionResourceSetupListHOReq);
+  bool decodefromPDUSessionResourceSetupListHOReq(
+      Ngap_PDUSessionResourceSetupListHOReq_t *pduSessionResourceSetupListHOReq);
  private:
   PDUSessionResourceSetupItemHOReq *pduSessionResourceSetupItemHOReq;
   int numofpduSessionResourceSetupItemHOReq;
-	};
+};
 
 }
 

src/ngap/ngapIEs/QosFlowItemWithDataForwarding.cpp

@@ -29,33 +29,31 @@
 #include <iostream>
 using namespace std;
 
-namespace ngap
-{
-	QosFlowItemWithDataForWarding::QosFlowItemWithDataForWarding()
-	{
+namespace ngap {
+QosFlowItemWithDataForWarding::QosFlowItemWithDataForWarding() {
   qosFlowIdentifier = NULL;
-	}
-	QosFlowItemWithDataForWarding::~QosFlowItemWithDataForWarding() {}
-	void QosFlowItemWithDataForWarding::getQosFlowItemWithDataForWarding(Ngap_QosFlowIdentifier_t &m_QosFlowIdentifier)
-	{
+}
+QosFlowItemWithDataForWarding::~QosFlowItemWithDataForWarding() {
+}
+void QosFlowItemWithDataForWarding::getQosFlowItemWithDataForWarding(
+    Ngap_QosFlowIdentifier_t &m_QosFlowIdentifier) {
   if (!qosFlowIdentifier)
     printf("qosFlowIdentifier null\n");
   else
     printf("qosFlowIdentifier \n");
-		if (qosFlowIdentifier->getQosFlowIdentifier(value))
-		{
-			m_QosFlowIdentifier = (Ngap_QosFlowIdentifier_t)value;
-		}
+  if (qosFlowIdentifier->getQosFlowIdentifier(value)) {
+    m_QosFlowIdentifier = (Ngap_QosFlowIdentifier_t) value;
   }
-	bool QosFlowItemWithDataForWarding::decodeformQosFlowItemWithDataForWarding(Ngap_QosFlowSetupResponseItemHOReqAck_t *qosFlowItemWithDataForWarding)
-	{
+}
+bool QosFlowItemWithDataForWarding::decodeformQosFlowItemWithDataForWarding(
+    Ngap_QosFlowSetupResponseItemHOReqAck_t *qosFlowItemWithDataForWarding) {
   qosFlowIdentifier = new QosFlowIdentifier();
-		if (!qosFlowIdentifier->decodefromQosFlowIdentifier(&(qosFlowItemWithDataForWarding->qosFlowIdentifier)))
-		{
+  if (!qosFlowIdentifier->decodefromQosFlowIdentifier(
+      &(qosFlowItemWithDataForWarding->qosFlowIdentifier))) {
     printf("false\n");
     return false;
   }
   printf("true\n");
   return true;
-	}
+}
 }  // namespace ngap

src/ngap/ngapIEs/QosFlowItemWithDataForwarding.hpp

@@ -30,25 +30,24 @@
 
 #include "QosFlowLevelQosParameters.hpp"
 #include "QosFlowIdentifier.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_QosFlowSetupResponseItemHOReqAck.h"
 }
-namespace ngap
-{
-	class QosFlowItemWithDataForWarding
-	{
+namespace ngap {
+class QosFlowItemWithDataForWarding {
  public:
   QosFlowItemWithDataForWarding();
   virtual ~QosFlowItemWithDataForWarding();
 
-		void getQosFlowItemWithDataForWarding(Ngap_QosFlowIdentifier_t &m_QosFlowIdentifier);
-		bool decodeformQosFlowItemWithDataForWarding(Ngap_QosFlowSetupResponseItemHOReqAck_t *qosFlowItemWithDataForWarding);
+  void getQosFlowItemWithDataForWarding(
+      Ngap_QosFlowIdentifier_t &m_QosFlowIdentifier);
+  bool decodeformQosFlowItemWithDataForWarding(
+      Ngap_QosFlowSetupResponseItemHOReqAck_t *qosFlowItemWithDataForWarding);
 
  private:
   long value;
   QosFlowIdentifier *qosFlowIdentifier;
-	};
+};
 }  // namespace ngap
 
 #endif // !_QOSFLOWITEMWITHDATAFORWARDING_H_

src/ngap/ngapIEs/QosFlowListWithDataForwarding.cpp

@@ -19,7 +19,7 @@
  *      contact@openairinterface.org
  */
 
- /*! \file
+/*! \file
  \brief
  \author  niuxiansheng-niu, BUPT
  \date 2020
@@ -30,25 +30,30 @@
 #include <iostream>
 using namespace std;
 namespace ngap {
-	QosFlowListWithDataForwarding::QosFlowListWithDataForwarding()
-	{
+QosFlowListWithDataForwarding::QosFlowListWithDataForwarding() {
   qosFlowItemWithDataForwarding = NULL;
   numofQosFlowItemWithDataForwarding = 0;
-	}
-	QosFlowListWithDataForwarding::~QosFlowListWithDataForwarding(){}
+}
+QosFlowListWithDataForwarding::~QosFlowListWithDataForwarding() {
+}
 
-	bool QosFlowListWithDataForwarding::decodeFormQosFlowListWithDataForwarding(Ngap_QosFlowSetupResponseListHOReqAck_t qosFlowSetupResponseList) {
+bool QosFlowListWithDataForwarding::decodeFormQosFlowListWithDataForwarding(
+    Ngap_QosFlowSetupResponseListHOReqAck_t qosFlowSetupResponseList) {
   numofQosFlowItemWithDataForwarding = qosFlowSetupResponseList.list.count;
-		qosFlowItemWithDataForwarding = new QosFlowItemWithDataForWarding[numofQosFlowItemWithDataForwarding]();
+  qosFlowItemWithDataForwarding =
+      new QosFlowItemWithDataForWarding[numofQosFlowItemWithDataForwarding]();
   for (int i = 0; i < numofQosFlowItemWithDataForwarding; i++) {
-			if (!qosFlowItemWithDataForwarding[i].decodeformQosFlowItemWithDataForWarding(qosFlowSetupResponseList.list.array[i]))
+    if (!qosFlowItemWithDataForwarding[i]
+        .decodeformQosFlowItemWithDataForWarding(
+        qosFlowSetupResponseList.list.array[i]))
       return false;
   }
   return true;
-	}
-	bool QosFlowListWithDataForwarding::getQosFlowListWithDataForwarding(QosFlowItemWithDataForWarding *&m_QosFlowItemWithDataForwarding, int &num){
+}
+bool QosFlowListWithDataForwarding::getQosFlowListWithDataForwarding(
+    QosFlowItemWithDataForWarding *&m_QosFlowItemWithDataForwarding, int &num) {
   m_QosFlowItemWithDataForwarding = qosFlowItemWithDataForwarding;
   num = numofQosFlowItemWithDataForwarding;
   return true;
-	}
+}
 }

src/ngap/ngapIEs/QosFlowListWithDataForwarding.hpp

@@ -19,7 +19,7 @@
  *      contact@openairinterface.org
  */
 
- /*! \file
+/*! \file
  \brief
  \author  niuxiansheng-niu, BUPT
  \date 2020
@@ -31,21 +31,23 @@
 
 #include "QosFlowLevelQosParameters.hpp"
 #include "QosFlowItemWithDataForwarding.hpp"
-extern "C"
-{
-	#include "Ngap_QosFlowSetupResponseListHOReqAck.h"
+extern "C" {
+#include "Ngap_QosFlowSetupResponseListHOReqAck.h"
 }
 namespace ngap {
-	class QosFlowListWithDataForwarding {
+class QosFlowListWithDataForwarding {
  public:
   QosFlowListWithDataForwarding();
   virtual ~QosFlowListWithDataForwarding();
-		bool getQosFlowListWithDataForwarding(QosFlowItemWithDataForWarding *&m_QosFlowItemWithDataForwarding, int &num);
-		bool decodeFormQosFlowListWithDataForwarding(Ngap_QosFlowSetupResponseListHOReqAck_t qosFlowSetupResponseList);
+  bool getQosFlowListWithDataForwarding(
+      QosFlowItemWithDataForWarding *&m_QosFlowItemWithDataForwarding,
+      int &num);
+  bool decodeFormQosFlowListWithDataForwarding(
+      Ngap_QosFlowSetupResponseListHOReqAck_t qosFlowSetupResponseList);
  private:
   //QosFlowIdentifier *qosFlowIdentifier;
-		QosFlowItemWithDataForWarding* qosFlowItemWithDataForwarding;
+  QosFlowItemWithDataForWarding *qosFlowItemWithDataForwarding;
   int numofQosFlowItemWithDataForwarding;
-	};
+};
 }
 #endif

src/ngap/ngapIEs/QosFlowToBeForwardedItem.cpp

@@ -26,31 +26,29 @@
  \email: contact@openairinterface.org
  */
 #include "QosFlowToBeForwardedItem.hpp"
-extern "C"
-{
+extern "C" {
 }
 #include <iostream>
 using namespace std;
-namespace ngap
-{
-    QosFlowToBeForwardedItem::QosFlowToBeForwardedItem()
-    {
+namespace ngap {
+QosFlowToBeForwardedItem::QosFlowToBeForwardedItem() {
   qosflowidentifier = NULL;
-    }
-    QosFlowToBeForwardedItem::~QosFlowToBeForwardedItem() {}
-    void QosFlowToBeForwardedItem::setQosFlowIdentifier(QosFlowIdentifier *m_qosflowidentifier)
-    {
+}
+QosFlowToBeForwardedItem::~QosFlowToBeForwardedItem() {
+}
+void QosFlowToBeForwardedItem::setQosFlowIdentifier(
+    QosFlowIdentifier *m_qosflowidentifier) {
   qosflowidentifier = m_qosflowidentifier;
-    }
-    bool QosFlowToBeForwardedItem::encodeQosFlowToBeForwardedItem(Ngap_QosFlowToBeForwardedItem_t *qosflowtobeforwardeditem)
-    {
+}
+bool QosFlowToBeForwardedItem::encodeQosFlowToBeForwardedItem(
+    Ngap_QosFlowToBeForwardedItem_t *qosflowtobeforwardeditem) {
   if (!qosflowidentifier)
     return false;
-        if (!qosflowidentifier->encode2QosFlowIdentifier(&qosflowtobeforwardeditem->qosFlowIdentifier))
-        {
+  if (!qosflowidentifier->encode2QosFlowIdentifier(
+      &qosflowtobeforwardeditem->qosFlowIdentifier)) {
     cout << "encode QFI error" << endl;
     return false;
   }
   return true;
-    }
+}
 }  // namespace ngap

src/ngap/ngapIEs/QosFlowToBeForwardedItem.hpp

@@ -28,22 +28,20 @@
 #ifndef _QOSFLOWTOBEFORWARDEDITEM_H_
 #define _QOSFLOWTOBEFORWARDEDITEM_H_
 #include "QosFlowIdentifier.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_QosFlowToBeForwardedItem.h"
 }
-namespace ngap
-{
-    class QosFlowToBeForwardedItem
-    {
+namespace ngap {
+class QosFlowToBeForwardedItem {
  public:
   QosFlowToBeForwardedItem();
   virtual ~QosFlowToBeForwardedItem();
   void setQosFlowIdentifier(QosFlowIdentifier *m_qosflowidentifier);
-        bool encodeQosFlowToBeForwardedItem(Ngap_QosFlowToBeForwardedItem_t *qosflowtobeforwardeditem);
+  bool encodeQosFlowToBeForwardedItem(
+      Ngap_QosFlowToBeForwardedItem_t *qosflowtobeforwardeditem);
 
  private:
   QosFlowIdentifier *qosflowidentifier;
-    };
+};
 }  // namespace ngap
 #endif

src/ngap/ngapIEs/QosFlowToBeForwardedList.cpp

@@ -28,40 +28,40 @@
 #include "QosFlowToBeForwardedList.hpp"
 #include <iostream>
 using namespace std;
-namespace ngap
-{
-    QosFlowToBeForwardedList::QosFlowToBeForwardedList()
-    {
+namespace ngap {
+QosFlowToBeForwardedList::QosFlowToBeForwardedList() {
   Qosflowtobeforwardeditem = NULL;
   numofqosflowtobeforwardeditem = 0;
-    }
-    QosFlowToBeForwardedList::~QosFlowToBeForwardedList() {}
-    void QosFlowToBeForwardedList::setQosFlowToBeForwardedItem(QosFlowToBeForwardedItem *m_qosflowtobeforwardeditem, int num)
-    {
+}
+QosFlowToBeForwardedList::~QosFlowToBeForwardedList() {
+}
+void QosFlowToBeForwardedList::setQosFlowToBeForwardedItem(
+    QosFlowToBeForwardedItem *m_qosflowtobeforwardeditem, int num) {
   Qosflowtobeforwardeditem = m_qosflowtobeforwardeditem;
   numofqosflowtobeforwardeditem = num;
-    }
-    bool QosFlowToBeForwardedList::encodeQosFlowToBeForwardedList(Ngap_QosFlowToBeForwardedList *&m_ngap_qosflowtobeforwardedlist)
-    {
-        m_ngap_qosflowtobeforwardedlist = (Ngap_QosFlowToBeForwardedList_t *)calloc(1, sizeof(Ngap_QosFlowToBeForwardedList_t));
-        for (int i = 0; i < numofqosflowtobeforwardeditem; i++)
-        {
+}
+bool QosFlowToBeForwardedList::encodeQosFlowToBeForwardedList(
+    Ngap_QosFlowToBeForwardedList *&m_ngap_qosflowtobeforwardedlist) {
+  m_ngap_qosflowtobeforwardedlist = (Ngap_QosFlowToBeForwardedList_t*) calloc(
+      1, sizeof(Ngap_QosFlowToBeForwardedList_t));
+  for (int i = 0; i < numofqosflowtobeforwardeditem; i++) {
     cout << "encoding list..." << endl;
-            Ngap_QosFlowToBeForwardedItem_t *response = (Ngap_QosFlowToBeForwardedItem_t *)calloc(1, sizeof(Ngap_QosFlowToBeForwardedItem_t));
+    Ngap_QosFlowToBeForwardedItem_t *response =
+        (Ngap_QosFlowToBeForwardedItem_t*) calloc(
+            1, sizeof(Ngap_QosFlowToBeForwardedItem_t));
     if (!response)
       return false;
-            if (!Qosflowtobeforwardeditem[i].encodeQosFlowToBeForwardedItem(response))
-            {
+    if (!Qosflowtobeforwardeditem[i].encodeQosFlowToBeForwardedItem(response)) {
       cout << "encode QosFlowTowardedItem error" << endl;
       return false;
     }
     cout << "QFI is " << response->qosFlowIdentifier << endl;
-            if (ASN_SEQUENCE_ADD(&m_ngap_qosflowtobeforwardedlist->list, response) != 0)
-            {
+    if (ASN_SEQUENCE_ADD(&m_ngap_qosflowtobeforwardedlist->list, response)
+        != 0) {
       cout << "encode QosFlowTowardedList error" << endl;
       return false;
     }
   }
   return true;
-    }
+}
 }  // namespace ngap

src/ngap/ngapIEs/QosFlowToBeForwardedList.hpp

@@ -29,23 +29,22 @@
 #define _QOSFLOWTOBEFORWARDEDLIST_H_
 
 #include "QosFlowToBeForwardedItem.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_QosFlowToBeForwardedList.h"
 }
-namespace ngap
-{
-    class QosFlowToBeForwardedList
-    {
+namespace ngap {
+class QosFlowToBeForwardedList {
  public:
   QosFlowToBeForwardedList();
   virtual ~QosFlowToBeForwardedList();
-        void setQosFlowToBeForwardedItem(QosFlowToBeForwardedItem *m_qosflowtobeforwardeditem, int num);
-        bool encodeQosFlowToBeForwardedList(Ngap_QosFlowToBeForwardedList *&m_ngap_qosflowtobeforwardedlist);
+  void setQosFlowToBeForwardedItem(
+      QosFlowToBeForwardedItem *m_qosflowtobeforwardeditem, int num);
+  bool encodeQosFlowToBeForwardedList(
+      Ngap_QosFlowToBeForwardedList *&m_ngap_qosflowtobeforwardedlist);
 
  private:
   QosFlowToBeForwardedItem *Qosflowtobeforwardeditem;
   int numofqosflowtobeforwardeditem;
-    };
+};
 }  // namespace ngap
 #endif

src/ngap/ngapIEs/RANStatusTransferTransparentContainer.cpp

@@ -30,38 +30,37 @@
 #include <vector>
 using namespace std;
 
-namespace ngap
-{
-    RANStatusTransferTransparentContainer::RANStatusTransferTransparentContainer()
-    {
+namespace ngap {
+RANStatusTransferTransparentContainer::RANStatusTransferTransparentContainer() {
   drb_sub_list = NULL;
-    }
-    RANStatusTransferTransparentContainer::~RANStatusTransferTransparentContainer() {}
-    void RANStatusTransferTransparentContainer::getdRBSubject_list(dRBSubjectList *&drblist)
-    {
+}
+RANStatusTransferTransparentContainer::~RANStatusTransferTransparentContainer() {
+}
+void RANStatusTransferTransparentContainer::getdRBSubject_list(
+    dRBSubjectList *&drblist) {
   drblist = drb_sub_list;
-    }
-    void RANStatusTransferTransparentContainer::setdRBSubject_list(dRBSubjectList *drblist)
-    {
+}
+void RANStatusTransferTransparentContainer::setdRBSubject_list(
+    dRBSubjectList *drblist) {
   drb_sub_list = drblist;
-    }
-    bool RANStatusTransferTransparentContainer::encoderanstatustransfer_transparentcontainer(Ngap_RANStatusTransfer_TransparentContainer_t *ranstatustransfer_transparentcontainer)
-    {
-        if (!drb_sub_list->encodefromdRBSubjectlist(ranstatustransfer_transparentcontainer->dRBsSubjectToStatusTransferList))
-        {
+}
+bool RANStatusTransferTransparentContainer::encoderanstatustransfer_transparentcontainer(
+    Ngap_RANStatusTransfer_TransparentContainer_t *ranstatustransfer_transparentcontainer) {
+  if (!drb_sub_list->encodefromdRBSubjectlist(
+      ranstatustransfer_transparentcontainer->dRBsSubjectToStatusTransferList)) {
     cout << "encoderanstatustransfer_transparentcontainer error" << endl;
     return false;
   }
   return true;
-    }
-    bool RANStatusTransferTransparentContainer::decoderanstatustransfer_transparentcontainer(Ngap_RANStatusTransfer_TransparentContainer_t *ranstatustransfer_transparentcontainer)
-    {
+}
+bool RANStatusTransferTransparentContainer::decoderanstatustransfer_transparentcontainer(
+    Ngap_RANStatusTransfer_TransparentContainer_t *ranstatustransfer_transparentcontainer) {
   drb_sub_list = new dRBSubjectList();
-        if (!drb_sub_list->decodefromdRBSubjectlist(ranstatustransfer_transparentcontainer->dRBsSubjectToStatusTransferList))
-        {
+  if (!drb_sub_list->decodefromdRBSubjectlist(
+      ranstatustransfer_transparentcontainer->dRBsSubjectToStatusTransferList)) {
     cout << "decoderanstatustransfer_transparentcontainer error" << endl;
     return false;
   }
   return true;
-    }
+}
 }  // namespace ngap

src/ngap/ngapIEs/RANStatusTransferTransparentContainer.hpp

@@ -29,14 +29,11 @@
 #define _RANSTATUSTRANSFERTRANSPATENTCONTAINER_H_
 #include "dRBsSubjectToStatusTransferList.hpp"
 #include "dRBsSubjectToStatusTransferItem.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_RANStatusTransfer-TransparentContainer.h"
 }
-namespace ngap
-{
-    class RANStatusTransferTransparentContainer
-    {
+namespace ngap {
+class RANStatusTransferTransparentContainer {
  private:
   /* data */
   dRBSubjectList *drb_sub_list;
@@ -46,9 +43,11 @@ namespace ngap
   virtual ~RANStatusTransferTransparentContainer();
   void getdRBSubject_list(dRBSubjectList *&drblist);
   void setdRBSubject_list(dRBSubjectList *drblist);
-        bool encoderanstatustransfer_transparentcontainer(Ngap_RANStatusTransfer_TransparentContainer_t *ranstatustransfer_transparentcontainer);
-        bool decoderanstatustransfer_transparentcontainer(Ngap_RANStatusTransfer_TransparentContainer_t *ranstatustransfer_transparentcontainer);
-    };
+  bool encoderanstatustransfer_transparentcontainer(
+      Ngap_RANStatusTransfer_TransparentContainer_t *ranstatustransfer_transparentcontainer);
+  bool decoderanstatustransfer_transparentcontainer(
+      Ngap_RANStatusTransfer_TransparentContainer_t *ranstatustransfer_transparentcontainer);
+};
 
 }  // namespace ngap
 #endif

src/ngap/ngapIEs/dRBStatusDL.cpp

@@ -29,40 +29,33 @@
 #include <iostream>
 #include <vector>
 using namespace std;
-namespace ngap
-{
-    dRBStatusDL::dRBStatusDL()
-    {
-        dl18 = (DRBStatusDL18 *)calloc(1, sizeof(DRBStatusDL18));
-    }
-    dRBStatusDL::~dRBStatusDL() {}
-    void dRBStatusDL::setDRBStatusDL18(DRBStatusDL18 *dL18)
-    {
+namespace ngap {
+dRBStatusDL::dRBStatusDL() {
+  dl18 = (DRBStatusDL18*) calloc(1, sizeof(DRBStatusDL18));
+}
+dRBStatusDL::~dRBStatusDL() {
+}
+void dRBStatusDL::setDRBStatusDL18(DRBStatusDL18 *dL18) {
   dl18 = dL18;
-    }
-    void dRBStatusDL::getDRBStatusDL18(DRBStatusDL18 *&dL18)
-    {
+}
+void dRBStatusDL::getDRBStatusDL18(DRBStatusDL18 *&dL18) {
   dL18 = dl18;
-    }
-    bool dRBStatusDL::encodedRBStatusDL(Ngap_DRBStatusDL_t *dL)
-    {
-        if (!dl18->encodeddRBStatusDL18(dL->choice.dRBStatusDL18))
-        {
+}
+bool dRBStatusDL::encodedRBStatusDL(Ngap_DRBStatusDL_t *dL) {
+  if (!dl18->encodeddRBStatusDL18(dL->choice.dRBStatusDL18)) {
     cout << "encodedRBStatusDL error" << endl;
     return false;
   }
   cout << "encodedRBStatusDL successfully" << endl;
   return true;
-    }
-    bool dRBStatusDL::decodedRBStatusDL(Ngap_DRBStatusDL_t *dL)
-    {
+}
+bool dRBStatusDL::decodedRBStatusDL(Ngap_DRBStatusDL_t *dL) {
   dl18 = new DRBStatusDL18();
-        if (!dl18->decodeddRBStatusDL18(dL->choice.dRBStatusDL18))
-        {
+  if (!dl18->decodeddRBStatusDL18(dL->choice.dRBStatusDL18)) {
     cout << "decodedRBStatusDL error" << endl;
     return false;
   }
   cout << "decodedRBStatusDL successfully" << endl;
   return true;
-    }
+}
 }  // namespace ngap

src/ngap/ngapIEs/dRBStatusDL.hpp

@@ -28,15 +28,12 @@
 #ifndef _DRBSTATUSDL_H_
 #define _DRBSTATUSDL_H_
 #include "dRBStatusDL18.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_DRBStatusDL.h"
 #include "Ngap_DRBStatusDL18.h"
 }
-namespace ngap
-{
-    class dRBStatusDL
-    {
+namespace ngap {
+class dRBStatusDL {
  private:
   /* data */
   DRBStatusDL18 *dl18;
@@ -48,7 +45,7 @@ namespace ngap
   void setDRBStatusDL18(DRBStatusDL18 *dL18);
   bool encodedRBStatusDL(Ngap_DRBStatusDL_t *dL);
   bool decodedRBStatusDL(Ngap_DRBStatusDL_t *dL);
-    };
+};
 
 }  // namespace ngap
 #endif

src/ngap/ngapIEs/dRBStatusDL18.cpp

@@ -29,38 +29,31 @@
 
 #include <iostream>
 using namespace std;
-namespace ngap
-{
-    DRBStatusDL18::DRBStatusDL18()
-    {
+namespace ngap {
+DRBStatusDL18::DRBStatusDL18() {
   pdcp_value = NULL;
-    }
-    DRBStatusDL18::~DRBStatusDL18() {}
-    void DRBStatusDL18::getcountvalue(COUNTValueForPDCP_SN18 *&count_value)
-    {
+}
+DRBStatusDL18::~DRBStatusDL18() {
+}
+void DRBStatusDL18::getcountvalue(COUNTValueForPDCP_SN18 *&count_value) {
   count_value = pdcp_value;
-    }
-    void DRBStatusDL18::setcountvalue(COUNTValueForPDCP_SN18 *count_value)
-    {
+}
+void DRBStatusDL18::setcountvalue(COUNTValueForPDCP_SN18 *count_value) {
   pdcp_value = count_value;
-    }
-    bool DRBStatusDL18::encodeddRBStatusDL18(Ngap_DRBStatusDL18_t *DL18)
-    {
-        if (!pdcp_value->encodedCOUNTValueForPDCP_SN18(DL18->dL_COUNTValue))
-        {
+}
+bool DRBStatusDL18::encodeddRBStatusDL18(Ngap_DRBStatusDL18_t *DL18) {
+  if (!pdcp_value->encodedCOUNTValueForPDCP_SN18(DL18->dL_COUNTValue)) {
     cout << "encodeddRBStatusDL18 error" << endl;
     return false;
   }
   return true;
-    }
-    bool DRBStatusDL18::decodeddRBStatusDL18(Ngap_DRBStatusDL18_t *DL18)
-    {
+}
+bool DRBStatusDL18::decodeddRBStatusDL18(Ngap_DRBStatusDL18_t *DL18) {
   pdcp_value = new COUNTValueForPDCP_SN18();
-        if (!pdcp_value->decodedCOUNTValueForPDCP_SN18(DL18->dL_COUNTValue))
-        {
+  if (!pdcp_value->decodedCOUNTValueForPDCP_SN18(DL18->dL_COUNTValue)) {
     cout << "decodeddRBStatusDL18 error" << endl;
     return false;
   }
   return true;
-    }
+}
 }  // namespace ngap

src/ngap/ngapIEs/dRBStatusDL18.hpp

@@ -28,14 +28,11 @@
 #ifndef _DRBSTATUSDL18_H_
 #define _DRBSTATUSDL18_H_
 #include "COUNTValueForPDCP_SN18.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_DRBStatusDL18.h"
 }
-namespace ngap
-{
-    class DRBStatusDL18
-    {
+namespace ngap {
+class DRBStatusDL18 {
  private:
   /* data */
   COUNTValueForPDCP_SN18 *pdcp_value;
@@ -47,6 +44,6 @@ namespace ngap
   void setcountvalue(COUNTValueForPDCP_SN18 *count_value);
   bool encodeddRBStatusDL18(Ngap_DRBStatusDL18_t *DL18);
   bool decodeddRBStatusDL18(Ngap_DRBStatusDL18_t *DL18);
-    };
+};
 }  // namespace ngap
 #endif

src/ngap/ngapIEs/dRBStatusUL.cpp

@@ -30,40 +30,33 @@
 #include <vector>
 using namespace std;
 
-namespace ngap
-{
-    dRBStatusUL::dRBStatusUL()
-    {
-        ul18 = (dRBStatusUL18 *)calloc(1, sizeof(dRBStatusUL18));
-    }
-    dRBStatusUL::~dRBStatusUL() {}
-    void dRBStatusUL::setdRBStatusUL(dRBStatusUL18 *uL18)
-    {
+namespace ngap {
+dRBStatusUL::dRBStatusUL() {
+  ul18 = (dRBStatusUL18*) calloc(1, sizeof(dRBStatusUL18));
+}
+dRBStatusUL::~dRBStatusUL() {
+}
+void dRBStatusUL::setdRBStatusUL(dRBStatusUL18 *uL18) {
   ul18 = uL18;
-    }
-    void dRBStatusUL::getdRBStatusUL(dRBStatusUL18 *&uL18)
-    {
+}
+void dRBStatusUL::getdRBStatusUL(dRBStatusUL18 *&uL18) {
   uL18 = ul18;
-    }
-    bool dRBStatusUL::encodedRBStatusUL(Ngap_DRBStatusUL_t *uL)
-    {
-        if (ul18->encodeddRBStatusUL18(uL->choice.dRBStatusUL18))
-        {
+}
+bool dRBStatusUL::encodedRBStatusUL(Ngap_DRBStatusUL_t *uL) {
+  if (ul18->encodeddRBStatusUL18(uL->choice.dRBStatusUL18)) {
     cout << "encodeddRBStatusUL18 error" << endl;
     return false;
   }
   cout << "encodedRBStatusUL successfully" << endl;
   return true;
-    }
-    bool dRBStatusUL::decodedRBStatusUL(Ngap_DRBStatusUL_t *uL)
-    {
+}
+bool dRBStatusUL::decodedRBStatusUL(Ngap_DRBStatusUL_t *uL) {
   ul18 = new dRBStatusUL18();
-        if (!ul18->decodeddRBStatusUL18(uL->choice.dRBStatusUL18))
-        {
+  if (!ul18->decodeddRBStatusUL18(uL->choice.dRBStatusUL18)) {
     cout << "decodeddRBStatusUL18 error" << endl;
     return false;
   }
   cout << "decodedRBStatusUL successfully" << endl;
   return true;
-    }
+}
 }  // namespace ngap

src/ngap/ngapIEs/dRBStatusUL.hpp

@@ -28,14 +28,11 @@
 #ifndef _DRBSTATUSUL_H_
 #define _DRBSTATUSUL_H_
 #include "dRBStatusUL18.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_DRBStatusUL.h"
 }
-namespace ngap
-{
-    class dRBStatusUL
-    {
+namespace ngap {
+class dRBStatusUL {
  private:
   /* data */
   dRBStatusUL18 *ul18;
@@ -47,6 +44,6 @@ namespace ngap
   void getdRBStatusUL(dRBStatusUL18 *&uL18);
   bool encodedRBStatusUL(Ngap_DRBStatusUL_t *uL);
   bool decodedRBStatusUL(Ngap_DRBStatusUL_t *uL);
-    };
+};
 }  // namespace ngap
 #endif

src/ngap/ngapIEs/dRBStatusUL18.cpp

@@ -29,38 +29,31 @@
 
 #include <iostream>
 using namespace std;
-namespace ngap
-{
-    dRBStatusUL18::dRBStatusUL18()
-    {
+namespace ngap {
+dRBStatusUL18::dRBStatusUL18() {
   pdcp_value = NULL;
-    }
-    dRBStatusUL18::~dRBStatusUL18() {}
-    void dRBStatusUL18::getcountvalue(COUNTValueForPDCP_SN18 *&count_value)
-    {
+}
+dRBStatusUL18::~dRBStatusUL18() {
+}
+void dRBStatusUL18::getcountvalue(COUNTValueForPDCP_SN18 *&count_value) {
   count_value = pdcp_value;
-    }
-    void dRBStatusUL18::setcountvalue(COUNTValueForPDCP_SN18 *count_value)
-    {
+}
+void dRBStatusUL18::setcountvalue(COUNTValueForPDCP_SN18 *count_value) {
   pdcp_value = count_value;
-    }
-    bool dRBStatusUL18::encodeddRBStatusUL18(Ngap_DRBStatusUL18_t *UL18)
-    {
-        if (!pdcp_value->encodedCOUNTValueForPDCP_SN18(UL18->uL_COUNTValue))
-        {
+}
+bool dRBStatusUL18::encodeddRBStatusUL18(Ngap_DRBStatusUL18_t *UL18) {
+  if (!pdcp_value->encodedCOUNTValueForPDCP_SN18(UL18->uL_COUNTValue)) {
     cout << "encodeddRBStatusUL18 error" << endl;
     return false;
   }
   return true;
-    }
-    bool dRBStatusUL18::decodeddRBStatusUL18(Ngap_DRBStatusUL18_t *UL18)
-    {
+}
+bool dRBStatusUL18::decodeddRBStatusUL18(Ngap_DRBStatusUL18_t *UL18) {
   pdcp_value = new COUNTValueForPDCP_SN18();
-        if (!pdcp_value->decodedCOUNTValueForPDCP_SN18(UL18->uL_COUNTValue))
-        {
+  if (!pdcp_value->decodedCOUNTValueForPDCP_SN18(UL18->uL_COUNTValue)) {
     cout << "decodeddRBStatusUL18 error" << endl;
     return false;
   }
   return true;
-    }
+}
 }  // namespace ngap

src/ngap/ngapIEs/dRBStatusUL18.hpp

@@ -28,14 +28,11 @@
 #ifndef _DRBSTATUSUL18_H_
 #define _DRBSTATUSUL18_H_
 #include "COUNTValueForPDCP_SN18.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_DRBStatusUL18.h"
 }
-namespace ngap
-{
-    class dRBStatusUL18
-    {
+namespace ngap {
+class dRBStatusUL18 {
  private:
   /* data */
   COUNTValueForPDCP_SN18 *pdcp_value;
@@ -47,7 +44,7 @@ namespace ngap
   void setcountvalue(COUNTValueForPDCP_SN18 *count_value);
   bool encodeddRBStatusUL18(Ngap_DRBStatusUL18_t *UL18);
   bool decodeddRBStatusUL18(Ngap_DRBStatusUL18_t *UL18);
-    };
+};
 
 }  // namespace ngap
 #endif

src/ngap/ngapIEs/dRBsSubjectToStatusTransferItem.cpp

@@ -31,67 +31,62 @@
 #include <vector>
 
 using namespace std;
-namespace ngap
-{
-    dRBSubjectItem::dRBSubjectItem()
-    {
+namespace ngap {
+dRBSubjectItem::dRBSubjectItem() {
   drb_id = NULL;
   drb_ul = NULL;
   drb_dl = NULL;
-    }
-    dRBSubjectItem::~dRBSubjectItem() {}
-    void dRBSubjectItem::setdRBSubjectItem(Ngap_DRB_ID_t *dRB_ID, dRBStatusUL *dRB_UL, dRBStatusDL *dRB_DL)
-    {
+}
+dRBSubjectItem::~dRBSubjectItem() {
+}
+void dRBSubjectItem::setdRBSubjectItem(Ngap_DRB_ID_t *dRB_ID,
+                                       dRBStatusUL *dRB_UL,
+                                       dRBStatusDL *dRB_DL) {
   drb_id = dRB_ID;
   drb_ul = dRB_UL;
   drb_dl = dRB_DL;
-    }
-    void dRBSubjectItem::getdRBSubjectItem(Ngap_DRB_ID_t *&dRB_ID, dRBStatusUL *&dRB_UL, dRBStatusDL *&dRB_DL)
-    {
+}
+void dRBSubjectItem::getdRBSubjectItem(Ngap_DRB_ID_t *&dRB_ID,
+                                       dRBStatusUL *&dRB_UL,
+                                       dRBStatusDL *&dRB_DL) {
   dRB_ID = drb_id;
   dRB_UL = drb_ul;
   dRB_DL = drb_dl;
-    }
-    bool dRBSubjectItem::decodefromdRBSubjectItem(Ngap_DRBsSubjectToStatusTransferItem_t *dRB_item)
-    {
-        if (dRB_item->dRB_ID)
-        {
+}
+bool dRBSubjectItem::decodefromdRBSubjectItem(
+    Ngap_DRBsSubjectToStatusTransferItem_t *dRB_item) {
+  if (dRB_item->dRB_ID) {
     drb_id = &dRB_item->dRB_ID;
     cout << "the decode drb_id is" << *drb_id << endl;
   }
   drb_ul = new dRBStatusUL();
-        if (!drb_ul->decodedRBStatusUL(&dRB_item->dRBStatusUL))
-        {
+  if (!drb_ul->decodedRBStatusUL(&dRB_item->dRBStatusUL)) {
     cout << "decode from dRBSubjectItem  dRBStatusUL error" << endl;
     return false;
   }
   drb_dl = new dRBStatusDL();
-        if (!drb_dl->decodedRBStatusDL(&dRB_item->dRBStatusDL))
-        {
+  if (!drb_dl->decodedRBStatusDL(&dRB_item->dRBStatusDL)) {
     cout << "decode from dRBSubjectItem  dRBStatusDL error" << endl;
     return false;
   }
   cout << "decode from dRBSubjectItem  successfully" << endl;
   return true;
-    }
-    bool dRBSubjectItem::encodedRBSubjectItem(Ngap_DRBsSubjectToStatusTransferItem_t *dRB_item)
-    {
-        if (drb_id)
-        {
+}
+bool dRBSubjectItem::encodedRBSubjectItem(
+    Ngap_DRBsSubjectToStatusTransferItem_t *dRB_item) {
+  if (drb_id) {
     dRB_item->dRB_ID = *drb_id;
     cout << "the encode drb_id is" << *drb_id << endl;
   }
-        if (!drb_ul->encodedRBStatusUL(&dRB_item->dRBStatusUL))
-        {
+  if (!drb_ul->encodedRBStatusUL(&dRB_item->dRBStatusUL)) {
     cout << "encode from dRBSubjectItem  dRBStatusUL error" << endl;
     return false;
   }
-        if (!drb_dl->encodedRBStatusDL(&dRB_item->dRBStatusDL))
-        {
+  if (!drb_dl->encodedRBStatusDL(&dRB_item->dRBStatusDL)) {
     cout << "encode from dRBSubjectItem  dRBStatusDL error" << endl;
     return false;
   }
   cout << "encode from dRBSubjectItem  successfully" << endl;
   return true;
-    }
+}
 }  // namespace ngap

src/ngap/ngapIEs/dRBsSubjectToStatusTransferItem.hpp

@@ -29,26 +29,26 @@
 #define _DRBSSUBJECTTOSTATUSTRANSFERITEM_H_
 #include "dRBStatusUL.hpp"
 #include "dRBStatusDL.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_DRBsSubjectToStatusTransferItem.h"
 }
-namespace ngap
-{
-    class dRBSubjectItem
-    {
+namespace ngap {
+class dRBSubjectItem {
  public:
   dRBSubjectItem();
   virtual ~dRBSubjectItem();
-        void getdRBSubjectItem(Ngap_DRB_ID_t *&dRB_ID, dRBStatusUL *&dRB_UL, dRBStatusDL *&dRB_DL);
-        void setdRBSubjectItem(Ngap_DRB_ID_t *dRB_ID, dRBStatusUL *dRB_UL, dRBStatusDL *dRB_DL);
-        bool decodefromdRBSubjectItem(Ngap_DRBsSubjectToStatusTransferItem_t *dRB_item);
+  void getdRBSubjectItem(Ngap_DRB_ID_t *&dRB_ID, dRBStatusUL *&dRB_UL,
+                         dRBStatusDL *&dRB_DL);
+  void setdRBSubjectItem(Ngap_DRB_ID_t *dRB_ID, dRBStatusUL *dRB_UL,
+                         dRBStatusDL *dRB_DL);
+  bool decodefromdRBSubjectItem(
+      Ngap_DRBsSubjectToStatusTransferItem_t *dRB_item);
   bool encodedRBSubjectItem(Ngap_DRBsSubjectToStatusTransferItem_t *dRB_item);
 
  private:
   Ngap_DRB_ID_t *drb_id;
   dRBStatusUL *drb_ul;
   dRBStatusDL *drb_dl;
-    };
+};
 }  // namespace ngap
 #endif

src/ngap/ngapIEs/dRBsSubjectToStatusTransferList.cpp

@@ -29,58 +29,55 @@
 #include <iostream>
 #include <vector>
 using namespace std;
-namespace ngap
-{
-    dRBSubjectList::dRBSubjectList()
-    {
+namespace ngap {
+dRBSubjectList::dRBSubjectList() {
   drbsubjectitem = NULL;
   numofitem = 0;
-    }
-    dRBSubjectList::~dRBSubjectList() {}
-    void dRBSubjectList::setdRBSubjectItem(dRBSubjectItem *m_item, int num)
-    {
+}
+dRBSubjectList::~dRBSubjectList() {
+}
+void dRBSubjectList::setdRBSubjectItem(dRBSubjectItem *m_item, int num) {
   drbsubjectitem = m_item;
   numofitem = num;
-    }
-    void dRBSubjectList::getdRBSubjectItem(dRBSubjectItem *&m_item, int &num)
-    {
+}
+void dRBSubjectList::getdRBSubjectItem(dRBSubjectItem *&m_item, int &num) {
   m_item = drbsubjectitem;
   num = numofitem;
-    }
-    bool dRBSubjectList::encodefromdRBSubjectlist(Ngap_DRBsSubjectToStatusTransferList_t &DRBsSubjectToStatusTransferList)
-    {
-        for (int i = 0; i < numofitem; i++)
-        {
-            Ngap_DRBsSubjectToStatusTransferItem_t *ie = (Ngap_DRBsSubjectToStatusTransferItem_t *)calloc(1, sizeof(Ngap_DRBsSubjectToStatusTransferItem_t));
+}
+bool dRBSubjectList::encodefromdRBSubjectlist(
+    Ngap_DRBsSubjectToStatusTransferList_t &DRBsSubjectToStatusTransferList) {
+  for (int i = 0; i < numofitem; i++) {
+    Ngap_DRBsSubjectToStatusTransferItem_t *ie =
+        (Ngap_DRBsSubjectToStatusTransferItem_t*) calloc(
+            1, sizeof(Ngap_DRBsSubjectToStatusTransferItem_t));
     if (!ie)
       return false;
-            if (!drbsubjectitem[i].encodedRBSubjectItem(ie))
-            {
+    if (!drbsubjectitem[i].encodedRBSubjectItem(ie)) {
       cout << "encodefromdRBSubjectlist error" << endl;
       return false;
     }
-            if (ASN_SEQUENCE_ADD(&DRBsSubjectToStatusTransferList.list, ie) != 0)
-            {
-                cout << "ASN_SEQUENCE_ADD(&DRBsSubjectToStatusTransferList.list, ie) error" << endl;
+    if (ASN_SEQUENCE_ADD(&DRBsSubjectToStatusTransferList.list, ie) != 0) {
+      cout
+          << "ASN_SEQUENCE_ADD(&DRBsSubjectToStatusTransferList.list, ie) error"
+          << endl;
       return false;
     }
   }
   cout << "encodefromdRBSubjectlist successfully" << endl;
   return true;
-    }
-    bool dRBSubjectList::decodefromdRBSubjectlist(Ngap_DRBsSubjectToStatusTransferList_t &DRBsSubjectToStatusTransferList)
-    {
+}
+bool dRBSubjectList::decodefromdRBSubjectlist(
+    Ngap_DRBsSubjectToStatusTransferList_t &DRBsSubjectToStatusTransferList) {
   numofitem = DRBsSubjectToStatusTransferList.list.count;
   drbsubjectitem = new dRBSubjectItem[numofitem]();
-        for (int i = 0; i < numofitem; i++)
-        {
-            if (!drbsubjectitem[i].decodefromdRBSubjectItem(DRBsSubjectToStatusTransferList.list.array[i]))
-            {
+  for (int i = 0; i < numofitem; i++) {
+    if (!drbsubjectitem[i].decodefromdRBSubjectItem(
+        DRBsSubjectToStatusTransferList.list.array[i])) {
       cout << "decodefromdRBSubjectlist error" << endl;
       return false;
     }
   }
   cout << "decodefromdRBSubjectlist successfully" << endl;
   return true;
-    }
+}
 }  // namespace ngap

src/ngap/ngapIEs/dRBsSubjectToStatusTransferList.hpp

@@ -28,26 +28,25 @@
 #ifndef _DRBSSUBJECTTOSTATUSTRANSFERLIST_H_
 #define _DRBSSUBJECTTOSTATUSTRANSFERLIST_H_
 #include "dRBsSubjectToStatusTransferItem.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_DRBsSubjectToStatusTransferList.h"
 #include "asn_SEQUENCE_OF.h"
 }
-namespace ngap
-{
-    class dRBSubjectList
-    {
+namespace ngap {
+class dRBSubjectList {
  public:
   dRBSubjectList();
   virtual ~dRBSubjectList();
   void setdRBSubjectItem(dRBSubjectItem *m_item, int num);
   void getdRBSubjectItem(dRBSubjectItem *&m_item, int &num);
-        bool decodefromdRBSubjectlist(Ngap_DRBsSubjectToStatusTransferList_t &DRBsSubjectToStatusTransferList);
-        bool encodefromdRBSubjectlist(Ngap_DRBsSubjectToStatusTransferList_t &DRBsSubjectToStatusTransferList);
+  bool decodefromdRBSubjectlist(
+      Ngap_DRBsSubjectToStatusTransferList_t &DRBsSubjectToStatusTransferList);
+  bool encodefromdRBSubjectlist(
+      Ngap_DRBsSubjectToStatusTransferList_t &DRBsSubjectToStatusTransferList);
 
  private:
   dRBSubjectItem *drbsubjectitem;
   int numofitem;
-    };
+};
 }  // namespace ngap
 #endif

src/ngap/ngapMsgs/DownlinkRANStatusTransfer.cpp

@@ -29,33 +29,31 @@
 #include <iostream>
 #include <vector>
 using namespace std;
-namespace ngap
-{
-    DownlinkRANStatusTransfer::DownlinkRANStatusTransfer()
-    {
+namespace ngap {
+DownlinkRANStatusTransfer::DownlinkRANStatusTransfer() {
   amfUeNgapId = NULL;
   ranUeNgapId = NULL;
   ranStatusTransfer_TransparentContainer = NULL;
   DownlinkranstatustransferIEs = NULL;
   DownlinkranstatustransferPDU = NULL;
-    }
-    DownlinkRANStatusTransfer::~DownlinkRANStatusTransfer()
-    {
-    }
-    void DownlinkRANStatusTransfer::setAmfUeNgapId(unsigned long id)
-    {
+}
+DownlinkRANStatusTransfer::~DownlinkRANStatusTransfer() {
+}
+void DownlinkRANStatusTransfer::setAmfUeNgapId(unsigned long id) {
   if (!amfUeNgapId)
     amfUeNgapId = new AMF_UE_NGAP_ID();
   amfUeNgapId->setAMF_UE_NGAP_ID(id);
 
-        Ngap_DownlinkRANStatusTransferIEs_t *ie = (Ngap_DownlinkRANStatusTransferIEs_t *)calloc(1, sizeof(Ngap_DownlinkRANStatusTransferIEs_t));
+  Ngap_DownlinkRANStatusTransferIEs_t *ie =
+      (Ngap_DownlinkRANStatusTransferIEs_t*) calloc(
+          1, sizeof(Ngap_DownlinkRANStatusTransferIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_AMF_UE_NGAP_ID;
   ie->criticality = Ngap_Criticality_reject;
-        ie->value.present = Ngap_DownlinkRANStatusTransferIEs__value_PR_AMF_UE_NGAP_ID;
+  ie->value.present =
+      Ngap_DownlinkRANStatusTransferIEs__value_PR_AMF_UE_NGAP_ID;
 
   int ret = amfUeNgapId->encode2AMF_UE_NGAP_ID(ie->value.choice.AMF_UE_NGAP_ID);
-        if (!ret)
-        {
+  if (!ret) {
     cout << "encode AMF_UE_NGAP_ID IE error" << endl;
     return;
   }
@@ -63,21 +61,22 @@ namespace ngap
   ret = ASN_SEQUENCE_ADD(&DownlinkranstatustransferIEs->protocolIEs.list, ie);
   if (ret != 0)
     cout << "encode AMF_UE_NGAP_ID IE error" << endl;
-    }
-    void DownlinkRANStatusTransfer::setRanUeNgapId(uint32_t id)
-    {
+}
+void DownlinkRANStatusTransfer::setRanUeNgapId(uint32_t id) {
   if (!ranUeNgapId)
     ranUeNgapId = new RAN_UE_NGAP_ID();
   ranUeNgapId->setRanUeNgapId(id);
 
-        Ngap_DownlinkRANStatusTransferIEs_t *ie = (Ngap_DownlinkRANStatusTransferIEs_t *)calloc(1, sizeof(Ngap_DownlinkRANStatusTransferIEs_t));
+  Ngap_DownlinkRANStatusTransferIEs_t *ie =
+      (Ngap_DownlinkRANStatusTransferIEs_t*) calloc(
+          1, sizeof(Ngap_DownlinkRANStatusTransferIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_RAN_UE_NGAP_ID;
   ie->criticality = Ngap_Criticality_reject;
-        ie->value.present = Ngap_DownlinkRANStatusTransferIEs__value_PR_RAN_UE_NGAP_ID;
+  ie->value.present =
+      Ngap_DownlinkRANStatusTransferIEs__value_PR_RAN_UE_NGAP_ID;
 
   int ret = ranUeNgapId->encode2RAN_UE_NGAP_ID(ie->value.choice.RAN_UE_NGAP_ID);
-        if (!ret)
-        {
+  if (!ret) {
     cout << "encode RAN_UE_NGAP_ID IE error" << endl;
     return;
   }
@@ -85,72 +84,86 @@ namespace ngap
   ret = ASN_SEQUENCE_ADD(&DownlinkranstatustransferIEs->protocolIEs.list, ie);
   if (ret != 0)
     cout << "encode RAN_UE_NGAP_ID IE error" << endl;
+}
+void DownlinkRANStatusTransfer::setRANStatusTransfer_TransparentContainer(
+    long drb_id, long ul_pcdp, long ul_hfn_pdcp, long dl_pcdp,
+    long dl_hfn_pdcp) {
+  if (!ranStatusTransfer_TransparentContainer) {
+    ranStatusTransfer_TransparentContainer =
+        new RANStatusTransferTransparentContainer();
   }
-    void DownlinkRANStatusTransfer::setRANStatusTransfer_TransparentContainer(long drb_id, long ul_pcdp, long ul_hfn_pdcp, long dl_pcdp, long dl_hfn_pdcp)
-    {
-        if (!ranStatusTransfer_TransparentContainer)
-        {
-            ranStatusTransfer_TransparentContainer = new RANStatusTransferTransparentContainer();
-        }
-        Ngap_DRB_ID_t *dRB_id = (Ngap_DRB_ID_t *)calloc(1, sizeof(Ngap_DRB_ID_t));
+  Ngap_DRB_ID_t *dRB_id = (Ngap_DRB_ID_t*) calloc(1, sizeof(Ngap_DRB_ID_t));
   dRB_id = &drb_id;
-        COUNTValueForPDCP_SN18 *UL_value = (COUNTValueForPDCP_SN18 *)calloc(1, sizeof(COUNTValueForPDCP_SN18));
+  COUNTValueForPDCP_SN18 *UL_value = (COUNTValueForPDCP_SN18*) calloc(
+      1, sizeof(COUNTValueForPDCP_SN18));
   UL_value->setvalue(ul_pcdp, ul_hfn_pdcp);
-        COUNTValueForPDCP_SN18 *DL_value = (COUNTValueForPDCP_SN18 *)calloc(1, sizeof(COUNTValueForPDCP_SN18));
+  COUNTValueForPDCP_SN18 *DL_value = (COUNTValueForPDCP_SN18*) calloc(
+      1, sizeof(COUNTValueForPDCP_SN18));
   DL_value->setvalue(dl_pcdp, dl_hfn_pdcp);
-        dRBStatusUL18 *UL18 = (dRBStatusUL18 *)calloc(1, sizeof(dRBStatusUL18));
+  dRBStatusUL18 *UL18 = (dRBStatusUL18*) calloc(1, sizeof(dRBStatusUL18));
   UL18->setcountvalue(UL_value);
-        DRBStatusDL18 *DL18 = (DRBStatusDL18 *)calloc(1, sizeof(DRBStatusDL18));
+  DRBStatusDL18 *DL18 = (DRBStatusDL18*) calloc(1, sizeof(DRBStatusDL18));
   DL18->setcountvalue(DL_value);
-        dRBStatusDL *DL = (dRBStatusDL *)calloc(1, sizeof(dRBStatusDL));
+  dRBStatusDL *DL = (dRBStatusDL*) calloc(1, sizeof(dRBStatusDL));
   DL->setDRBStatusDL18(DL18);
-        dRBStatusUL *UL = (dRBStatusUL *)calloc(1, sizeof(dRBStatusUL));
+  dRBStatusUL *UL = (dRBStatusUL*) calloc(1, sizeof(dRBStatusUL));
   UL->setdRBStatusUL(UL18);
-        dRBSubjectItem *m_item = (dRBSubjectItem *)calloc(1, sizeof(dRBSubjectItem));
+  dRBSubjectItem *m_item = (dRBSubjectItem*) calloc(1, sizeof(dRBSubjectItem));
   m_item->setdRBSubjectItem(dRB_id, UL, DL);
-        dRBSubjectList *m_list = (dRBSubjectList *)calloc(1, sizeof(dRBSubjectList));
+  dRBSubjectList *m_list = (dRBSubjectList*) calloc(1, sizeof(dRBSubjectList));
   m_list->setdRBSubjectItem(m_item, 1);
   ranStatusTransfer_TransparentContainer->setdRBSubject_list(m_list);
-        Ngap_DownlinkRANStatusTransferIEs_t *ie = (Ngap_DownlinkRANStatusTransferIEs_t *)calloc(1, sizeof(Ngap_DownlinkRANStatusTransferIEs_t));
+  Ngap_DownlinkRANStatusTransferIEs_t *ie =
+      (Ngap_DownlinkRANStatusTransferIEs_t*) calloc(
+          1, sizeof(Ngap_DownlinkRANStatusTransferIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_RANStatusTransfer_TransparentContainer;
   ie->criticality = Ngap_Criticality_reject;
-        ie->value.present = Ngap_DownlinkRANStatusTransferIEs__value_PR_RANStatusTransfer_TransparentContainer;
-        bool ret = ranStatusTransfer_TransparentContainer->encoderanstatustransfer_transparentcontainer(&ie->value.choice.RANStatusTransfer_TransparentContainer);
-        if (!ret)
-        {
+  ie->value.present =
+      Ngap_DownlinkRANStatusTransferIEs__value_PR_RANStatusTransfer_TransparentContainer;
+  bool ret = ranStatusTransfer_TransparentContainer
+      ->encoderanstatustransfer_transparentcontainer(
+      &ie->value.choice.RANStatusTransfer_TransparentContainer);
+  if (!ret) {
     cout << "encode ranstatustransfer_transparentcontainer error" << endl;
   }
-        if (ASN_SEQUENCE_ADD(&DownlinkranstatustransferIEs->protocolIEs.list, ie) != 0)
-        {
+  if (ASN_SEQUENCE_ADD(&DownlinkranstatustransferIEs->protocolIEs.list, ie)
+      != 0) {
     cout << "encode ranstatustransfer_transparentcontainer error 2" << endl;
   }
-    }
-    void DownlinkRANStatusTransfer::setmessagetype()
-    {
-        if (!DownlinkranstatustransferPDU)
-        {
-            DownlinkranstatustransferPDU = (Ngap_NGAP_PDU_t *)calloc(1, sizeof(Ngap_NGAP_PDU_t));
+}
+void DownlinkRANStatusTransfer::setmessagetype() {
+  if (!DownlinkranstatustransferPDU) {
+    DownlinkranstatustransferPDU = (Ngap_NGAP_PDU_t*) calloc(
+        1, sizeof(Ngap_NGAP_PDU_t));
   }
   MessageType downlinkranstatustransfermessageIEs;
-        downlinkranstatustransfermessageIEs.setProcedureCode(Ngap_ProcedureCode_id_DownlinkRANStatusTransfer);
-        downlinkranstatustransfermessageIEs.setTypeOfMessage(Ngap_NGAP_PDU_PR_initiatingMessage);
+  downlinkranstatustransfermessageIEs.setProcedureCode(
+      Ngap_ProcedureCode_id_DownlinkRANStatusTransfer);
+  downlinkranstatustransfermessageIEs.setTypeOfMessage(
+      Ngap_NGAP_PDU_PR_initiatingMessage);
   downlinkranstatustransfermessageIEs.setCriticality(Ngap_Criticality_ignore);
-        downlinkranstatustransfermessageIEs.setValuePresent(Ngap_InitiatingMessage__value_PR_DownlinkRANStatusTransfer);
-        if (downlinkranstatustransfermessageIEs.getProcedureCode() == Ngap_ProcedureCode_id_DownlinkRANStatusTransfer && downlinkranstatustransfermessageIEs.getTypeOfMessage() == Ngap_NGAP_PDU_PR_initiatingMessage)
-        {
-            downlinkranstatustransfermessageIEs.encode2pdu(DownlinkranstatustransferPDU);
-            DownlinkranstatustransferIEs = &(DownlinkranstatustransferPDU->choice.initiatingMessage->value.choice.DownlinkRANStatusTransfer);
-        }
-        else
-        {
-            cout << "[warning] This information doesn't refer to downlinkranstatustransfer Message!!!" << endl;
+  downlinkranstatustransfermessageIEs.setValuePresent(
+      Ngap_InitiatingMessage__value_PR_DownlinkRANStatusTransfer);
+  if (downlinkranstatustransfermessageIEs.getProcedureCode()
+      == Ngap_ProcedureCode_id_DownlinkRANStatusTransfer
+      && downlinkranstatustransfermessageIEs.getTypeOfMessage()
+          == Ngap_NGAP_PDU_PR_initiatingMessage) {
+    downlinkranstatustransfermessageIEs.encode2pdu(
+        DownlinkranstatustransferPDU);
+    DownlinkranstatustransferIEs = &(DownlinkranstatustransferPDU->choice
+        .initiatingMessage->value.choice.DownlinkRANStatusTransfer);
+  } else {
+    cout
+        << "[warning] This information doesn't refer to downlinkranstatustransfer Message!!!"
+        << endl;
   }
-    }
-    int DownlinkRANStatusTransfer::encodetobuffer(uint8_t *buf, int buf_size)
-    {
+}
+int DownlinkRANStatusTransfer::encodetobuffer(uint8_t *buf, int buf_size) {
   asn_fprint(stderr, &asn_DEF_Ngap_NGAP_PDU, DownlinkranstatustransferPDU);
-        asn_enc_rval_t er = aper_encode_to_buffer(&asn_DEF_Ngap_NGAP_PDU, NULL, DownlinkranstatustransferPDU, buf, buf_size);
+  asn_enc_rval_t er = aper_encode_to_buffer(&asn_DEF_Ngap_NGAP_PDU, NULL,
+                                            DownlinkranstatustransferPDU, buf,
+                                            buf_size);
   cout << "er.encoded(" << er.encoded << ")" << endl;
   return er.encoded;
-    }
+}
 }  // namespace ngap

src/ngap/ngapMsgs/DownlinkRANStatusTransfer.hpp

@@ -32,8 +32,7 @@
 #include "MessageType.hpp"
 #include "RANStatusTransferTransparentContainer.hpp"
 #include "dRBStatusDL18.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_UplinkRANStatusTransfer.h"
 #include "Ngap_RANStatusTransfer-TransparentContainer.h"
 #include "Ngap_NGAP-PDU.h"
@@ -43,23 +42,23 @@ extern "C"
 }
 namespace ngap
 {
-    class DownlinkRANStatusTransfer
-    {
-    public:
+class DownlinkRANStatusTransfer
+{
+public:
   DownlinkRANStatusTransfer();
   virtual ~DownlinkRANStatusTransfer();
   void setmessagetype();
   void setAmfUeNgapId(unsigned long id);  //40 bits
-        void setRanUeNgapId(uint32_t id);      // 32 bits
+  void setRanUeNgapId(uint32_t id);// 32 bits
   void setRANStatusTransfer_TransparentContainer(long drb_id, long ul_pcdp, long ul_hfn_pdcp, long dl_pcdp, long dl_hfn_pdcp);
   int encodetobuffer(uint8_t *buf, int buf_size);
 
-    private:
+private:
   Ngap_NGAP_PDU_t *DownlinkranstatustransferPDU;
   Ngap_DownlinkRANStatusTransfer_t *DownlinkranstatustransferIEs;
   AMF_UE_NGAP_ID *amfUeNgapId;
   RAN_UE_NGAP_ID *ranUeNgapId;
   RANStatusTransferTransparentContainer *ranStatusTransfer_TransparentContainer;
-    };
+};
 }  // namespace ngap
 #endif

src/ngap/ngapMsgs/HandoverCommandMsg.cpp

 #include "HandoverCommandMsg.hpp"
-extern "C"{
-  #include "constr_TYPE.h"
-  #include "Ngap_NGAP-PDU.h"
-  #include "asn_codecs.h"
-  #include "per_encoder.h"
-  #include "per_decoder.h"
-  #include "constraints.h"
-  #include "Ngap_PDUSessionResourceHandoverItem.h"
+extern "C" {
+#include "constr_TYPE.h"
+#include "Ngap_NGAP-PDU.h"
+#include "asn_codecs.h"
+#include "per_encoder.h"
+#include "per_decoder.h"
+#include "constraints.h"
+#include "Ngap_PDUSessionResourceHandoverItem.h"
 }
 
 #include <iostream>
@@ -14,10 +14,9 @@ extern "C"{
 
 using namespace std;
 
-namespace ngap{
+namespace ngap {
 
-	HandoverCommandMsg::HandoverCommandMsg()
-	{
+HandoverCommandMsg::HandoverCommandMsg() {
   amfUeNgapId = NULL;
   ranUeNgapId = NULL;
   ngap_handovertype = NULL;
@@ -28,129 +27,139 @@ namespace ngap{
   CriticalityDiagnostics = NULL;
   handoverCommandPdu = NULL;
   handoverCommandIEs = NULL;
-	}
-	HandoverCommandMsg::~HandoverCommandMsg() {}
+}
+HandoverCommandMsg::~HandoverCommandMsg() {
+}
 
-	unsigned long HandoverCommandMsg::getAmfUeNgapId()
-	{
+unsigned long HandoverCommandMsg::getAmfUeNgapId() {
   return amfUeNgapId->getAMF_UE_NGAP_ID();
-	}
+}
 
-	uint32_t HandoverCommandMsg::getRanUeNgapId()
-	{
+uint32_t HandoverCommandMsg::getRanUeNgapId() {
   return ranUeNgapId->getRanUeNgapId();
-	}
+}
 
-	bool HandoverCommandMsg::decodefrompdu(Ngap_NGAP_PDU_t *ngap_msg_pdu)
-	{
+bool HandoverCommandMsg::decodefrompdu(Ngap_NGAP_PDU_t *ngap_msg_pdu) {
   handoverCommandPdu = ngap_msg_pdu;
 
-		if (handoverCommandPdu->present == Ngap_NGAP_PDU_PR_successfulOutcome)
-		{
-			if (handoverCommandPdu->choice.successfulOutcome && handoverCommandPdu->choice.successfulOutcome->procedureCode == Ngap_ProcedureCode_id_HandoverPreparation && handoverCommandPdu->choice.successfulOutcome->criticality == Ngap_Criticality_reject && handoverCommandPdu->choice.successfulOutcome->value.present == Ngap_SuccessfulOutcome__value_PR_HandoverCommand)
-			{
-				handoverCommandIEs = &handoverCommandPdu->choice.successfulOutcome->value.choice.HandoverCommand;
-			}
-			else
-			{
+  if (handoverCommandPdu->present == Ngap_NGAP_PDU_PR_successfulOutcome) {
+    if (handoverCommandPdu->choice.successfulOutcome
+        && handoverCommandPdu->choice.successfulOutcome->procedureCode
+            == Ngap_ProcedureCode_id_HandoverPreparation
+        && handoverCommandPdu->choice.successfulOutcome->criticality
+            == Ngap_Criticality_reject
+        && handoverCommandPdu->choice.successfulOutcome->value.present
+            == Ngap_SuccessfulOutcome__value_PR_HandoverCommand) {
+      handoverCommandIEs = &handoverCommandPdu->choice.successfulOutcome->value
+          .choice.HandoverCommand;
+    } else {
       cout << "Check HandoverCommand message error!!!" << endl;
       return false;
     }
-		}
-		else
-		{
+  } else {
     cout << "HandoverRequired MessageType error!!!" << endl;
     return false;
   }
-		for (int i = 0; i < handoverCommandIEs->protocolIEs.list.count; i++)
-		{
-			switch (handoverCommandIEs->protocolIEs.list.array[i]->id)
-			{
+  for (int i = 0; i < handoverCommandIEs->protocolIEs.list.count; i++) {
+    switch (handoverCommandIEs->protocolIEs.list.array[i]->id) {
       case Ngap_ProtocolIE_ID_id_AMF_UE_NGAP_ID: {
-				if (handoverCommandIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_reject && handoverCommandIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverCommandIEs__value_PR_AMF_UE_NGAP_ID)
-				{
+        if (handoverCommandIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_reject
+            && handoverCommandIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverCommandIEs__value_PR_AMF_UE_NGAP_ID) {
           amfUeNgapId = new AMF_UE_NGAP_ID();
-					if (!amfUeNgapId->decodefromAMF_UE_NGAP_ID(handoverCommandIEs->protocolIEs.list.array[i]->value.choice.AMF_UE_NGAP_ID))
-					{
+          if (!amfUeNgapId->decodefromAMF_UE_NGAP_ID(
+              handoverCommandIEs->protocolIEs.list.array[i]->value.choice
+                  .AMF_UE_NGAP_ID)) {
             cout << "decoded ngap AMF_UE_NGAP_ID IE error" << endl;
             return false;
           }
-				}
-				else
-				{
+        } else {
           cout << "decoded ngap AMF_UE_NGAP_ID IE error" << endl;
           return false;
         }
-			}break;
+      }
+        break;
       case Ngap_ProtocolIE_ID_id_RAN_UE_NGAP_ID: {
-				if (handoverCommandIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_reject && handoverCommandIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverCommandIEs__value_PR_RAN_UE_NGAP_ID)
-				{
+        if (handoverCommandIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_reject
+            && handoverCommandIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverCommandIEs__value_PR_RAN_UE_NGAP_ID) {
           ranUeNgapId = new RAN_UE_NGAP_ID();
-					if (!ranUeNgapId->decodefromRAN_UE_NGAP_ID(handoverCommandIEs->protocolIEs.list.array[i]->value.choice.RAN_UE_NGAP_ID))
-					{
+          if (!ranUeNgapId->decodefromRAN_UE_NGAP_ID(
+              handoverCommandIEs->protocolIEs.list.array[i]->value.choice
+                  .RAN_UE_NGAP_ID)) {
             cout << "decoded ngap RAN_UE_NGAP_ID IE error" << endl;
             return false;
           }
-				}
-				else
-				{
+        } else {
           cout << "decoded ngap RAN_UE_NGAP_ID IE error" << endl;
           return false;
         }
-			}break;
+      }
+        break;
       case Ngap_ProtocolIE_ID_id_HandoverType: {
-				if (handoverCommandIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_reject && handoverCommandIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverCommandIEs__value_PR_HandoverType)
-				{
+        if (handoverCommandIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_reject
+            && handoverCommandIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverCommandIEs__value_PR_HandoverType) {
           ngap_handovertype = new Ngap_HandoverType_t();
-					*ngap_handovertype = handoverCommandIEs->protocolIEs.list.array[i]->value.choice.HandoverType;
-				}
-				else
-				{
+          *ngap_handovertype = handoverCommandIEs->protocolIEs.list.array[i]
+              ->value.choice.HandoverType;
+        } else {
           cout << "decoded ngap Handover Type IE error" << endl;
           return false;
         }
-			}break;
-			case Ngap_ProtocolIE_ID_id_PDUSessionResourceHandoverList: {
-				if (handoverCommandIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_ignore && handoverCommandIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverCommandIEs__value_PR_PDUSessionResourceHandoverList)
-				{
       }
-				else
-				{
-					cout << "decoded ngap PDUSessionResourceHandoverList IE error" << endl;
+        break;
+      case Ngap_ProtocolIE_ID_id_PDUSessionResourceHandoverList: {
+        if (handoverCommandIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_ignore
+            && handoverCommandIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverCommandIEs__value_PR_PDUSessionResourceHandoverList) {
+        } else {
+          cout << "decoded ngap PDUSessionResourceHandoverList IE error"
+              << endl;
           return false;
         }
-			}break;
-			case Ngap_ProtocolIE_ID_id_PDUSessionResourceToReleaseListHOCmd: {
-				if (handoverCommandIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_ignore && handoverCommandIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverCommandIEs__value_PR_PDUSessionResourceToReleaseListHOCmd)
-				{
-				
       }
-				else
-				{
-					cout << "decoded ngap PDUSessionResourceToReleaseListHOCmd IE error" << endl;
+        break;
+      case Ngap_ProtocolIE_ID_id_PDUSessionResourceToReleaseListHOCmd: {
+        if (handoverCommandIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_ignore
+            && handoverCommandIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverCommandIEs__value_PR_PDUSessionResourceToReleaseListHOCmd) {
+
+        } else {
+          cout << "decoded ngap PDUSessionResourceToReleaseListHOCmd IE error"
+              << endl;
           return false;
         }
-			}break;
-			case Ngap_ProtocolIE_ID_id_TargetToSource_TransparentContainer: {
-				if (handoverCommandIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_reject && handoverCommandIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverCommandIEs__value_PR_TargetToSource_TransparentContainer)
-				{
       }
-				else
-				{
-					cout << "decoded ngap TargetToSource_TransparentContainer IE error" << endl;
+        break;
+      case Ngap_ProtocolIE_ID_id_TargetToSource_TransparentContainer: {
+        if (handoverCommandIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_reject
+            && handoverCommandIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverCommandIEs__value_PR_TargetToSource_TransparentContainer) {
+        } else {
+          cout << "decoded ngap TargetToSource_TransparentContainer IE error"
+              << endl;
           return false;
         }
-			}break;
-			case Ngap_ProtocolIE_ID_id_CriticalityDiagnostics: {
-				if (handoverCommandIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_ignore && handoverCommandIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverCommandIEs__value_PR_CriticalityDiagnostics)
-				{
       }
-				else
-				{
+        break;
+      case Ngap_ProtocolIE_ID_id_CriticalityDiagnostics: {
+        if (handoverCommandIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_ignore
+            && handoverCommandIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverCommandIEs__value_PR_CriticalityDiagnostics) {
+        } else {
           cout << "decoded ngap CriticalityDiagnostics IE error" << endl;
           return false;
         }
-			}break;
+      }
+        break;
       default: {
         cout << "decoded ngap message pdu error" << endl;
         return false;
@@ -159,151 +168,149 @@ namespace ngap{
   }
 
   return true;
-	}
+}
 
-	int  HandoverCommandMsg::encode2buffer(uint8_t *buf, int buf_size)
-	{
+int HandoverCommandMsg::encode2buffer(uint8_t *buf, int buf_size) {
   asn_fprint(stderr, &asn_DEF_Ngap_NGAP_PDU, handoverCommandPdu);
-		asn_enc_rval_t er = aper_encode_to_buffer(&asn_DEF_Ngap_NGAP_PDU, NULL, handoverCommandPdu, buf, buf_size);
+  asn_enc_rval_t er = aper_encode_to_buffer(&asn_DEF_Ngap_NGAP_PDU, NULL,
+                                            handoverCommandPdu, buf, buf_size);
   cout << "er.encoded(" << er.encoded << ")" << endl;
   return er.encoded;
-	}
+}
 
-	void HandoverCommandMsg::setMessageType()
-	{
-		if (!handoverCommandPdu) handoverCommandPdu = (Ngap_NGAP_PDU_t*)calloc(1, sizeof(Ngap_NGAP_PDU_t));
+void HandoverCommandMsg::setMessageType() {
+  if (!handoverCommandPdu)
+    handoverCommandPdu = (Ngap_NGAP_PDU_t*) calloc(1, sizeof(Ngap_NGAP_PDU_t));
 
   MessageType HandoverCommandMessageTypeIE;
-		HandoverCommandMessageTypeIE.setProcedureCode(Ngap_ProcedureCode_id_HandoverPreparation);
-		HandoverCommandMessageTypeIE.setTypeOfMessage(Ngap_NGAP_PDU_PR_successfulOutcome);
+  HandoverCommandMessageTypeIE.setProcedureCode(
+      Ngap_ProcedureCode_id_HandoverPreparation);
+  HandoverCommandMessageTypeIE.setTypeOfMessage(
+      Ngap_NGAP_PDU_PR_successfulOutcome);
   HandoverCommandMessageTypeIE.setCriticality(Ngap_Criticality_reject);
-		HandoverCommandMessageTypeIE.setValuePresent(Ngap_SuccessfulOutcome__value_PR_HandoverCommand);
+  HandoverCommandMessageTypeIE.setValuePresent(
+      Ngap_SuccessfulOutcome__value_PR_HandoverCommand);
 
-		if (HandoverCommandMessageTypeIE.getProcedureCode() == Ngap_ProcedureCode_id_HandoverPreparation && HandoverCommandMessageTypeIE.getTypeOfMessage() == Ngap_NGAP_PDU_PR_successfulOutcome)
-		{
+  if (HandoverCommandMessageTypeIE.getProcedureCode()
+      == Ngap_ProcedureCode_id_HandoverPreparation
+      && HandoverCommandMessageTypeIE.getTypeOfMessage()
+          == Ngap_NGAP_PDU_PR_successfulOutcome) {
     HandoverCommandMessageTypeIE.encode2pdu(handoverCommandPdu);
-			handoverCommandIEs = &(handoverCommandPdu->choice.successfulOutcome->value.choice.HandoverCommand);
-		}
-		else
-		{
-			cout << "[warning] This information doesn't refer to HandoverCommand Message!!!" << endl;
-		}
+    handoverCommandIEs = &(handoverCommandPdu->choice.successfulOutcome->value
+        .choice.HandoverCommand);
+  } else {
+    cout
+        << "[warning] This information doesn't refer to HandoverCommand Message!!!"
+        << endl;
   }
+}
 
-	void HandoverCommandMsg::setAmfUeNgapId(unsigned long id)
-	{
+void HandoverCommandMsg::setAmfUeNgapId(unsigned long id) {
   if (!amfUeNgapId)
     amfUeNgapId = new AMF_UE_NGAP_ID();
   amfUeNgapId->setAMF_UE_NGAP_ID(id);
 
-		Ngap_HandoverCommandIEs_t *ie = (Ngap_HandoverCommandIEs_t *)calloc(1, sizeof(Ngap_HandoverCommandIEs_t));
+  Ngap_HandoverCommandIEs_t *ie = (Ngap_HandoverCommandIEs_t*) calloc(
+      1, sizeof(Ngap_HandoverCommandIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_AMF_UE_NGAP_ID;
   ie->criticality = Ngap_Criticality_reject;
   ie->value.present = Ngap_HandoverCommandIEs__value_PR_AMF_UE_NGAP_ID;
 
   int ret = amfUeNgapId->encode2AMF_UE_NGAP_ID(ie->value.choice.AMF_UE_NGAP_ID);
-		if (!ret)
-		{
+  if (!ret) {
     cout << "encode AMF_UE_NGAP_ID IE error" << endl;
     return;
   }
 
   ret = ASN_SEQUENCE_ADD(&handoverCommandIEs->protocolIEs.list, ie);
-		if (ret != 0) cout << "encode AMF_UE_NGAP_ID IE error" << endl;
-	}
+  if (ret != 0)
+    cout << "encode AMF_UE_NGAP_ID IE error" << endl;
+}
 
-	void HandoverCommandMsg::setRanUeNgapId(uint32_t ran_ue_ngap_id)
-	{
+void HandoverCommandMsg::setRanUeNgapId(uint32_t ran_ue_ngap_id) {
   if (!ranUeNgapId)
     ranUeNgapId = new RAN_UE_NGAP_ID();
   ranUeNgapId->setRanUeNgapId(ran_ue_ngap_id);
 
-		Ngap_HandoverCommandIEs_t *ie = (Ngap_HandoverCommandIEs_t *)calloc(1, sizeof(Ngap_HandoverCommandIEs_t));
+  Ngap_HandoverCommandIEs_t *ie = (Ngap_HandoverCommandIEs_t*) calloc(
+      1, sizeof(Ngap_HandoverCommandIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_RAN_UE_NGAP_ID;
   ie->criticality = Ngap_Criticality_reject;
   ie->value.present = Ngap_HandoverCommandIEs__value_PR_RAN_UE_NGAP_ID;
 
   int ret = ranUeNgapId->encode2RAN_UE_NGAP_ID(ie->value.choice.RAN_UE_NGAP_ID);
-		if (!ret)
-		{
+  if (!ret) {
     cout << "encode RAN_UE_NGAP_ID IE error" << endl;
     return;
   }
 
   ret = ASN_SEQUENCE_ADD(&handoverCommandIEs->protocolIEs.list, ie);
-		if (ret != 0) cout << "encode RAN_UE_NGAP_ID IE error" << endl;
-	}
+  if (ret != 0)
+    cout << "encode RAN_UE_NGAP_ID IE error" << endl;
+}
 
-	void HandoverCommandMsg::setHandoverType(long type) 
-	{
+void HandoverCommandMsg::setHandoverType(long type) {
   if (!ngap_handovertype)
     ngap_handovertype = new Ngap_HandoverType_t();
-		Ngap_HandoverCommandIEs_t *ie = (Ngap_HandoverCommandIEs_t *)calloc(1, sizeof(Ngap_HandoverCommandIEs_t));
+  Ngap_HandoverCommandIEs_t *ie = (Ngap_HandoverCommandIEs_t*) calloc(
+      1, sizeof(Ngap_HandoverCommandIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_HandoverType;
   ie->criticality = Ngap_Criticality_reject;
   ie->value.present = Ngap_HandoverCommandIEs__value_PR_HandoverType;
   ie->value.choice.HandoverType = type;
   int ret = ASN_SEQUENCE_ADD(&handoverCommandIEs->protocolIEs.list, ie);
-		if (ret != 0) cout << "encode HandoverType IE error" << endl;
-	}
+  if (ret != 0)
+    cout << "encode HandoverType IE error" << endl;
+}
 
-	void HandoverCommandMsg::setPduSessionResourceHandoverList(std::vector<PDUSessionResourceHandoverItem_t> list)
-	{
+void HandoverCommandMsg::setPduSessionResourceHandoverList(
+    std::vector<PDUSessionResourceHandoverItem_t> list) {
   if (!PDUSessionResourceHandoverList)
-			PDUSessionResourceHandoverList = new Ngap_PDUSessionResourceHandoverList_t();
-		Ngap_HandoverCommandIEs_t *ie = (Ngap_HandoverCommandIEs_t *)calloc(1, sizeof(Ngap_HandoverCommandIEs_t));
-		
-		for (int i = 0; i < list.size(); i++)
-		{
-			Ngap_PDUSessionResourceHandoverItem_t *item = (Ngap_PDUSessionResourceHandoverItem_t *)calloc(1, sizeof(Ngap_PDUSessionResourceHandoverItem_t));
+    PDUSessionResourceHandoverList =
+        new Ngap_PDUSessionResourceHandoverList_t();
+  Ngap_HandoverCommandIEs_t *ie = (Ngap_HandoverCommandIEs_t*) calloc(
+      1, sizeof(Ngap_HandoverCommandIEs_t));
+
+  for (int i = 0; i < list.size(); i++) {
+    Ngap_PDUSessionResourceHandoverItem_t *item =
+        (Ngap_PDUSessionResourceHandoverItem_t*) calloc(
+            1, sizeof(Ngap_PDUSessionResourceHandoverItem_t));
     item->pDUSessionID = list[i].pduSessionId;
     item->handoverCommandTransfer = list[i].HandoverCommandTransfer;
     int ret = ASN_SEQUENCE_ADD(&PDUSessionResourceHandoverList->list, item);
-			if (ret != 0) cout << "encode PDUSessionResourceHandoverListItem IE error" << endl;
+    if (ret != 0)
+      cout << "encode PDUSessionResourceHandoverListItem IE error" << endl;
   }
 
   ie->id = Ngap_ProtocolIE_ID_id_PDUSessionResourceHandoverList;
   ie->criticality = Ngap_Criticality_ignore;
-		ie->value.present = Ngap_HandoverCommandIEs__value_PR_PDUSessionResourceHandoverList;
-		ie->value.choice.PDUSessionResourceHandoverList = *PDUSessionResourceHandoverList;
+  ie->value.present =
+      Ngap_HandoverCommandIEs__value_PR_PDUSessionResourceHandoverList;
+  ie->value.choice.PDUSessionResourceHandoverList =
+      *PDUSessionResourceHandoverList;
   int ret = ASN_SEQUENCE_ADD(&handoverCommandIEs->protocolIEs.list, ie);
-		if (ret != 0) cout << "encode PDUSessionResourceHandoverList IE error" << endl;
+  if (ret != 0)
+    cout << "encode PDUSessionResourceHandoverList IE error" << endl;
 
-	}
+}
 
-	void HandoverCommandMsg::setTargetToSource_TransparentContainer(OCTET_STRING_t targetTosource) 
-	{
+void HandoverCommandMsg::setTargetToSource_TransparentContainer(
+    OCTET_STRING_t targetTosource) {
   if (!TargetToSource_TransparentContainer)
-			TargetToSource_TransparentContainer = new Ngap_TargetToSource_TransparentContainer_t();
+    TargetToSource_TransparentContainer =
+        new Ngap_TargetToSource_TransparentContainer_t();
 
-		Ngap_HandoverCommandIEs_t *ie = (Ngap_HandoverCommandIEs_t *)calloc(1, sizeof(Ngap_HandoverCommandIEs_t));
+  Ngap_HandoverCommandIEs_t *ie = (Ngap_HandoverCommandIEs_t*) calloc(
+      1, sizeof(Ngap_HandoverCommandIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_TargetToSource_TransparentContainer;
   ie->criticality = Ngap_Criticality_reject;
-		ie->value.present = Ngap_HandoverCommandIEs__value_PR_TargetToSource_TransparentContainer;
+  ie->value.present =
+      Ngap_HandoverCommandIEs__value_PR_TargetToSource_TransparentContainer;
   ie->value.choice.TargetToSource_TransparentContainer = targetTosource;
   int ret = ASN_SEQUENCE_ADD(&handoverCommandIEs->protocolIEs.list, ie);
-		if (ret != 0) cout << "encode HandoverType IE error" << endl;
-	}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+  if (ret != 0)
+    cout << "encode HandoverType IE error" << endl;
+}
 
 }
 

src/ngap/ngapMsgs/HandoverCommandMsg.hpp

@@ -11,23 +11,21 @@
 #include "AMF-UE-NGAP-ID.hpp"
 #include "RAN-UE-NGAP-ID.hpp"
 #include "Cause.hpp"
-extern "C"{
-  #include "Ngap_NGAP-PDU.h"
-  #include "Ngap_ProtocolIE-Field.h"
-  #include "Ngap_NGSetupRequest.h"
+extern "C" {
+#include "Ngap_NGAP-PDU.h"
+#include "Ngap_ProtocolIE-Field.h"
+#include "Ngap_NGSetupRequest.h"
 }
 
-namespace ngap{
+namespace ngap {
 
-
-	typedef struct {
+typedef struct {
   uint8_t pduSessionId;
   OCTET_STRING_t HandoverCommandTransfer;
-	}PDUSessionResourceHandoverItem_t;
-
+}PDUSessionResourceHandoverItem_t;
 
-	class HandoverCommandMsg{
-	public:	
+class HandoverCommandMsg {
+public:
   HandoverCommandMsg();
   virtual ~HandoverCommandMsg();
 
@@ -35,12 +33,10 @@ namespace ngap{
   void setAmfUeNgapId(unsigned long id);//40 bits
   void setRanUeNgapId(uint32_t id);// 32 bits
 
-
   void setHandoverType(long type);
   void setPduSessionResourceHandoverList(std::vector<PDUSessionResourceHandoverItem_t> list);
   void setTargetToSource_TransparentContainer(OCTET_STRING_t targetTosource);
 
-
   int encode2buffer(uint8_t *buf, int buf_size);
   bool decodefrompdu(Ngap_NGAP_PDU_t *ngap_msg_pdu);
   unsigned long getAmfUeNgapId();//return -1;(不存在)
@@ -51,7 +47,7 @@ namespace ngap{
    void getDirectForwardingPathAvailability(Ngap_DirectForwardingPathAvailability_t directpathavailable);
    void getPDUSessionResourceList(Ngap_PDUSessionResourceHandoverList_t pdusessionresourcelist);
    void getSourceToTargetTransparentContainer();*/
-	private: 
+private:
   Ngap_NGAP_PDU_t *handoverCommandPdu;
   Ngap_HandoverCommand_t *handoverCommandIEs;
   /***************** for decoding ****************/
@@ -64,7 +60,7 @@ namespace ngap{
   Ngap_TargetToSource_TransparentContainer_t *TargetToSource_TransparentContainer;
   Ngap_CriticalityDiagnostics_t *CriticalityDiagnostics;
 
-	};
+};
 
 }
 

src/ngap/ngapMsgs/HandoverNotifyMsg.cpp

@@ -19,7 +19,7 @@
  *      contact@openairinterface.org
  */
 
- /*! \file HandoverNotifyMsg.cpp
+/*! \file HandoverNotifyMsg.cpp
  \brief
  \author  niuxiansheng-niu, BUPT
  \date 2020
@@ -40,165 +40,171 @@ extern "C" {
 
 using namespace std;
 namespace ngap {
-	HandoverNotifyMsg::HandoverNotifyMsg()
-	{
+HandoverNotifyMsg::HandoverNotifyMsg() {
   amfUeNgapId = NULL;
   ranUeNgapId = NULL;
   userLocationInformation = NULL;
-	}
-	HandoverNotifyMsg::~HandoverNotifyMsg() {};
-	unsigned long HandoverNotifyMsg::getAmfUeNgapId()
-	{
+}
+HandoverNotifyMsg::~HandoverNotifyMsg() {
+}
+;
+unsigned long HandoverNotifyMsg::getAmfUeNgapId() {
   return amfUeNgapId->getAMF_UE_NGAP_ID();
-	}
-	int  HandoverNotifyMsg::encode2buffer(uint8_t* buf, int buf_size)
-	{
+}
+int HandoverNotifyMsg::encode2buffer(uint8_t *buf, int buf_size) {
   asn_fprint(stderr, &asn_DEF_Ngap_NGAP_PDU, handoverNotifyPdu);
-		asn_enc_rval_t er = aper_encode_to_buffer(&asn_DEF_Ngap_NGAP_PDU, NULL, handoverNotifyPdu, buf, buf_size);
+  asn_enc_rval_t er = aper_encode_to_buffer(&asn_DEF_Ngap_NGAP_PDU, NULL,
+                                            handoverNotifyPdu, buf, buf_size);
   cout << "er.encoded(" << er.encoded << ")" << endl;
   return er.encoded;
-	}
-	bool HandoverNotifyMsg::decodefrompdu(Ngap_NGAP_PDU_t* ngap_msg_pdu)
-	{
+}
+bool HandoverNotifyMsg::decodefrompdu(Ngap_NGAP_PDU_t *ngap_msg_pdu) {
   handoverNotifyPdu = ngap_msg_pdu;
 
-		if (handoverNotifyPdu->present == Ngap_NGAP_PDU_PR_initiatingMessage)
-		{
-			if (handoverNotifyPdu->choice.initiatingMessage && handoverNotifyPdu->choice.initiatingMessage->procedureCode == Ngap_ProcedureCode_id_HandoverPreparation && handoverNotifyPdu->choice.initiatingMessage->criticality == Ngap_Criticality_reject && handoverNotifyPdu->choice.initiatingMessage->value.present == Ngap_InitiatingMessage__value_PR_HandoverNotify)
-			{
-				handoverNotifyIEs = &handoverNotifyPdu->choice.initiatingMessage->value.choice.HandoverNotify;
-			}
-			else
-			{
+  if (handoverNotifyPdu->present == Ngap_NGAP_PDU_PR_initiatingMessage) {
+    if (handoverNotifyPdu->choice.initiatingMessage
+        && handoverNotifyPdu->choice.initiatingMessage->procedureCode
+            == Ngap_ProcedureCode_id_HandoverPreparation
+        && handoverNotifyPdu->choice.initiatingMessage->criticality
+            == Ngap_Criticality_reject
+        && handoverNotifyPdu->choice.initiatingMessage->value.present
+            == Ngap_InitiatingMessage__value_PR_HandoverNotify) {
+      handoverNotifyIEs = &handoverNotifyPdu->choice.initiatingMessage->value
+          .choice.HandoverNotify;
+    } else {
       cout << "Check HandoverNotify message error!!!" << endl;
       return false;
     }
-		}
-		else
-		{
+  } else {
     cout << "HandoverNotify MessageType error!!!" << endl;
     return false;
   }
-		for (int i = 0; i < handoverNotifyIEs->protocolIEs.list.count; i++)
-		{
-			switch (handoverNotifyIEs->protocolIEs.list.array[i]->id)
-			{
+  for (int i = 0; i < handoverNotifyIEs->protocolIEs.list.count; i++) {
+    switch (handoverNotifyIEs->protocolIEs.list.array[i]->id) {
       case Ngap_ProtocolIE_ID_id_AMF_UE_NGAP_ID: {
-				if (handoverNotifyIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_reject && handoverNotifyIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverNotifyIEs__value_PR_AMF_UE_NGAP_ID)
-				{
+        if (handoverNotifyIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_reject
+            && handoverNotifyIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverNotifyIEs__value_PR_AMF_UE_NGAP_ID) {
           amfUeNgapId = new AMF_UE_NGAP_ID();
-					if (!amfUeNgapId->decodefromAMF_UE_NGAP_ID(handoverNotifyIEs->protocolIEs.list.array[i]->value.choice.AMF_UE_NGAP_ID))
-					{
+          if (!amfUeNgapId->decodefromAMF_UE_NGAP_ID(
+              handoverNotifyIEs->protocolIEs.list.array[i]->value.choice
+                  .AMF_UE_NGAP_ID)) {
             cout << "decoded ngap AMF_UE_NGAP_ID IE error" << endl;
             return false;
           }
-				}
-				else
-				{
+        } else {
           cout << "decoded ngap AMF_UE_NGAP_ID IE error" << endl;
           return false;
         }
-			}break;
-			case Ngap_ProtocolIE_ID_id_RAN_UE_NGAP_ID:{
-				if (handoverNotifyIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_reject && handoverNotifyIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverNotifyIEs__value_PR_RAN_UE_NGAP_ID)
-				{
+      }
+        break;
+      case Ngap_ProtocolIE_ID_id_RAN_UE_NGAP_ID: {
+        if (handoverNotifyIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_reject
+            && handoverNotifyIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverNotifyIEs__value_PR_RAN_UE_NGAP_ID) {
           ranUeNgapId = new RAN_UE_NGAP_ID();
-					if (!ranUeNgapId->decodefromRAN_UE_NGAP_ID(handoverNotifyIEs->protocolIEs.list.array[i]->value.choice.RAN_UE_NGAP_ID))
-					{
+          if (!ranUeNgapId->decodefromRAN_UE_NGAP_ID(
+              handoverNotifyIEs->protocolIEs.list.array[i]->value.choice
+                  .RAN_UE_NGAP_ID)) {
             cout << "decoded ngap RAN_UE_NGAP_ID IE error" << endl;
             return false;
           }
-				}
-				else
-				{
+        } else {
           cout << "decoded ngap RAN_UE_NGAP_ID IE error" << endl;
           return false;
         }
       }
       case Ngap_ProtocolIE_ID_id_UserLocationInformation: {
-				if (handoverNotifyIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_ignore && handoverNotifyIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverNotifyIEs__value_PR_UserLocationInformation)
-				{
+        if (handoverNotifyIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_ignore
+            && handoverNotifyIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverNotifyIEs__value_PR_UserLocationInformation) {
           userLocationInformation = new UserLocationInformation();
-					if (!userLocationInformation->decodefromUserLocationInformation(&handoverNotifyIEs->protocolIEs.list.array[i]->value.choice.UserLocationInformation))
-					{
+          if (!userLocationInformation->decodefromUserLocationInformation(
+              &handoverNotifyIEs->protocolIEs.list.array[i]->value.choice
+                  .UserLocationInformation)) {
             cout << "decoded ngap UserLocationInformation IE error" << endl;
             return false;
           }
-				}
-				else
-				{
+        } else {
           cout << "decoded ngap UserLocationInformation IE error" << endl;
           return false;
         }
-			}break;
       }
+        break;
     }
-		return true;
   }
-	void HandoverNotifyMsg::setUserLocationInfoNR(struct NrCgi_s cig, struct Tai_s tai)
-	{
+  return true;
+}
+void HandoverNotifyMsg::setUserLocationInfoNR(struct NrCgi_s cig,
+                                              struct Tai_s tai) {
   if (!userLocationInformation)
     userLocationInformation = new UserLocationInformation();
 
   //userLocationInformation->setInformation(UserLocationInformationEUTRA * informationEUTRA);
-		UserLocationInformationNR* informationNR = new UserLocationInformationNR();
-		NR_CGI* nR_CGI = new NR_CGI();
-		PlmnId* plmnId_cgi = new PlmnId();
-		NRCellIdentity* nRCellIdentity = new NRCellIdentity();
+  UserLocationInformationNR *informationNR = new UserLocationInformationNR();
+  NR_CGI *nR_CGI = new NR_CGI();
+  PlmnId *plmnId_cgi = new PlmnId();
+  NRCellIdentity *nRCellIdentity = new NRCellIdentity();
   plmnId_cgi->setMccMnc(cig.mcc, cig.mnc);
   nRCellIdentity->setNRCellIdentity(cig.nrCellID);
   nR_CGI->setNR_CGI(plmnId_cgi, nRCellIdentity);
 
-		TAI* tai_nr = new TAI();
-		PlmnId* plmnId_tai = new PlmnId();
+  TAI *tai_nr = new TAI();
+  PlmnId *plmnId_tai = new PlmnId();
   plmnId_tai->setMccMnc(tai.mcc, tai.mnc);
-		TAC* tac = new TAC();
+  TAC *tac = new TAC();
   tac->setTac(tai.tac);
   tai_nr->setTAI(plmnId_tai, tac);
   informationNR->setInformationNR(nR_CGI, tai_nr);
   userLocationInformation->setInformation(informationNR);
 
-		Ngap_HandoverNotifyIEs_t* ie = (Ngap_HandoverNotifyIEs_t*)calloc(1, sizeof(Ngap_HandoverNotifyIEs_t));
+  Ngap_HandoverNotifyIEs_t *ie = (Ngap_HandoverNotifyIEs_t*) calloc(
+      1, sizeof(Ngap_HandoverNotifyIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_UserLocationInformation;
   ie->criticality = Ngap_Criticality_ignore;
   ie->value.present = Ngap_HandoverNotifyIEs__value_PR_UserLocationInformation;
 
-		int ret = userLocationInformation->encodefromUserLocationInformation(&ie->value.choice.UserLocationInformation);
-		if (!ret)
-		{
+  int ret = userLocationInformation->encodefromUserLocationInformation(
+      &ie->value.choice.UserLocationInformation);
+  if (!ret) {
     cout << "encode UserLocationInformation IE error" << endl;
     return;
   }
 
   ret = ASN_SEQUENCE_ADD(&handoverNotifyIEs->protocolIEs.list, ie);
-		if (ret != 0) cout << "encode UserLocationInformation IE error" << endl;
-	}
-	uint32_t HandoverNotifyMsg::getRanUeNgapId()
-	{
+  if (ret != 0)
+    cout << "encode UserLocationInformation IE error" << endl;
+}
+uint32_t HandoverNotifyMsg::getRanUeNgapId() {
   return ranUeNgapId->getRanUeNgapId();
-	}
-	bool HandoverNotifyMsg::getUserLocationInfoNR(struct NrCgi_s& cig, struct Tai_s& tai)
-	{
-		UserLocationInformationNR* informationNR;
+}
+bool HandoverNotifyMsg::getUserLocationInfoNR(struct NrCgi_s &cig,
+                                              struct Tai_s &tai) {
+  UserLocationInformationNR *informationNR;
   userLocationInformation->getInformation(informationNR);
-		if (userLocationInformation->getChoiceOfUserLocationInformation() != Ngap_UserLocationInformation_PR_userLocationInformationNR) return false;
-		NR_CGI* nR_CGI;
-		TAI* nR_TAI;
+  if (userLocationInformation->getChoiceOfUserLocationInformation()
+      != Ngap_UserLocationInformation_PR_userLocationInformationNR)
+    return false;
+  NR_CGI *nR_CGI;
+  TAI *nR_TAI;
   informationNR->getInformationNR(nR_CGI, nR_TAI);
-		PlmnId* cgi_plmnId;
-		NRCellIdentity* nRCellIdentity;
+  PlmnId *cgi_plmnId;
+  NRCellIdentity *nRCellIdentity;
   nR_CGI->getNR_CGI(cgi_plmnId, nRCellIdentity);
   cgi_plmnId->getMcc(cig.mcc);
   cgi_plmnId->getMnc(cig.mnc);
   cig.nrCellID = nRCellIdentity->getNRCellIdentity();
 
-		PlmnId* tai_plmnId;
-		TAC* tac;
+  PlmnId *tai_plmnId;
+  TAC *tac;
   nR_TAI->getTAI(tai_plmnId, tac);
   tai_plmnId->getMcc(tai.mcc);
   tai_plmnId->getMnc(tai.mnc);
   tai.tac = tac->getTac();
 
   return true;
-	}
+}
 }

src/ngap/ngapMsgs/HandoverNotifyMsg.hpp

@@ -19,7 +19,7 @@
  *      contact@openairinterface.org
  */
 
- /*! \file HandoverNotifyMsg.hpp
+/*! \file HandoverNotifyMsg.hpp
  \brief
  \author  niuxiansheng-niu, BUPT
  \date 2020
@@ -42,24 +42,24 @@ extern "C" {
 }
 
 namespace ngap {
-	class HandoverNotifyMsg{
+class HandoverNotifyMsg {
  public:
   HandoverNotifyMsg();
   virtual ~HandoverNotifyMsg();
-		int  encode2buffer(uint8_t* buf, int buf_size);
-		bool decodefrompdu(Ngap_NGAP_PDU_t* ngap_msg_pdu);
+  int encode2buffer(uint8_t *buf, int buf_size);
+  bool decodefrompdu(Ngap_NGAP_PDU_t *ngap_msg_pdu);
   void setUserLocationInfoNR(struct NrCgi_s cig, struct Tai_s tai);
-		unsigned long getAmfUeNgapId();//return -1;()
-		uint32_t getRanUeNgapId();//return -1;()
-		bool getUserLocationInfoNR(struct NrCgi_s& cig, struct Tai_s& tai);
+  unsigned long getAmfUeNgapId();  //return -1;(������)
+  uint32_t getRanUeNgapId();  //return -1;(������)
+  bool getUserLocationInfoNR(struct NrCgi_s &cig, struct Tai_s &tai);
 
  private:
-		Ngap_NGAP_PDU_t* handoverNotifyPdu;
-		Ngap_HandoverNotify_t* handoverNotifyIEs;
-		AMF_UE_NGAP_ID* amfUeNgapId;
-		RAN_UE_NGAP_ID* ranUeNgapId;
-		UserLocationInformation* userLocationInformation;
-	};
+  Ngap_NGAP_PDU_t *handoverNotifyPdu;
+  Ngap_HandoverNotify_t *handoverNotifyIEs;
+  AMF_UE_NGAP_ID *amfUeNgapId;
+  RAN_UE_NGAP_ID *ranUeNgapId;
+  UserLocationInformation *userLocationInformation;
+};
 
 }
 #endif

src/ngap/ngapMsgs/HandoverRequest.cpp

 #include "HandoverRequest.hpp"
 
-extern "C"{
-  #include "constr_TYPE.h"
-  #include "Ngap_NGAP-PDU.h"
-  #include "asn_codecs.h"
-  #include "per_encoder.h"
-  #include "per_decoder.h"
-  #include "constraints.h"
+extern "C" {
+#include "constr_TYPE.h"
+#include "Ngap_NGAP-PDU.h"
+#include "asn_codecs.h"
+#include "per_encoder.h"
+#include "per_decoder.h"
+#include "constraints.h"
 }
 
 #include <iostream>
@@ -14,11 +14,10 @@ extern "C"{
 
 using namespace std;
 
-namespace ngap{
+namespace ngap {
 
-	HandoverRequest::HandoverRequest()
-	{
-		amfUeNgapId=NULL;
+HandoverRequest::HandoverRequest() {
+  amfUeNgapId = NULL;
   handovertype = NULL;
   cause = NULL;
   ueAggregateMaximumBitRate = NULL;
@@ -30,16 +29,15 @@ namespace ngap{
   guami = NULL;
   handoverRequestPdu = NULL;
   handoverRequestIEs = NULL;
-	}
-	HandoverRequest::~HandoverRequest() {}
+}
+HandoverRequest::~HandoverRequest() {
+}
 
-	unsigned long HandoverRequest::getAmfUeNgapId()
-	{
+unsigned long HandoverRequest::getAmfUeNgapId() {
   return amfUeNgapId->getAMF_UE_NGAP_ID();
-	}
-
+}
 
-	/*bool HandoverRequest::decodefrompdu(Ngap_NGAP_PDU_t *ngap_msg_pdu)
+/*bool HandoverRequest::decodefrompdu(Ngap_NGAP_PDU_t *ngap_msg_pdu)
  {
  handoverCommandPdu = ngap_msg_pdu;
 
@@ -159,74 +157,83 @@ namespace ngap{
  return true;
  }*/
 
-	int  HandoverRequest::encode2buffer(uint8_t *buf, int buf_size)
-	{
+int HandoverRequest::encode2buffer(uint8_t *buf, int buf_size) {
   asn_fprint(stderr, &asn_DEF_Ngap_NGAP_PDU, handoverRequestPdu);
-		asn_enc_rval_t er = aper_encode_to_buffer(&asn_DEF_Ngap_NGAP_PDU, NULL, handoverRequestPdu, buf, buf_size);
+  asn_enc_rval_t er = aper_encode_to_buffer(&asn_DEF_Ngap_NGAP_PDU, NULL,
+                                            handoverRequestPdu, buf, buf_size);
   cout << "er.encoded(" << er.encoded << ")" << endl;
   return er.encoded;
-	}
+}
 
-	void HandoverRequest::setMessageType()
-	{
-		if (!handoverRequestPdu) handoverRequestPdu = (Ngap_NGAP_PDU_t*)calloc(1, sizeof(Ngap_NGAP_PDU_t));
+void HandoverRequest::setMessageType() {
+  if (!handoverRequestPdu)
+    handoverRequestPdu = (Ngap_NGAP_PDU_t*) calloc(1, sizeof(Ngap_NGAP_PDU_t));
 
   MessageType handoverRequestMessageTypeIE;
-		handoverRequestMessageTypeIE.setProcedureCode(Ngap_ProcedureCode_id_HandoverResourceAllocation);
-		handoverRequestMessageTypeIE.setTypeOfMessage(Ngap_NGAP_PDU_PR_initiatingMessage);
+  handoverRequestMessageTypeIE.setProcedureCode(
+      Ngap_ProcedureCode_id_HandoverResourceAllocation);
+  handoverRequestMessageTypeIE.setTypeOfMessage(
+      Ngap_NGAP_PDU_PR_initiatingMessage);
   handoverRequestMessageTypeIE.setCriticality(Ngap_Criticality_reject);
-		handoverRequestMessageTypeIE.setValuePresent(Ngap_InitiatingMessage__value_PR_HandoverRequest);
+  handoverRequestMessageTypeIE.setValuePresent(
+      Ngap_InitiatingMessage__value_PR_HandoverRequest);
 
-		if (handoverRequestMessageTypeIE.getProcedureCode() == Ngap_ProcedureCode_id_HandoverResourceAllocation && handoverRequestMessageTypeIE.getTypeOfMessage() ==Ngap_NGAP_PDU_PR_initiatingMessage)
-		{
+  if (handoverRequestMessageTypeIE.getProcedureCode()
+      == Ngap_ProcedureCode_id_HandoverResourceAllocation
+      && handoverRequestMessageTypeIE.getTypeOfMessage()
+          == Ngap_NGAP_PDU_PR_initiatingMessage) {
     handoverRequestMessageTypeIE.encode2pdu(handoverRequestPdu);
-			handoverRequestIEs = &(handoverRequestPdu->choice.initiatingMessage->value.choice.HandoverRequest);
-		}
-		else
-		{
-			cout << "[warning] This information doesn't refer to HandoverRequest Message!!!" << endl;
+    handoverRequestIEs = &(handoverRequestPdu->choice.initiatingMessage->value
+        .choice.HandoverRequest);
+  } else {
+    cout
+        << "[warning] This information doesn't refer to HandoverRequest Message!!!"
+        << endl;
   }
-	}
-	void HandoverRequest::setAmfUeNgapId(unsigned long id)
-	{
+}
+void HandoverRequest::setAmfUeNgapId(unsigned long id) {
   if (!amfUeNgapId)
     amfUeNgapId = new AMF_UE_NGAP_ID();
   amfUeNgapId->setAMF_UE_NGAP_ID(id);
 
-		Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t *)calloc(1, sizeof(Ngap_HandoverRequestIEs_t));
+  Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t*) calloc(
+      1, sizeof(Ngap_HandoverRequestIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_AMF_UE_NGAP_ID;
   ie->criticality = Ngap_Criticality_reject;
   ie->value.present = Ngap_HandoverRequestIEs__value_PR_AMF_UE_NGAP_ID;
 
   int ret = amfUeNgapId->encode2AMF_UE_NGAP_ID(ie->value.choice.AMF_UE_NGAP_ID);
-		if (!ret)
-		{
+  if (!ret) {
     cout << "encode AMF_UE_NGAP_ID IE error" << endl;
     return;
   }
 
   ret = ASN_SEQUENCE_ADD(&handoverRequestIEs->protocolIEs.list, ie);
-		if (ret != 0) cout << "encode AMF_UE_NGAP_ID IE error" << endl;
-	}
+  if (ret != 0)
+    cout << "encode AMF_UE_NGAP_ID IE error" << endl;
+}
 
-	void HandoverRequest::setHandoverType(long type)//0--intra5gs
+void HandoverRequest::setHandoverType(long type)  //0--intra5gs
     {
   if (!handovertype)
     handovertype = new Ngap_HandoverType_t();
-		Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t *)calloc(1, sizeof(Ngap_HandoverRequestIEs_t));
+  Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t*) calloc(
+      1, sizeof(Ngap_HandoverRequestIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_HandoverType;
   ie->criticality = Ngap_Criticality_reject;
   ie->value.present = Ngap_HandoverRequestIEs__value_PR_HandoverType;
   ie->value.choice.HandoverType = type;
   int ret = ASN_SEQUENCE_ADD(&handoverRequestIEs->protocolIEs.list, ie);
-		if (ret != 0) cout << "encode HandoverType IE error" << endl;
-	}
+  if (ret != 0)
+    cout << "encode HandoverType IE error" << endl;
+}
 
-	void HandoverRequest::setCause(Ngap_Cause_PR m_causePresent,long value)//
+void HandoverRequest::setCause(Ngap_Cause_PR m_causePresent, long value)  //
                                {
   if (!cause)
     cause = new Cause;
-		Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t *)calloc(1, sizeof(Ngap_HandoverRequestIEs_t));
+  Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t*) calloc(
+      1, sizeof(Ngap_HandoverRequestIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_Cause;
   ie->criticality = Ngap_Criticality_ignore;
   ie->value.present = Ngap_HandoverRequestIEs__value_PR_Cause;
@@ -235,84 +242,98 @@ namespace ngap{
   cause->setValue(value);
   cause->encode2Cause(&(ie->value.choice.Cause));
   int ret = ASN_SEQUENCE_ADD(&handoverRequestIEs->protocolIEs.list, ie);
-		if (ret != 0) cout << "encode Cause IE error" << endl;
-	}
+  if (ret != 0)
+    cout << "encode Cause IE error" << endl;
+}
 
-	void HandoverRequest::setUEAggregateMaximumBitRate(long bit_rate_downlink,long bit_rate_uplink)
-	{
+void HandoverRequest::setUEAggregateMaximumBitRate(long bit_rate_downlink,
+                                                   long bit_rate_uplink) {
   if (!ueAggregateMaximumBitRate)
     ueAggregateMaximumBitRate = new UEAggregateMaxBitRate;
 
-		ueAggregateMaximumBitRate->setUEAggregateMaxBitRate(bit_rate_downlink,bit_rate_uplink);
+  ueAggregateMaximumBitRate->setUEAggregateMaxBitRate(bit_rate_downlink,
+                                                      bit_rate_uplink);
 
-		Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t *)calloc(1, sizeof(Ngap_HandoverRequestIEs_t));
+  Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t*) calloc(
+      1, sizeof(Ngap_HandoverRequestIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_UEAggregateMaximumBitRate;
   ie->criticality = Ngap_Criticality_reject;
-		ie->value.present = Ngap_HandoverRequestIEs__value_PR_UEAggregateMaximumBitRate;
-		ueAggregateMaximumBitRate->encode2UEAggregateMaxBitRate(ie->value.choice.UEAggregateMaximumBitRate);
+  ie->value.present =
+      Ngap_HandoverRequestIEs__value_PR_UEAggregateMaximumBitRate;
+  ueAggregateMaximumBitRate->encode2UEAggregateMaxBitRate(
+      ie->value.choice.UEAggregateMaximumBitRate);
 
   int ret = ASN_SEQUENCE_ADD(&handoverRequestIEs->protocolIEs.list, ie);
-		if (ret != 0) cout << "encode UEAggregateMaximumBitRate IE error" << endl;
-	}
-	void HandoverRequest::setUESecurityCapabilities(uint16_t m_NR_EncryptionAlgs, uint16_t m_NR_IntegrityProtectionAlgs, uint16_t m_E_UTRA_EncryptionAlgs, uint16_t m_E_UTRA_IntegrityProtectionAlgs)
-	{
+  if (ret != 0)
+    cout << "encode UEAggregateMaximumBitRate IE error" << endl;
+}
+void HandoverRequest::setUESecurityCapabilities(
+    uint16_t m_NR_EncryptionAlgs, uint16_t m_NR_IntegrityProtectionAlgs,
+    uint16_t m_E_UTRA_EncryptionAlgs,
+    uint16_t m_E_UTRA_IntegrityProtectionAlgs) {
   if (!ueSecurityCapabilities)
     ueSecurityCapabilities = new UESecurityCapabilities;
 
-		Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t *)calloc(1, sizeof(Ngap_HandoverRequestIEs_t));
+  Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t*) calloc(
+      1, sizeof(Ngap_HandoverRequestIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_UESecurityCapabilities;
   ie->criticality = Ngap_Criticality_reject;
   ie->value.present = Ngap_HandoverRequestIEs__value_PR_UESecurityCapabilities;
-		ueSecurityCapabilities->setUESecurityCapabilities( m_NR_EncryptionAlgs, m_NR_IntegrityProtectionAlgs, m_E_UTRA_EncryptionAlgs, m_E_UTRA_IntegrityProtectionAlgs);
-		ueSecurityCapabilities->encode2UESecurityCapabilities((ie->value.choice.UESecurityCapabilities));
-		
+  ueSecurityCapabilities->setUESecurityCapabilities(
+      m_NR_EncryptionAlgs, m_NR_IntegrityProtectionAlgs,
+      m_E_UTRA_EncryptionAlgs, m_E_UTRA_IntegrityProtectionAlgs);
+  ueSecurityCapabilities->encode2UESecurityCapabilities(
+      (ie->value.choice.UESecurityCapabilities));
 
   int ret = ASN_SEQUENCE_ADD(&handoverRequestIEs->protocolIEs.list, ie);
-		if (ret != 0) cout << "encode UESecurityCapabilities IE error" << endl;
-	}
+  if (ret != 0)
+    cout << "encode UESecurityCapabilities IE error" << endl;
+}
 
-	void HandoverRequest::setGUAMI(PlmnId* m_plmnId, AMFRegionID* m_aMFRegionID, AMFSetID* m_aMFSetID, AMFPointer* m_aMFPointer)
-	{
+void HandoverRequest::setGUAMI(PlmnId *m_plmnId, AMFRegionID *m_aMFRegionID,
+                               AMFSetID *m_aMFSetID, AMFPointer *m_aMFPointer) {
   if (!guami)
     guami = new GUAMI;
 
-		Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t *)calloc(1, sizeof(Ngap_HandoverRequestIEs_t));
+  Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t*) calloc(
+      1, sizeof(Ngap_HandoverRequestIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_GUAMI;
   ie->criticality = Ngap_Criticality_reject;
   ie->value.present = Ngap_HandoverRequestIEs__value_PR_GUAMI;
-		guami->setGUAMI( m_plmnId,  m_aMFRegionID, m_aMFSetID,  m_aMFPointer);
+  guami->setGUAMI(m_plmnId, m_aMFRegionID, m_aMFSetID, m_aMFPointer);
   guami->encode2GUAMI(&(ie->value.choice.GUAMI));
 
   int ret = ASN_SEQUENCE_ADD(&handoverRequestIEs->protocolIEs.list, ie);
-		if (ret != 0) cout << "encode GUAMI IE error" << endl;
-	}
-	void HandoverRequest::setAllowedNSSAI(std::vector<S_NSSAI> list)
-	{
+  if (ret != 0)
+    cout << "encode GUAMI IE error" << endl;
+}
+void HandoverRequest::setAllowedNSSAI(std::vector<S_NSSAI> list) {
   if (!allowedNSSAI)
     allowedNSSAI = new Ngap_AllowedNSSAI_t();
 
-		for (int i = 0; i < list.size(); i++)
-		{
-			Ngap_AllowedNSSAI_Item_t *item = (Ngap_AllowedNSSAI_Item_t *)calloc(1, sizeof(Ngap_AllowedNSSAI_Item_t));
+  for (int i = 0; i < list.size(); i++) {
+    Ngap_AllowedNSSAI_Item_t *item = (Ngap_AllowedNSSAI_Item_t*) calloc(
+        1, sizeof(Ngap_AllowedNSSAI_Item_t));
     //item->s_NSSAI = list[i].s_NSSAI;
     //S_NSSAI *s_NSSAI = new S_NSSAI();
     list[i].encode2S_NSSAI(&item->s_NSSAI);
     int ret = ASN_SEQUENCE_ADD(&allowedNSSAI->list, item);
-			if (ret != 0) cout << "encode PDUSessionResourceHandoverListItem IE error" << endl;
+    if (ret != 0)
+      cout << "encode PDUSessionResourceHandoverListItem IE error" << endl;
   }
   asn_fprint(stderr, &asn_DEF_Ngap_AllowedNSSAI, allowedNSSAI);
-		Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t *)calloc(1, sizeof(Ngap_HandoverRequestIEs_t));
+  Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t*) calloc(
+      1, sizeof(Ngap_HandoverRequestIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_AllowedNSSAI;
   ie->criticality = Ngap_Criticality_reject;
   ie->value.present = Ngap_HandoverRequestIEs__value_PR_AllowedNSSAI;
   ie->value.choice.AllowedNSSAI = *allowedNSSAI;
   int ret = ASN_SEQUENCE_ADD(&handoverRequestIEs->protocolIEs.list, ie);
-		if (ret != 0) cout << "encode AllowedNSSAI IE error" << endl;
+  if (ret != 0)
+    cout << "encode AllowedNSSAI IE error" << endl;
 
-	
-	}
-	void HandoverRequest::setSecurityContext(long count, uint8_t* buffer)
-	{
+}
+void HandoverRequest::setSecurityContext(long count, uint8_t *buffer) {
   if (!SecurityContext)
     SecurityContext = new Ngap_SecurityContext_t();
 
@@ -321,66 +342,77 @@ namespace ngap{
   securitykey.encode2bitstring(SecurityContext->nextHopNH);
   SecurityContext->nextHopChainingCount = count;
 
-
-
-		Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t *)calloc(1, sizeof(Ngap_HandoverRequestIEs_t));
+  Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t*) calloc(
+      1, sizeof(Ngap_HandoverRequestIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_SecurityContext;
   ie->criticality = Ngap_Criticality_reject;
   ie->value.present = Ngap_HandoverRequestIEs__value_PR_SecurityContext;
   ie->value.choice.SecurityContext = *SecurityContext;
   int ret = ASN_SEQUENCE_ADD(&handoverRequestIEs->protocolIEs.list, ie);
-		if (ret != 0) cout << "encode SecurityContext IE error" << endl;
+  if (ret != 0)
+    cout << "encode SecurityContext IE error" << endl;
 
-	}
+}
 
-	void HandoverRequest::setPduSessionResourceSetupList(std::vector<PDUSessionResourceSetupRequestItem_t>list)
-	{
+void HandoverRequest::setPduSessionResourceSetupList(
+    std::vector<PDUSessionResourceSetupRequestItem_t> list) {
   if (!PDUSessionResourceSetupList)
     PDUSessionResourceSetupList = new PDUSessionResourceSetupListHOReq();
-		PDUSessionResourceSetupItemHOReq * m_pduSessionResourceSetupItemHOReq = new PDUSessionResourceSetupItemHOReq[list.size()]();
+  PDUSessionResourceSetupItemHOReq *m_pduSessionResourceSetupItemHOReq =
+      new PDUSessionResourceSetupItemHOReq[list.size()]();
 
-		for (int i = 0; i < list.size(); i++)
-		{
-			PDUSessionID * m_pDUSessionID = new PDUSessionID();
+  for (int i = 0; i < list.size(); i++) {
+    PDUSessionID *m_pDUSessionID = new PDUSessionID();
     m_pDUSessionID->setPDUSessionID(list[i].pduSessionId);
-			S_NSSAI * m_s_NSSAI = new S_NSSAI();
+    S_NSSAI *m_s_NSSAI = new S_NSSAI();
     m_s_NSSAI->setSst(list[i].s_nssai.sst);
     if (list[i].s_nssai.sd.size())
       m_s_NSSAI->setSd(list[i].s_nssai.sd);
-			m_pduSessionResourceSetupItemHOReq[i].setPDUSessionResourceSetupItemHOReq(m_pDUSessionID, m_s_NSSAI, list[i].pduSessionResourceSetupRequestTransfer);
+    m_pduSessionResourceSetupItemHOReq[i].setPDUSessionResourceSetupItemHOReq(
+        m_pDUSessionID, m_s_NSSAI,
+        list[i].pduSessionResourceSetupRequestTransfer);
   }
 
-		PDUSessionResourceSetupList->setPDUSessionResourceSetupListHOReq(m_pduSessionResourceSetupItemHOReq, list.size());
+  PDUSessionResourceSetupList->setPDUSessionResourceSetupListHOReq(
+      m_pduSessionResourceSetupItemHOReq, list.size());
 
-		Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t *)calloc(1, sizeof(Ngap_HandoverRequestIEs_t));
+  Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t*) calloc(
+      1, sizeof(Ngap_HandoverRequestIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_PDUSessionResourceSetupListHOReq;
   ie->criticality = Ngap_Criticality_reject;
-		ie->value.present = Ngap_HandoverRequestIEs__value_PR_PDUSessionResourceSetupListHOReq;
+  ie->value.present =
+      Ngap_HandoverRequestIEs__value_PR_PDUSessionResourceSetupListHOReq;
 
-		int ret = PDUSessionResourceSetupList->encode2PDUSessionResourceSetupListHOReq(&ie->value.choice.PDUSessionResourceSetupListHOReq);
-		if (!ret)
-		{
+  int ret =
+      PDUSessionResourceSetupList->encode2PDUSessionResourceSetupListHOReq(
+          &ie->value.choice.PDUSessionResourceSetupListHOReq);
+  if (!ret) {
     cout << "encode PDUSessionResourceSetupListSUReq IE error" << endl;
     return;
   }
 
   ret = ASN_SEQUENCE_ADD(&handoverRequestIEs->protocolIEs.list, ie);
-		if (ret != 0) cout << "encode PDUSessionResourceSetupListSUReq IE error" << endl;
-	}
+  if (ret != 0)
+    cout << "encode PDUSessionResourceSetupListSUReq IE error" << endl;
+}
 
-	void HandoverRequest::setSourceToTarget_TransparentContainer(OCTET_STRING_t sourceTotarget)
-	{
+void HandoverRequest::setSourceToTarget_TransparentContainer(
+    OCTET_STRING_t sourceTotarget) {
   if (!SourceToTarget_TransparentContainer)
-			SourceToTarget_TransparentContainer = new Ngap_SourceToTarget_TransparentContainer_t();
+    SourceToTarget_TransparentContainer =
+        new Ngap_SourceToTarget_TransparentContainer_t();
 
-		Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t *)calloc(1, sizeof(Ngap_HandoverRequestIEs_t));
+  Ngap_HandoverRequestIEs_t *ie = (Ngap_HandoverRequestIEs_t*) calloc(
+      1, sizeof(Ngap_HandoverRequestIEs_t));
   ie->id = Ngap_ProtocolIE_ID_id_SourceToTarget_TransparentContainer;
   ie->criticality = Ngap_Criticality_reject;
-		ie->value.present = Ngap_HandoverRequestIEs__value_PR_SourceToTarget_TransparentContainer;
+  ie->value.present =
+      Ngap_HandoverRequestIEs__value_PR_SourceToTarget_TransparentContainer;
   ie->value.choice.SourceToTarget_TransparentContainer = sourceTotarget;
   int ret = ASN_SEQUENCE_ADD(&handoverRequestIEs->protocolIEs.list, ie);
-		if (ret != 0) cout << "encode SourceToTarget_TransparentContainer IE error" << endl;
-	}
+  if (ret != 0)
+    cout << "encode SourceToTarget_TransparentContainer IE error" << endl;
+}
 
 }
 

src/ngap/ngapMsgs/HandoverRequest.hpp

@@ -12,11 +12,11 @@
 #include "RAN-UE-NGAP-ID.hpp"
 #include "Cause.hpp"
 #include  "UEAggregateMaxBitRate.hpp"
-extern "C"{
-  #include "Ngap_NGAP-PDU.h"
-  #include "Ngap_ProtocolIE-Field.h"
-  #include "Ngap_NGSetupRequest.h"
-  #include "Ngap_AllowedNSSAI-Item.h"
+extern "C" {
+#include "Ngap_NGAP-PDU.h"
+#include "Ngap_ProtocolIE-Field.h"
+#include "Ngap_NGSetupRequest.h"
+#include "Ngap_AllowedNSSAI-Item.h"
 }
 
 #include "UESecurityCapabilities.hpp"
@@ -24,12 +24,10 @@ extern "C"{
 #include "GUAMI.hpp"
 #include "S-NSSAI.hpp"
 #include "SecurityKey.hpp"
-namespace ngap{
+namespace ngap {
 
-
-
-	class HandoverRequest{
-	public:	
+class HandoverRequest {
+public:
   HandoverRequest();
   virtual ~HandoverRequest();
 
@@ -51,7 +49,7 @@ namespace ngap{
   //bool decodefrompdu(Ngap_NGAP_PDU_t *ngap_msg_pdu);
   unsigned long getAmfUeNgapId();//return -1;(不存在)
 
-	private: 
+private:
   Ngap_NGAP_PDU_t *handoverRequestPdu;
   Ngap_HandoverRequest_t *handoverRequestIEs;
   /***************** for decoding ****************/
@@ -75,7 +73,7 @@ namespace ngap{
   GUAMI *guami;
   //Redirection for Voice EPS Fallback 
   //CN Assisted RAN Parameters Tuning
-	};
+};
 
 }
 

src/ngap/ngapMsgs/HandoverRequestAck.cpp

@@ -30,8 +30,7 @@
 #include "TransportLayerAddress.hpp"
 #include "String2Value.hpp"
 #include "GTP-TEID.hpp"
-extern "C"
-{
+extern "C" {
 #include "constr_TYPE.h"
 #include "Ngap_NGAP-PDU.h"
 #include "asn_codecs.h"
@@ -46,170 +45,176 @@ extern "C"
 
 using namespace std;
 
-namespace ngap
-{
+namespace ngap {
 
-	HandoverRequestAck::HandoverRequestAck()
-	{
+HandoverRequestAck::HandoverRequestAck() {
   amfUeNgapId = NULL;
   ranUeNgapId = NULL;
   pduSessionResourceAdmittedList = NULL;
   PDUSessionResourceFailedToSetupList = NULL;
   TargetToSource_TransparentContainer = NULL;
   CriticalityDiagnostics = NULL;
-	}
-	HandoverRequestAck::~HandoverRequestAck() {}
-	unsigned long HandoverRequestAck::getAmfUeNgapId()
-	{
+}
+HandoverRequestAck::~HandoverRequestAck() {
+}
+unsigned long HandoverRequestAck::getAmfUeNgapId() {
   return amfUeNgapId->getAMF_UE_NGAP_ID();
-	}
-	void HandoverRequestAck::setMessageType()
-	{
+}
+void HandoverRequestAck::setMessageType() {
   if (!handoverRequestAckPdu)
-			handoverRequestAckPdu = (Ngap_NGAP_PDU_t *)calloc(1, sizeof(Ngap_NGAP_PDU_t));
+    handoverRequestAckPdu = (Ngap_NGAP_PDU_t*) calloc(1,
+                                                      sizeof(Ngap_NGAP_PDU_t));
 
   MessageType handoverRequestMessageTypeIE;
-		handoverRequestMessageTypeIE.setProcedureCode(Ngap_ProcedureCode_id_HandoverResourceAllocation);
-		handoverRequestMessageTypeIE.setTypeOfMessage(Ngap_NGAP_PDU_PR_initiatingMessage);
+  handoverRequestMessageTypeIE.setProcedureCode(
+      Ngap_ProcedureCode_id_HandoverResourceAllocation);
+  handoverRequestMessageTypeIE.setTypeOfMessage(
+      Ngap_NGAP_PDU_PR_initiatingMessage);
   handoverRequestMessageTypeIE.setCriticality(Ngap_Criticality_reject);
-		handoverRequestMessageTypeIE.setValuePresent(Ngap_InitiatingMessage__value_PR_HandoverRequest);
+  handoverRequestMessageTypeIE.setValuePresent(
+      Ngap_InitiatingMessage__value_PR_HandoverRequest);
 
-		if (handoverRequestMessageTypeIE.getProcedureCode() == Ngap_ProcedureCode_id_HandoverResourceAllocation && handoverRequestMessageTypeIE.getTypeOfMessage() == Ngap_NGAP_PDU_PR_initiatingMessage)
-		{
+  if (handoverRequestMessageTypeIE.getProcedureCode()
+      == Ngap_ProcedureCode_id_HandoverResourceAllocation
+      && handoverRequestMessageTypeIE.getTypeOfMessage()
+          == Ngap_NGAP_PDU_PR_initiatingMessage) {
     handoverRequestMessageTypeIE.encode2pdu(handoverRequestAckPdu);
-			handoverRequestAckIEs = &(handoverRequestAckPdu->choice.successfulOutcome->value.choice.HandoverRequestAcknowledge);
-		}
-		else
-		{
-			cout << "[warning] This information doesn't refer to HandoverRequest Message!!!" << endl;
-		}
+    handoverRequestAckIEs = &(handoverRequestAckPdu->choice.successfulOutcome
+        ->value.choice.HandoverRequestAcknowledge);
+  } else {
+    cout
+        << "[warning] This information doesn't refer to HandoverRequest Message!!!"
+        << endl;
   }
-	uint32_t HandoverRequestAck::getRanUeNgapId()
-	{
+}
+uint32_t HandoverRequestAck::getRanUeNgapId() {
   return ranUeNgapId->getRanUeNgapId();
-	}
-	OCTET_STRING_t HandoverRequestAck::getTargetToSource_TransparentContainer()
-	{
+}
+OCTET_STRING_t HandoverRequestAck::getTargetToSource_TransparentContainer() {
   return *TargetToSource_TransparentContainer;
-	}
+}
 
-	bool HandoverRequestAck::getPDUSessionResourceAdmittedList(std::vector<PDUSessionResourceAdmittedItem_t> &list)
-	{
+bool HandoverRequestAck::getPDUSessionResourceAdmittedList(
+    std::vector<PDUSessionResourceAdmittedItem_t> &list) {
   if (!pduSessionResourceAdmittedList)
     return false;
 
   PDUSessionResourceAdmittedItem *m_pduSessionResourceAdmittedItem;
   int num = 0;
-		pduSessionResourceAdmittedList->getPDUSessionResourceAdmittedList(m_pduSessionResourceAdmittedItem, num);
+  pduSessionResourceAdmittedList->getPDUSessionResourceAdmittedList(
+      m_pduSessionResourceAdmittedItem, num);
 
-		for (int i = 0; i < num; i++)
-		{
+  for (int i = 0; i < num; i++) {
     PDUSessionResourceAdmittedItem_t response;
 
     PDUSessionID *m_pDUSessionID;
-			m_pduSessionResourceAdmittedItem[i].getPDUSessionResourceAdmittedItem(m_pDUSessionID, response.handoverRequestAcknowledgeTransfer);
+    m_pduSessionResourceAdmittedItem[i].getPDUSessionResourceAdmittedItem(
+        m_pDUSessionID, response.handoverRequestAcknowledgeTransfer);
     m_pDUSessionID->getPDUSessionID(response.pduSessionId);
     list.push_back(response);
   }
 
   return true;
-	}
+}
 
-	bool HandoverRequestAck::decodefrompdu(Ngap_NGAP_PDU_t *ngap_msg_pdu)
-	{
+bool HandoverRequestAck::decodefrompdu(Ngap_NGAP_PDU_t *ngap_msg_pdu) {
   handoverRequestAckPdu = ngap_msg_pdu;
 
-		if (handoverRequestAckPdu->present == Ngap_NGAP_PDU_PR_successfulOutcome)
-		{
-			if (handoverRequestAckPdu->choice.successfulOutcome && handoverRequestAckPdu->choice.successfulOutcome->procedureCode == Ngap_ProcedureCode_id_HandoverResourceAllocation && handoverRequestAckPdu->choice.successfulOutcome->criticality == Ngap_Criticality_reject && handoverRequestAckPdu->choice.successfulOutcome->value.present == Ngap_SuccessfulOutcome__value_PR_HandoverRequestAcknowledge)
-			{
-				handoverRequestAckIEs = &handoverRequestAckPdu->choice.successfulOutcome->value.choice.HandoverRequestAcknowledge;
-			}
-			else
-			{
+  if (handoverRequestAckPdu->present == Ngap_NGAP_PDU_PR_successfulOutcome) {
+    if (handoverRequestAckPdu->choice.successfulOutcome
+        && handoverRequestAckPdu->choice.successfulOutcome->procedureCode
+            == Ngap_ProcedureCode_id_HandoverResourceAllocation
+        && handoverRequestAckPdu->choice.successfulOutcome->criticality
+            == Ngap_Criticality_reject
+        && handoverRequestAckPdu->choice.successfulOutcome->value.present
+            == Ngap_SuccessfulOutcome__value_PR_HandoverRequestAcknowledge) {
+      handoverRequestAckIEs = &handoverRequestAckPdu->choice.successfulOutcome
+          ->value.choice.HandoverRequestAcknowledge;
+    } else {
       cout << "Check handoverRequestAck message error!!!" << endl;
       return false;
     }
-		}
-		else
-		{
+  } else {
     cout << "handoverRequestAck MessageType error!!!" << endl;
     return false;
   }
-		for (int i = 0; i < handoverRequestAckIEs->protocolIEs.list.count; i++)
-		{
-			switch (handoverRequestAckIEs->protocolIEs.list.array[i]->id)
-			{
-			case Ngap_ProtocolIE_ID_id_AMF_UE_NGAP_ID:
-			{
-				if (handoverRequestAckIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_ignore && handoverRequestAckIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverRequestAcknowledgeIEs__value_PR_AMF_UE_NGAP_ID)
-				{
+  for (int i = 0; i < handoverRequestAckIEs->protocolIEs.list.count; i++) {
+    switch (handoverRequestAckIEs->protocolIEs.list.array[i]->id) {
+      case Ngap_ProtocolIE_ID_id_AMF_UE_NGAP_ID: {
+        if (handoverRequestAckIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_ignore
+            && handoverRequestAckIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverRequestAcknowledgeIEs__value_PR_AMF_UE_NGAP_ID) {
           amfUeNgapId = new AMF_UE_NGAP_ID();
-					if (!amfUeNgapId->decodefromAMF_UE_NGAP_ID(handoverRequestAckIEs->protocolIEs.list.array[i]->value.choice.AMF_UE_NGAP_ID))
-					{
+          if (!amfUeNgapId->decodefromAMF_UE_NGAP_ID(
+              handoverRequestAckIEs->protocolIEs.list.array[i]->value.choice
+                  .AMF_UE_NGAP_ID)) {
             cout << "decoded ngap AMF_UE_NGAP_ID IE error" << endl;
             return false;
           }
-				}
-				else
-				{
+        } else {
           cout << "decoded ngap AMF_UE_NGAP_ID IE error" << endl;
           return false;
         }
       }
         break;
-			case Ngap_ProtocolIE_ID_id_RAN_UE_NGAP_ID:
-			{
-				if (handoverRequestAckIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_ignore && handoverRequestAckIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverRequestAcknowledgeIEs__value_PR_RAN_UE_NGAP_ID)
-				{
+      case Ngap_ProtocolIE_ID_id_RAN_UE_NGAP_ID: {
+        if (handoverRequestAckIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_ignore
+            && handoverRequestAckIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverRequestAcknowledgeIEs__value_PR_RAN_UE_NGAP_ID) {
           ranUeNgapId = new RAN_UE_NGAP_ID();
-					if (!ranUeNgapId->decodefromRAN_UE_NGAP_ID(handoverRequestAckIEs->protocolIEs.list.array[i]->value.choice.RAN_UE_NGAP_ID))
-					{
+          if (!ranUeNgapId->decodefromRAN_UE_NGAP_ID(
+              handoverRequestAckIEs->protocolIEs.list.array[i]->value.choice
+                  .RAN_UE_NGAP_ID)) {
             cout << "decoded ngap RAN_UE_NGAP_ID IE error" << endl;
             return false;
           }
-				}
-				else
-				{
+        } else {
           cout << "decoded ngap RAN_UE_NGAP_ID IE error" << endl;
           return false;
         }
       }
         break;
-			case Ngap_ProtocolIE_ID_id_PDUSessionResourceAdmittedList:
-			{
-				if (handoverRequestAckIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_ignore && handoverRequestAckIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverRequestAcknowledgeIEs__value_PR_PDUSessionResourceAdmittedList)
-				{
+      case Ngap_ProtocolIE_ID_id_PDUSessionResourceAdmittedList: {
+        if (handoverRequestAckIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_ignore
+            && handoverRequestAckIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverRequestAcknowledgeIEs__value_PR_PDUSessionResourceAdmittedList) {
           pduSessionResourceAdmittedList = new PDUSessionResourceAdmittedList();
-					if (!pduSessionResourceAdmittedList->decodefromPDUSessionResourceAdmittedList(&handoverRequestAckIEs->protocolIEs.list.array[i]->value.choice.PDUSessionResourceAdmittedList))
-					{
-						cout << "decoded ngap PDUSessionResourceAdmittedList IE error" << endl;
+          if (!pduSessionResourceAdmittedList
+              ->decodefromPDUSessionResourceAdmittedList(
+              &handoverRequestAckIEs->protocolIEs.list.array[i]->value.choice
+                  .PDUSessionResourceAdmittedList)) {
+            cout << "decoded ngap PDUSessionResourceAdmittedList IE error"
+                << endl;
             return false;
           }
-				}
-				else
-				{
-					cout << "decoded ngap PDUSessionResourceAdmittedList Type IE error" << endl;
+        } else {
+          cout << "decoded ngap PDUSessionResourceAdmittedList Type IE error"
+              << endl;
           return false;
         }
       }
         break;
-			case Ngap_ProtocolIE_ID_id_TargetToSource_TransparentContainer:
-			{
-				if (handoverRequestAckIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_reject && handoverRequestAckIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverRequestAcknowledgeIEs__value_PR_TargetToSource_TransparentContainer)
-				{
-					TargetToSource_TransparentContainer = new Ngap_TargetToSource_TransparentContainer_t();
-					*TargetToSource_TransparentContainer = handoverRequestAckIEs->protocolIEs.list.array[i]->value.choice.TargetToSource_TransparentContainer;
-				}
-				else
-				{
-					cout << "decoded ngap TargetToSource_TransparentContainer IE error" << endl;
+      case Ngap_ProtocolIE_ID_id_TargetToSource_TransparentContainer: {
+        if (handoverRequestAckIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_reject
+            && handoverRequestAckIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverRequestAcknowledgeIEs__value_PR_TargetToSource_TransparentContainer) {
+          TargetToSource_TransparentContainer =
+              new Ngap_TargetToSource_TransparentContainer_t();
+          *TargetToSource_TransparentContainer = handoverRequestAckIEs
+              ->protocolIEs.list.array[i]->value.choice
+              .TargetToSource_TransparentContainer;
+        } else {
+          cout << "decoded ngap TargetToSource_TransparentContainer IE error"
+              << endl;
           return false;
         }
       }
         break;
-			default:
-			{
+      default: {
         cout << "decoded ngap message pdu error" << endl;
         return false;
       }
@@ -217,17 +222,18 @@ namespace ngap
   }
 
   return true;
-	}
+}
 
-	int HandoverRequestAck::encode2buffer(uint8_t *buf, int buf_size)
-	{
+int HandoverRequestAck::encode2buffer(uint8_t *buf, int buf_size) {
   asn_fprint(stderr, &asn_DEF_Ngap_NGAP_PDU, handoverRequestAckPdu);
-		asn_enc_rval_t er = aper_encode_to_buffer(&asn_DEF_Ngap_NGAP_PDU, NULL, handoverRequestAckPdu, buf, buf_size);
+  asn_enc_rval_t er = aper_encode_to_buffer(&asn_DEF_Ngap_NGAP_PDU, NULL,
+                                            handoverRequestAckPdu, buf,
+                                            buf_size);
   cout << "er.encoded(" << er.encoded << ")" << endl;
   return er.encoded;
-	}
+}
 
-	/*	void HandoverRequestAck::setMessageType()
+/*	void HandoverRequestAck::setMessageType()
  {
  if (!handoverRequestAckPdu) handoverRequestAckPdu = (Ngap_NGAP_PDU_t*)calloc(1, sizeof(Ngap_NGAP_PDU_t));
 
@@ -247,8 +253,8 @@ namespace ngap
  cout << "[warning] This information doesn't refer to HandoverRequestAcknowledge Message!!!" << endl;
  }
  }
-*/
-	/*	void HandoverRequestAck::setAmfUeNgapId(unsigned long id)
+ */
+/*	void HandoverRequestAck::setAmfUeNgapId(unsigned long id)
  {
  if (!amfUeNgapId)
  amfUeNgapId = new AMF_UE_NGAP_ID();
@@ -269,8 +275,8 @@ namespace ngap
  ret = ASN_SEQUENCE_ADD(&handoverRequestAckIEs->protocolIEs.list, ie);
  if (ret != 0) cout << "encode AMF_UE_NGAP_ID IE error" << endl;
  }
-*/
-	/*	void HandoverRequestAck::setRanUeNgapId(uint32_t ran_ue_ngap_id)
+ */
+/*	void HandoverRequestAck::setRanUeNgapId(uint32_t ran_ue_ngap_id)
  {
  if (!ranUeNgapId)
  ranUeNgapId = new RAN_UE_NGAP_ID();
@@ -292,8 +298,8 @@ namespace ngap
  if (ret != 0) cout << "encode RAN_UE_NGAP_ID IE error" << endl;
  }
 
-*/
-	/*	void HandoverRequestAck::setPDUSessionResourceAdmittedList(std::vector<Ngap_PDUSessionResourceAdmittedItem_t> list)
+ */
+/*	void HandoverRequestAck::setPDUSessionResourceAdmittedList(std::vector<Ngap_PDUSessionResourceAdmittedItem_t> list)
  {
  if (!PDUSessionResourceAdmittedList)
  PDUSessionResourceAdmittedList = new Ngap_PDUSessionResourceAdmittedList_t();
@@ -331,8 +337,8 @@ namespace ngap
  if (ret != 0) cout << "encode PDUSessionResourceAdmittedList IE error" << endl;
 
  }
-*/
-	/*	void HandoverRequestAck::setTargetToSource_TransparentContainer(OCTET_STRING_t targetTosource)
+ */
+/*	void HandoverRequestAck::setTargetToSource_TransparentContainer(OCTET_STRING_t targetTosource)
  {
  if (!TargetToSource_TransparentContainer)
  TargetToSource_TransparentContainer = new Ngap_TargetToSource_TransparentContainer_t();
@@ -346,6 +352,6 @@ namespace ngap
  if (ret != 0) cout << "encode TargetToSource_TransparentContainer IE error" << endl;
  }
 
-*/
+ */
 
 }  // namespace ngap

src/ngap/ngapMsgs/HandoverRequestAck.hpp

@@ -51,20 +51,21 @@ extern "C" {
 
 namespace ngap {
 
-	class HandoverRequestAck {
+class HandoverRequestAck {
  public:
   HandoverRequestAck();
   virtual ~HandoverRequestAck();
 
-		int  encode2buffer(uint8_t* buf, int buf_size);
-		bool decodefrompdu(Ngap_NGAP_PDU_t* ngap_msg_pdu);
+  int encode2buffer(uint8_t *buf, int buf_size);
+  bool decodefrompdu(Ngap_NGAP_PDU_t *ngap_msg_pdu);
 
-		unsigned long getAmfUeNgapId();//return -1;(不存在)
-		uint32_t getRanUeNgapId();//return -1;(不存在)
+  unsigned long getAmfUeNgapId();  //return -1;(不存在)
+  uint32_t getRanUeNgapId();  //return -1;(不存在)
 
   void setMessageType();  //Initialize the PDU and populate the MessageType;
   OCTET_STRING_t getTargetToSource_TransparentContainer();
-		bool getPDUSessionResourceAdmittedList(std::vector<PDUSessionResourceAdmittedItem_t>& list); 
+  bool getPDUSessionResourceAdmittedList(
+      std::vector<PDUSessionResourceAdmittedItem_t> &list);
 
  private:
   Ngap_NGAP_PDU_t *handoverRequestAckPdu;
@@ -72,13 +73,13 @@ namespace ngap {
   /***************** for decoding ****************/
   AMF_UE_NGAP_ID *amfUeNgapId;
   RAN_UE_NGAP_ID *ranUeNgapId;
-		Ngap_HandoverType_t* handovertype;
+  Ngap_HandoverType_t *handovertype;
 
   PDUSessionResourceAdmittedList *pduSessionResourceAdmittedList;
   Ngap_PDUSessionResourceFailedToSetupListHOAck_t *PDUSessionResourceFailedToSetupList;
   Ngap_TargetToSource_TransparentContainer_t *TargetToSource_TransparentContainer;
   Ngap_CriticalityDiagnostics_t *CriticalityDiagnostics;
-	};
+};
 
 }
 

src/ngap/ngapMsgs/HandoverRequiredMsg.cpp

 #include "HandoverRequiredMsg.hpp"
-extern "C"{
-  #include "constr_TYPE.h"
-  #include "Ngap_NGAP-PDU.h"
-  #include "asn_codecs.h"
-  #include "per_encoder.h"
-  #include "per_decoder.h"
-  #include "constraints.h"
+extern "C" {
+#include "constr_TYPE.h"
+#include "Ngap_NGAP-PDU.h"
+#include "asn_codecs.h"
+#include "per_encoder.h"
+#include "per_decoder.h"
+#include "constraints.h"
 }
 #include "TAI.hpp"
 #include <iostream>
@@ -13,10 +13,9 @@ extern "C"{
 
 using namespace std;
 
-namespace ngap{
+namespace ngap {
 
-	HandoverRequiredMsg::HandoverRequiredMsg()
-	{
+HandoverRequiredMsg::HandoverRequiredMsg() {
   amfUeNgapId = NULL;
   ranUeNgapId = NULL;
   handovertype = NULL;
@@ -25,209 +24,224 @@ namespace ngap{
   directforwardingPathAvailability = NULL;
   PDUSessionResourceList = NULL;
   SourceToTarget_TransparentContainer = NULL;
-	}
-	HandoverRequiredMsg::~HandoverRequiredMsg() {}
+}
+HandoverRequiredMsg::~HandoverRequiredMsg() {
+}
 
-	unsigned long HandoverRequiredMsg::getAmfUeNgapId()
-	{
+unsigned long HandoverRequiredMsg::getAmfUeNgapId() {
   return amfUeNgapId->getAMF_UE_NGAP_ID();
-	}
+}
 
-	uint32_t HandoverRequiredMsg::getRanUeNgapId()
-	{
+uint32_t HandoverRequiredMsg::getRanUeNgapId() {
   return ranUeNgapId->getRanUeNgapId();
-	}
+}
 
-	Ngap_HandoverType_t HandoverRequiredMsg::getHandoverType()
-	{
+Ngap_HandoverType_t HandoverRequiredMsg::getHandoverType() {
   return *handovertype;
-	}
-	Ngap_Cause_PR HandoverRequiredMsg::getChoiceOfCause()
-	{
+}
+Ngap_Cause_PR HandoverRequiredMsg::getChoiceOfCause() {
   return cause->getChoiceOfCause();
-	}
-	long HandoverRequiredMsg::getCauseValue()
-	{
+}
+long HandoverRequiredMsg::getCauseValue() {
   return cause->getValue();
-	}
-	void HandoverRequiredMsg::getGlobalRanNodeId(GlobalgNBId *&ptr)
-	{
-		ptr->decodefromGlobalgNBId(targetid->choice.targetRANNodeID->globalRANNodeID.choice.globalGNB_ID);
-	}
-	void HandoverRequiredMsg::getTAI(TAI *&ptr)
-	{
+}
+void HandoverRequiredMsg::getGlobalRanNodeId(GlobalgNBId *&ptr) {
+  ptr->decodefromGlobalgNBId(
+      targetid->choice.targetRANNodeID->globalRANNodeID.choice.globalGNB_ID);
+}
+void HandoverRequiredMsg::getTAI(TAI *&ptr) {
   ptr->decodefromTAI(&(targetid->choice.targetRANNodeID->selectedTAI));
-	}
-	OCTET_STRING_t HandoverRequiredMsg::getSourceToTarget_TransparentContainer()
-	{
+}
+OCTET_STRING_t HandoverRequiredMsg::getSourceToTarget_TransparentContainer() {
   return *SourceToTarget_TransparentContainer;
 
-	}
+}
 
-	bool HandoverRequiredMsg::getPDUSessionResourceList(std::vector<PDUSessionResourceItem_t> &list)
-	{
-		if (!PDUSessionResourceList) return false;
+bool HandoverRequiredMsg::getPDUSessionResourceList(
+    std::vector<PDUSessionResourceItem_t> &list) {
+  if (!PDUSessionResourceList)
+    return false;
 
   PDUSessionResourceItemHORqd *m_pduSessionResourceItemHORqd;
   int num = 0;
-		PDUSessionResourceList->getPDUSessionResourceListHORqd(m_pduSessionResourceItemHORqd, num);
+  PDUSessionResourceList->getPDUSessionResourceListHORqd(
+      m_pduSessionResourceItemHORqd, num);
 
-		for (int i = 0; i < num; i++)
-		{
+  for (int i = 0; i < num; i++) {
     PDUSessionResourceItem_t response;
 
     PDUSessionID *m_pDUSessionID;
-			m_pduSessionResourceItemHORqd[i].getPDUSessionResourceItemHORqd(m_pDUSessionID, response.HandoverRequiredTransfer);
+    m_pduSessionResourceItemHORqd[i].getPDUSessionResourceItemHORqd(
+        m_pDUSessionID, response.HandoverRequiredTransfer);
     m_pDUSessionID->getPDUSessionID(response.pduSessionId);
 
     list.push_back(response);
   }
 
   return true;
-	}
+}
 
-	long HandoverRequiredMsg::getDirectForwardingPathAvailability()
-	{	
+long HandoverRequiredMsg::getDirectForwardingPathAvailability() {
   return *directforwardingPathAvailability;
-	}
+}
 
-	bool HandoverRequiredMsg::decodefrompdu(Ngap_NGAP_PDU_t *ngap_msg_pdu)
-	{
+bool HandoverRequiredMsg::decodefrompdu(Ngap_NGAP_PDU_t *ngap_msg_pdu) {
   handoverRequiredPdu = ngap_msg_pdu;
 
-		if (handoverRequiredPdu->present == Ngap_NGAP_PDU_PR_initiatingMessage)
-		{
-			if (handoverRequiredPdu->choice.initiatingMessage && handoverRequiredPdu->choice.initiatingMessage->procedureCode == Ngap_ProcedureCode_id_HandoverPreparation && handoverRequiredPdu->choice.initiatingMessage->criticality == Ngap_Criticality_reject && handoverRequiredPdu->choice.initiatingMessage->value.present == Ngap_InitiatingMessage__value_PR_HandoverRequired)
-			{
-				handoverRequiredIEs = &handoverRequiredPdu->choice.initiatingMessage->value.choice.HandoverRequired;
-			}
-			else
-			{
+  if (handoverRequiredPdu->present == Ngap_NGAP_PDU_PR_initiatingMessage) {
+    if (handoverRequiredPdu->choice.initiatingMessage
+        && handoverRequiredPdu->choice.initiatingMessage->procedureCode
+            == Ngap_ProcedureCode_id_HandoverPreparation
+        && handoverRequiredPdu->choice.initiatingMessage->criticality
+            == Ngap_Criticality_reject
+        && handoverRequiredPdu->choice.initiatingMessage->value.present
+            == Ngap_InitiatingMessage__value_PR_HandoverRequired) {
+      handoverRequiredIEs = &handoverRequiredPdu->choice.initiatingMessage
+          ->value.choice.HandoverRequired;
+    } else {
       cout << "Check HandoverRequired message error!!!" << endl;
       return false;
     }
-		}
-		else
-		{
+  } else {
     cout << "HandoverRequired MessageType error!!!" << endl;
     return false;
   }
-		for (int i = 0; i < handoverRequiredIEs->protocolIEs.list.count; i++)
-		{
-			switch (handoverRequiredIEs->protocolIEs.list.array[i]->id)
-			{
+  for (int i = 0; i < handoverRequiredIEs->protocolIEs.list.count; i++) {
+    switch (handoverRequiredIEs->protocolIEs.list.array[i]->id) {
       case Ngap_ProtocolIE_ID_id_AMF_UE_NGAP_ID: {
-				if (handoverRequiredIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_reject && handoverRequiredIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverRequiredIEs__value_PR_AMF_UE_NGAP_ID)
-				{
+        if (handoverRequiredIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_reject
+            && handoverRequiredIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverRequiredIEs__value_PR_AMF_UE_NGAP_ID) {
           amfUeNgapId = new AMF_UE_NGAP_ID();
-					if (!amfUeNgapId->decodefromAMF_UE_NGAP_ID(handoverRequiredIEs->protocolIEs.list.array[i]->value.choice.AMF_UE_NGAP_ID))
-					{
+          if (!amfUeNgapId->decodefromAMF_UE_NGAP_ID(
+              handoverRequiredIEs->protocolIEs.list.array[i]->value.choice
+                  .AMF_UE_NGAP_ID)) {
             cout << "decoded ngap AMF_UE_NGAP_ID IE error" << endl;
             return false;
           }
-				}
-				else
-				{
+        } else {
           cout << "decoded ngap AMF_UE_NGAP_ID IE error" << endl;
           return false;
         }
-			}break;
+      }
+        break;
       case Ngap_ProtocolIE_ID_id_RAN_UE_NGAP_ID: {
-				if (handoverRequiredIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_reject && handoverRequiredIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverRequiredIEs__value_PR_RAN_UE_NGAP_ID)
-				{
+        if (handoverRequiredIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_reject
+            && handoverRequiredIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverRequiredIEs__value_PR_RAN_UE_NGAP_ID) {
           ranUeNgapId = new RAN_UE_NGAP_ID();
-					if (!ranUeNgapId->decodefromRAN_UE_NGAP_ID(handoverRequiredIEs->protocolIEs.list.array[i]->value.choice.RAN_UE_NGAP_ID))
-					{
+          if (!ranUeNgapId->decodefromRAN_UE_NGAP_ID(
+              handoverRequiredIEs->protocolIEs.list.array[i]->value.choice
+                  .RAN_UE_NGAP_ID)) {
             cout << "decoded ngap RAN_UE_NGAP_ID IE error" << endl;
             return false;
           }
-				}
-				else
-				{
+        } else {
           cout << "decoded ngap RAN_UE_NGAP_ID IE error" << endl;
           return false;
         }
-			}break;
+      }
+        break;
       case Ngap_ProtocolIE_ID_id_HandoverType: {
-				if (handoverRequiredIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_reject && handoverRequiredIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverRequiredIEs__value_PR_HandoverType)
-				{
+        if (handoverRequiredIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_reject
+            && handoverRequiredIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverRequiredIEs__value_PR_HandoverType) {
           handovertype = new Ngap_HandoverType_t();
-					*handovertype = handoverRequiredIEs->protocolIEs.list.array[i]->value.choice.HandoverType;
-				}
-				else
-				{
+          *handovertype = handoverRequiredIEs->protocolIEs.list.array[i]->value
+              .choice.HandoverType;
+        } else {
           cout << "decoded ngap Handover Type IE error" << endl;
           return false;
         }
-			}break;
+      }
+        break;
       case Ngap_ProtocolIE_ID_id_Cause: {
-				if (handoverRequiredIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_ignore && handoverRequiredIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverRequiredIEs__value_PR_Cause)
-				{
+        if (handoverRequiredIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_ignore
+            && handoverRequiredIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverRequiredIEs__value_PR_Cause) {
           cause = new Cause();
-					if(!cause->decodefromCause(&handoverRequiredIEs->protocolIEs.list.array[i]->value.choice.Cause))
-					{
+          if (!cause->decodefromCause(
+              &handoverRequiredIEs->protocolIEs.list.array[i]->value.choice
+                  .Cause)) {
             cout << "decoded ngap Cause IE error" << endl;
             return false;
           }
-				}
-				else
-				{
+        } else {
           cout << "decoded ngap Cause IE error" << endl;
           return false;
         }
-			}break;
+      }
+        break;
       case Ngap_ProtocolIE_ID_id_TargetID: {
-				if (handoverRequiredIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_reject && handoverRequiredIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverRequiredIEs__value_PR_TargetID)
-				{
+        if (handoverRequiredIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_reject
+            && handoverRequiredIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverRequiredIEs__value_PR_TargetID) {
           targetid = new Ngap_TargetID_t();
-					*targetid = handoverRequiredIEs->protocolIEs.list.array[i]->value.choice.TargetID;	
-				}
-				else
-				{
+          *targetid = handoverRequiredIEs->protocolIEs.list.array[i]->value
+              .choice.TargetID;
+        } else {
           cout << "decoded ngap TargetID IE error" << endl;
           return false;
         }
-			}break;
-			case Ngap_ProtocolIE_ID_id_DirectForwardingPathAvailability: {
-				if (handoverRequiredIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_ignore && handoverRequiredIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverRequiredIEs__value_PR_DirectForwardingPathAvailability)
-				{
-					directforwardingPathAvailability = new Ngap_DirectForwardingPathAvailability_t();
-					*directforwardingPathAvailability = handoverRequiredIEs->protocolIEs.list.array[i]->value.choice.DirectForwardingPathAvailability;
       }
-				else
-				{
-					cout << "decoded ngap DirectForwardingPathAvailability IE error" << endl;
+        break;
+      case Ngap_ProtocolIE_ID_id_DirectForwardingPathAvailability: {
+        if (handoverRequiredIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_ignore
+            && handoverRequiredIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverRequiredIEs__value_PR_DirectForwardingPathAvailability) {
+          directforwardingPathAvailability =
+              new Ngap_DirectForwardingPathAvailability_t();
+          *directforwardingPathAvailability = handoverRequiredIEs->protocolIEs
+              .list.array[i]->value.choice.DirectForwardingPathAvailability;
+        } else {
+          cout << "decoded ngap DirectForwardingPathAvailability IE error"
+              << endl;
           return false;
         }
-			}break;
+      }
+        break;
       case Ngap_ProtocolIE_ID_id_PDUSessionResourceListHORqd: {
-				if (handoverRequiredIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_reject && handoverRequiredIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverRequiredIEs__value_PR_PDUSessionResourceListHORqd)
-				{
+        if (handoverRequiredIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_reject
+            && handoverRequiredIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverRequiredIEs__value_PR_PDUSessionResourceListHORqd) {
           PDUSessionResourceList = new PDUSessionResourceListHORqd();
-					if (!PDUSessionResourceList->decodefromPDUSessionResourceListHORqd(&handoverRequiredIEs->protocolIEs.list.array[i]->value.choice.PDUSessionResourceListHORqd))
-					{
-						cout << "decoded ngap PDUSessionResourceSetupListCxtRes IE error" << endl;
+          if (!PDUSessionResourceList->decodefromPDUSessionResourceListHORqd(
+              &handoverRequiredIEs->protocolIEs.list.array[i]->value.choice
+                  .PDUSessionResourceListHORqd)) {
+            cout << "decoded ngap PDUSessionResourceSetupListCxtRes IE error"
+                << endl;
             return false;
           }
-				}
-				else
-				{
+        } else {
           cout << "decoded ngap PDUSessionResourceListHORqd IE error" << endl;
           return false;
         }
-			}break;
-			case Ngap_ProtocolIE_ID_id_SourceToTarget_TransparentContainer: {
-				if (handoverRequiredIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_reject && handoverRequiredIEs->protocolIEs.list.array[i]->value.present == Ngap_HandoverRequiredIEs__value_PR_SourceToTarget_TransparentContainer)
-				{
-					SourceToTarget_TransparentContainer = new Ngap_SourceToTarget_TransparentContainer_t();
-					*SourceToTarget_TransparentContainer = handoverRequiredIEs->protocolIEs.list.array[i]->value.choice.SourceToTarget_TransparentContainer;
       }
-				else
-				{
-					cout << "decoded ngap SourceToTarget_TransparentContainer IE error" << endl;
+        break;
+      case Ngap_ProtocolIE_ID_id_SourceToTarget_TransparentContainer: {
+        if (handoverRequiredIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_reject
+            && handoverRequiredIEs->protocolIEs.list.array[i]->value.present
+                == Ngap_HandoverRequiredIEs__value_PR_SourceToTarget_TransparentContainer) {
+          SourceToTarget_TransparentContainer =
+              new Ngap_SourceToTarget_TransparentContainer_t();
+          *SourceToTarget_TransparentContainer = handoverRequiredIEs
+              ->protocolIEs.list.array[i]->value.choice
+              .SourceToTarget_TransparentContainer;
+        } else {
+          cout << "decoded ngap SourceToTarget_TransparentContainer IE error"
+              << endl;
           return false;
         }
-			}break;
+      }
+        break;
       default: {
         cout << "decoded ngap message pdu error" << endl;
         return false;
@@ -236,35 +250,15 @@ namespace ngap{
   }
 
   return true;
-	}
+}
 
-	int  HandoverRequiredMsg::encode2buffer(uint8_t *buf, int buf_size)
-	{
+int HandoverRequiredMsg::encode2buffer(uint8_t *buf, int buf_size) {
   asn_fprint(stderr, &asn_DEF_Ngap_NGAP_PDU, handoverRequiredPdu);
-		asn_enc_rval_t er = aper_encode_to_buffer(&asn_DEF_Ngap_NGAP_PDU, NULL, handoverRequiredPdu, buf, buf_size);
+  asn_enc_rval_t er = aper_encode_to_buffer(&asn_DEF_Ngap_NGAP_PDU, NULL,
+                                            handoverRequiredPdu, buf, buf_size);
   cout << "er.encoded(" << er.encoded << ")" << endl;
   return er.encoded;
-	}
-
-	
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+}
 
 }
 

src/ngap/ngapMsgs/HandoverRequiredMsg.hpp

@@ -11,26 +11,24 @@
 #include "AMF-UE-NGAP-ID.hpp"
 #include "RAN-UE-NGAP-ID.hpp"
 #include "Cause.hpp"
-extern "C"{
-  #include "Ngap_NGAP-PDU.h"
-  #include "Ngap_ProtocolIE-Field.h"
-  #include "Ngap_NGSetupRequest.h"
+extern "C" {
+#include "Ngap_NGAP-PDU.h"
+#include "Ngap_ProtocolIE-Field.h"
+#include "Ngap_NGSetupRequest.h"
 }
 #include "TAI.hpp"
 #include "NgapIEsStruct.hpp"
 #include "PDUSessionResourceListHORqd.hpp"
-namespace ngap{
+namespace ngap {
 
-
-
-	class HandoverRequiredMsg{
-	public:	
+class HandoverRequiredMsg {
+public:
   HandoverRequiredMsg();
   virtual ~HandoverRequiredMsg();
 
   int encode2buffer(uint8_t *buf, int buf_size);
   bool decodefrompdu(Ngap_NGAP_PDU_t *ngap_msg_pdu);
-		unsigned long getAmfUeNgapId();//return -1;(不存在)
+  unsigned long getAmfUeNgapId();  //return -1;(不存在)
   uint32_t getRanUeNgapId();//return -1;(不存在)
 
   Ngap_HandoverType_t getHandoverType();
@@ -42,7 +40,7 @@ namespace ngap{
   bool getPDUSessionResourceList(std::vector<PDUSessionResourceItem_t> &list);
   long getDirectForwardingPathAvailability();
 
-	private: 
+private:
   Ngap_NGAP_PDU_t *handoverRequiredPdu;
   Ngap_HandoverRequired_t *handoverRequiredIEs;
   /***************** for decoding ****************/
@@ -55,7 +53,7 @@ namespace ngap{
   PDUSessionResourceListHORqd *PDUSessionResourceList;
   Ngap_SourceToTarget_TransparentContainer_t *SourceToTarget_TransparentContainer;
 
-	};
+};
 
 }
 

src/ngap/ngapMsgs/UplinkRANStatusTransfer.cpp

@@ -31,114 +31,119 @@
 #include <vector>
 
 using namespace std;
-namespace ngap
-{
-    UplinkRANStatusTransfer::UplinkRANStatusTransfer()
-    {
+namespace ngap {
+UplinkRANStatusTransfer::UplinkRANStatusTransfer() {
   amfUeNgapId = NULL;
   ranUeNgapId = NULL;
   ranStatusTransfer_TransparentContainer = NULL;
-    }
-    UplinkRANStatusTransfer::~UplinkRANStatusTransfer() {}
-    unsigned long UplinkRANStatusTransfer::getAmfUeNgapId()
-    {
+}
+UplinkRANStatusTransfer::~UplinkRANStatusTransfer() {
+}
+unsigned long UplinkRANStatusTransfer::getAmfUeNgapId() {
   return amfUeNgapId->getAMF_UE_NGAP_ID();
-    }
+}
 
-    uint32_t UplinkRANStatusTransfer::getRanUeNgapId()
-    {
+uint32_t UplinkRANStatusTransfer::getRanUeNgapId() {
   return ranUeNgapId->getRanUeNgapId();
-    }
-    void UplinkRANStatusTransfer::getRANStatusTransfer_TransparentContainer(RANStatusTransferTransparentContainer *&ranstatustransfer_transparentcontainer)
-    {
-        ranstatustransfer_transparentcontainer = ranStatusTransfer_TransparentContainer;
-    }
-    bool UplinkRANStatusTransfer::defromPDU(Ngap_NGAP_PDU_t *ngap_msg_pdu)
-    {
+}
+void UplinkRANStatusTransfer::getRANStatusTransfer_TransparentContainer(
+    RANStatusTransferTransparentContainer *&ranstatustransfer_transparentcontainer) {
+  ranstatustransfer_transparentcontainer =
+      ranStatusTransfer_TransparentContainer;
+}
+bool UplinkRANStatusTransfer::defromPDU(Ngap_NGAP_PDU_t *ngap_msg_pdu) {
   UplinkRANStatusTransferPDU = ngap_msg_pdu;
-        if (UplinkRANStatusTransferPDU->present == Ngap_NGAP_PDU_PR_initiatingMessage)
-        {
-            if (UplinkRANStatusTransferPDU->choice.initiatingMessage && UplinkRANStatusTransferPDU->choice.initiatingMessage->procedureCode == Ngap_ProcedureCode_id_UplinkRANStatusTransfer && UplinkRANStatusTransferPDU->choice.initiatingMessage->criticality == Ngap_Criticality_ignore && UplinkRANStatusTransferPDU->choice.initiatingMessage->value.present == Ngap_InitiatingMessage__value_PR_UplinkRANStatusTransfer)
-            {
-                UplinkRANStatusTransferIEs = &UplinkRANStatusTransferPDU->choice.initiatingMessage->value.choice.UplinkRANStatusTransfer;
-            }
-            else
-            {
+  if (UplinkRANStatusTransferPDU->present
+      == Ngap_NGAP_PDU_PR_initiatingMessage) {
+    if (UplinkRANStatusTransferPDU->choice.initiatingMessage
+        && UplinkRANStatusTransferPDU->choice.initiatingMessage->procedureCode
+            == Ngap_ProcedureCode_id_UplinkRANStatusTransfer
+        && UplinkRANStatusTransferPDU->choice.initiatingMessage->criticality
+            == Ngap_Criticality_ignore
+        && UplinkRANStatusTransferPDU->choice.initiatingMessage->value.present
+            == Ngap_InitiatingMessage__value_PR_UplinkRANStatusTransfer) {
+      UplinkRANStatusTransferIEs = &UplinkRANStatusTransferPDU->choice
+          .initiatingMessage->value.choice.UplinkRANStatusTransfer;
+    } else {
       cout << "Check uplinkranstatustransfer message error!!!" << endl;
       return false;
     }
-        }
-        else
-        {
+  } else {
     cout << "uplinkranstatustransfer message type error" << endl;
     return false;
   }
-        for (int i = 0; i < UplinkRANStatusTransferIEs->protocolIEs.list.count; i++)
-        {
-            switch (UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->id)
-            {
-            case Ngap_ProtocolIE_ID_id_AMF_UE_NGAP_ID:
-            {
-                if (UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_reject && UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->value.present == Ngap_UplinkRANStatusTransferIEs__value_PR_AMF_UE_NGAP_ID)
-                {
+  for (int i = 0; i < UplinkRANStatusTransferIEs->protocolIEs.list.count; i++) {
+    switch (UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->id) {
+      case Ngap_ProtocolIE_ID_id_AMF_UE_NGAP_ID: {
+        if (UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_reject
+            && UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->value
+                .present
+                == Ngap_UplinkRANStatusTransferIEs__value_PR_AMF_UE_NGAP_ID) {
           amfUeNgapId = new AMF_UE_NGAP_ID();
-                    if (!amfUeNgapId->decodefromAMF_UE_NGAP_ID(UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->value.choice.AMF_UE_NGAP_ID))
-                    {
+          if (!amfUeNgapId->decodefromAMF_UE_NGAP_ID(
+              UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->value
+                  .choice.AMF_UE_NGAP_ID)) {
             cout << "decoded ngap AMF_UE_NGAP_ID IE error" << endl;
             return false;
           }
-                }
-                else
-                {
+        } else {
           cout << "decoded ngap AMF_UE_NGAP_ID IE error" << endl;
           return false;
         }
       }
         break;
-            case Ngap_ProtocolIE_ID_id_RAN_UE_NGAP_ID:
-            {
-                if (UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_reject && UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->value.present == Ngap_UplinkRANStatusTransferIEs__value_PR_RAN_UE_NGAP_ID)
-                {
+      case Ngap_ProtocolIE_ID_id_RAN_UE_NGAP_ID: {
+        if (UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_reject
+            && UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->value
+                .present
+                == Ngap_UplinkRANStatusTransferIEs__value_PR_RAN_UE_NGAP_ID) {
           ranUeNgapId = new RAN_UE_NGAP_ID();
-                    if (!ranUeNgapId->decodefromRAN_UE_NGAP_ID(UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->value.choice.RAN_UE_NGAP_ID))
-                    {
+          if (!ranUeNgapId->decodefromRAN_UE_NGAP_ID(
+              UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->value
+                  .choice.RAN_UE_NGAP_ID)) {
             cout << "decoded ngap RAN_UE_NGAP_ID IE error" << endl;
             return false;
           }
-                }
-                else
-                {
+        } else {
           cout << "decoded ngap RAN_UE_NGAP_ID IE error" << endl;
           return false;
         }
       }
         break;
-            case Ngap_ProtocolIE_ID_id_RANStatusTransfer_TransparentContainer:
-            {
-                if (UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->criticality == Ngap_Criticality_reject && UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->value.present == Ngap_UplinkRANStatusTransferIEs__value_PR_RANStatusTransfer_TransparentContainer)
-                {
-                    ranStatusTransfer_TransparentContainer = new RANStatusTransferTransparentContainer();
-                    if (!ranStatusTransfer_TransparentContainer->decoderanstatustransfer_transparentcontainer(&UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->value.choice.RANStatusTransfer_TransparentContainer))
-                    {
-                        cout << "decoded ngap ranStatusTransfer_TransparentContainer error" << endl;
+      case Ngap_ProtocolIE_ID_id_RANStatusTransfer_TransparentContainer: {
+        if (UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->criticality
+            == Ngap_Criticality_reject
+            && UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->value
+                .present
+                == Ngap_UplinkRANStatusTransferIEs__value_PR_RANStatusTransfer_TransparentContainer) {
+          ranStatusTransfer_TransparentContainer =
+              new RANStatusTransferTransparentContainer();
+          if (!ranStatusTransfer_TransparentContainer
+              ->decoderanstatustransfer_transparentcontainer(
+              &UplinkRANStatusTransferIEs->protocolIEs.list.array[i]->value
+                  .choice.RANStatusTransfer_TransparentContainer)) {
+            cout << "decoded ngap ranStatusTransfer_TransparentContainer error"
+                << endl;
             return false;
           }
-                    cout << "can get the buffer of RANStatusTransfer_TransparentContainer" << endl;
-                }
-                else
-                {
-                    cout << "cann't get the buffer of RANStatusTransfer_TransparentContainer" << endl;
+          cout << "can get the buffer of RANStatusTransfer_TransparentContainer"
+              << endl;
+        } else {
+          cout
+              << "cann't get the buffer of RANStatusTransfer_TransparentContainer"
+              << endl;
         }
       }
         break;
-            default:
-            {
+      default: {
         cout << "decoded ngap message pdu error" << endl;
         return false;
       }
     }
   }
   return true;
-    }
+}
 
 }  // namespace ngap

src/ngap/ngapMsgs/UplinkRANStatusTransfer.hpp

@@ -31,8 +31,7 @@
 #include "RAN-UE-NGAP-ID.hpp"
 #include "NgapIEsStruct.hpp"
 #include "RANStatusTransferTransparentContainer.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_UplinkRANStatusTransfer.h"
 #include "Ngap_RANStatusTransfer-TransparentContainer.h"
 #include "Ngap_NGAP-PDU.h"
@@ -41,23 +40,23 @@ extern "C"
 }
 namespace ngap
 {
-    class UplinkRANStatusTransfer
-    {
-    public:
+class UplinkRANStatusTransfer
+{
+public:
   UplinkRANStatusTransfer();
   virtual ~UplinkRANStatusTransfer();
   unsigned long getAmfUeNgapId();  //return -1;(不存在)
-        uint32_t getRanUeNgapId();      //return -1;(不存在)
+  uint32_t getRanUeNgapId();//return -1;(不存在)
   void getRANStatusTransfer_TransparentContainer(RANStatusTransferTransparentContainer *&ranstatustransfer_transparentcontainer);
   bool defromPDU(Ngap_NGAP_PDU_t *ngap_msg_pdu);
 
-    private:
+private:
   Ngap_NGAP_PDU_t *UplinkRANStatusTransferPDU;
   Ngap_UplinkRANStatusTransfer_t *UplinkRANStatusTransferIEs;
   AMF_UE_NGAP_ID *amfUeNgapId;
   RAN_UE_NGAP_ID *ranUeNgapId;
   RANStatusTransferTransparentContainer *ranStatusTransfer_TransparentContainer;
-    };
+};
 }  // namespace ngap
 
 #endif