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;
 
@@ -114,7 +120,7 @@ public:
   bool is_sr;
   bstring n2sm;
   uint8_t pdu_session_id;
-  bool is_pdu_exist; //true is no pdu context
+  bool is_pdu_exist;  //true is no pdu context
   bool isn2sm_avaliable;
 };
 
@@ -140,7 +146,7 @@ class itti_pdu_session_resource_setup_request : public itti_msg_n2 {
 class itti_pdu_session_resource_release_command : public itti_msg_n2 {
  public:
   itti_pdu_session_resource_release_command(const task_id_t origin,
-                                          const task_id_t destination)
+                                            const task_id_t destination)
       :
       itti_msg_n2(PDU_SESSION_RESOURCE_RELEASE_COMMAND, origin, destination) {
   }
@@ -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()
-    {
-        pdcp = 0;
-        hfn_pdcp = 0;
-    }
-    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)
-    {
-        pDCP = pdcp;
-        hFN_PDCP = hfn_pdcp;
-    }
-    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)
-    {
-        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
+namespace ngap {
+COUNTValueForPDCP_SN18::COUNTValueForPDCP_SN18() {
+  pdcp = 0;
+  hfn_pdcp = 0;
+}
+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) {
+  pDCP = pdcp;
+  hFN_PDCP = hfn_pdcp;
+}
+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) {
+  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,27 +27,24 @@
  */
 #ifndef _COUNTVALUEFORPDCP_SN18_H_
 #define _COUNTVALUEFORPDCP_SN18_H_
-extern "C"
-{
+extern "C" {
 #include "Ngap_COUNTValueForPDCP-SN18.h"
 }
-namespace ngap
-{
-    class COUNTValueForPDCP_SN18
-    {
-    private:
-        /* data */
-        long pdcp;
-        long hfn_pdcp;
+namespace ngap {
+class COUNTValueForPDCP_SN18 {
+ private:
+  /* data */
+  long pdcp;
+  long hfn_pdcp;
 
-    public:
-        COUNTValueForPDCP_SN18(/* args */);
-        virtual ~COUNTValueForPDCP_SN18();
-        void getvalue(long &pDCP, long &hFN_PDCP);
-        void setvalue(long pDCP, long hfn_PDCP);
-        bool encodedCOUNTValueForPDCP_SN18(Ngap_COUNTValueForPDCP_SN18_t &countvalue);
-        bool decodedCOUNTValueForPDCP_SN18(Ngap_COUNTValueForPDCP_SN18_t &countValue);
-    };
+ public:
+  COUNTValueForPDCP_SN18(/* args */);
+  virtual ~COUNTValueForPDCP_SN18();
+  void getvalue(long &pDCP, long &hFN_PDCP);
+  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
+}  // namespace ngap
 #endif

src/ngap/ngapIEs/PDUSessionResourceAdmittedItem.cpp

@@ -25,48 +25,53 @@
  \date 2020
  \email: contact@openairinterface.org
  */
-#include "PDUSessionResourceAdmittedItem.hpp"
+#include "PDUSessionResourceAdmittedItem.hpp"
 
 #include <iostream>
 using namespace std;
 
-namespace ngap{
-	PDUSessionResourceAdmittedItem::PDUSessionResourceAdmittedItem()
-	{
-		pDUSessionID = NULL;
-	}
-	PDUSessionResourceAdmittedItem::~PDUSessionResourceAdmittedItem(){}
-	
-	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;
-		
-		return true; 
-	}
-	//......
-	bool PDUSessionResourceAdmittedItem::decodefromPDUSessionResourceAdmittedItem(Ngap_PDUSessionResourceAdmittedItem_t *pdUSessionResourceAdmittedItem)
-	{
-		pDUSessionID = new PDUSessionID();
-		if(!pDUSessionID->decodefromPDUSessionID(pdUSessionResourceAdmittedItem->pDUSessionID)) return false;
-		handoverrequestAcktransfer = pdUSessionResourceAdmittedItem->handoverRequestAcknowledgeTransfer;
-			
-		return true;
-	}
-	void PDUSessionResourceAdmittedItem::getPDUSessionResourceAdmittedItem(PDUSessionID *&m_pDUSessionID, OCTET_STRING_t&m_handoverrequestAcktransfer)
-	{
-		m_pDUSessionID = pDUSessionID;
-		m_handoverrequestAcktransfer = handoverrequestAcktransfer;
-	}
+namespace ngap {
+PDUSessionResourceAdmittedItem::PDUSessionResourceAdmittedItem() {
+  pDUSessionID = NULL;
+}
+PDUSessionResourceAdmittedItem::~PDUSessionResourceAdmittedItem() {
+}
+
+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;
+
+  return true;
+}
+//�����......
+bool PDUSessionResourceAdmittedItem::decodefromPDUSessionResourceAdmittedItem(
+    Ngap_PDUSessionResourceAdmittedItem_t *pdUSessionResourceAdmittedItem) {
+  pDUSessionID = new PDUSessionID();
+  if (!pDUSessionID->decodefromPDUSessionID(
+      pdUSessionResourceAdmittedItem->pDUSessionID))
+    return false;
+  handoverrequestAcktransfer = pdUSessionResourceAdmittedItem
+      ->handoverRequestAcknowledgeTransfer;
 
+  return true;
+}
+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{
-
-	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);
-	private:
-		PDUSessionID *pDUSessionID;
-		OCTET_STRING_t handoverrequestAcktransfer;
-	};
+namespace ngap {
+
+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);
+ private:
+  PDUSessionID *pDUSessionID;
+  OCTET_STRING_t handoverrequestAcktransfer;
+};
 
 }
 
 #endif
 
-
-
-
-

src/ngap/ngapIEs/PDUSessionResourceAdmittedList.cpp

 #include "PDUSessionResourceAdmittedList.hpp"
-
-#include <iostream>
-using namespace std;
-
-namespace ngap{
-	PDUSessionResourceAdmittedList::PDUSessionResourceAdmittedList()
-	{
-		pduSessionResourceAdmittedItem = NULL;
-		numofSessionResourceAdmittedItem = 0;
-	}
-	PDUSessionResourceAdmittedList::~PDUSessionResourceAdmittedList(){}
-	
-	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;
-		}
-		
-		return true; 
-	}
-	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;
-		}
-		
-		return true;
-	}
-	void PDUSessionResourceAdmittedList::getPDUSessionResourceAdmittedList(PDUSessionResourceAdmittedItem *&m_pduSessionResourceAdmittedItem,int &num)
-	{
-		m_pduSessionResourceAdmittedItem = pduSessionResourceAdmittedItem;
-		num = numofSessionResourceAdmittedItem;
-	}
-
-}
 
+#include <iostream>
+using namespace std;
 
+namespace ngap {
+PDUSessionResourceAdmittedList::PDUSessionResourceAdmittedList() {
+  pduSessionResourceAdmittedItem = NULL;
+  numofSessionResourceAdmittedItem = 0;
+}
+PDUSessionResourceAdmittedList::~PDUSessionResourceAdmittedList() {
+}
 
+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;
+  }
+
+  return true;
+}
+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;
+  }
+
+  return true;
+}
+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{
-
-	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);
-	private:
-		PDUSessionResourceAdmittedItem *pduSessionResourceAdmittedItem;
-		int numofSessionResourceAdmittedItem;
-	};
+namespace ngap {
+
+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);
+ 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));
-        dLForwardingUP_TNLInformation = NULL;
-        qosFlowToBeForwardedList = NULL;
+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) {
+  if (!qosFlowToBeForwardedList)
+    qosFlowToBeForwardedList = new QosFlowToBeForwardedList();
+  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) {
+    cout << "array OK" << endl;
+    if (handovercommandtransferIE->qosFlowToBeForwardedList->list.array[0]) {
+      cout << "QFI in list "
+          << handovercommandtransferIE->qosFlowToBeForwardedList->list.array[0]
+              ->qosFlowIdentifier << endl;
+    } else {
+      cout << "error1" << endl;
     }
-    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++)
-        {
-            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)
-        {
-            cout << "array OK" << endl;
-            if (handovercommandtransferIE->qosFlowToBeForwardedList->list.array[0])
-            {
-                cout << "QFI in list " << handovercommandtransferIE->qosFlowToBeForwardedList->list.array[0]->qosFlowIdentifier << endl;
-            }
-            else
-            {
-                cout << "error1" << endl;
-            }
-        }
-        else
-        {
-            cout << "error2" << endl;
-        }
+  } else {
+    cout << "error2" << endl;
+  }
 
-        if (!ret)
-        {
-            cout << "encode QosFlowToBeForwardedList IE error" << endl;
-            return;
-        }
-    }
-    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));
-        handovercommandtransferIE->dLForwardingUP_TNLInformation = test;
-        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);
-        cout << "er.encoded(" << er.encoded << ")" << endl;
-        return er.encoded;
-    }
+  if (!ret) {
+    cout << "encode QosFlowToBeForwardedList IE error" << endl;
+    return;
+  }
+}
+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));
+  handovercommandtransferIE->dLForwardingUP_TNLInformation = test;
+  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);
+  cout << "er.encoded(" << er.encoded << ")" << endl;
+  return er.encoded;
+}
 
-} // namespace ngap
+}  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceHandoverCommandTransfer.hpp

@@ -31,28 +31,27 @@
 #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
