e2ap/pkg/e2ap_wrapper/packer_e2ap.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 2019 Nokia
   5
   6    Licensed under the Apache License, Version 2.0 (the "License");
   7    you may not use this file except in compliance with the License.
   8    You may obtain a copy of the License at
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17 ==================================================================================
  18 */
  19
  20 package e2ap_wrapper
  21
  22 // #cgo LDFLAGS: -le2ap_wrapper -le2ap -lgnbx2 -lgnbnrt -lstdc++
  23 // #include <stdlib.h>
  24 // #include <c_types.h>
  25 // #include <E2AP_if.h>
  26 // #include <memtrack.h>
  27 // #include <strings.h>
  28 //
  29 // void initSubsRequest(RICSubscriptionRequest_t *data){
  30 //   bzero(data,sizeof(RICSubscriptionRequest_t));
  31 // }
  32 // void initSubsResponse(RICSubscriptionResponse_t *data){
  33 //   bzero(data,sizeof(RICSubscriptionResponse_t));
  34 // }
  35 // void initSubsFailure(RICSubscriptionFailure_t *data){
  36 //   bzero(data,sizeof(RICSubscriptionFailure_t));
  37 // }
  38 // void initSubsDeleteRequest(RICSubscriptionDeleteRequest_t *data){
  39 //   bzero(data,sizeof(RICSubscriptionDeleteRequest_t));
  40 // }
  41 // void initSubsDeleteResponse(RICSubscriptionDeleteResponse_t *data){
  42 //   bzero(data,sizeof(RICSubscriptionDeleteResponse_t));
  43 // }
  44 // void initSubsDeleteFailure(RICSubscriptionDeleteFailure_t *data){
  45 //   bzero(data,sizeof(RICSubscriptionDeleteFailure_t));
  46 // }
  47 //
  48 import "C"
  49
  50 import (
  51         "bytes"
  52         "fmt"
  53         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/conv"
  54         "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
  55         "strings"
  56         "unsafe"
  57 )
  58
  59 const cLogBufferMaxSize = 40960
  60 const cMsgBufferMaxSize = 40960
  61 const cMsgBufferExtra = 512
  62
  63 //-----------------------------------------------------------------------------
  64 //
  65 //-----------------------------------------------------------------------------
  66 func cMessageInfoToMessageInfo(minfo *C.E2MessageInfo_t) *e2ap.MessageInfo {
  67
  68         msgInfo := &e2ap.MessageInfo{}
  69
  70         switch minfo.messageType {
  71         case C.cE2InitiatingMessage:
  72                 msgInfo.MsgType = e2ap.E2AP_InitiatingMessage
  73                 switch minfo.messageId {
  74                 case C.cRICSubscriptionRequest:
  75                         msgInfo.MsgId = e2ap.E2AP_RICSubscriptionRequest
  76                         return msgInfo
  77                 case C.cRICSubscriptionDeleteRequest:
  78                         msgInfo.MsgId = e2ap.E2AP_RICSubscriptionDeleteRequest
  79                         return msgInfo
  80                 }
  81         case C.cE2SuccessfulOutcome:
  82                 msgInfo.MsgType = e2ap.E2AP_SuccessfulOutcome
  83                 switch minfo.messageId {
  84                 case C.cRICSubscriptionResponse:
  85                         msgInfo.MsgId = e2ap.E2AP_RICSubscriptionResponse
  86                         return msgInfo
  87                 case C.cRICsubscriptionDeleteResponse:
  88                         msgInfo.MsgId = e2ap.E2AP_RICSubscriptionDeleteResponse
  89                         return msgInfo
  90                 }
  91         case C.cE2UnsuccessfulOutcome:
  92                 msgInfo.MsgType = e2ap.E2AP_UnsuccessfulOutcome
  93                 switch minfo.messageId {
  94                 case C.cRICSubscriptionFailure:
  95                         msgInfo.MsgId = e2ap.E2AP_RICSubscriptionFailure
  96                         return msgInfo
  97                 case C.cRICsubscriptionDeleteFailure:
  98                         msgInfo.MsgId = e2ap.E2AP_RICSubscriptionDeleteFailure
  99                         return msgInfo
 100                 }
 101         }
 102         return nil
 103 }
 104
 105 //-----------------------------------------------------------------------------
 106 //
 107 //-----------------------------------------------------------------------------
 108 type e2apEntryRequestID struct {
 109         entry *C.RICRequestID_t
 110 }
 111
 112 func (e2Item *e2apEntryRequestID) set(id *e2ap.RequestId) error {
 113         e2Item.entry.ricRequestorID = (C.uint32_t)(id.Id)
 114         e2Item.entry.ricInstanceID = (C.uint32_t)(id.InstanceId)
 115         return nil
 116 }
 117
 118 func (e2Item *e2apEntryRequestID) get(id *e2ap.RequestId) error {
 119         id.Id = (uint32)(e2Item.entry.ricRequestorID)
 120         id.InstanceId = (uint32)(e2Item.entry.ricInstanceID)
 121         return nil
 122 }
 123
 124 //-----------------------------------------------------------------------------
 125 //
 126 //-----------------------------------------------------------------------------
 127 type e2apEntryActionToBeSetupItem struct {
 128         entry *C.RICActionToBeSetupItem_t
 129 }
 130
 131 func (e2Item *e2apEntryActionToBeSetupItem) set(dynMemHead *C.mem_track_hdr_t, id *e2ap.ActionToBeSetupItem) error {
 132
 133         e2Item.entry.ricActionID = (C.ulong)(id.ActionId)
 134         e2Item.entry.ricActionType = (C.uint64_t)(id.ActionType)
 135         if id.RicActionDefinitionPresent {
 136                 e2Item.entry.ricActionDefinitionPresent = true
 137                 if err := (&e2apEntryActionDefinitionChoice{entry: &e2Item.entry.ricActionDefinitionChoice}).set(dynMemHead, &id.ActionDefinitionChoice); err != nil {
 138                         return err
 139                 }
 140         }
 141         if id.SubsequentAction.Present {
 142                 e2Item.entry.ricSubsequentActionPresent = true
 143                 e2Item.entry.ricSubsequentAction.ricSubsequentActionType = (C.uint64_t)(id.SubsequentAction.Type)
 144                 e2Item.entry.ricSubsequentAction.ricTimeToWait = (C.uint64_t)(id.SubsequentAction.TimetoWait)
 145         }
 146         return nil
 147 }
 148
 149 func (e2Item *e2apEntryActionToBeSetupItem) get(id *e2ap.ActionToBeSetupItem) error {
 150
 151         id.ActionId = (uint64)(e2Item.entry.ricActionID)
 152         id.ActionType = (uint64)(e2Item.entry.ricActionType)
 153         if e2Item.entry.ricActionDefinitionPresent {
 154                 id.RicActionDefinitionPresent = true
 155                 if err := (&e2apEntryActionDefinitionChoice{entry: &e2Item.entry.ricActionDefinitionChoice}).get(&id.ActionDefinitionChoice); err != nil {
 156                         return err
 157                 }
 158         }
 159         if e2Item.entry.ricSubsequentActionPresent {
 160                 id.SubsequentAction.Present = true
 161                 id.SubsequentAction.Type = (uint64)(e2Item.entry.ricSubsequentAction.ricSubsequentActionType)
 162                 id.SubsequentAction.TimetoWait = (uint64)(e2Item.entry.ricSubsequentAction.ricTimeToWait)
 163         }
 164         return nil
 165 }
 166
 167 //-----------------------------------------------------------------------------
 168 //
 169 //-----------------------------------------------------------------------------
 170 type e2apEntryActionDefinitionChoice struct {
 171         entry *C.RICActionDefinitionChoice_t
 172 }
 173
 174 func (e2Item *e2apEntryActionDefinitionChoice) set(dynMemHead *C.mem_track_hdr_t, id *e2ap.ActionDefinitionChoice) error {
 175
 176         if id.ActionDefinitionX2Format1Present {
 177                 e2Item.entry.actionDefinitionX2Format1Present = true
 178                 errorNro := C.allocActionDefinitionX2Format1(dynMemHead, &e2Item.entry.actionDefinitionX2Format1)
 179                 if errorNro != C.e2err_OK {
 180                         return fmt.Errorf("e2err(%s)", C.GoString(C.getE2ErrorString(errorNro)))
 181                 }
 182                 if err := (&e2apEntryE2SMgNBX2actionDefinition{entry: e2Item.entry.actionDefinitionX2Format1}).set(dynMemHead, &id.ActionDefinitionX2Format1); err != nil {
 183                         return err
 184                 }
 185
 186         } else if id.ActionDefinitionX2Format2Present {
 187                 e2Item.entry.actionDefinitionX2Format2Present = true
 188                 errorNro := C.allocActionDefinitionX2Format2(dynMemHead, &e2Item.entry.actionDefinitionX2Format2)
 189                 if errorNro != C.e2err_OK {
 190                         return fmt.Errorf("e2err(%s)", C.GoString(C.getE2ErrorString(errorNro)))
 191                 }
 192                 if err := (&e2apEntryActionDefinitionFormat2{entry: e2Item.entry.actionDefinitionX2Format2}).set(dynMemHead, &id.ActionDefinitionX2Format2); err != nil {
 193                         return err
 194                 }
 195         } else if id.ActionDefinitionNRTFormat1Present {
 196                 e2Item.entry.actionDefinitionNRTFormat1Present = true
 197                 errorNro := C.allocActionDefinitionNRTFormat1(dynMemHead, &e2Item.entry.actionDefinitionNRTFormat1)
 198                 if errorNro != C.e2err_OK {
 199                         return fmt.Errorf("e2err(%s)", C.GoString(C.getE2ErrorString(errorNro)))
 200                 }
 201                 if err := (&e2apEntryE2SMgNBNRTactionDefinitionFormat1{entry: e2Item.entry.actionDefinitionNRTFormat1}).set(dynMemHead, &id.ActionDefinitionNRTFormat1); err != nil {
 202                         return err
 203                 }
 204         } else {
 205                 return fmt.Errorf("Set() Missing mandatory ActionDefinition element")
 206         }
 207         return nil
 208 }
 209
 210 func (e2Item *e2apEntryActionDefinitionChoice) get(id *e2ap.ActionDefinitionChoice) error {
 211         if e2Item.entry.actionDefinitionX2Format1Present {
 212                 id.ActionDefinitionX2Format1Present = true
 213                 if err := (&e2apEntryE2SMgNBX2actionDefinition{entry: e2Item.entry.actionDefinitionX2Format1}).get(&id.ActionDefinitionX2Format1); err != nil {
 214                         return err
 215                 }
 216         } else if e2Item.entry.actionDefinitionX2Format2Present {
 217                 id.ActionDefinitionX2Format2Present = true
 218                 if err := (&e2apEntryActionDefinitionFormat2{entry: e2Item.entry.actionDefinitionX2Format2}).get(&id.ActionDefinitionX2Format2); err != nil {
 219                         return err
 220                 }
 221         } else if e2Item.entry.actionDefinitionNRTFormat1Present {
 222                 id.ActionDefinitionNRTFormat1Present = true
 223                 if err := (&e2apEntryE2SMgNBNRTactionDefinitionFormat1{entry: e2Item.entry.actionDefinitionNRTFormat1}).get(&id.ActionDefinitionNRTFormat1); err != nil {
 224                         return err
 225                 }
 226         } else {
 227                 return fmt.Errorf("Get() Missing mandatory ActionDefinition element")
 228         }
 229         return nil
 230 }
 231
 232 //-----------------------------------------------------------------------------
 233 //
 234 //-----------------------------------------------------------------------------
 235 type e2apEntryE2SMgNBX2actionDefinition struct {
 236         entry *C.E2SMgNBX2actionDefinition_t
 237 }
 238
 239 func (e2Item *e2apEntryE2SMgNBX2actionDefinition) set(dynMemHead *C.mem_track_hdr_t, id *e2ap.E2SMgNBX2actionDefinition) error {
 240
 241         e2Item.entry.styleID = (C.uint64_t)(id.StyleID)
 242         // 1..255
 243         e2Item.entry.actionParameterCount = 0
 244         for i := 0; i < len(id.ActionParameterItems); i++ {
 245                 if err := (&e2apEntryActionParameterItem{entry: &e2Item.entry.actionParameterItem[i]}).set(dynMemHead, &id.ActionParameterItems[i]); err != nil {
 246                         return err
 247                 }
 248                 e2Item.entry.actionParameterCount++
 249         }
 250         return nil
 251 }
 252
 253 func (e2Item *e2apEntryE2SMgNBX2actionDefinition) get(id *e2ap.E2SMgNBX2actionDefinition) error {
 254
 255         id.StyleID = (uint64)(e2Item.entry.styleID)
 256
 257         // 1..255
 258         length := (int)(e2Item.entry.actionParameterCount)
 259         id.ActionParameterItems = make([]e2ap.ActionParameterItem, length)
 260         for i := 0; i < length; i++ {
 261                 if err := (&e2apEntryActionParameterItem{entry: &e2Item.entry.actionParameterItem[i]}).get(&id.ActionParameterItems[i]); err != nil {
 262                         return err
 263                 }
 264         }
 265         return nil
 266 }
 267
 268 //-----------------------------------------------------------------------------
 269 //
 270 //-----------------------------------------------------------------------------
 271 type e2apEntryE2SMgNBNRTactionDefinitionFormat1 struct {
 272         entry *C.E2SMgNBNRTActionDefinitionFormat1_t
 273 }
 274
 275 func (e2Item *e2apEntryE2SMgNBNRTactionDefinitionFormat1) set(dynMemHead *C.mem_track_hdr_t, id *e2ap.E2SMgNBNRTActionDefinitionFormat1) error {
 276         // 1..255
 277         e2Item.entry.ranParameterCount = 0
 278         for i := 0; i < len(id.RanParameterList); i++ {
 279                 if err := (&e2apEntryRANParameterItem{entry: &e2Item.entry.ranParameterList[i]}).set(dynMemHead, &id.RanParameterList[i]); err != nil {
 280                         return err
 281                 }
 282                 e2Item.entry.ranParameterCount++
 283         }
 284         return nil
 285 }
 286
 287 func (e2Item *e2apEntryE2SMgNBNRTactionDefinitionFormat1) get(id *e2ap.E2SMgNBNRTActionDefinitionFormat1) error {
 288         // 1..255
 289         length := (int)(e2Item.entry.ranParameterCount)
 290         id.RanParameterList = make([]e2ap.RANParameterItem, length)
 291         for i := 0; i < length; i++ {
 292                 if err := (&e2apEntryRANParameterItem{entry: &e2Item.entry.ranParameterList[i]}).get(&id.RanParameterList[i]); err != nil {
 293                         return err
 294                 }
 295         }
 296         return nil
 297 }
 298
 299 //-----------------------------------------------------------------------------
 300 //
 301 //-----------------------------------------------------------------------------
 302 type e2apEntryActionParameterItem struct {
 303         entry *C.ActionParameterItem_t
 304 }
 305
 306 func (e2Item *e2apEntryActionParameterItem) set(dynMemHead *C.mem_track_hdr_t, id *e2ap.ActionParameterItem) error {
 307
 308         e2Item.entry.parameterID = (C.uint32_t)(id.ParameterID)
 309         if err := (&e2apEntryActionParameterValue{entry: &e2Item.entry.actionParameterValue}).set(dynMemHead, &id.ActionParameterValue); err != nil {
 310                 return err
 311         }
 312         return nil
 313 }
 314
 315 func (e2Item *e2apEntryActionParameterItem) get(id *e2ap.ActionParameterItem) error {
 316
 317         id.ParameterID = (uint32)(e2Item.entry.parameterID)
 318         if err := (&e2apEntryActionParameterValue{entry: &e2Item.entry.actionParameterValue}).get(&id.ActionParameterValue); err != nil {
 319                 return err
 320         }
 321         return nil
 322 }
 323
 324 //-----------------------------------------------------------------------------
 325 //
 326 //-----------------------------------------------------------------------------
 327 type e2apEntryActionParameterValue struct {
 328         entry *C.ActionParameterValue_t
 329 }
 330
 331 func (e2Item *e2apEntryActionParameterValue) set(dynMemHead *C.mem_track_hdr_t, id *e2ap.ActionParameterValue) error {
 332
 333         if id.ValueIntPresent {
 334                 e2Item.entry.valueInt = (C.int64_t)(id.ValueInt)
 335                 e2Item.entry.valueIntPresent = true
 336         } else if id.ValueEnumPresent {
 337                 e2Item.entry.valueEnum = (C.int64_t)(id.ValueEnum)
 338                 e2Item.entry.valueEnumPresent = true
 339         } else if id.ValueBoolPresent {
 340                 e2Item.entry.valueBool = (C.bool)(id.ValueBool)
 341                 e2Item.entry.valueBoolPresent = true
 342         } else if id.ValueBitSPresent {
 343                 if C.addBitString(dynMemHead, &e2Item.entry.valueBitS, (C.uint64_t)(id.ValueBitS.Length), unsafe.Pointer(&id.ValueBitS.Data[0]), (C.uint8_t)(id.ValueBitS.UnusedBits)) == false {
 344                         return fmt.Errorf("Alloc valueBitS fail")
 345                 }
 346                 e2Item.entry.valueBitSPresent = true
 347         } else if id.ValueOctSPresent {
 348                 if C.addOctetString(dynMemHead, &e2Item.entry.valueOctS, (C.uint64_t)(id.ValueOctS.Length), unsafe.Pointer(&id.ValueOctS.Data[0])) == false {
 349                         return fmt.Errorf("Alloc valueOctS fail")
 350                 }
 351                 e2Item.entry.valueOctSPresent = true
 352         } else if id.ValuePrtSPresent {
 353                 if C.addOctetString(dynMemHead, &e2Item.entry.valuePrtS, (C.uint64_t)(id.ValuePrtS.Length), unsafe.Pointer(&id.ValuePrtS.Data[0])) == false {
 354                         return fmt.Errorf("Alloc valuePrtS fail")
 355                 }
 356                 e2Item.entry.valuePrtSPresent = true
 357         }
 358         return nil
 359 }
 360
 361 func (e2Item *e2apEntryActionParameterValue) get(id *e2ap.ActionParameterValue) error {
 362
 363         if e2Item.entry.valueIntPresent {
 364                 id.ValueInt = (int64)(e2Item.entry.valueInt)
 365                 id.ValueIntPresent = true
 366         } else if e2Item.entry.valueEnumPresent {
 367                 id.ValueEnum = (int64)(e2Item.entry.valueEnum)
 368                 id.ValueEnumPresent = true
 369         } else if e2Item.entry.valueBoolPresent {
 370                 id.ValueBool = (bool)(e2Item.entry.valueBool)
 371                 id.ValueBoolPresent = true
 372         } else if e2Item.entry.valueBitSPresent {
 373                 id.ValueBitSPresent = true
 374                 id.ValueBitS.Length = (uint64)(e2Item.entry.valueBitS.byteLength)
 375                 id.ValueBitS.UnusedBits = (uint8)(e2Item.entry.valueBitS.unusedBits)
 376                 id.ValueBitS.Data = make([]uint8, id.ValueBitS.Length)
 377                 C.memcpy(unsafe.Pointer(&id.ValueBitS.Data[0]), unsafe.Pointer(e2Item.entry.valueBitS.data), C.size_t(e2Item.entry.valueBitS.byteLength))
 378         } else if e2Item.entry.valueOctSPresent {
 379                 id.ValueOctSPresent = true
 380                 id.ValueOctS.Length = (uint64)(e2Item.entry.valueOctS.length)
 381                 id.ValueOctS.Data = make([]uint8, id.ValueOctS.Length)
 382                 C.memcpy(unsafe.Pointer(&id.ValueOctS.Data[0]), unsafe.Pointer(e2Item.entry.valueOctS.data), C.size_t(e2Item.entry.valueOctS.length))
 383         } else if e2Item.entry.valuePrtSPresent {
 384                 id.ValuePrtSPresent = true
 385                 id.ValuePrtS.Length = (uint64)(e2Item.entry.valuePrtS.length)
 386                 id.ValuePrtS.Data = make([]uint8, id.ValuePrtS.Length)
 387                 C.memcpy(unsafe.Pointer(&id.ValuePrtS.Data[0]), unsafe.Pointer(e2Item.entry.valuePrtS.data), C.size_t(e2Item.entry.valuePrtS.length))
 388         }
 389         return nil
 390 }
 391
 392 //-----------------------------------------------------------------------------
 393 //
 394 //-----------------------------------------------------------------------------
 395 type e2apEntryActionDefinitionFormat2 struct {
 396         entry *C.E2SMgNBX2ActionDefinitionFormat2_t
 397 }
 398
 399 func (e2Item *e2apEntryActionDefinitionFormat2) set(dynMemHead *C.mem_track_hdr_t, id *e2ap.ActionDefinitionFormat2) error {
 400         // 1..15
 401         e2Item.entry.ranUeGroupCount = 0
 402         for i := 0; i < len(id.RanUEgroupItems); i++ {
 403                 if err := (&e2apEntryRANueGroupItem{entry: &e2Item.entry.ranUeGroupItem[i]}).set(dynMemHead, &id.RanUEgroupItems[i]); err != nil {
 404                         return err
 405                 }
 406                 e2Item.entry.ranUeGroupCount++
 407         }
 408         return nil
 409 }
 410
 411 func (e2Item *e2apEntryActionDefinitionFormat2) get(id *e2ap.ActionDefinitionFormat2) error {
 412         // 1..15
 413         length := (int)(e2Item.entry.ranUeGroupCount)
 414         id.RanUEgroupItems = make([]e2ap.RANueGroupItem, length)
 415         for i := 0; i < length; i++ {
 416                 if err := (&e2apEntryRANueGroupItem{entry: &e2Item.entry.ranUeGroupItem[i]}).get(&id.RanUEgroupItems[i]); err != nil {
 417                         return err
 418                 }
 419         }
 420         return nil
 421 }
 422
 423 //-----------------------------------------------------------------------------
 424 //
 425 //-----------------------------------------------------------------------------
 426 type e2apEntryRANueGroupItem struct {
 427         entry *C.RANueGroupItem_t
 428 }
 429
 430 func (e2Item *e2apEntryRANueGroupItem) set(dynMemHead *C.mem_track_hdr_t, id *e2ap.RANueGroupItem) error {
 431         e2Item.entry.ranUEgroupID = (C.int64_t)(id.RanUEgroupID)
 432         if err := (&e2apEntryRANueGroupDefinition{entry: &e2Item.entry.ranUEgroupDefinition}).set(dynMemHead, &id.RanUEgroupDefinition); err != nil {
 433                 return err
 434         }
 435         if err := (&e2apEntryRANimperativePolicy{entry: &e2Item.entry.ranPolicy}).set(dynMemHead, &id.RanPolicy); err != nil {
 436                 return err
 437         }
 438         return nil
 439 }
 440
 441 func (e2Item *e2apEntryRANueGroupItem) get(id *e2ap.RANueGroupItem) error {
 442         id.RanUEgroupID = (int64)(e2Item.entry.ranUEgroupID)
 443         if err := (&e2apEntryRANueGroupDefinition{entry: &e2Item.entry.ranUEgroupDefinition}).get(&id.RanUEgroupDefinition); err != nil {
 444                 return err
 445         }
 446         if err := (&e2apEntryRANimperativePolicy{entry: &e2Item.entry.ranPolicy}).get(&id.RanPolicy); err != nil {
 447                 return err
 448         }
 449         return nil
 450 }
 451
 452 //-----------------------------------------------------------------------------
 453 //
 454 //-----------------------------------------------------------------------------
 455 type e2apEntryRANueGroupDefinition struct {
 456         entry *C.RANueGroupDefinition_t
 457 }
 458
 459 func (e2Item *e2apEntryRANueGroupDefinition) set(dynMemHead *C.mem_track_hdr_t, id *e2ap.RANueGroupDefinition) error {
 460         // 1..255
 461         e2Item.entry.ranUeGroupDefCount = 0
 462         for i := 0; i < len(id.RanUEGroupDefItems); i++ {
 463                 if err := (&e2apEntryRANueGroupDefItem{entry: &e2Item.entry.ranUeGroupDefItem[i]}).set(dynMemHead, &id.RanUEGroupDefItems[i]); err != nil {
 464                         return err
 465                 }
 466                 e2Item.entry.ranUeGroupDefCount++
 467         }
 468         return nil
 469 }
 470
 471 func (e2Item *e2apEntryRANueGroupDefinition) get(id *e2ap.RANueGroupDefinition) error {
 472         // 1..255
 473         length := (int)(e2Item.entry.ranUeGroupDefCount)
 474         id.RanUEGroupDefItems = make([]e2ap.RANueGroupDefItem, length)
 475         for i := 0; i < length; i++ {
 476                 if err := (&e2apEntryRANueGroupDefItem{entry: &e2Item.entry.ranUeGroupDefItem[i]}).get(&id.RanUEGroupDefItems[i]); err != nil {
 477                         return err
 478                 }
 479         }
 480         return nil
 481 }
 482
 483 //-----------------------------------------------------------------------------
 484 //
 485 //-----------------------------------------------------------------------------
 486 type e2apEntryRANimperativePolicy struct {
 487         entry *C.RANimperativePolicy_t
 488 }
 489
 490 func (e2Item *e2apEntryRANimperativePolicy) set(dynMemHead *C.mem_track_hdr_t, id *e2ap.RANimperativePolicy) error {
 491         // 1..255
 492         e2Item.entry.ranParameterCount = 0
 493         for i := 0; i < len(id.RanParameterItems); i++ {
 494                 if err := (&e2apEntryRANParameterItem{entry: &e2Item.entry.ranParameterItem[i]}).set(dynMemHead, &id.RanParameterItems[i]); err != nil {
 495                         return err
 496                 }
 497                 e2Item.entry.ranParameterCount++
 498         }
 499         return nil
 500 }
 501
 502 func (e2Item *e2apEntryRANimperativePolicy) get(id *e2ap.RANimperativePolicy) error {
 503         // 1..255
 504         length := (int)(e2Item.entry.ranParameterCount)
 505         id.RanParameterItems = make([]e2ap.RANParameterItem, length)
 506         for i := 0; i < length; i++ {
 507                 if err := (&e2apEntryRANParameterItem{entry: &e2Item.entry.ranParameterItem[i]}).get(&id.RanParameterItems[i]); err != nil {
 508                         return err
 509                 }
 510         }
 511         return nil
 512 }
 513
 514 //-----------------------------------------------------------------------------
 515 //
 516 //-----------------------------------------------------------------------------
 517 type e2apEntryRANueGroupDefItem struct {
 518         entry *C.RANueGroupDefItem_t
 519 }
 520
 521 func (e2Item *e2apEntryRANueGroupDefItem) set(dynMemHead *C.mem_track_hdr_t, id *e2ap.RANueGroupDefItem) error {
 522
 523         e2Item.entry.ranParameterID = (C.uint32_t)(id.RanParameterID)
 524         e2Item.entry.ranParameterTest = (C.uint8_t)(id.RanParameterTest)
 525         if err := (&e2apEntryRANParameterValue{entry: &e2Item.entry.ranParameterValue}).set(dynMemHead, &id.RanParameterValue); err != nil {
 526                 return err
 527         }
 528         return nil
 529 }
 530
 531 func (e2Item *e2apEntryRANueGroupDefItem) get(id *e2ap.RANueGroupDefItem) error {
 532
 533         id.RanParameterID = (uint32)(e2Item.entry.ranParameterID)
 534         id.RanParameterTest = (uint8)(e2Item.entry.ranParameterTest)
 535         if err := (&e2apEntryRANParameterValue{entry: &e2Item.entry.ranParameterValue}).get(&id.RanParameterValue); err != nil {
 536                 return err
 537         }
 538         return nil
 539 }
 540
 541 //-----------------------------------------------------------------------------
 542 //
 543 //-----------------------------------------------------------------------------
 544 type e2apEntryRANParameterItem struct {
 545         entry *C.RANParameterItem_t
 546 }
 547
 548 func (e2Item *e2apEntryRANParameterItem) set(dynMemHead *C.mem_track_hdr_t, id *e2ap.RANParameterItem) error {
 549
 550         e2Item.entry.ranParameterID = (C.uint32_t)(id.RanParameterID)
 551         if err := (&e2apEntryRANParameterValue{entry: &e2Item.entry.ranParameterValue}).set(dynMemHead, &id.RanParameterValue); err != nil {
 552                 return err
 553         }
 554         return nil
 555 }
 556
 557 func (e2Item *e2apEntryRANParameterItem) get(id *e2ap.RANParameterItem) error {
 558
 559         id.RanParameterID = (uint8)(e2Item.entry.ranParameterID)
 560         if err := (&e2apEntryRANParameterValue{entry: &e2Item.entry.ranParameterValue}).get(&id.RanParameterValue); err != nil {
 561                 return err
 562         }
 563         return nil
 564 }
 565
 566 //-----------------------------------------------------------------------------
 567 //
 568 //-----------------------------------------------------------------------------
 569 type e2apEntryRANParameterValue struct {
 570         entry *C.RANParameterValue_t
 571 }
 572
 573 func (e2Item *e2apEntryRANParameterValue) set(dynMemHead *C.mem_track_hdr_t, id *e2ap.RANParameterValue) error {
 574
 575         if id.ValueIntPresent {
 576                 e2Item.entry.valueInt = (C.int64_t)(id.ValueInt)
 577                 e2Item.entry.valueIntPresent = true
 578         } else if id.ValueEnumPresent {
 579                 e2Item.entry.valueEnum = (C.int64_t)(id.ValueEnum)
 580                 e2Item.entry.valueEnumPresent = true
 581         } else if id.ValueBoolPresent {
 582                 e2Item.entry.valueBool = (C.bool)(id.ValueBool)
 583                 e2Item.entry.valueBoolPresent = true
 584         } else if id.ValueBitSPresent {
 585                 if C.addBitString(dynMemHead, &e2Item.entry.valueBitS, (C.uint64_t)(id.ValueBitS.Length), unsafe.Pointer(&id.ValueBitS.Data[0]), (C.uint8_t)(id.ValueBitS.UnusedBits)) == false {
 586                         return fmt.Errorf("Alloc valueBitS fail")
 587                 }
 588                 e2Item.entry.valueBitSPresent = true
 589         } else if id.ValueOctSPresent {
 590                 if C.addOctetString(dynMemHead, &e2Item.entry.valueOctS, (C.uint64_t)(id.ValueOctS.Length), unsafe.Pointer(&id.ValueOctS.Data[0])) == false {
 591                         return fmt.Errorf("Alloc valueOctS fail")
 592                 }
 593                 e2Item.entry.valueOctSPresent = true
 594         } else if id.ValuePrtSPresent {
 595                 if C.addOctetString(dynMemHead, &e2Item.entry.valuePrtS, (C.uint64_t)(id.ValuePrtS.Length), unsafe.Pointer(&id.ValuePrtS.Data[0])) == false {
 596                         return fmt.Errorf("Alloc valuePrtS fail")
 597                 }
 598                 e2Item.entry.valuePrtSPresent = true
 599         }
 600         return nil
 601 }
 602
 603 func (e2Item *e2apEntryRANParameterValue) get(id *e2ap.RANParameterValue) error {
 604
 605         if e2Item.entry.valueIntPresent {
 606                 id.ValueInt = (int64)(e2Item.entry.valueInt)
 607                 id.ValueIntPresent = true
 608         } else if e2Item.entry.valueEnumPresent {
 609                 id.ValueEnum = (int64)(e2Item.entry.valueEnum)
 610                 id.ValueEnumPresent = true
 611         } else if e2Item.entry.valueBoolPresent {
 612                 id.ValueBool = (bool)(e2Item.entry.valueBool)
 613                 id.ValueBoolPresent = true
 614         } else if e2Item.entry.valueBitSPresent {
 615                 id.ValueBitSPresent = true
 616                 id.ValueBitS.Length = (uint64)(e2Item.entry.valueBitS.byteLength)
 617                 id.ValueBitS.UnusedBits = (uint8)(e2Item.entry.valueBitS.unusedBits)
 618                 id.ValueBitS.Data = make([]uint8, id.ValueBitS.Length)
 619                 C.memcpy(unsafe.Pointer(&id.ValueBitS.Data[0]), unsafe.Pointer(e2Item.entry.valueBitS.data), C.size_t(e2Item.entry.valueBitS.byteLength))
 620         } else if e2Item.entry.valueOctSPresent {
 621                 id.ValueOctSPresent = true
 622                 id.ValueOctS.Length = (uint64)(e2Item.entry.valueOctS.length)
 623                 id.ValueOctS.Data = make([]uint8, id.ValueOctS.Length)
 624                 C.memcpy(unsafe.Pointer(&id.ValueOctS.Data[0]), unsafe.Pointer(e2Item.entry.valueOctS.data), C.size_t(e2Item.entry.valueOctS.length))
 625         } else if e2Item.entry.valuePrtSPresent {
 626                 id.ValuePrtSPresent = true
 627                 id.ValuePrtS.Length = (uint64)(e2Item.entry.valuePrtS.length)
 628                 id.ValuePrtS.Data = make([]uint8, id.ValuePrtS.Length)
 629                 C.memcpy(unsafe.Pointer(&id.ValuePrtS.Data[0]), unsafe.Pointer(e2Item.entry.valuePrtS.data), C.size_t(e2Item.entry.valuePrtS.length))
 630         }
 631         return nil
 632 }
 633
 634 //-----------------------------------------------------------------------------
 635 //
 636 //-----------------------------------------------------------------------------
 637 type e2apEntryPlmnIdentity struct {
 638         entry *C.PLMNIdentity_t
 639 }
 640
 641 func (plmnId *e2apEntryPlmnIdentity) set(id conv.PlmnIdentityIf) error {
 642
 643         buf := new(bytes.Buffer)
 644         id.EncodeTo(buf)
 645         data := buf.Bytes()
 646         plmnId.entry.contentLength = (C.uint8_t)(len(data))
 647         for i := 0; i < len(data); i++ {
 648                 plmnId.entry.pLMNIdentityVal[i] = (C.uint8_t)(data[i])
 649         }
 650         return nil
 651 }
 652
 653 func (plmnId *e2apEntryPlmnIdentity) get(id conv.PlmnIdentityIf) error {
 654         conlen := (int)(plmnId.entry.contentLength)
 655         bcdBuf := make([]uint8, conlen)
 656         for i := 0; i < conlen; i++ {
 657                 bcdBuf[i] = (uint8)(plmnId.entry.pLMNIdentityVal[i])
 658         }
 659         reader := bytes.NewReader(bcdBuf)
 660         id.DecodeFrom(reader)
 661         return nil
 662 }
 663
 664 //-----------------------------------------------------------------------------
 665 //
 666 //-----------------------------------------------------------------------------
 667 type e2apEntryGlobalEnbId struct {
 668         entry *C.GlobalNodeID_t
 669 }
 670
 671 func (enbId *e2apEntryGlobalEnbId) checkbits(bits uint8) error {
 672         switch bits {
 673         case e2ap.E2AP_ENBIDMacroPBits20:
 674                 return nil
 675         case e2ap.E2AP_ENBIDHomeBits28:
 676                 return nil
 677         case e2ap.E2AP_ENBIDShortMacroits18:
 678                 return nil
 679         case e2ap.E2AP_ENBIDlongMacroBits21:
 680                 return nil
 681         }
 682         return fmt.Errorf("GlobalEnbId: given bits %d not match allowed: 20,28,18,21", bits)
 683 }
 684
 685 func (enbId *e2apEntryGlobalEnbId) set(id *e2ap.GlobalNodeId) error {
 686         if err := enbId.checkbits(id.NodeId.Bits); err != nil {
 687                 return err
 688         }
 689         enbId.entry.nodeID.bits = (C.uchar)(id.NodeId.Bits)
 690         enbId.entry.nodeID.nodeID = (C.uint32_t)(id.NodeId.Id)
 691         return (&e2apEntryPlmnIdentity{entry: &enbId.entry.pLMNIdentity}).set(&id.PlmnIdentity)
 692 }
 693
 694 func (enbId *e2apEntryGlobalEnbId) get(id *e2ap.GlobalNodeId) error {
 695         if err := enbId.checkbits((uint8)(enbId.entry.nodeID.bits)); err != nil {
 696                 return err
 697         }
 698         id.NodeId.Bits = (uint8)(enbId.entry.nodeID.bits)
 699         id.NodeId.Id = (uint32)(enbId.entry.nodeID.nodeID)
 700         return (&e2apEntryPlmnIdentity{entry: &enbId.entry.pLMNIdentity}).get(&id.PlmnIdentity)
 701 }
 702
 703 //-----------------------------------------------------------------------------
 704 //
 705 //-----------------------------------------------------------------------------
 706 type e2apEntryGlobalGnbId struct {
 707         entry *C.GlobalNodeID_t
 708 }
 709
 710 func (gnbId *e2apEntryGlobalGnbId) checkbits(bits uint8) error {
 711         if bits < 22 || bits > 32 {
 712                 return fmt.Errorf("GlobalGnbId: given bits %d not match allowed: 22-32", bits)
 713         }
 714         return nil
 715 }
 716
 717 func (gnbId *e2apEntryGlobalGnbId) set(id *e2ap.GlobalNodeId) error {
 718         if err := gnbId.checkbits(id.NodeId.Bits); err != nil {
 719                 return err
 720         }
 721         gnbId.entry.nodeID.bits = (C.uchar)(id.NodeId.Bits)
 722         gnbId.entry.nodeID.nodeID = (C.uint32_t)(id.NodeId.Id)
 723         return (&e2apEntryPlmnIdentity{entry: &gnbId.entry.pLMNIdentity}).set(&id.PlmnIdentity)
 724 }
 725
 726 func (gnbId *e2apEntryGlobalGnbId) get(id *e2ap.GlobalNodeId) error {
 727         if err := gnbId.checkbits((uint8)(gnbId.entry.nodeID.bits)); err != nil {
 728                 return err
 729         }
 730         id.NodeId.Bits = (uint8)(gnbId.entry.nodeID.bits)
 731         id.NodeId.Id = (uint32)(gnbId.entry.nodeID.nodeID)
 732         return (&e2apEntryPlmnIdentity{entry: &gnbId.entry.pLMNIdentity}).get(&id.PlmnIdentity)
 733 }
 734
 735 //-----------------------------------------------------------------------------
 736 //
 737 //-----------------------------------------------------------------------------
 738 type e2apEntryInterfaceId struct {
 739         entry *C.InterfaceID_t
 740 }
 741
 742 func (indId *e2apEntryInterfaceId) set(id *e2ap.InterfaceId) error {
 743         if id.GlobalEnbId.Present {
 744                 indId.entry.globalENBIDPresent = true
 745                 if err := (&e2apEntryGlobalEnbId{entry: &indId.entry.globalENBID}).set(&id.GlobalEnbId); err != nil {
 746                         return err
 747                 }
 748         }
 749
 750         if id.GlobalGnbId.Present {
 751                 indId.entry.globalGNBIDPresent = true
 752                 if err := (&e2apEntryGlobalGnbId{entry: &indId.entry.globalGNBID}).set(&id.GlobalGnbId); err != nil {
 753                         return err
 754                 }
 755         }
 756         return nil
 757 }
 758
 759 func (indId *e2apEntryInterfaceId) get(id *e2ap.InterfaceId) error {
 760         if indId.entry.globalENBIDPresent == true {
 761                 id.GlobalEnbId.Present = true
 762                 if err := (&e2apEntryGlobalEnbId{entry: &indId.entry.globalENBID}).get(&id.GlobalEnbId); err != nil {
 763                         return err
 764                 }
 765         }
 766
 767         if indId.entry.globalGNBIDPresent == true {
 768                 id.GlobalGnbId.Present = true
 769                 if err := (&e2apEntryGlobalGnbId{entry: &indId.entry.globalGNBID}).get(&id.GlobalGnbId); err != nil {
 770                         return err
 771                 }
 772         }
 773         return nil
 774 }
 775
 776 //-----------------------------------------------------------------------------
 777 //
 778 //-----------------------------------------------------------------------------
 779 type e2apEntryEventTrigger struct {
 780         entry *C.RICEventTriggerDefinition_t
 781 }
 782
 783 func (evtTrig *e2apEntryEventTrigger) set(id *e2ap.EventTriggerDefinition) error {
 784         if id.NBX2EventTriggerDefinitionPresent {
 785                 evtTrig.entry.E2SMgNBX2EventTriggerDefinitionPresent = true
 786                 return (&e2apEntryX2EventTrigger{entry: &evtTrig.entry.e2SMgNBX2eventTriggerDefinition}).set(&id.X2EventTriggerDefinition)
 787
 788         } else if id.NBNRTEventTriggerDefinitionPresent {
 789                 evtTrig.entry.E2SMgNBNRTEventTriggerDefinitionPresent = true
 790                 return (&e2apEntryNRTEventTrigger{entry: &evtTrig.entry.e2SMgNBNRTEventTriggerDefinition}).set(&id.NBNRTEventTriggerDefinition)
 791         }
 792         return fmt.Errorf("Set() empty EventTriggerDefinition")
 793 }
 794
 795 func (evtTrig *e2apEntryEventTrigger) get(id *e2ap.EventTriggerDefinition) error {
 796         if evtTrig.entry.E2SMgNBX2EventTriggerDefinitionPresent {
 797                 id.NBX2EventTriggerDefinitionPresent = true
 798                 return (&e2apEntryX2EventTrigger{entry: &evtTrig.entry.e2SMgNBX2eventTriggerDefinition}).get(&id.X2EventTriggerDefinition)
 799
 800         } else if evtTrig.entry.E2SMgNBNRTEventTriggerDefinitionPresent {
 801                 id.NBNRTEventTriggerDefinitionPresent = true
 802                 return (&e2apEntryNRTEventTrigger{entry: &evtTrig.entry.e2SMgNBNRTEventTriggerDefinition}).get(&id.NBNRTEventTriggerDefinition)
 803         }
 804         return fmt.Errorf("Get() empty EventTriggerDefinition")
 805 }
 806
 807 //-----------------------------------------------------------------------------
 808 //
 809 //-----------------------------------------------------------------------------
 810 type e2apEntryX2EventTrigger struct {
 811         entry *C.E2SMgNBX2eventTriggerDefinition_t
 812 }
 813
 814 func (evtTrig *e2apEntryX2EventTrigger) set(id *e2ap.X2EventTriggerDefinition) error {
 815         evtTrig.entry.interfaceDirection = (C.uint8_t)(id.InterfaceDirection)
 816         evtTrig.entry.interfaceMessageType.procedureCode = (C.uint8_t)(id.ProcedureCode)
 817         evtTrig.entry.interfaceMessageType.typeOfMessage = (C.uint8_t)(id.TypeOfMessage)
 818         return (&e2apEntryInterfaceId{entry: &evtTrig.entry.interfaceID}).set(&id.InterfaceId)
 819 }
 820
 821 func (evtTrig *e2apEntryX2EventTrigger) get(id *e2ap.X2EventTriggerDefinition) error {
 822         id.InterfaceDirection = (uint32)(evtTrig.entry.interfaceDirection)
 823         id.ProcedureCode = (uint32)(evtTrig.entry.interfaceMessageType.procedureCode)
 824         id.TypeOfMessage = (uint64)(evtTrig.entry.interfaceMessageType.typeOfMessage)
 825         return (&e2apEntryInterfaceId{entry: &evtTrig.entry.interfaceID}).get(&id.InterfaceId)
 826 }
 827
 828 //-----------------------------------------------------------------------------
 829 //
 830 //-----------------------------------------------------------------------------
 831 type e2apEntryNRTEventTrigger struct {
 832         entry *C.E2SMgNBNRTEventTriggerDefinition_t
 833 }
 834
 835 func (evtTrig *e2apEntryNRTEventTrigger) set(id *e2ap.NBNRTEventTriggerDefinition) error {
 836         evtTrig.entry.eventDefinitionFormat1.triggerNature = (C.uint8_t)(id.TriggerNature)
 837         return nil
 838 }
 839
 840 func (evtTrig *e2apEntryNRTEventTrigger) get(id *e2ap.NBNRTEventTriggerDefinition) error {
 841         id.TriggerNature = (uint8)(evtTrig.entry.eventDefinitionFormat1.triggerNature)
 842         return nil
 843 }
 844
 845 //-----------------------------------------------------------------------------
 846 //
 847 //-----------------------------------------------------------------------------
 848 type e2apEntryAdmittedList struct {
 849         entry *C.RICActionAdmittedList_t
 850 }
 851
 852 func (item *e2apEntryAdmittedList) set(data *e2ap.ActionAdmittedList) error {
 853
 854         if len(data.Items) > 16 {
 855                 return fmt.Errorf("ActionAdmittedList: too long %d while allowed %d", len(data.Items), 16)
 856         }
 857
 858         item.entry.contentLength = 0
 859         for i := 0; i < len(data.Items); i++ {
 860                 item.entry.ricActionID[item.entry.contentLength] = (C.ulong)(data.Items[i].ActionId)
 861                 item.entry.contentLength++
 862         }
 863         return nil
 864 }
 865
 866 func (item *e2apEntryAdmittedList) get(data *e2ap.ActionAdmittedList) error {
 867         conlen := (int)(item.entry.contentLength)
 868         data.Items = make([]e2ap.ActionAdmittedItem, conlen)
 869         for i := 0; i < conlen; i++ {
 870                 data.Items[i].ActionId = (uint64)(item.entry.ricActionID[i])
 871         }
 872         return nil
 873 }
 874
 875 //-----------------------------------------------------------------------------
 876 //
 877 //-----------------------------------------------------------------------------
 878 type e2apEntryNotAdmittedList struct {
 879         entry *C.RICActionNotAdmittedList_t
 880 }
 881
 882 func (item *e2apEntryNotAdmittedList) set(data *e2ap.ActionNotAdmittedList) error {
 883
 884         if len(data.Items) > 16 {
 885                 return fmt.Errorf("e2apEntryNotAdmittedList: too long %d while allowed %d", len(data.Items), 16)
 886         }
 887
 888         item.entry.contentLength = 0
 889         for i := 0; i < len(data.Items); i++ {
 890                 item.entry.RICActionNotAdmittedItem[item.entry.contentLength].ricActionID = (C.ulong)(data.Items[i].ActionId)
 891                 item.entry.RICActionNotAdmittedItem[item.entry.contentLength].cause.content = (C.uchar)(data.Items[i].Cause.Content)
 892                 item.entry.RICActionNotAdmittedItem[item.entry.contentLength].cause.causeVal = (C.uchar)(data.Items[i].Cause.Value)
 893                 item.entry.contentLength++
 894         }
 895
 896         return nil
 897 }
 898
 899 func (item *e2apEntryNotAdmittedList) get(data *e2ap.ActionNotAdmittedList) error {
 900         conlen := (int)(item.entry.contentLength)
 901         data.Items = make([]e2ap.ActionNotAdmittedItem, conlen)
 902         for i := 0; i < conlen; i++ {
 903                 data.Items[i].ActionId = (uint64)(item.entry.RICActionNotAdmittedItem[i].ricActionID)
 904                 data.Items[i].Cause.Content = (uint8)(item.entry.RICActionNotAdmittedItem[i].cause.content)
 905                 data.Items[i].Cause.Value = (uint8)(item.entry.RICActionNotAdmittedItem[i].cause.causeVal)
 906         }
 907         return nil
 908 }
 909
 910 //-----------------------------------------------------------------------------
 911 //
 912 //-----------------------------------------------------------------------------
 913 type e2apEntryCriticalityDiagnostic struct {
 914         entry *C.CriticalityDiagnostics__t
 915 }
 916
 917 func (item *e2apEntryCriticalityDiagnostic) set(data *e2ap.CriticalityDiagnostics) error {
 918
 919         item.entry.procedureCodePresent = (C.bool)(data.ProcCodePresent)
 920         item.entry.procedureCode = (C.uchar)(data.ProcCode)
 921
 922         item.entry.triggeringMessagePresent = (C.bool)(data.TrigMsgPresent)
 923         item.entry.triggeringMessage = (C.uchar)(data.TrigMsg)
 924
 925         item.entry.procedureCriticalityPresent = (C.bool)(data.ProcCritPresent)
 926         item.entry.procedureCriticality = (C.uchar)(data.ProcCrit)
 927
 928         item.entry.criticalityDiagnosticsIELength = 0
 929         item.entry.iEsCriticalityDiagnosticsPresent = false
 930         for i := 0; i < len(data.CriticalityDiagnosticsIEList.Items); i++ {
 931                 item.entry.criticalityDiagnosticsIEListItem[i].iECriticality = (C.uint8_t)(data.CriticalityDiagnosticsIEList.Items[i].IeCriticality)
 932                 item.entry.criticalityDiagnosticsIEListItem[i].iE_ID = (C.uint32_t)(data.CriticalityDiagnosticsIEList.Items[i].IeID)
 933                 item.entry.criticalityDiagnosticsIEListItem[i].typeOfError = (C.uint8_t)(data.CriticalityDiagnosticsIEList.Items[i].TypeOfError)
 934                 item.entry.criticalityDiagnosticsIELength++
 935                 item.entry.iEsCriticalityDiagnosticsPresent = true
 936         }
 937         return nil
 938 }
 939
 940 func (item *e2apEntryCriticalityDiagnostic) get(data *e2ap.CriticalityDiagnostics) error {
 941
 942         data.ProcCodePresent = (bool)(item.entry.procedureCodePresent)
 943         data.ProcCode = (uint64)(item.entry.procedureCode)
 944
 945         data.TrigMsgPresent = (bool)(item.entry.triggeringMessagePresent)
 946         data.TrigMsg = (uint64)(item.entry.triggeringMessage)
 947
 948         data.ProcCritPresent = (bool)(item.entry.procedureCriticalityPresent)
 949         data.ProcCrit = (uint8)(item.entry.procedureCriticality)
 950
 951         if item.entry.iEsCriticalityDiagnosticsPresent == true {
 952                 conlen := (int)(item.entry.criticalityDiagnosticsIELength)
 953                 data.CriticalityDiagnosticsIEList.Items = make([]e2ap.CriticalityDiagnosticsIEListItem, conlen)
 954                 for i := 0; i < conlen; i++ {
 955                         data.CriticalityDiagnosticsIEList.Items[i].IeCriticality = (uint8)(item.entry.criticalityDiagnosticsIEListItem[i].iECriticality)
 956                         data.CriticalityDiagnosticsIEList.Items[i].IeID = (uint32)(item.entry.criticalityDiagnosticsIEListItem[i].iE_ID)
 957                         data.CriticalityDiagnosticsIEList.Items[i].TypeOfError = (uint8)(item.entry.criticalityDiagnosticsIEListItem[i].typeOfError)
 958                 }
 959         }
 960         return nil
 961 }
 962
 963 /*
 964 //-----------------------------------------------------------------------------
 965 //
 966 //-----------------------------------------------------------------------------
 967 type e2apEntryCallProcessId struct {
 968         entry *C.RICCallProcessID_t
 969 }
 970
 971 func (callProcId *e2apEntryCallProcessId) set(data *e2ap.CallProcessId) error {
 972         callProcId.entry.ricCallProcessIDVal = (C.uint64_t)(data.CallProcessIDVal)
 973         return nil
 974 }
 975
 976 func (callProcId *e2apEntryCallProcessId) get(data *e2ap.CallProcessId) error {
 977         data.CallProcessIDVal = (uint32)(callProcId.entry.ricCallProcessIDVal)
 978         return nil
 979 }
 980 */
 981
 982 //-----------------------------------------------------------------------------
 983 //
 984 //-----------------------------------------------------------------------------
 985
 986 type e2apMessagePacker struct {
 987         expectedInfo C.E2MessageInfo_t
 988         pduMsgInfo   C.E2MessageInfo_t
 989         pdu          *C.e2ap_pdu_ptr_t
 990         lb           []byte
 991         p            unsafe.Pointer
 992         plen         C.size_t
 993 }
 994
 995 func (e2apMsg *e2apMessagePacker) init(minfo C.E2MessageInfo_t) {
 996         e2apMsg.expectedInfo = minfo
 997         e2apMsg.lb = make([]byte, cLogBufferMaxSize)
 998         e2apMsg.lb[0] = 0
 999         e2apMsg.p = C.malloc(C.size_t(cMsgBufferMaxSize))
1000         e2apMsg.plen = C.size_t(cMsgBufferMaxSize) - cMsgBufferExtra
1001 }
1002
1003 func (e2apMsg *e2apMessagePacker) fini() {
1004         C.free(e2apMsg.p)
1005         e2apMsg.plen = 0
1006         e2apMsg.p = nil
1007 }
1008
1009 func (e2apMsg *e2apMessagePacker) lbString() string {
1010         return "logbuffer(" + string(e2apMsg.lb[:strings.Index(string(e2apMsg.lb[:]), "\000")]) + ")"
1011 }
1012
1013 func (e2apMsg *e2apMessagePacker) packeddata() *e2ap.PackedData {
1014         return &e2ap.PackedData{C.GoBytes(e2apMsg.p, C.int(e2apMsg.plen))}
1015 }
1016
1017 func (e2apMsg *e2apMessagePacker) checkerr(errorNro C.uint64_t) error {
1018         if errorNro != C.e2err_OK {
1019                 return fmt.Errorf("e2err(%s) %s", C.GoString(C.getE2ErrorString(errorNro)), e2apMsg.lbString())
1020         }
1021         return nil
1022 }
1023
1024 func (e2apMsg *e2apMessagePacker) unpacktopdu(data *e2ap.PackedData) error {
1025         e2apMsg.pdu = C.unpackE2AP_pdu((C.size_t)(len(data.Buf)), (*C.uchar)(unsafe.Pointer(&data.Buf[0])), (*C.char)(unsafe.Pointer(&e2apMsg.lb[0])), &e2apMsg.pduMsgInfo)
1026         if e2apMsg.pduMsgInfo.messageType != e2apMsg.expectedInfo.messageType || e2apMsg.pduMsgInfo.messageId != e2apMsg.expectedInfo.messageId {
1027                 return fmt.Errorf("unpack e2ap %s %s", e2apMsg.lbString(), e2apMsg.String())
1028         }
1029         return nil
1030 }
1031
1032 func (e2apMsg *e2apMessagePacker) messageInfoPdu() *e2ap.MessageInfo {
1033         return cMessageInfoToMessageInfo(&e2apMsg.pduMsgInfo)
1034 }
1035
1036 func (e2apMsg *e2apMessagePacker) messageInfoExpected() *e2ap.MessageInfo {
1037         return cMessageInfoToMessageInfo(&e2apMsg.expectedInfo)
1038 }
1039
1040 func (e2apMsg *e2apMessagePacker) String() string {
1041         var ret string
1042         pduInfo := e2apMsg.messageInfoPdu()
1043         if pduInfo != nil {
1044                 ret += "pduinfo(" + pduInfo.String() + ")"
1045         } else {
1046                 ret += "pduinfo(N/A)"
1047         }
1048         expInfo := e2apMsg.messageInfoExpected()
1049         if expInfo != nil {
1050                 ret += " expinfo(" + expInfo.String() + ")"
1051         } else {
1052                 ret += " expinfo(N/A)"
1053         }
1054         return ret
1055 }
1056
1057 //-----------------------------------------------------------------------------
1058 //
1059 //-----------------------------------------------------------------------------
1060
1061 type e2apMsgPackerSubscriptionRequest struct {
1062         e2apMessagePacker
1063         msgC *C.RICSubscriptionRequest_t
1064         msgG *e2ap.E2APSubscriptionRequest
1065 }
1066
1067 func (e2apMsg *e2apMsgPackerSubscriptionRequest) init() {
1068         e2apMsg.e2apMessagePacker.init(C.E2MessageInfo_t{C.cE2InitiatingMessage, C.cRICSubscriptionRequest})
1069         e2apMsg.msgC = &C.RICSubscriptionRequest_t{}
1070         e2apMsg.msgG = &e2ap.E2APSubscriptionRequest{}
1071         C.initSubsRequest(e2apMsg.msgC)
1072 }
1073
1074 func (e2apMsg *e2apMsgPackerSubscriptionRequest) Pack(data *e2ap.E2APSubscriptionRequest) (error, *e2ap.PackedData) {
1075
1076         e2apMsg.init()
1077
1078         defer e2apMsg.fini()
1079         e2apMsg.msgG = data
1080
1081         var dynMemHead C.mem_track_hdr_t
1082         C.mem_track_init(&dynMemHead)
1083         defer C.mem_track_free(&dynMemHead)
1084
1085         e2apMsg.msgC.ranFunctionID = (C.uint16_t)(e2apMsg.msgG.FunctionId)
1086         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&e2apMsg.msgG.RequestId); err != nil {
1087                 return err, nil
1088         }
1089         if err := (&e2apEntryEventTrigger{entry: &e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition}).set(&e2apMsg.msgG.EventTriggerDefinition); err != nil {
1090                 return err, nil
1091         }
1092         if len(e2apMsg.msgG.ActionSetups) > 16 {
1093                 return fmt.Errorf("IndicationMessage.InterfaceMessage: too long %d while allowed %d", len(e2apMsg.msgG.ActionSetups), 16), nil
1094         }
1095         e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength = 0
1096         for i := 0; i < len(e2apMsg.msgG.ActionSetups); i++ {
1097                 item := &e2apEntryActionToBeSetupItem{entry: &e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength]}
1098                 e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength += 1
1099                 if err := item.set(&dynMemHead, &e2apMsg.msgG.ActionSetups[i]); err != nil {
1100                         return err, nil
1101                 }
1102         }
1103         errorNro := C.packRICSubscriptionRequest(&e2apMsg.plen, (*C.uchar)(e2apMsg.p), (*C.char)(unsafe.Pointer(&e2apMsg.lb[0])), e2apMsg.msgC)
1104         if err := e2apMsg.checkerr(errorNro); err != nil {
1105                 return err, nil
1106         }
1107         return nil, e2apMsg.packeddata()
1108 }
1109
1110 func (e2apMsg *e2apMsgPackerSubscriptionRequest) UnPack(msg *e2ap.PackedData) (error, *e2ap.E2APSubscriptionRequest) {
1111
1112         e2apMsg.init()
1113         defer e2apMsg.fini()
1114
1115         if err := e2apMsg.e2apMessagePacker.unpacktopdu(msg); err != nil {
1116                 return err, e2apMsg.msgG
1117         }
1118
1119         var dynMemHead C.mem_track_hdr_t
1120         C.mem_track_init(&dynMemHead)
1121         defer C.mem_track_free(&dynMemHead)
1122
1123         errorNro := C.getRICSubscriptionRequestData(&dynMemHead, e2apMsg.e2apMessagePacker.pdu, e2apMsg.msgC)
1124         if err := e2apMsg.checkerr(errorNro); err != nil {
1125                 return err, e2apMsg.msgG
1126         }
1127
1128         e2apMsg.msgG.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID)
1129         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&e2apMsg.msgG.RequestId); err != nil {
1130                 return err, e2apMsg.msgG
1131         }
1132         if err := (&e2apEntryEventTrigger{entry: &e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition}).get(&e2apMsg.msgG.EventTriggerDefinition); err != nil {
1133                 return err, e2apMsg.msgG
1134         }
1135         conlen := (int)(e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength)
1136         e2apMsg.msgG.ActionSetups = make([]e2ap.ActionToBeSetupItem, conlen)
1137         for i := 0; i < conlen; i++ {
1138                 item := &e2apEntryActionToBeSetupItem{entry: &e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[i]}
1139                 if err := item.get(&e2apMsg.msgG.ActionSetups[i]); err != nil {
1140                         return err, e2apMsg.msgG
1141                 }
1142         }
1143         return nil, e2apMsg.msgG
1144
1145 }
1146
1147 func (e2apMsg *e2apMsgPackerSubscriptionRequest) String() string {
1148         var b bytes.Buffer
1149         fmt.Fprintln(&b, "ricSubscriptionRequest.")
1150         fmt.Fprintln(&b, "  ricRequestID.")
1151         fmt.Fprintln(&b, "     ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
1152         fmt.Fprintln(&b, "     ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
1153         fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
1154         fmt.Fprintln(&b, "  ricSubscriptionDetails.")
1155         fmt.Fprintln(&b, "    ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.")
1156         fmt.Fprintln(&b, "      contentLength =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength)
1157         fmt.Fprintln(&b, "      interfaceID.globalENBIDPresent =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBIDPresent)
1158         if e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBIDPresent {
1159                 fmt.Fprintln(&b, "      interfaceID.globalENBID.pLMNIdentity.contentLength =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.contentLength)
1160                 fmt.Fprintln(&b, "      interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[0] =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[0])
1161                 fmt.Fprintln(&b, "      interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[1] =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[1])
1162                 fmt.Fprintln(&b, "      interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[2] =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[2])
1163                 fmt.Fprintln(&b, "      interfaceID.globalENBID.nodeID.bits =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.bits)
1164                 fmt.Fprintln(&b, "      interfaceID.globalENBID.nodeID.nodeID =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.nodeID)
1165         }
1166         fmt.Fprintln(&b, "      interfaceID.globalGNBIDPresent =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBIDPresent)
1167         if e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBIDPresent {
1168                 fmt.Fprintln(&b, "      interfaceID.globalGNBID.pLMNIdentity.contentLength =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.contentLength)
1169                 fmt.Fprintln(&b, "      interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[0] =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[0])
1170                 fmt.Fprintln(&b, "      interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[1] =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[1])
1171                 fmt.Fprintln(&b, "      interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[2] =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[2])
1172                 fmt.Fprintln(&b, "      interfaceID.globalGNBID.nodeID.bits =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.nodeID.bits)
1173                 fmt.Fprintln(&b, "      interfaceID.globalGNBID.nodeID.nodeID =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.nodeID.nodeID)
1174         }
1175         fmt.Fprintln(&b, "      interfaceDirection = ", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceDirection)
1176         fmt.Fprintln(&b, "      interfaceMessageType.procedureCode =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceMessageType.procedureCode)
1177         fmt.Fprintln(&b, "      interfaceMessageType.typeOfMessage =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceMessageType.typeOfMessage)
1178         fmt.Fprintln(&b, "    ricActionToBeSetupItemIEs.")
1179         fmt.Fprintln(&b, "      contentLength =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength)
1180         var index uint8
1181         index = 0
1182         for (C.uchar)(index) < e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength {
1183                 fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionID =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionID)
1184                 fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionType =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionType)
1185
1186                 fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionDefinitionPresent =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent)
1187                 if e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent {
1188                         fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionDefinitionChoice.actionDefinitionX2Format1Present =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.actionDefinitionX2Format1Present)
1189                         fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionDefinitionChoice.actionDefinitionX2Format2Present =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.actionDefinitionX2Format2Present)
1190                         fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionDefinitionChoice.actionDefinitionNRTFormat1Present =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.actionDefinitionNRTFormat1Present)
1191                         // Dynamically allocated C-structs are already freed. Can't print those.
1192                 }
1193
1194                 fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricSubsequentActionPresent =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent)
1195                 if e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent {
1196                         fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricSubsequentAction.ricSubsequentActionType =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricSubsequentActionType)
1197                         fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricSubsequentAction.ricTimeToWait =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricTimeToWait)
1198                 }
1199                 index++
1200         }
1201         return b.String()
1202 }
1203
1204 //-----------------------------------------------------------------------------
1205 //
1206 //-----------------------------------------------------------------------------
1207 type e2apMsgPackerSubscriptionResponse struct {
1208         e2apMessagePacker
1209         msgC *C.RICSubscriptionResponse_t
1210         msgG *e2ap.E2APSubscriptionResponse
1211 }
1212
1213 func (e2apMsg *e2apMsgPackerSubscriptionResponse) init() {
1214         e2apMsg.e2apMessagePacker.init(C.E2MessageInfo_t{C.cE2SuccessfulOutcome, C.cRICSubscriptionResponse})
1215         e2apMsg.msgC = &C.RICSubscriptionResponse_t{}
1216         e2apMsg.msgG = &e2ap.E2APSubscriptionResponse{}
1217         C.initSubsResponse(e2apMsg.msgC)
1218 }
1219
1220 func (e2apMsg *e2apMsgPackerSubscriptionResponse) Pack(data *e2ap.E2APSubscriptionResponse) (error, *e2ap.PackedData) {
1221         e2apMsg.init()
1222         defer e2apMsg.fini()
1223         e2apMsg.msgG = data
1224
1225         e2apMsg.msgC.ranFunctionID = (C.uint16_t)(e2apMsg.msgG.FunctionId)
1226         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&e2apMsg.msgG.RequestId); err != nil {
1227                 return err, nil
1228         }
1229         if err := (&e2apEntryAdmittedList{entry: &e2apMsg.msgC.ricActionAdmittedList}).set(&e2apMsg.msgG.ActionAdmittedList); err != nil {
1230                 return err, nil
1231         }
1232         e2apMsg.msgC.ricActionNotAdmittedListPresent = false
1233         if len(e2apMsg.msgG.ActionNotAdmittedList.Items) > 0 {
1234                 e2apMsg.msgC.ricActionNotAdmittedListPresent = true
1235                 if err := (&e2apEntryNotAdmittedList{entry: &e2apMsg.msgC.ricActionNotAdmittedList}).set(&e2apMsg.msgG.ActionNotAdmittedList); err != nil {
1236                         return err, nil
1237                 }
1238         }
1239
1240         errorNro := C.packRICSubscriptionResponse(&e2apMsg.plen, (*C.uchar)(e2apMsg.p), (*C.char)(unsafe.Pointer(&e2apMsg.lb[0])), e2apMsg.msgC)
1241         if err := e2apMsg.checkerr(errorNro); err != nil {
1242                 return err, nil
1243         }
1244         return nil, e2apMsg.packeddata()
1245 }
1246
1247 func (e2apMsg *e2apMsgPackerSubscriptionResponse) UnPack(msg *e2ap.PackedData) (error, *e2ap.E2APSubscriptionResponse) {
1248
1249         e2apMsg.init()
1250         defer e2apMsg.fini()
1251
1252         if err := e2apMsg.e2apMessagePacker.unpacktopdu(msg); err != nil {
1253                 return err, e2apMsg.msgG
1254         }
1255         errorNro := C.getRICSubscriptionResponseData(e2apMsg.e2apMessagePacker.pdu, e2apMsg.msgC)
1256         if err := e2apMsg.checkerr(errorNro); err != nil {
1257                 return err, e2apMsg.msgG
1258         }
1259
1260         e2apMsg.msgG.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID)
1261         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&e2apMsg.msgG.RequestId); err != nil {
1262                 return err, e2apMsg.msgG
1263         }
1264         if err := (&e2apEntryAdmittedList{entry: &e2apMsg.msgC.ricActionAdmittedList}).get(&e2apMsg.msgG.ActionAdmittedList); err != nil {
1265                 return err, e2apMsg.msgG
1266         }
1267         if e2apMsg.msgC.ricActionNotAdmittedListPresent == true {
1268                 if err := (&e2apEntryNotAdmittedList{entry: &e2apMsg.msgC.ricActionNotAdmittedList}).get(&e2apMsg.msgG.ActionNotAdmittedList); err != nil {
1269                         return err, e2apMsg.msgG
1270                 }
1271         }
1272         return nil, e2apMsg.msgG
1273 }
1274
1275 func (e2apMsg *e2apMsgPackerSubscriptionResponse) String() string {
1276         var b bytes.Buffer
1277         fmt.Fprintln(&b, "ricSubscriptionResponse.")
1278         fmt.Fprintln(&b, "  ricRequestID.")
1279         fmt.Fprintln(&b, "    ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
1280         fmt.Fprintln(&b, "    ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
1281         fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
1282         fmt.Fprintln(&b, "  ricActionAdmittedList.")
1283         fmt.Fprintln(&b, "    contentLength =", e2apMsg.msgC.ricActionAdmittedList.contentLength)
1284         var index uint8
1285         index = 0
1286         for (C.uchar)(index) < e2apMsg.msgC.ricActionAdmittedList.contentLength {
1287                 fmt.Fprintln(&b, "    ricActionAdmittedList.ricActionID[index] =", e2apMsg.msgC.ricActionAdmittedList.ricActionID[index])
1288                 index++
1289         }
1290         if e2apMsg.msgC.ricActionNotAdmittedListPresent {
1291                 fmt.Fprintln(&b, "  ricActionNotAdmittedListPresent =", e2apMsg.msgC.ricActionNotAdmittedListPresent)
1292                 fmt.Fprintln(&b, "    ricActionNotAdmittedList.")
1293                 fmt.Fprintln(&b, "    contentLength =", e2apMsg.msgC.ricActionNotAdmittedList.contentLength)
1294                 index = 0
1295                 for (C.uchar)(index) < e2apMsg.msgC.ricActionNotAdmittedList.contentLength {
1296                         fmt.Fprintln(&b, "      RICActionNotAdmittedItem[index].ricActionID =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID)
1297                         fmt.Fprintln(&b, "      RICActionNotAdmittedItem[index].cause.content =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content)
1298                         fmt.Fprintln(&b, "      RICActionNotAdmittedItem[index].cause.causeVal =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal)
1299                         index++
1300                 }
1301         }
1302         return b.String()
1303 }
1304
1305 //-----------------------------------------------------------------------------
1306 //
1307 //-----------------------------------------------------------------------------
1308 type e2apMsgPackerSubscriptionFailure struct {
1309         e2apMessagePacker
1310         msgC *C.RICSubscriptionFailure_t
1311         msgG *e2ap.E2APSubscriptionFailure
1312 }
1313
1314 func (e2apMsg *e2apMsgPackerSubscriptionFailure) init() {
1315         e2apMsg.e2apMessagePacker.init(C.E2MessageInfo_t{C.cE2UnsuccessfulOutcome, C.cRICSubscriptionFailure})
1316         e2apMsg.msgC = &C.RICSubscriptionFailure_t{}
1317         e2apMsg.msgG = &e2ap.E2APSubscriptionFailure{}
1318         C.initSubsFailure(e2apMsg.msgC)
1319 }
1320
1321 func (e2apMsg *e2apMsgPackerSubscriptionFailure) Pack(data *e2ap.E2APSubscriptionFailure) (error, *e2ap.PackedData) {
1322         e2apMsg.init()
1323         defer e2apMsg.fini()
1324         e2apMsg.msgG = data
1325
1326         e2apMsg.msgC.ranFunctionID = (C.uint16_t)(e2apMsg.msgG.FunctionId)
1327         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&e2apMsg.msgG.RequestId); err != nil {
1328                 return err, nil
1329         }
1330         if err := (&e2apEntryNotAdmittedList{entry: &e2apMsg.msgC.ricActionNotAdmittedList}).set(&e2apMsg.msgG.ActionNotAdmittedList); err != nil {
1331                 return err, nil
1332         }
1333         e2apMsg.msgC.criticalityDiagnosticsPresent = false
1334         if e2apMsg.msgG.CriticalityDiagnostics.Present {
1335                 e2apMsg.msgC.criticalityDiagnosticsPresent = true
1336                 if err := (&e2apEntryCriticalityDiagnostic{entry: &e2apMsg.msgC.criticalityDiagnostics}).set(&e2apMsg.msgG.CriticalityDiagnostics); err != nil {
1337                         return err, nil
1338                 }
1339         }
1340
1341         errorNro := C.packRICSubscriptionFailure(&e2apMsg.plen, (*C.uchar)(e2apMsg.p), (*C.char)(unsafe.Pointer(&e2apMsg.lb[0])), e2apMsg.msgC)
1342         if err := e2apMsg.checkerr(errorNro); err != nil {
1343                 return err, nil
1344         }
1345         return nil, e2apMsg.packeddata()
1346 }
1347
1348 func (e2apMsg *e2apMsgPackerSubscriptionFailure) UnPack(msg *e2ap.PackedData) (error, *e2ap.E2APSubscriptionFailure) {
1349         e2apMsg.init()
1350         defer e2apMsg.fini()
1351
1352         if err := e2apMsg.e2apMessagePacker.unpacktopdu(msg); err != nil {
1353                 return err, e2apMsg.msgG
1354         }
1355         errorNro := C.getRICSubscriptionFailureData(e2apMsg.e2apMessagePacker.pdu, e2apMsg.msgC)
1356         if err := e2apMsg.checkerr(errorNro); err != nil {
1357                 return err, e2apMsg.msgG
1358         }
1359
1360         e2apMsg.msgG.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID)
1361         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&e2apMsg.msgG.RequestId); err != nil {
1362                 return err, e2apMsg.msgG
1363         }
1364         if err := (&e2apEntryNotAdmittedList{entry: &e2apMsg.msgC.ricActionNotAdmittedList}).get(&e2apMsg.msgG.ActionNotAdmittedList); err != nil {
1365                 return err, e2apMsg.msgG
1366         }
1367         if e2apMsg.msgC.criticalityDiagnosticsPresent == true {
1368                 e2apMsg.msgG.CriticalityDiagnostics.Present = true
1369                 if err := (&e2apEntryCriticalityDiagnostic{entry: &e2apMsg.msgC.criticalityDiagnostics}).get(&e2apMsg.msgG.CriticalityDiagnostics); err != nil {
1370                         return err, e2apMsg.msgG
1371                 }
1372         }
1373         return nil, e2apMsg.msgG
1374 }
1375
1376 func (e2apMsg *e2apMsgPackerSubscriptionFailure) String() string {
1377         var b bytes.Buffer
1378         fmt.Fprintln(&b, "ricSubscriptionFailure.")
1379         fmt.Fprintln(&b, "  ricRequestID.")
1380         fmt.Fprintln(&b, "    ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
1381         fmt.Fprintln(&b, "    ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
1382         fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
1383         fmt.Fprintln(&b, "  ricActionNotAdmittedList.")
1384         fmt.Fprintln(&b, "    contentLength =", e2apMsg.msgC.ricActionNotAdmittedList.contentLength)
1385         var index uint8
1386         index = 0
1387         for (C.uchar)(index) < e2apMsg.msgC.ricActionNotAdmittedList.contentLength {
1388                 fmt.Fprintln(&b, "    RICActionNotAdmittedItem[index].ricActionID =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID)
1389                 fmt.Fprintln(&b, "    RICActionNotAdmittedItem[index].cause.content =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content)
1390                 fmt.Fprintln(&b, "    RICActionNotAdmittedItem[index].cause.causeVal =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal)
1391                 index++
1392         }
1393         /* NOT SUPPORTED
1394         if e2apMsg.msgC.criticalityDiagnosticsPresent {
1395                 fmt.Fprintln(&b, "  criticalityDiagnosticsPresent =", e2apMsg.msgC.criticalityDiagnosticsPresent)
1396                 fmt.Fprintln(&b, "    criticalityDiagnostics.")
1397                 fmt.Fprintln(&b, "    procedureCodePresent =", e2apMsg.msgC.criticalityDiagnostics.procedureCodePresent)
1398                 fmt.Fprintln(&b, "      procedureCode =", e2apMsg.msgC.criticalityDiagnostics.procedureCode)
1399                 fmt.Fprintln(&b, "    triggeringMessagePresent =", e2apMsg.msgC.criticalityDiagnostics.triggeringMessagePresent)
1400                 fmt.Fprintln(&b, "      triggeringMessage =", e2apMsg.msgC.criticalityDiagnostics.triggeringMessage)
1401                 fmt.Fprintln(&b, "    procedureCriticalityPresent=", e2apMsg.msgC.criticalityDiagnostics.procedureCriticalityPresent)
1402                 fmt.Fprintln(&b, "      procedureCriticality =", e2apMsg.msgC.criticalityDiagnostics.procedureCriticality)
1403                 fmt.Fprintln(&b, "    iEsCriticalityDiagnosticsPresent =", e2apMsg.msgC.criticalityDiagnostics.iEsCriticalityDiagnosticsPresent)
1404                 fmt.Fprintln(&b, "      criticalityDiagnosticsIELength =", e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIELength)
1405                 var index2 uint16
1406                 index2 = 0
1407                 for (C.ushort)(index2) < e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIELength {
1408                         fmt.Fprintln(&b, "      criticalityDiagnosticsIEListItem[index2].iECriticality =", e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIEListItem[index2].iECriticality)
1409                         fmt.Fprintln(&b, "      criticalityDiagnosticsIEListItem[index2].iE_ID =", e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIEListItem[index2].iE_ID)
1410                         fmt.Fprintln(&b, "      criticalityDiagnosticsIEListItem[index2].typeOfError =", e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIEListItem[index2].typeOfError)
1411                         index2++
1412                 }
1413         }
1414         */
1415         return b.String()
1416 }
1417
1418 //-----------------------------------------------------------------------------
1419 //
1420 //-----------------------------------------------------------------------------
1421 type e2apMsgPackerSubscriptionDeleteRequest struct {
1422         e2apMessagePacker
1423         msgC *C.RICSubscriptionDeleteRequest_t
1424         msgG *e2ap.E2APSubscriptionDeleteRequest
1425 }
1426
1427 func (e2apMsg *e2apMsgPackerSubscriptionDeleteRequest) init() {
1428         e2apMsg.e2apMessagePacker.init(C.E2MessageInfo_t{C.cE2InitiatingMessage, C.cRICSubscriptionDeleteRequest})
1429         e2apMsg.msgC = &C.RICSubscriptionDeleteRequest_t{}
1430         e2apMsg.msgG = &e2ap.E2APSubscriptionDeleteRequest{}
1431         C.initSubsDeleteRequest(e2apMsg.msgC)
1432 }
1433
1434 func (e2apMsg *e2apMsgPackerSubscriptionDeleteRequest) Pack(data *e2ap.E2APSubscriptionDeleteRequest) (error, *e2ap.PackedData) {
1435         e2apMsg.init()
1436         defer e2apMsg.fini()
1437         e2apMsg.msgG = data
1438
1439         e2apMsg.msgC.ranFunctionID = (C.uint16_t)(e2apMsg.msgG.FunctionId)
1440         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&e2apMsg.msgG.RequestId); err != nil {
1441                 return err, nil
1442         }
1443
1444         errorNro := C.packRICSubscriptionDeleteRequest(&e2apMsg.plen, (*C.uchar)(e2apMsg.p), (*C.char)(unsafe.Pointer(&e2apMsg.lb[0])), e2apMsg.msgC)
1445         if err := e2apMsg.checkerr(errorNro); err != nil {
1446                 return err, nil
1447         }
1448         return nil, e2apMsg.packeddata()
1449 }
1450
1451 func (e2apMsg *e2apMsgPackerSubscriptionDeleteRequest) UnPack(msg *e2ap.PackedData) (error, *e2ap.E2APSubscriptionDeleteRequest) {
1452         e2apMsg.init()
1453         defer e2apMsg.fini()
1454
1455         if err := e2apMsg.e2apMessagePacker.unpacktopdu(msg); err != nil {
1456                 return err, e2apMsg.msgG
1457         }
1458         errorNro := C.getRICSubscriptionDeleteRequestData(e2apMsg.e2apMessagePacker.pdu, e2apMsg.msgC)
1459         if err := e2apMsg.checkerr(errorNro); err != nil {
1460                 return err, e2apMsg.msgG
1461         }
1462
1463         e2apMsg.msgG.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID)
1464         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&e2apMsg.msgG.RequestId); err != nil {
1465                 return err, e2apMsg.msgG
1466         }
1467         return nil, e2apMsg.msgG
1468
1469 }
1470
1471 func (e2apMsg *e2apMsgPackerSubscriptionDeleteRequest) String() string {
1472         var b bytes.Buffer
1473         fmt.Fprintln(&b, "ricSubscriptionDeleteRequest.")
1474         fmt.Fprintln(&b, "  ricRequestID.")
1475         fmt.Fprintln(&b, "     ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
1476         fmt.Fprintln(&b, "     ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
1477         fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
1478         return b.String()
1479 }
1480
1481 //-----------------------------------------------------------------------------
1482 //
1483 //-----------------------------------------------------------------------------
1484 type e2apMsgPackerSubscriptionDeleteResponse struct {
1485         e2apMessagePacker
1486         msgC *C.RICSubscriptionDeleteResponse_t
1487         msgG *e2ap.E2APSubscriptionDeleteResponse
1488 }
1489
1490 func (e2apMsg *e2apMsgPackerSubscriptionDeleteResponse) init() {
1491         e2apMsg.e2apMessagePacker.init(C.E2MessageInfo_t{C.cE2SuccessfulOutcome, C.cRICsubscriptionDeleteResponse})
1492         e2apMsg.msgC = &C.RICSubscriptionDeleteResponse_t{}
1493         e2apMsg.msgG = &e2ap.E2APSubscriptionDeleteResponse{}
1494         C.initSubsDeleteResponse(e2apMsg.msgC)
1495 }
1496
1497 func (e2apMsg *e2apMsgPackerSubscriptionDeleteResponse) Pack(data *e2ap.E2APSubscriptionDeleteResponse) (error, *e2ap.PackedData) {
1498         e2apMsg.init()
1499         defer e2apMsg.fini()
1500         e2apMsg.msgG = data
1501
1502         e2apMsg.msgC.ranFunctionID = (C.uint16_t)(e2apMsg.msgG.FunctionId)
1503         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&e2apMsg.msgG.RequestId); err != nil {
1504                 return err, nil
1505         }
1506
1507         errorNro := C.packRICSubscriptionDeleteResponse(&e2apMsg.plen, (*C.uchar)(e2apMsg.p), (*C.char)(unsafe.Pointer(&e2apMsg.lb[0])), e2apMsg.msgC)
1508         if err := e2apMsg.checkerr(errorNro); err != nil {
1509                 return err, nil
1510         }
1511         return nil, e2apMsg.packeddata()
1512 }
1513
1514 func (e2apMsg *e2apMsgPackerSubscriptionDeleteResponse) UnPack(msg *e2ap.PackedData) (error, *e2ap.E2APSubscriptionDeleteResponse) {
1515         e2apMsg.init()
1516         defer e2apMsg.fini()
1517
1518         if err := e2apMsg.e2apMessagePacker.unpacktopdu(msg); err != nil {
1519                 return err, e2apMsg.msgG
1520         }
1521         errorNro := C.getRICSubscriptionDeleteResponseData(e2apMsg.e2apMessagePacker.pdu, e2apMsg.msgC)
1522         if err := e2apMsg.checkerr(errorNro); err != nil {
1523                 return err, e2apMsg.msgG
1524         }
1525
1526         e2apMsg.msgG.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID)
1527         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&e2apMsg.msgG.RequestId); err != nil {
1528                 return err, e2apMsg.msgG
1529         }
1530         return nil, e2apMsg.msgG
1531 }
1532
1533 func (e2apMsg *e2apMsgPackerSubscriptionDeleteResponse) String() string {
1534         var b bytes.Buffer
1535         fmt.Fprintln(&b, "ricSubscriptionDeleteResponse.")
1536         fmt.Fprintln(&b, "  ricRequestID.")
1537         fmt.Fprintln(&b, "    ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
1538         fmt.Fprintln(&b, "    ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
1539         fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
1540         return b.String()
1541 }
1542
1543 //-----------------------------------------------------------------------------
1544 //
1545 //-----------------------------------------------------------------------------
1546 type e2apMsgPackerSubscriptionDeleteFailure struct {
1547         e2apMessagePacker
1548         msgC *C.RICSubscriptionDeleteFailure_t
1549         msgG *e2ap.E2APSubscriptionDeleteFailure
1550 }
1551
1552 func (e2apMsg *e2apMsgPackerSubscriptionDeleteFailure) init() {
1553         e2apMsg.e2apMessagePacker.init(C.E2MessageInfo_t{C.cE2UnsuccessfulOutcome, C.cRICsubscriptionDeleteFailure})
1554         e2apMsg.msgC = &C.RICSubscriptionDeleteFailure_t{}
1555         e2apMsg.msgG = &e2ap.E2APSubscriptionDeleteFailure{}
1556         C.initSubsDeleteFailure(e2apMsg.msgC)
1557 }
1558
1559 func (e2apMsg *e2apMsgPackerSubscriptionDeleteFailure) Pack(data *e2ap.E2APSubscriptionDeleteFailure) (error, *e2ap.PackedData) {
1560         e2apMsg.init()
1561         defer e2apMsg.fini()
1562         e2apMsg.msgG = data
1563
1564         e2apMsg.msgC.ranFunctionID = (C.uint16_t)(e2apMsg.msgG.FunctionId)
1565         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&e2apMsg.msgG.RequestId); err != nil {
1566                 return err, nil
1567         }
1568         e2apMsg.msgC.cause.content = (C.uchar)(e2apMsg.msgG.Cause.Content)
1569         e2apMsg.msgC.cause.causeVal = (C.uchar)(e2apMsg.msgG.Cause.Value)
1570         e2apMsg.msgC.criticalityDiagnosticsPresent = false
1571         if e2apMsg.msgG.CriticalityDiagnostics.Present {
1572                 e2apMsg.msgC.criticalityDiagnosticsPresent = true
1573                 if err := (&e2apEntryCriticalityDiagnostic{entry: &e2apMsg.msgC.criticalityDiagnostics}).set(&e2apMsg.msgG.CriticalityDiagnostics); err != nil {
1574                         return err, nil
1575                 }
1576         }
1577
1578         errorNro := C.packRICSubscriptionDeleteFailure(&e2apMsg.plen, (*C.uchar)(e2apMsg.p), (*C.char)(unsafe.Pointer(&e2apMsg.lb[0])), e2apMsg.msgC)
1579         if err := e2apMsg.checkerr(errorNro); err != nil {
1580                 return err, nil
1581         }
1582         return nil, e2apMsg.packeddata()
1583 }
1584
1585 func (e2apMsg *e2apMsgPackerSubscriptionDeleteFailure) UnPack(msg *e2ap.PackedData) (error, *e2ap.E2APSubscriptionDeleteFailure) {
1586         e2apMsg.init()
1587         defer e2apMsg.fini()
1588
1589         if err := e2apMsg.e2apMessagePacker.unpacktopdu(msg); err != nil {
1590                 return err, e2apMsg.msgG
1591         }
1592         errorNro := C.getRICSubscriptionDeleteFailureData(e2apMsg.e2apMessagePacker.pdu, e2apMsg.msgC)
1593         if err := e2apMsg.checkerr(errorNro); err != nil {
1594                 return err, e2apMsg.msgG
1595         }
1596
1597         e2apMsg.msgG.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID)
1598         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&e2apMsg.msgG.RequestId); err != nil {
1599                 return err, e2apMsg.msgG
1600         }
1601         e2apMsg.msgG.Cause.Content = (uint8)(e2apMsg.msgC.cause.content)
1602         e2apMsg.msgG.Cause.Value = (uint8)(e2apMsg.msgC.cause.causeVal)
1603         if e2apMsg.msgC.criticalityDiagnosticsPresent == true {
1604                 e2apMsg.msgG.CriticalityDiagnostics.Present = true
1605                 if err := (&e2apEntryCriticalityDiagnostic{entry: &e2apMsg.msgC.criticalityDiagnostics}).get(&e2apMsg.msgG.CriticalityDiagnostics); err != nil {
1606                         return err, e2apMsg.msgG
1607                 }
1608         }
1609         return nil, e2apMsg.msgG
1610 }
1611
1612 func (e2apMsg *e2apMsgPackerSubscriptionDeleteFailure) String() string {
1613         var b bytes.Buffer
1614         fmt.Fprintln(&b, "ricSubscriptionDeleteFailure.")
1615         fmt.Fprintln(&b, "  ricRequestID.")
1616         fmt.Fprintln(&b, "    ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
1617         fmt.Fprintln(&b, "    ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
1618         fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
1619         /*      NOT SUPPORTED
1620                 if e2apMsg.msgC.criticalityDiagnosticsPresent {
1621                         fmt.Fprintln(&b, "  criticalityDiagnosticsPresent =", e2apMsg.msgC.criticalityDiagnosticsPresent)
1622                         fmt.Fprintln(&b, "    criticalityDiagnostics.")
1623                         fmt.Fprintln(&b, "    procedureCodePresent =", e2apMsg.msgC.criticalityDiagnostics.procedureCodePresent)
1624                         fmt.Fprintln(&b, "      procedureCode =", e2apMsg.msgC.criticalityDiagnostics.procedureCode)
1625                         fmt.Fprintln(&b, "    triggeringMessagePresent =", e2apMsg.msgC.criticalityDiagnostics.triggeringMessagePresent)
1626                         fmt.Fprintln(&b, "      triggeringMessage =", e2apMsg.msgC.criticalityDiagnostics.triggeringMessage)
1627                         fmt.Fprintln(&b, "    procedureCriticalityPresent=", e2apMsg.msgC.criticalityDiagnostics.procedureCriticalityPresent)
1628                         fmt.Fprintln(&b, "      procedureCriticality =", e2apMsg.msgC.criticalityDiagnostics.procedureCriticality)
1629                         fmt.Fprintln(&b, "    iEsCriticalityDiagnosticsPresent =", e2apMsg.msgC.criticalityDiagnostics.iEsCriticalityDiagnosticsPresent)
1630                         fmt.Fprintln(&b, "      criticalityDiagnosticsIELength =", e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIELength)
1631                         var index2 uint16
1632                         index2 = 0
1633                         for (C.ushort)(index2) < e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIELength {
1634                                 fmt.Fprintln(&b, "      criticalityDiagnosticsIEListItem[index2].iECriticality =", e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIEListItem[index2].iECriticality)
1635                                 fmt.Fprintln(&b, "      criticalityDiagnosticsIEListItem[index2].iE_ID =", e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIEListItem[index2].iE_ID)
1636                                 fmt.Fprintln(&b, "      criticalityDiagnosticsIEListItem[index2].typeOfError =", e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIEListItem[index2].typeOfError)
1637                                 index2++
1638                         }
1639                 }
1640         */
1641         return b.String()
1642 }
1643
1644 //-----------------------------------------------------------------------------
1645 // Public E2AP packer creators
1646 //-----------------------------------------------------------------------------
1647
1648 type cppasn1E2APPacker struct{}
1649
1650 func (*cppasn1E2APPacker) NewPackerSubscriptionRequest() e2ap.E2APMsgPackerSubscriptionRequestIf {
1651         return &e2apMsgPackerSubscriptionRequest{}
1652 }
1653
1654 func (*cppasn1E2APPacker) NewPackerSubscriptionResponse() e2ap.E2APMsgPackerSubscriptionResponseIf {
1655         return &e2apMsgPackerSubscriptionResponse{}
1656 }
1657
1658 func (*cppasn1E2APPacker) NewPackerSubscriptionFailure() e2ap.E2APMsgPackerSubscriptionFailureIf {
1659         return &e2apMsgPackerSubscriptionFailure{}
1660 }
1661
1662 func (*cppasn1E2APPacker) NewPackerSubscriptionDeleteRequest() e2ap.E2APMsgPackerSubscriptionDeleteRequestIf {
1663         return &e2apMsgPackerSubscriptionDeleteRequest{}
1664 }
1665
1666 func (*cppasn1E2APPacker) NewPackerSubscriptionDeleteResponse() e2ap.E2APMsgPackerSubscriptionDeleteResponseIf {
1667         return &e2apMsgPackerSubscriptionDeleteResponse{}
1668 }
1669
1670 func (*cppasn1E2APPacker) NewPackerSubscriptionDeleteFailure() e2ap.E2APMsgPackerSubscriptionDeleteFailureIf {
1671         return &e2apMsgPackerSubscriptionDeleteFailure{}
1672 }
1673
1674 func NewAsn1E2Packer() e2ap.E2APPackerIf {
1675         return &cppasn1E2APPacker{}
1676 }