-    {
-    private:
-        /* data */
-        Ngap_HandoverCommandTransfer_t *handovercommandtransferIE;
-        UpTransportLayerInformation *dLForwardingUP_TNLInformation;
-        QosFlowToBeForwardedList *qosFlowToBeForwardedList;
+namespace ngap {
+class PDUSessionResourceHandoverCommandTransfer {
+ private:
+  /* data */
+  Ngap_HandoverCommandTransfer_t *handovercommandtransferIE;
+  UpTransportLayerInformation *dLForwardingUP_TNLInformation;
+  QosFlowToBeForwardedList *qosFlowToBeForwardedList;
 
-    public:
-        PDUSessionResourceHandoverCommandTransfer(/* args */);
-        virtual ~PDUSessionResourceHandoverCommandTransfer();
-        void setUPTransportLayerInformation(GtpTunnel_t uptlinfo);
-        void setQosFlowToBeForwardedList(std::vector<QosFlowToBeForwardedItem_t> list);
-        int encodePDUSessionResourceHandoverCommandTransfer(uint8_t *buf, int buf_size);
-    };
+ public:
+  PDUSessionResourceHandoverCommandTransfer(/* args */);
+  virtual ~PDUSessionResourceHandoverCommandTransfer();
+  void setUPTransportLayerInformation(GtpTunnel_t uptlinfo);
+  void setQosFlowToBeForwardedList(
+      std::vector<QosFlowToBeForwardedItem_t> list);
+  int encodePDUSessionResourceHandoverCommandTransfer(uint8_t *buf,
+                                                      int buf_size);
+};
 
-} // namespace ngap
+}  // namespace ngap
 #endif

src/ngap/ngapIEs/PDUSessionResourceHandoverRequestAckTransfer.cpp

@@ -20,15 +20,14 @@
  */
 
 /*! \file
-  \brief
-  \author  niuxiansheng-niu, BUPT
-  \date 2020
-  \email: contact@openairinterface.org
-  */
+ \brief
+ \author  niuxiansheng-niu, BUPT
+ \date 2020
+ \email: contact@openairinterface.org
+ */
 #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));
-		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)
-		{
-			cout << "Decoded handoverRequestAcknowledegTransfer successfully" << endl;
-		}
-		else if (rc.code == RC_WMORE)
-		{
-			cout << "More data expected, call again" << endl;
-			return false;
-		}
-		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))
-		{
-			cout << "decoded ngap DL_NGU_UP_TNLInformation IE error" << endl;
-			return false;
-		}
-		QosFlowSetupResponseList = new QosFlowListWithDataForwarding();
-		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))
-			return false;
-		TransportLayerAddress *m_transportLayerAddress;
-		GtpTeid *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)
-	{
-		if (!QosFlowSetupResponseList)
-			return false;
-		QosFlowItemWithDataForWarding *m_qosflowitemwithdataforwarding;
-		int num = 0;
-		if (QosFlowSetupResponseList->getQosFlowListWithDataForwarding(m_qosflowitemwithdataforwarding, num))
-		{
-			cout << "successful decode QosFlowList" << endl;
-		}
-		for (int i = 0; i < num; i++)
-		{
-			QosFlowLItemWithDataForwarding_t response;
-			m_qosflowitemwithdataforwarding[i].getQosFlowItemWithDataForWarding(response.qosFlowIdentifier);
-			list.push_back(response);
-		}
-		return true;
-	}
-} // namespace ngap
+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) {
+    cout << "Decoded handoverRequestAcknowledegTransfer successfully" << endl;
+  } else if (rc.code == RC_WMORE) {
+    cout << "More data expected, call again" << endl;
+    return false;
+  } 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)) {
+    cout << "decoded ngap DL_NGU_UP_TNLInformation IE error" << endl;
+    return false;
+  }
+  QosFlowSetupResponseList = new QosFlowListWithDataForwarding();
+  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))
+    return false;
+  TransportLayerAddress *m_transportLayerAddress;
+  GtpTeid *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) {
+  if (!QosFlowSetupResponseList)
+    return false;
+  QosFlowItemWithDataForWarding *m_qosflowitemwithdataforwarding;
+  int num = 0;
+  if (QosFlowSetupResponseList->getQosFlowListWithDataForwarding(
+      m_qosflowitemwithdataforwarding, num)) {
+    cout << "successful decode QosFlowList" << endl;
+  }
+  for (int i = 0; i < num; i++) {
+    QosFlowLItemWithDataForwarding_t response;
+    m_qosflowitemwithdataforwarding[i].getQosFlowItemWithDataForWarding(
+        response.qosFlowIdentifier);
+    list.push_back(response);
+  }
+  return true;
+}
+}  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceHandoverRequestAckTransfer.hpp

@@ -20,11 +20,11 @@
  */
 
 /*! \file
-  \brief
-  \author  niuxiansheng-niu, BUPT
-  \date 2020
-  \email: contact@openairinterface.org
-  */
+ \brief
+ \author  niuxiansheng-niu, BUPT
+ \date 2020
+ \email: contact@openairinterface.org
+ */
 #ifndef _PDUSESSIONRESOURCEHANDOVERREQUESTACKTRANSFER_H_
 #define _PDUSESSIONRESOURCEHANDOVERREQUESTACKTRANSFER_H_
 
@@ -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
-	{
-	public:
-		PDUSessionResourceHandoverRequestAckTransfer();
-		virtual ~PDUSessionResourceHandoverRequestAckTransfer();
-		bool decodefromHandoverRequestAckTransfer(uint8_t *buf, int buf_size);
-		bool getUpTransportLayerInformation2(GtpTunnel_t *&upTnlInfo);
-		bool getqosFlowSetupResponseList(std::vector<QosFlowLItemWithDataForwarding_t> &list);
+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);
 
-	private:
-		Ngap_HandoverRequestAcknowledgeTransfer_t *handoverRequestAcknowledegTransferIEs;
-		UpTransportLayerInformation *dLForwardingUP_TNLInformation;
-		QosFlowListWithDataForwarding *QosFlowSetupResponseList;
-	};
-} // namespace ngap
+ private:
+  Ngap_HandoverRequestAcknowledgeTransfer_t *handoverRequestAcknowledegTransferIEs;
+  UpTransportLayerInformation *dLForwardingUP_TNLInformation;
+  QosFlowListWithDataForwarding *QosFlowSetupResponseList;
+};
+}  // namespace ngap
 
-#endif
+#endif
\ No newline at end of file

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));
-		DirectForwardingPathAvailability = NULL;
-	}
-	PDUSessionResourceHandoverRequiredTransfer::~PDUSessionResourceHandoverRequiredTransfer(){}
+namespace ngap {
+PDUSessionResourceHandoverRequiredTransfer::PDUSessionResourceHandoverRequiredTransfer() {
+  handoverrquiredTransferIEs = (Ngap_HandoverRequiredTransfer_t*) calloc(
+      1, sizeof(Ngap_HandoverRequiredTransfer_t));
+  DirectForwardingPathAvailability = NULL;
+}
+PDUSessionResourceHandoverRequiredTransfer::~PDUSessionResourceHandoverRequiredTransfer() {
+}
+
+void PDUSessionResourceHandoverRequiredTransfer::setDirectForwardingPathAvailability(
+    Ngap_DirectForwardingPathAvailability_t directForwardingPathAvailability) {
+  if (!DirectForwardingPathAvailability)
+    DirectForwardingPathAvailability =
+        new Ngap_DirectForwardingPathAvailability_t();
+  *DirectForwardingPathAvailability = directForwardingPathAvailability;
+}
 
-	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;
+  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;
+    return false;
+  } else {
+    cout << "Failure to decode data" << endl;
+    return false;
+  }
+  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;
+  }
+
+  return true;
+}
 
-	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;
-			return false;
-		}
-		else
-		{
-			cout<<"Failure to decode data"<<endl;
-			return false;
-		}
-		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;
-		}
-	
-		return true;
-  	}
+bool PDUSessionResourceHandoverRequiredTransfer::getDirectForwardingPathAvailability(
+    long *directForwardingPathAvailability) {
+  directForwardingPathAvailability = DirectForwardingPathAvailability;
+  return true;
+}
 
-	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{
-
-	class PDUSessionResourceHandoverRequiredTransfer {
-		
-	public:
-		PDUSessionResourceHandoverRequiredTransfer();
-		virtual ~PDUSessionResourceHandoverRequiredTransfer();
-		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);
-	private:
-		Ngap_HandoverRequiredTransfer_t *handoverrquiredTransferIEs;
-		Ngap_DirectForwardingPathAvailability_t *DirectForwardingPathAvailability;
-	};
+namespace ngap {
+
+class PDUSessionResourceHandoverRequiredTransfer {
+
+ public:
+  PDUSessionResourceHandoverRequiredTransfer();
+  virtual ~PDUSessionResourceHandoverRequiredTransfer();
+  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);
+ private:
+  Ngap_HandoverRequiredTransfer_t *handoverrquiredTransferIEs;
+  Ngap_DirectForwardingPathAvailability_t *DirectForwardingPathAvailability;
+};
 
 }
 #endif
 
-
-

src/ngap/ngapIEs/PDUSessionResourceItemHORqd.cpp

@@ -25,47 +25,51 @@
  \date 2020
  \email: contact@openairinterface.org
  */
-#include "PDUSessionResourceItemHORqd.hpp"
+#include "PDUSessionResourceItemHORqd.hpp"
 
 #include <iostream>
 using namespace std;
 
-namespace ngap{
-	PDUSessionResourceItemHORqd::PDUSessionResourceItemHORqd()
-	{
-		pDUSessionID = NULL;
-	}
-	PDUSessionResourceItemHORqd::~PDUSessionResourceItemHORqd(){}
-	
-	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;
-		
-		return true; 
-	}
-	bool PDUSessionResourceItemHORqd::decodefromPDUSessionResourceItemHORqd(Ngap_PDUSessionResourceItemHORqd_t *pdUSessionResourceItemHORqd)
-	{
-		pDUSessionID = new PDUSessionID();
-		if(!pDUSessionID->decodefromPDUSessionID(pdUSessionResourceItemHORqd->pDUSessionID)) return false;
-		handoverrequiredtransfer = pdUSessionResourceItemHORqd->handoverRequiredTransfer;
-			
-		return true;
-	}
-	void PDUSessionResourceItemHORqd::getPDUSessionResourceItemHORqd(PDUSessionID *&m_pDUSessionID, OCTET_STRING_t&m_handoverrequiredtransfer)
-	{
-		m_pDUSessionID = pDUSessionID;
-		m_handoverrequiredtransfer = handoverrequiredtransfer;
-	}
+namespace ngap {
+PDUSessionResourceItemHORqd::PDUSessionResourceItemHORqd() {
+  pDUSessionID = NULL;
+}
+PDUSessionResourceItemHORqd::~PDUSessionResourceItemHORqd() {
+}
+
+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;
+
+  return true;
+}
+bool PDUSessionResourceItemHORqd::decodefromPDUSessionResourceItemHORqd(
+    Ngap_PDUSessionResourceItemHORqd_t *pdUSessionResourceItemHORqd) {
+  pDUSessionID = new PDUSessionID();
+  if (!pDUSessionID->decodefromPDUSessionID(
+      pdUSessionResourceItemHORqd->pDUSessionID))
+    return false;
+  handoverrequiredtransfer = pdUSessionResourceItemHORqd
+      ->handoverRequiredTransfer;
 
+  return true;
+}
+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{
-
-	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);
-		
-		bool encode2PDUSessionResourceItemHORqd(Ngap_PDUSessionResourceItemHORqd_t *pdUSessionResourceItemHORqd);
-		bool decodefromPDUSessionResourceItemHORqd(Ngap_PDUSessionResourceItemHORqd_t *pdUSessionResourceItemHORqd);
-	private:
-		PDUSessionID *pDUSessionID;
-		OCTET_STRING_t handoverrequiredtransfer;
-	};
+namespace ngap {
 
-}
-
-#endif
+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);
 
+  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

 #include "PDUSessionResourceListHORqd.hpp"
-
-#include <iostream>
-using namespace std;
-
-namespace ngap{
-	PDUSessionResourceListHORqd::PDUSessionResourceListHORqd()
-	{
-		pduSessionResourceItemHORqd = NULL;
-		numofpduSessionResourceItemHORqd = 0;
-	}
-	PDUSessionResourceListHORqd::~PDUSessionResourceListHORqd(){}
-	
-	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;
-		}
-		
-		return true; 
-	}
-	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;
-		}
-		
-		return true;
-	}
-	void PDUSessionResourceListHORqd::getPDUSessionResourceListHORqd(PDUSessionResourceItemHORqd *&m_pduSessionResourceItemHORqd,int &num)
-	{
-		m_pduSessionResourceItemHORqd = pduSessionResourceItemHORqd;
-		num = numofpduSessionResourceItemHORqd;
-	}
-
-}
 
+#include <iostream>
+using namespace std;
 
+namespace ngap {
+PDUSessionResourceListHORqd::PDUSessionResourceListHORqd() {
+  pduSessionResourceItemHORqd = NULL;
+  numofpduSessionResourceItemHORqd = 0;
+}
+PDUSessionResourceListHORqd::~PDUSessionResourceListHORqd() {
+}
 
+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;
+  }
+
+  return true;
+}
+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;
+  }
+
+  return true;
+}
+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{
-
-	class PDUSessionResourceListHORqd {
-	public:
-		PDUSessionResourceListHORqd();
-		virtual ~PDUSessionResourceListHORqd();
-		
-		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);
-	private:
-		PDUSessionResourceItemHORqd *pduSessionResourceItemHORqd;
-		int numofpduSessionResourceItemHORqd;
-	};
+namespace ngap {
+
+class PDUSessionResourceListHORqd {
+ public:
+  PDUSessionResourceListHORqd();
+  virtual ~PDUSessionResourceListHORqd();
+
+  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);
+ private:
+  PDUSessionResourceItemHORqd *pduSessionResourceItemHORqd;
+  int numofpduSessionResourceItemHORqd;
+};
 
 }
 

src/ngap/ngapIEs/PDUSessionResourceReleaseCommandTransfer.cpp

@@ -39,143 +39,146 @@ extern "C" {
 using namespace std;
 
 namespace ngap {
-	PDUSessionResourceReleaseCommandTransfer::PDUSessionResourceReleaseCommandTransfer()
-	{
-		pduSessionResourceReleaseCommandTransferIEs = (Ngap_PDUSessionResourceReleaseCommandTransfer_t *)calloc(1, sizeof(Ngap_PDUSessionResourceReleaseCommandTransfer_t));
-		causeValue = NULL;
-	}
-	PDUSessionResourceReleaseCommandTransfer::~PDUSessionResourceReleaseCommandTransfer() {
-		//if(pduSessionResourceReleaseCommandTransferIEs) ASN_STRUCT_FREE(asn_DEF_Ngap_PDUSessionResourceReleaseCommandTransfer,pduSessionResourceReleaseCommandTransferIEs);
-		if (causeValue) delete causeValue;
-		//if (pduSessionResourceReleaseCommandTransferIEs) free(pduSessionResourceReleaseCommandTransferIEs);
-	}
-
-	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)
-		{
-			cout << "encode CauseRadioNetwork IE error" << endl;
-			return;
-		}
-	}
-	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)
-		{
-			cout << "encode CauseTransport IE error" << endl;
-			return;
-		}
-	}
-	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)
-		{
-			cout << "encode CauseNas IE error" << endl;
-			return;
-		}
-	}
-	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)
-		{
-			cout << "encode CauseProtocol IE error" << endl;
-			return;
-		}
-	}
-	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)
-		{
-			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);
-		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)
-		{
-			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;
-			return false;
-		}
-		cout << "rc.consumed to decode = " << rc.consumed << endl;
-		cout << endl;
-		//asn_fprint(stderr, &asn_DEF_Ngap_PDUSessionResourceSetupUnsuccessfulTransfer, pduSessionResourceSetupUnsuccessfulTransferIEs);
-
-		causeValue = new Cause();
-		if (!causeValue->decodefromCause(&pduSessionResourceReleaseCommandTransferIEs->cause))
-		{
-			cout << "decoded ngap Cause IE error" << endl;
-			return false;
-		}
-
-		return true;
-	}
-
-	long PDUSessionResourceReleaseCommandTransfer::getChoiceOfCause()
-	{
-		if (!causeValue) return -1;
-
-		return causeValue->getChoiceOfCause();
-	}
-	long PDUSessionResourceReleaseCommandTransfer::getCause()
-	{
-		if (!causeValue) return -1;
-
-		return causeValue->getValue();
-	}
+PDUSessionResourceReleaseCommandTransfer::PDUSessionResourceReleaseCommandTransfer() {
+  pduSessionResourceReleaseCommandTransferIEs =
+      (Ngap_PDUSessionResourceReleaseCommandTransfer_t*) calloc(
+          1, sizeof(Ngap_PDUSessionResourceReleaseCommandTransfer_t));
+  causeValue = NULL;
+}
+PDUSessionResourceReleaseCommandTransfer::~PDUSessionResourceReleaseCommandTransfer() {
+  //if(pduSessionResourceReleaseCommandTransferIEs) ASN_STRUCT_FREE(asn_DEF_Ngap_PDUSessionResourceReleaseCommandTransfer,pduSessionResourceReleaseCommandTransferIEs);
+  if (causeValue)
+    delete causeValue;
+  //if (pduSessionResourceReleaseCommandTransferIEs) free(pduSessionResourceReleaseCommandTransferIEs);
+}
+
+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) {
+    cout << "encode CauseRadioNetwork IE error" << endl;
+    return;
+  }
+}
+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) {
+    cout << "encode CauseTransport IE error" << endl;
+    return;
+  }
+}
+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) {
+    cout << "encode CauseNas IE error" << endl;
+    return;
+  }
+}
+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) {
+    cout << "encode CauseProtocol IE error" << endl;
+    return;
+  }
+}
+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) {
+    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);
+  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) {
+    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;
+    return false;
+  }
+  cout << "rc.consumed to decode = " << rc.consumed << endl;
+  cout << endl;
+  //asn_fprint(stderr, &asn_DEF_Ngap_PDUSessionResourceSetupUnsuccessfulTransfer, pduSessionResourceSetupUnsuccessfulTransferIEs);
+
+  causeValue = new Cause();
+  if (!causeValue->decodefromCause(
+      &pduSessionResourceReleaseCommandTransferIEs->cause)) {
+    cout << "decoded ngap Cause IE error" << endl;
+    return false;
+  }
+
+  return true;
+}
+
+long PDUSessionResourceReleaseCommandTransfer::getChoiceOfCause() {
+  if (!causeValue)
+    return -1;
+
+  return causeValue->getChoiceOfCause();
+}
+long PDUSessionResourceReleaseCommandTransfer::getCause() {
+  if (!causeValue)
+    return -1;
+
+  return causeValue->getValue();
+}
 }

src/ngap/ngapIEs/PDUSessionResourceReleaseCommandTransfer.hpp

@@ -5,39 +5,37 @@
 
 #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();
-		virtual ~PDUSessionResourceReleaseCommandTransfer();
-		
-		void setCauseRadioNetwork(e_Ngap_CauseRadioNetwork cause_value);
-		void setCauseTransport(e_Ngap_CauseTransport cause_value);
-		void setCauseNas(e_Ngap_CauseNas cause_value);
-		void setCauseProtocol(e_Ngap_CauseProtocol cause_value);
-		void setCauseMisc(e_Ngap_CauseMisc cause_value);
-		int  encode2buffer(uint8_t *buf, int buf_size);
-		//Decapsulation
-		bool decodefromIE(uint8_t *buf, int buf_size);
-		long getChoiceOfCause();
-		long getCause();
+ public:
+  PDUSessionResourceReleaseCommandTransfer();
+  virtual ~PDUSessionResourceReleaseCommandTransfer();
 
-	private:
-		Ngap_PDUSessionResourceReleaseCommandTransfer_t *pduSessionResourceReleaseCommandTransferIEs;
+  void setCauseRadioNetwork(e_Ngap_CauseRadioNetwork cause_value);
+  void setCauseTransport(e_Ngap_CauseTransport cause_value);
+  void setCauseNas(e_Ngap_CauseNas cause_value);
+  void setCauseProtocol(e_Ngap_CauseProtocol cause_value);
+  void setCauseMisc(e_Ngap_CauseMisc cause_value);
+  int encode2buffer(uint8_t *buf, int buf_size);
+  //Decapsulation
+  bool decodefromIE(uint8_t *buf, int buf_size);
+  long getChoiceOfCause();
+  long getCause();
 
-		Cause *causeValue;
+ private:
+  Ngap_PDUSessionResourceReleaseCommandTransfer_t *pduSessionResourceReleaseCommandTransferIEs;
 
-	};
+  Cause *causeValue;
+
+};
 
 }
 #endif
 
-

src/ngap/ngapIEs/PDUSessionResourceReleaseItemCmd.cpp

@@ -25,48 +25,57 @@
  \date 2020
  \email: contact@openairinterface.org
  */
-#include "PDUSessionResourceReleaseItemCmd.hpp"
+#include "PDUSessionResourceReleaseItemCmd.hpp"
 
 #include <iostream>
 using namespace std;
 
-namespace ngap{
-	PDUSessionResourceReleaseItemCmd::PDUSessionResourceReleaseItemCmd()
-	{
-		pDUSessionID = NULL;
-	}
-	PDUSessionResourceReleaseItemCmd::~PDUSessionResourceReleaseItemCmd(){
-		if (pDUSessionID) delete pDUSessionID;
-	}
-	
-	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;
-		
-		return true; 
-	}
-	bool PDUSessionResourceReleaseItemCmd::decodefromPDUSessionResourceReleaseItemCmd(Ngap_PDUSessionResourceToReleaseItemRelCmd_t *pduSessionResourceReleaseCommandTransfer)
-	{
-		pDUSessionID = new PDUSessionID();
-		if(!pDUSessionID->decodefromPDUSessionID(pduSessionResourceReleaseCommandTransfer->pDUSessionID)) return false;
-		pDUSessionResourceReleaseCommandTransfer = pduSessionResourceReleaseCommandTransfer->pDUSessionResourceReleaseCommandTransfer;
-			
-		return true;
-	}
-	void PDUSessionResourceReleaseItemCmd::getPDUSessionResourceReleaseItemCmd(PDUSessionID *&m_pDUSessionID, OCTET_STRING_t &m_pDUSessionResourceReleaseCommandTransfer)
-	{
-		m_pDUSessionID = pDUSessionID;
-		m_pDUSessionResourceReleaseCommandTransfer = pDUSessionResourceReleaseCommandTransfer;
-	}
+namespace ngap {
+PDUSessionResourceReleaseItemCmd::PDUSessionResourceReleaseItemCmd() {
+  pDUSessionID = NULL;
+}
+PDUSessionResourceReleaseItemCmd::~PDUSessionResourceReleaseItemCmd() {
+  if (pDUSessionID)
+    delete pDUSessionID;
+}
+
+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;
+
+  return true;
+}
+bool PDUSessionResourceReleaseItemCmd::decodefromPDUSessionResourceReleaseItemCmd(
+    Ngap_PDUSessionResourceToReleaseItemRelCmd_t *pduSessionResourceReleaseCommandTransfer) {
+  pDUSessionID = new PDUSessionID();
+  if (!pDUSessionID->decodefromPDUSessionID(
+      pduSessionResourceReleaseCommandTransfer->pDUSessionID))
+    return false;
+  pDUSessionResourceReleaseCommandTransfer =
+      pduSessionResourceReleaseCommandTransfer
+          ->pDUSessionResourceReleaseCommandTransfer;
 
+  return true;
+}
+void PDUSessionResourceReleaseItemCmd::getPDUSessionResourceReleaseItemCmd(
+    PDUSessionID *&m_pDUSessionID,
+    OCTET_STRING_t &m_pDUSessionResourceReleaseCommandTransfer) {
+  m_pDUSessionID = pDUSessionID;
+  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 {
-	public:
-		PDUSessionResourceReleaseItemCmd();
-		virtual ~PDUSessionResourceReleaseItemCmd();
-		
-		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);
-	private:
-		PDUSessionID *pDUSessionID;
-		OCTET_STRING_t pDUSessionResourceReleaseCommandTransfer;
-	};
-	
-}
-
-#endif
+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);
 
+  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

 #include "PDUSessionResourceReleaseListCmd.hpp"
-
-#include <iostream>
-using namespace std;
-
-namespace ngap{
-	PDUSessionResourceReleaseListCmd::PDUSessionResourceReleaseListCmd()
-	{
-		pduSessionResourceReleaseItemCmd = NULL;
-		numofpduSessionResourceReleaseItemCmd = 0;
-	}
-	PDUSessionResourceReleaseListCmd::~PDUSessionResourceReleaseListCmd(){
-		if (pduSessionResourceReleaseItemCmd) delete[] pduSessionResourceReleaseItemCmd;
-	}
-	
-	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;
-		}
-		
-		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;
-		}
-		
-		return true;
-	}
-	void PDUSessionResourceReleaseListCmd::getPDUSessionResourceReleaseListCmd(PDUSessionResourceReleaseItemCmd *&m_pduSessionResourceReleaseItemCmd,int &num)
-	{
-		m_pduSessionResourceReleaseItemCmd = pduSessionResourceReleaseItemCmd;
-		num = numofpduSessionResourceReleaseItemCmd;
-	}
-
-}
 
+#include <iostream>
+using namespace std;
 
+namespace ngap {
+PDUSessionResourceReleaseListCmd::PDUSessionResourceReleaseListCmd() {
+  pduSessionResourceReleaseItemCmd = NULL;
+  numofpduSessionResourceReleaseItemCmd = 0;
+}
+PDUSessionResourceReleaseListCmd::~PDUSessionResourceReleaseListCmd() {
+  if (pduSessionResourceReleaseItemCmd)
+    delete[] pduSessionResourceReleaseItemCmd;
+}
 
+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;
+  }
+
+  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;
+  }
+
+  return true;
+}
+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{
-
-	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);
-	private:
-		PDUSessionResourceReleaseItemCmd *pduSessionResourceReleaseItemCmd;
-		int numofpduSessionResourceReleaseItemCmd;
-	};
+namespace ngap {
+
+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);
+ 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;
 }
 
 //------------------------------------------------------------------------------
@@ -65,7 +66,7 @@ bool PDUSessionResourceReleasedItemRelRes::encode2PDUSessionResourceReleasedItem
 
   pduSessionResourceReleasedItemRelRes
       ->pDUSessionResourceReleaseResponseTransfer =
-          pDUSessionResourceReleaseResponseTransfer;
+      pDUSessionResourceReleaseResponseTransfer;
 
   return true;
 }

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;
@@ -86,7 +83,7 @@ bool PDUSessionResourceReleasedListRelRes::decodefromPDUSessionResourceReleasedL
   for (int i = 0; i < maxnoofPDUSessions; i++) {
     if (!pduSessionResourceReleasedItemRelRes[i]
         .decodefromPDUSessionResourceReleasedItemRelRes(
-            pduSessionResourceReleasedListRelRes->list.array[i]))
+        pduSessionResourceReleasedListRelRes->list.array[i]))
       return false;
   }
   return true;

src/ngap/ngapIEs/PDUSessionResourceSetupItemHOReq.cpp

 #include "PDUSessionResourceSetupItemHOReq.hpp"
-
-#include <iostream>
-using namespace std;
-
-namespace ngap{
-	PDUSessionResourceSetupItemHOReq::PDUSessionResourceSetupItemHOReq()
-	{
-		pDUSessionID = NULL;
-		s_NSSAI = NULL;
-	}
-	PDUSessionResourceSetupItemHOReq::~PDUSessionResourceSetupItemHOReq(){}
-	
-	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;
-		
-		return true; 
-	}
-	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;
-			
-		return true;
-	}
-	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;
-	}
-
-}
 
+#include <iostream>
+using namespace std;
 
+namespace ngap {
+PDUSessionResourceSetupItemHOReq::PDUSessionResourceSetupItemHOReq() {
+  pDUSessionID = NULL;
+  s_NSSAI = NULL;
+}
+PDUSessionResourceSetupItemHOReq::~PDUSessionResourceSetupItemHOReq() {
+}
 
+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;
+
+  return true;
+}
+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;
+
+  return true;
+}
+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;
+}
+
+}
 

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{
-
-	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);
-	private:
-		PDUSessionID *pDUSessionID;
-		S_NSSAI	 *s_NSSAI;
-		OCTET_STRING_t pDUSessionResourceSetupRequestTransfer;
-	};
+namespace ngap {
+
+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);
+ private:
+  PDUSessionID *pDUSessionID;
+  S_NSSAI *s_NSSAI;
+  OCTET_STRING_t pDUSessionResourceSetupRequestTransfer;
+};
 
 }
 
 #endif
 
-
-
-
-

src/ngap/ngapIEs/PDUSessionResourceSetupListHOReq.cpp

 #include "PDUSessionResourceSetupListHOReq.hpp"
-
-#include <iostream>
-using namespace std;
-
-namespace ngap{
-	PDUSessionResourceSetupListHOReq::PDUSessionResourceSetupListHOReq()
-	{
-		pduSessionResourceSetupItemHOReq = NULL;
-		numofpduSessionResourceSetupItemHOReq = 0;
-	}
-	PDUSessionResourceSetupListHOReq::~PDUSessionResourceSetupListHOReq(){}
-	
-	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;
-		}
-		
-		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;
-		}
-		
-		return true;
-	}
-	void PDUSessionResourceSetupListHOReq::getPDUSessionResourceSetupListHOReq(PDUSessionResourceSetupItemHOReq *&m_pduSessionResourceSetupItemHOReq,int &num)
-	{
-		m_pduSessionResourceSetupItemHOReq = pduSessionResourceSetupItemHOReq;
-		num = numofpduSessionResourceSetupItemHOReq;
-	}
-
-}
 
+#include <iostream>
+using namespace std;
 
+namespace ngap {
+PDUSessionResourceSetupListHOReq::PDUSessionResourceSetupListHOReq() {
+  pduSessionResourceSetupItemHOReq = NULL;
+  numofpduSessionResourceSetupItemHOReq = 0;
+}
+PDUSessionResourceSetupListHOReq::~PDUSessionResourceSetupListHOReq() {
+}
+
+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;
+  }
+
+  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;
+  }
+
+  return true;
+}
+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{
-
-	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);
-	private:
-		PDUSessionResourceSetupItemHOReq *pduSessionResourceSetupItemHOReq;
-		int numofpduSessionResourceSetupItemHOReq;
-	};
+namespace ngap {
+
+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);
+ private:
+  PDUSessionResourceSetupItemHOReq *pduSessionResourceSetupItemHOReq;
+  int numofpduSessionResourceSetupItemHOReq;
+};
 
 }
 

src/ngap/ngapIEs/QosFlowItemWithDataForwarding.cpp

@@ -20,42 +20,40 @@
  */
 
 /*! \file
-  \brief
-  \author  niuxiansheng-niu, BUPT
-  \date 2020
-  \email: contact@openairinterface.org
-  */
+ \brief
+ \author  niuxiansheng-niu, BUPT
+ \date 2020
+ \email: contact@openairinterface.org
+ */
 #include "QosFlowItemWithDataForwarding.hpp"
 #include <iostream>
 using namespace std;
 
-namespace ngap
-{
-	QosFlowItemWithDataForWarding::QosFlowItemWithDataForWarding()
-	{
-		qosFlowIdentifier = NULL;
-	}
-	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;
-		}
-	}
-	bool QosFlowItemWithDataForWarding::decodeformQosFlowItemWithDataForWarding(Ngap_QosFlowSetupResponseItemHOReqAck_t *qosFlowItemWithDataForWarding)
-	{
-		qosFlowIdentifier = new QosFlowIdentifier();
-		if (!qosFlowIdentifier->decodefromQosFlowIdentifier(&(qosFlowItemWithDataForWarding->qosFlowIdentifier)))
-		{
-			printf("false\n");
-			return false;
-		}
-		printf("true\n");
-		return true;
-	}
-} // namespace ngap
+namespace ngap {
+QosFlowItemWithDataForWarding::QosFlowItemWithDataForWarding() {
+  qosFlowIdentifier = NULL;
+}
+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;
+  }
+}
+bool QosFlowItemWithDataForWarding::decodeformQosFlowItemWithDataForWarding(
+    Ngap_QosFlowSetupResponseItemHOReqAck_t *qosFlowItemWithDataForWarding) {
+  qosFlowIdentifier = new QosFlowIdentifier();
+  if (!qosFlowIdentifier->decodefromQosFlowIdentifier(
+      &(qosFlowItemWithDataForWarding->qosFlowIdentifier))) {
+    printf("false\n");
+    return false;
+  }
+  printf("true\n");
+  return true;
+}
+}  // namespace ngap

src/ngap/ngapIEs/QosFlowItemWithDataForwarding.hpp

@@ -20,35 +20,34 @@
  */
 
 /*! \file
-  \brief
-  \author  niuxiansheng-niu, BUPT
-  \date 2020
-  \email: contact@openairinterface.org
-  */
+ \brief
+ \author  niuxiansheng-niu, BUPT
+ \date 2020
+ \email: contact@openairinterface.org
+ */
 #ifndef _QOSFLOWITEMWITHDATAFORWARDING_H_
 #define _QOSFLOWITEMWITHDATAFORWARDING_H_
 
 #include "QosFlowLevelQosParameters.hpp"
 #include "QosFlowIdentifier.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_QosFlowSetupResponseItemHOReqAck.h"
 }
-namespace ngap
-{
-	class QosFlowItemWithDataForWarding
-	{
-	public:
-		QosFlowItemWithDataForWarding();
-		virtual ~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
+ private:
+  long value;
+  QosFlowIdentifier *qosFlowIdentifier;
+};
+}  // namespace ngap
 
 #endif // !_QOSFLOWITEMWITHDATAFORWARDING_H_

src/ngap/ngapIEs/QosFlowListWithDataForwarding.cpp

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

src/ngap/ngapIEs/QosFlowListWithDataForwarding.hpp

@@ -19,33 +19,35 @@
  *      contact@openairinterface.org
  */
 
- /*! \file
-  \brief
-  \author  niuxiansheng-niu, BUPT
-  \date 2020
-  \email: contact@openairinterface.org
-  */
+/*! \file
+ \brief
+ \author  niuxiansheng-niu, BUPT
+ \date 2020
+ \email: contact@openairinterface.org
+ */
 
 #ifndef _QOSFLOWLISTWITHDATAFORWRADING_H_
 #define _QOSFLOWLISTWITHDATAFORWRADING_H_
 
 #include "QosFlowLevelQosParameters.hpp"
 #include "QosFlowItemWithDataForwarding.hpp"
-extern "C"
-{
-	#include "Ngap_QosFlowSetupResponseListHOReqAck.h"
+extern "C" {
+#include "Ngap_QosFlowSetupResponseListHOReqAck.h"
 }
 namespace ngap {
-	class QosFlowListWithDataForwarding {
-	public:
-		QosFlowListWithDataForwarding();
-		virtual ~QosFlowListWithDataForwarding();
-		bool getQosFlowListWithDataForwarding(QosFlowItemWithDataForWarding *&m_QosFlowItemWithDataForwarding, int &num);
-		bool decodeFormQosFlowListWithDataForwarding(Ngap_QosFlowSetupResponseListHOReqAck_t qosFlowSetupResponseList);
-	private:
-		//QosFlowIdentifier *qosFlowIdentifier;
-		QosFlowItemWithDataForWarding* qosFlowItemWithDataForwarding;
-		int numofQosFlowItemWithDataForwarding;
-	};
+class QosFlowListWithDataForwarding {
+ public:
+  QosFlowListWithDataForwarding();
+  virtual ~QosFlowListWithDataForwarding();
+  bool getQosFlowListWithDataForwarding(
+      QosFlowItemWithDataForWarding *&m_QosFlowItemWithDataForwarding,
+      int &num);
+  bool decodeFormQosFlowListWithDataForwarding(
+      Ngap_QosFlowSetupResponseListHOReqAck_t qosFlowSetupResponseList);
+ private:
+  //QosFlowIdentifier *qosFlowIdentifier;
+  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()
-    {
-        qosflowidentifier = NULL;
-    }
-    QosFlowToBeForwardedItem::~QosFlowToBeForwardedItem() {}
-    void QosFlowToBeForwardedItem::setQosFlowIdentifier(QosFlowIdentifier *m_qosflowidentifier)
-    {
-        qosflowidentifier = m_qosflowidentifier;
-    }
-    bool QosFlowToBeForwardedItem::encodeQosFlowToBeForwardedItem(Ngap_QosFlowToBeForwardedItem_t *qosflowtobeforwardeditem)
-    {
-        if (!qosflowidentifier)
-            return false;
-        if (!qosflowidentifier->encode2QosFlowIdentifier(&qosflowtobeforwardeditem->qosFlowIdentifier))
-        {
-            cout << "encode QFI error" << endl;
-            return false;
-        }
-        return true;
-    }
-} // namespace ngap
+namespace ngap {
+QosFlowToBeForwardedItem::QosFlowToBeForwardedItem() {
+  qosflowidentifier = NULL;
+}
+QosFlowToBeForwardedItem::~QosFlowToBeForwardedItem() {
+}
+void QosFlowToBeForwardedItem::setQosFlowIdentifier(
+    QosFlowIdentifier *m_qosflowidentifier) {
+  qosflowidentifier = m_qosflowidentifier;
+}
+bool QosFlowToBeForwardedItem::encodeQosFlowToBeForwardedItem(
+    Ngap_QosFlowToBeForwardedItem_t *qosflowtobeforwardeditem) {
+  if (!qosflowidentifier)
+    return false;
+  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
-    {
-    public:
-        QosFlowToBeForwardedItem();
-        virtual ~QosFlowToBeForwardedItem();
-        void setQosFlowIdentifier(QosFlowIdentifier *m_qosflowidentifier);
-        bool encodeQosFlowToBeForwardedItem(Ngap_QosFlowToBeForwardedItem_t *qosflowtobeforwardeditem);
+namespace ngap {
+class QosFlowToBeForwardedItem {
+ public:
+  QosFlowToBeForwardedItem();
+  virtual ~QosFlowToBeForwardedItem();
+  void setQosFlowIdentifier(QosFlowIdentifier *m_qosflowidentifier);
+  bool encodeQosFlowToBeForwardedItem(
+      Ngap_QosFlowToBeForwardedItem_t *qosflowtobeforwardeditem);
 
-    private:
-        QosFlowIdentifier *qosflowidentifier;
-    };
-} // namespace ngap
+ 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()
-    {
-        Qosflowtobeforwardeditem = NULL;
-        numofqosflowtobeforwardeditem = 0;
+namespace ngap {
+QosFlowToBeForwardedList::QosFlowToBeForwardedList() {
+  Qosflowtobeforwardeditem = NULL;
+  numofqosflowtobeforwardeditem = 0;
+}
+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++) {
+    cout << "encoding list..." << endl;
+    Ngap_QosFlowToBeForwardedItem_t *response =
+        (Ngap_QosFlowToBeForwardedItem_t*) calloc(
+            1, sizeof(Ngap_QosFlowToBeForwardedItem_t));
+    if (!response)
+      return false;
+    if (!Qosflowtobeforwardeditem[i].encodeQosFlowToBeForwardedItem(response)) {
+      cout << "encode QosFlowTowardedItem error" << endl;
+      return false;
     }
-    QosFlowToBeForwardedList::~QosFlowToBeForwardedList() {}
-    void QosFlowToBeForwardedList::setQosFlowToBeForwardedItem(QosFlowToBeForwardedItem *m_qosflowtobeforwardeditem, int num)
-    {
-        Qosflowtobeforwardeditem = m_qosflowtobeforwardeditem;
-        numofqosflowtobeforwardeditem = num;
+    cout << "QFI is " << response->qosFlowIdentifier << endl;
+    if (ASN_SEQUENCE_ADD(&m_ngap_qosflowtobeforwardedlist->list, response)
+        != 0) {
+      cout << "encode QosFlowTowardedList error" << endl;
+      return false;
     }
-    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));
-            if (!response)
-                return false;
-            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)
-            {
-                cout << "encode QosFlowTowardedList error" << endl;
-                return false;
-            }
-        }
-        return true;
-    }
-} // namespace ngap
+  }
+  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
-    {
-    public:
-        QosFlowToBeForwardedList();
-        virtual ~QosFlowToBeForwardedList();
-        void setQosFlowToBeForwardedItem(QosFlowToBeForwardedItem *m_qosflowtobeforwardeditem, int num);
-        bool encodeQosFlowToBeForwardedList(Ngap_QosFlowToBeForwardedList *&m_ngap_qosflowtobeforwardedlist);
+namespace ngap {
+class QosFlowToBeForwardedList {
+ public:
+  QosFlowToBeForwardedList();
+  virtual ~QosFlowToBeForwardedList();
+  void setQosFlowToBeForwardedItem(
+      QosFlowToBeForwardedItem *m_qosflowtobeforwardeditem, int num);
+  bool encodeQosFlowToBeForwardedList(
+      Ngap_QosFlowToBeForwardedList *&m_ngap_qosflowtobeforwardedlist);
 
-    private:
-        QosFlowToBeForwardedItem *Qosflowtobeforwardeditem;
-        int numofqosflowtobeforwardeditem;
-    };
-} // namespace ngap
+ 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()
-    {
-        drb_sub_list = NULL;
-    }
-    RANStatusTransferTransparentContainer::~RANStatusTransferTransparentContainer() {}
-    void RANStatusTransferTransparentContainer::getdRBSubject_list(dRBSubjectList *&drblist)
-    {
-        drblist = drb_sub_list;
-    }
-    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))
-        {
-            cout << "encoderanstatustransfer_transparentcontainer error" << endl;
-            return false;
-        }
-        return true;
-    }
-    bool RANStatusTransferTransparentContainer::decoderanstatustransfer_transparentcontainer(Ngap_RANStatusTransfer_TransparentContainer_t *ranstatustransfer_transparentcontainer)
-    {
-        drb_sub_list = new dRBSubjectList();
-        if (!drb_sub_list->decodefromdRBSubjectlist(ranstatustransfer_transparentcontainer->dRBsSubjectToStatusTransferList))
-        {
-            cout << "decoderanstatustransfer_transparentcontainer error" << endl;
-            return false;
-        }
-        return true;
-    }
-} // namespace ngap
+namespace ngap {
+RANStatusTransferTransparentContainer::RANStatusTransferTransparentContainer() {
+  drb_sub_list = NULL;
+}
+RANStatusTransferTransparentContainer::~RANStatusTransferTransparentContainer() {
+}
+void RANStatusTransferTransparentContainer::getdRBSubject_list(
+    dRBSubjectList *&drblist) {
+  drblist = drb_sub_list;
+}
+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)) {
+    cout << "encoderanstatustransfer_transparentcontainer error" << endl;
+    return false;
+  }
+  return true;
+}
+bool RANStatusTransferTransparentContainer::decoderanstatustransfer_transparentcontainer(
+    Ngap_RANStatusTransfer_TransparentContainer_t *ranstatustransfer_transparentcontainer) {
+  drb_sub_list = new dRBSubjectList();
+  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,26 +29,25 @@
 #define _RANSTATUSTRANSFERTRANSPATENTCONTAINER_H_
 #include "dRBsSubjectToStatusTransferList.hpp"
 #include "dRBsSubjectToStatusTransferItem.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_RANStatusTransfer-TransparentContainer.h"
 }
-namespace ngap
-{
-    class RANStatusTransferTransparentContainer
-    {
-    private:
-        /* data */
-        dRBSubjectList *drb_sub_list;
+namespace ngap {
+class RANStatusTransferTransparentContainer {
+ private:
+  /* data */
+  dRBSubjectList *drb_sub_list;
 
-    public:
-        RANStatusTransferTransparentContainer(/* args */);
-        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);
-    };
+ public:
+  RANStatusTransferTransparentContainer(/* args */);
+  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);
+};
 
-} // namespace ngap
+}  // 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)
-    {
-        dl18 = dL18;
-    }
-    void dRBStatusDL::getDRBStatusDL18(DRBStatusDL18 *&dL18)
-    {
-        dL18 = dl18;
-    }
-    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)
-    {
-        dl18 = new DRBStatusDL18();
-        if (!dl18->decodeddRBStatusDL18(dL->choice.dRBStatusDL18))
-        {
-            cout << "decodedRBStatusDL error" << endl;
-            return false;
-        }
-        cout << "decodedRBStatusDL successfully" << endl;
-        return true;
-    }
-} // namespace ngap
+namespace ngap {
+dRBStatusDL::dRBStatusDL() {
+  dl18 = (DRBStatusDL18*) calloc(1, sizeof(DRBStatusDL18));
+}
+dRBStatusDL::~dRBStatusDL() {
+}
+void dRBStatusDL::setDRBStatusDL18(DRBStatusDL18 *dL18) {
+  dl18 = dL18;
+}
+void dRBStatusDL::getDRBStatusDL18(DRBStatusDL18 *&dL18) {
+  dL18 = dl18;
+}
+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) {
+  dl18 = new 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,27 +28,24 @@
 #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
-    {
-    private:
-        /* data */
-        DRBStatusDL18 *dl18;
+namespace ngap {
+class dRBStatusDL {
+ private:
+  /* data */
+  DRBStatusDL18 *dl18;
 
-    public:
-        dRBStatusDL();
-        virtual ~dRBStatusDL();
-        void getDRBStatusDL18(DRBStatusDL18 *&dL18);
-        void setDRBStatusDL18(DRBStatusDL18 *dL18);
-        bool encodedRBStatusDL(Ngap_DRBStatusDL_t *dL);
-        bool decodedRBStatusDL(Ngap_DRBStatusDL_t *dL);
-    };
+ public:
+  dRBStatusDL();
+  virtual ~dRBStatusDL();
+  void getDRBStatusDL18(DRBStatusDL18 *&dL18);
+  void setDRBStatusDL18(DRBStatusDL18 *dL18);
+  bool encodedRBStatusDL(Ngap_DRBStatusDL_t *dL);
+  bool decodedRBStatusDL(Ngap_DRBStatusDL_t *dL);
+};
 
-} // namespace ngap
+}  // namespace ngap
 #endif

src/ngap/ngapIEs/dRBStatusDL18.cpp

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

src/ngap/ngapIEs/dRBStatusDL18.hpp

@@ -28,25 +28,22 @@
 #ifndef _DRBSTATUSDL18_H_
 #define _DRBSTATUSDL18_H_
 #include "COUNTValueForPDCP_SN18.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_DRBStatusDL18.h"
 }
-namespace ngap
-{
-    class DRBStatusDL18
-    {
-    private:
-        /* data */
-        COUNTValueForPDCP_SN18 *pdcp_value;
+namespace ngap {
+class DRBStatusDL18 {
+ private:
+  /* data */
+  COUNTValueForPDCP_SN18 *pdcp_value;
 
-    public:
-        DRBStatusDL18(/* args */);
-        virtual ~DRBStatusDL18();
-        void getcountvalue(COUNTValueForPDCP_SN18 *&count_value);
-        void setcountvalue(COUNTValueForPDCP_SN18 *count_value);
-        bool encodeddRBStatusDL18(Ngap_DRBStatusDL18_t *DL18);
-        bool decodeddRBStatusDL18(Ngap_DRBStatusDL18_t *DL18);
-    };
-} // namespace ngap
+ public:
+  DRBStatusDL18(/* args */);
+  virtual ~DRBStatusDL18();
+  void getcountvalue(COUNTValueForPDCP_SN18 *&count_value);
+  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)
-    {
-        ul18 = uL18;
-    }
-    void dRBStatusUL::getdRBStatusUL(dRBStatusUL18 *&uL18)
-    {
-        uL18 = ul18;
-    }
-    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)
-    {
-        ul18 = new dRBStatusUL18();
-        if (!ul18->decodeddRBStatusUL18(uL->choice.dRBStatusUL18))
-        {
-            cout << "decodeddRBStatusUL18 error" << endl;
-            return false;
-        }
-        cout << "decodedRBStatusUL successfully" << endl;
-        return true;
-    }
-} // namespace ngap
+namespace ngap {
+dRBStatusUL::dRBStatusUL() {
+  ul18 = (dRBStatusUL18*) calloc(1, sizeof(dRBStatusUL18));
+}
+dRBStatusUL::~dRBStatusUL() {
+}
+void dRBStatusUL::setdRBStatusUL(dRBStatusUL18 *uL18) {
+  ul18 = uL18;
+}
+void dRBStatusUL::getdRBStatusUL(dRBStatusUL18 *&uL18) {
+  uL18 = ul18;
+}
+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) {
+  ul18 = new 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,25 +28,22 @@
 #ifndef _DRBSTATUSUL_H_
 #define _DRBSTATUSUL_H_
 #include "dRBStatusUL18.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_DRBStatusUL.h"
 }
-namespace ngap
-{
-    class dRBStatusUL
-    {
-    private:
-        /* data */
-        dRBStatusUL18 *ul18;
+namespace ngap {
+class dRBStatusUL {
+ private:
+  /* data */
+  dRBStatusUL18 *ul18;
 
-    public:
-        dRBStatusUL(/* args */);
-        virtual ~dRBStatusUL();
-        void setdRBStatusUL(dRBStatusUL18 *uL18);
-        void getdRBStatusUL(dRBStatusUL18 *&uL18);
-        bool encodedRBStatusUL(Ngap_DRBStatusUL_t *uL);
-        bool decodedRBStatusUL(Ngap_DRBStatusUL_t *uL);
-    };
-} // namespace ngap
+ public:
+  dRBStatusUL(/* args */);
+  virtual ~dRBStatusUL();
+  void setdRBStatusUL(dRBStatusUL18 *uL18);
+  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()
-    {
-        pdcp_value = NULL;
-    }
-    dRBStatusUL18::~dRBStatusUL18() {}
-    void dRBStatusUL18::getcountvalue(COUNTValueForPDCP_SN18 *&count_value)
-    {
-        count_value = pdcp_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))
-        {
-            cout << "encodeddRBStatusUL18 error" << endl;
-            return false;
-        }
-        return true;
-    }
-    bool dRBStatusUL18::decodeddRBStatusUL18(Ngap_DRBStatusUL18_t *UL18)
-    {
-        pdcp_value = new COUNTValueForPDCP_SN18();
-        if (!pdcp_value->decodedCOUNTValueForPDCP_SN18(UL18->uL_COUNTValue))
-        {
-            cout << "decodeddRBStatusUL18 error" << endl;
-            return false;
-        }
-        return true;
-    }
-} // namespace ngap
+namespace ngap {
+dRBStatusUL18::dRBStatusUL18() {
+  pdcp_value = NULL;
+}
+dRBStatusUL18::~dRBStatusUL18() {
+}
+void dRBStatusUL18::getcountvalue(COUNTValueForPDCP_SN18 *&count_value) {
+  count_value = pdcp_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)) {
+    cout << "encodeddRBStatusUL18 error" << endl;
+    return false;
+  }
+  return true;
+}
+bool dRBStatusUL18::decodeddRBStatusUL18(Ngap_DRBStatusUL18_t *UL18) {
+  pdcp_value = new COUNTValueForPDCP_SN18();
+  if (!pdcp_value->decodedCOUNTValueForPDCP_SN18(UL18->uL_COUNTValue)) {
+    cout << "decodeddRBStatusUL18 error" << endl;
+    return false;
+  }
+  return true;
+}
+}  // namespace ngap

src/ngap/ngapIEs/dRBStatusUL18.hpp

@@ -28,26 +28,23 @@
 #ifndef _DRBSTATUSUL18_H_
 #define _DRBSTATUSUL18_H_
 #include "COUNTValueForPDCP_SN18.hpp"
-extern "C"
-{
+extern "C" {
 #include "Ngap_DRBStatusUL18.h"
 }
-namespace ngap
-{
-    class dRBStatusUL18
-    {
-    private:
-        /* data */
-        COUNTValueForPDCP_SN18 *pdcp_value;
+namespace ngap {
+class dRBStatusUL18 {
+ private:
+  /* data */
+  COUNTValueForPDCP_SN18 *pdcp_value;
 
-    public:
-        dRBStatusUL18(/* args */);
-        virtual ~dRBStatusUL18();
-        void getcountvalue(COUNTValueForPDCP_SN18 *&count_value);
-        void setcountvalue(COUNTValueForPDCP_SN18 *count_value);
-        bool encodeddRBStatusUL18(Ngap_DRBStatusUL18_t *UL18);
-        bool decodeddRBStatusUL18(Ngap_DRBStatusUL18_t *UL18);
-    };
+ public:
+  dRBStatusUL18(/* args */);
+  virtual ~dRBStatusUL18();
+  void getcountvalue(COUNTValueForPDCP_SN18 *&count_value);
+  void setcountvalue(COUNTValueForPDCP_SN18 *count_value);
+  bool encodeddRBStatusUL18(Ngap_DRBStatusUL18_t *UL18);
+  bool decodeddRBStatusUL18(Ngap_DRBStatusUL18_t *UL18);
+};
 
-} // namespace ngap
+}  // namespace ngap
 #endif

src/ngap/ngapIEs/dRBsSubjectToStatusTransferItem.cpp

@@ -31,67 +31,62 @@
 #include <vector>
 
 using namespace std;
-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)
-    {
-        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)
-    {
-        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)
-        {
-            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))
-        {
-            cout << "decode from dRBSubjectItem  dRBStatusUL error" << endl;
-            return false;
-        }
-        drb_dl = new 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)
-        {
-            dRB_item->dRB_ID = *drb_id;
-            cout << "the encode drb_id is" << *drb_id << endl;
-        }
-        if (!drb_ul->encodedRBStatusUL(&dRB_item->dRBStatusUL))
-        {
-            cout << "encode from dRBSubjectItem  dRBStatusUL error" << endl;
-            return false;
-        }
-        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
+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) {
+  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) {
+  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) {
+    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)) {
+    cout << "decode from dRBSubjectItem  dRBStatusUL error" << endl;
+    return false;
+  }
+  drb_dl = new 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) {
+    dRB_item->dRB_ID = *drb_id;
+    cout << "the encode drb_id is" << *drb_id << endl;
+  }
+  if (!drb_ul->encodedRBStatusUL(&dRB_item->dRBStatusUL)) {
+    cout << "encode from dRBSubjectItem  dRBStatusUL error" << endl;
+    return false;
+  }
+  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
-    {
-    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);
-        bool encodedRBSubjectItem(Ngap_DRBsSubjectToStatusTransferItem_t *dRB_item);
+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);
+  bool encodedRBSubjectItem(Ngap_DRBsSubjectToStatusTransferItem_t *dRB_item);
 
-    private:
-        Ngap_DRB_ID_t *drb_id;
-        dRBStatusUL *drb_ul;
-        dRBStatusDL *drb_dl;
-    };
-} // namespace ngap
+ 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()
-    {
-        drbsubjectitem = NULL;
-        numofitem = 0;
+namespace ngap {
+dRBSubjectList::dRBSubjectList() {
+  drbsubjectitem = NULL;
+  numofitem = 0;
+}
+dRBSubjectList::~dRBSubjectList() {
+}
+void dRBSubjectList::setdRBSubjectItem(dRBSubjectItem *m_item, int num) {
+  drbsubjectitem = m_item;
+  numofitem = 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));
+    if (!ie)
+      return false;
+    if (!drbsubjectitem[i].encodedRBSubjectItem(ie)) {
+      cout << "encodefromdRBSubjectlist error" << endl;
+      return false;
     }
-    dRBSubjectList::~dRBSubjectList() {}
-    void dRBSubjectList::setdRBSubjectItem(dRBSubjectItem *m_item, int num)
-    {
-        drbsubjectitem = m_item;
-        numofitem = num;
+    if (ASN_SEQUENCE_ADD(&DRBsSubjectToStatusTransferList.list, ie) != 0) {
+      cout
+          << "ASN_SEQUENCE_ADD(&DRBsSubjectToStatusTransferList.list, ie) error"
+          << endl;
+      return false;
     }
-    void dRBSubjectList::getdRBSubjectItem(dRBSubjectItem *&m_item, int &num)
-    {
-        m_item = drbsubjectitem;
-        num = numofitem;
+  }
+  cout << "encodefromdRBSubjectlist successfully" << endl;
+  return true;
+}
+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])) {
+      cout << "decodefromdRBSubjectlist error" << endl;
+      return false;
     }
-    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))
-            {
-                cout << "encodefromdRBSubjectlist error" << endl;
-                return false;
-            }
-            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)
-    {
-        numofitem = DRBsSubjectToStatusTransferList.list.count;
-        drbsubjectitem = new dRBSubjectItem[numofitem]();
-        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
+  }
+  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
-    {
-    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);
+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);
 
-    private:
-        dRBSubjectItem *drbsubjectitem;
-        int numofitem;
-    };
-} // namespace ngap
+ private:
+  dRBSubjectItem *drbsubjectitem;
+  int numofitem;
+};
+}  // namespace ngap
 #endif

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:
-        DownlinkRANStatusTransfer();
-        virtual ~DownlinkRANStatusTransfer();
-        void setmessagetype();
-        void setAmfUeNgapId(unsigned long id); //40 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);
+class DownlinkRANStatusTransfer
+{
+public:
+  DownlinkRANStatusTransfer();
+  virtual ~DownlinkRANStatusTransfer();
+  void setmessagetype();
+  void setAmfUeNgapId(unsigned long id);  //40 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:
-        Ngap_NGAP_PDU_t *DownlinkranstatustransferPDU;
-        Ngap_DownlinkRANStatusTransfer_t *DownlinkranstatustransferIEs;
-        AMF_UE_NGAP_ID *amfUeNgapId;
-        RAN_UE_NGAP_ID *ranUeNgapId;
-        RANStatusTransferTransparentContainer *ranStatusTransfer_TransparentContainer;
-    };
-} // namespace ngap
+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.hpp

@@ -11,60 +11,56 @@
 #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{
-
-
-	typedef struct {
-		uint8_t pduSessionId;
-		OCTET_STRING_t HandoverCommandTransfer;
-	}PDUSessionResourceHandoverItem_t;
-
-
-	class HandoverCommandMsg{
-	public:	
-		HandoverCommandMsg();
-		virtual ~HandoverCommandMsg();
-
-		void setMessageType(); //Initialize the PDU and populate the MessageType;
-		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;(不存在)
-		uint32_t getRanUeNgapId();//return -1;(不存在)
-		/*void getHandoverType(Ngap_HandoverType_t &handovertype);
-		void getCause(Cause cause);
-		void getTargetID(Ngap_TargetID_t targetID);
-		void getDirectForwardingPathAvailability(Ngap_DirectForwardingPathAvailability_t directpathavailable);
-		void getPDUSessionResourceList(Ngap_PDUSessionResourceHandoverList_t pdusessionresourcelist);
-		void getSourceToTargetTransparentContainer();*/	
-	private: 
-		Ngap_NGAP_PDU_t *handoverCommandPdu;
-		Ngap_HandoverCommand_t *handoverCommandIEs;
-		/***************** for decoding ****************/
-		AMF_UE_NGAP_ID *amfUeNgapId;
-		RAN_UE_NGAP_ID *ranUeNgapId;
-		Ngap_HandoverType_t *ngap_handovertype;
-		Ngap_NASSecurityParametersFromNGRAN_t	 *NASSecurityParametersFromNGRAN;
-		Ngap_PDUSessionResourceHandoverList_t	 *PDUSessionResourceHandoverList;
-		Ngap_PDUSessionResourceToReleaseListHOCmd_t	 *PDUSessionResourceToReleaseListHOCmd;
-		Ngap_TargetToSource_TransparentContainer_t	 *TargetToSource_TransparentContainer;
-		Ngap_CriticalityDiagnostics_t	 *CriticalityDiagnostics;
-
-	};
+namespace ngap {
+
+typedef struct {
+  uint8_t pduSessionId;
+  OCTET_STRING_t HandoverCommandTransfer;
+}PDUSessionResourceHandoverItem_t;
+
+class HandoverCommandMsg {
+public:
+  HandoverCommandMsg();
+  virtual ~HandoverCommandMsg();
+
+  void setMessageType();  //Initialize the PDU and populate the MessageType;
+  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;(不存在)
+  uint32_t getRanUeNgapId();//return -1;(不存在)
+  /*void getHandoverType(Ngap_HandoverType_t &handovertype);
+   void getCause(Cause cause);
+   void getTargetID(Ngap_TargetID_t targetID);
+   void getDirectForwardingPathAvailability(Ngap_DirectForwardingPathAvailability_t directpathavailable);
+   void getPDUSessionResourceList(Ngap_PDUSessionResourceHandoverList_t pdusessionresourcelist);
+   void getSourceToTargetTransparentContainer();*/
+private:
+  Ngap_NGAP_PDU_t *handoverCommandPdu;
+  Ngap_HandoverCommand_t *handoverCommandIEs;
+  /***************** for decoding ****************/
+  AMF_UE_NGAP_ID *amfUeNgapId;
+  RAN_UE_NGAP_ID *ranUeNgapId;
+  Ngap_HandoverType_t *ngap_handovertype;
+  Ngap_NASSecurityParametersFromNGRAN_t *NASSecurityParametersFromNGRAN;
+  Ngap_PDUSessionResourceHandoverList_t *PDUSessionResourceHandoverList;
+  Ngap_PDUSessionResourceToReleaseListHOCmd_t *PDUSessionResourceToReleaseListHOCmd;
+  Ngap_TargetToSource_TransparentContainer_t *TargetToSource_TransparentContainer;
+  Ngap_CriticalityDiagnostics_t *CriticalityDiagnostics;
+
+};
 
 }
 

src/ngap/ngapMsgs/HandoverNotifyMsg.hpp

@@ -19,12 +19,12 @@
  *      contact@openairinterface.org
  */
 
- /*! \file HandoverNotifyMsg.hpp
-  \brief
-  \author  niuxiansheng-niu, BUPT
-  \date 2020
-  \email: contact@openairinterface.org
-  */
+/*! \file HandoverNotifyMsg.hpp
+ \brief
+ \author  niuxiansheng-niu, BUPT
+ \date 2020
+ \email: contact@openairinterface.org
+ */
 #ifndef _HANDOVERNOTIFYMSG_H_
 #define _HANDOVERNOTIFYMSG_H_
 
@@ -42,24 +42,24 @@ extern "C" {
 }
 
 namespace ngap {
-	class HandoverNotifyMsg{
-	public:
-		HandoverNotifyMsg();
-		virtual ~HandoverNotifyMsg();
-		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);
+class HandoverNotifyMsg {
+ public:
+  HandoverNotifyMsg();
+  virtual ~HandoverNotifyMsg();
+  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);
 
-	private:
-		Ngap_NGAP_PDU_t* handoverNotifyPdu;
-		Ngap_HandoverNotify_t* handoverNotifyIEs;
-		AMF_UE_NGAP_ID* amfUeNgapId;
-		RAN_UE_NGAP_ID* ranUeNgapId;
-		UserLocationInformation* userLocationInformation;
-	};
+ private:
+  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/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:
-        UplinkRANStatusTransfer();
-        virtual ~UplinkRANStatusTransfer();
-        unsigned long getAmfUeNgapId(); //return -1;(不存在)
-        uint32_t getRanUeNgapId();      //return -1;(不存在)
-        void getRANStatusTransfer_TransparentContainer(RANStatusTransferTransparentContainer *&ranstatustransfer_transparentcontainer);
-        bool defromPDU(Ngap_NGAP_PDU_t *ngap_msg_pdu);
+class UplinkRANStatusTransfer
+{
+public:
+  UplinkRANStatusTransfer();
+  virtual ~UplinkRANStatusTransfer();
+  unsigned long getAmfUeNgapId();  //return -1;(不存在)
+  uint32_t getRanUeNgapId();//return -1;(不存在)
+  void getRANStatusTransfer_TransparentContainer(RANStatusTransferTransparentContainer *&ranstatustransfer_transparentcontainer);
+  bool defromPDU(Ngap_NGAP_PDU_t *ngap_msg_pdu);
 
-    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
+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