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         fmt.Printf("RANParameterValue e2Item.entry.valuePrtSPresent = %v\n", e2Item.entry.valuePrtSPresent)
 606         if e2Item.entry.valueIntPresent {
 607                 id.ValueInt = (int64)(e2Item.entry.valueInt)
 608                 id.ValueIntPresent = true
 609         } else if e2Item.entry.valueEnumPresent {
 610                 id.ValueEnum = (int64)(e2Item.entry.valueEnum)
 611                 id.ValueEnumPresent = true
 612         } else if e2Item.entry.valueBoolPresent {
 613                 id.ValueBool = (bool)(e2Item.entry.valueBool)
 614                 id.ValueBoolPresent = true
 615         } else if e2Item.entry.valueBitSPresent {
 616                 id.ValueBitSPresent = true
 617                 id.ValueBitS.Length = (uint64)(e2Item.entry.valueBitS.byteLength)
 618                 id.ValueBitS.UnusedBits = (uint8)(e2Item.entry.valueBitS.unusedBits)
 619                 id.ValueBitS.Data = make([]uint8, id.ValueBitS.Length)
 620                 C.memcpy(unsafe.Pointer(&id.ValueBitS.Data[0]), unsafe.Pointer(e2Item.entry.valueBitS.data), C.size_t(e2Item.entry.valueBitS.byteLength))
 621         } else if e2Item.entry.valueOctSPresent {
 622                 id.ValueOctSPresent = true
 623                 id.ValueOctS.Length = (uint64)(e2Item.entry.valueOctS.length)
 624                 id.ValueOctS.Data = make([]uint8, id.ValueOctS.Length)
 625                 C.memcpy(unsafe.Pointer(&id.ValueOctS.Data[0]), unsafe.Pointer(e2Item.entry.valueOctS.data), C.size_t(e2Item.entry.valueOctS.length))
 626         } else if e2Item.entry.valuePrtSPresent {
 627                 id.ValuePrtSPresent = true
 628                 id.ValuePrtS.Length = (uint64)(e2Item.entry.valuePrtS.length)
 629                 id.ValuePrtS.Data = make([]uint8, id.ValuePrtS.Length)
 630                 C.memcpy(unsafe.Pointer(&id.ValuePrtS.Data[0]), unsafe.Pointer(e2Item.entry.valuePrtS.data), C.size_t(e2Item.entry.valuePrtS.length))
 631         }
 632         return nil
 633 }
 634
 635 //-----------------------------------------------------------------------------
 636 //
 637 //-----------------------------------------------------------------------------
 638 type e2apEntryPlmnIdentity struct {
 639         entry *C.PLMNIdentity_t
 640 }
 641
 642 func (plmnId *e2apEntryPlmnIdentity) set(id conv.PlmnIdentityIf) error {
 643
 644         buf := new(bytes.Buffer)
 645         id.EncodeTo(buf)
 646         data := buf.Bytes()
 647         plmnId.entry.contentLength = (C.uint8_t)(len(data))
 648         for i := 0; i < len(data); i++ {
 649                 plmnId.entry.pLMNIdentityVal[i] = (C.uint8_t)(data[i])
 650         }
 651         return nil
 652 }
 653
 654 func (plmnId *e2apEntryPlmnIdentity) get(id conv.PlmnIdentityIf) error {
 655         conlen := (int)(plmnId.entry.contentLength)
 656         bcdBuf := make([]uint8, conlen)
 657         for i := 0; i < conlen; i++ {
 658                 bcdBuf[i] = (uint8)(plmnId.entry.pLMNIdentityVal[i])
 659         }
 660         reader := bytes.NewReader(bcdBuf)
 661         id.DecodeFrom(reader)
 662         return nil
 663 }
 664
 665 //-----------------------------------------------------------------------------
 666 //
 667 //-----------------------------------------------------------------------------
 668 type e2apEntryGlobalEnbId struct {
 669         entry *C.GlobalNodeID_t
 670 }
 671
 672 func (enbId *e2apEntryGlobalEnbId) checkbits(bits uint8) error {
 673         switch bits {
 674         case e2ap.E2AP_ENBIDMacroPBits20:
 675                 return nil
 676         case e2ap.E2AP_ENBIDHomeBits28:
 677                 return nil
 678         case e2ap.E2AP_ENBIDShortMacroits18:
 679                 return nil
 680         case e2ap.E2AP_ENBIDlongMacroBits21:
 681                 return nil
 682         }
 683         return fmt.Errorf("GlobalEnbId: given bits %d not match allowed: 20,28,18,21", bits)
 684 }
 685
 686 func (enbId *e2apEntryGlobalEnbId) set(id *e2ap.GlobalNodeId) error {
 687         if err := enbId.checkbits(id.NodeId.Bits); err != nil {
 688                 return err
 689         }
 690         enbId.entry.nodeID.bits = (C.uchar)(id.NodeId.Bits)
 691         enbId.entry.nodeID.nodeID = (C.uint32_t)(id.NodeId.Id)
 692         return (&e2apEntryPlmnIdentity{entry: &enbId.entry.pLMNIdentity}).set(&id.PlmnIdentity)
 693 }
 694
 695 func (enbId *e2apEntryGlobalEnbId) get(id *e2ap.GlobalNodeId) error {
 696         if err := enbId.checkbits((uint8)(enbId.entry.nodeID.bits)); err != nil {
 697                 return err
 698         }
 699         id.NodeId.Bits = (uint8)(enbId.entry.nodeID.bits)
 700         id.NodeId.Id = (uint32)(enbId.entry.nodeID.nodeID)
 701         return (&e2apEntryPlmnIdentity{entry: &enbId.entry.pLMNIdentity}).get(&id.PlmnIdentity)
 702 }
 703
 704 //-----------------------------------------------------------------------------
 705 //
 706 //-----------------------------------------------------------------------------
 707 type e2apEntryGlobalGnbId struct {
 708         entry *C.GlobalNodeID_t
 709 }
 710
 711 func (gnbId *e2apEntryGlobalGnbId) checkbits(bits uint8) error {
 712         if bits < 22 || bits > 32 {
 713                 return fmt.Errorf("GlobalGnbId: given bits %d not match allowed: 22-32", bits)
 714         }
 715         return nil
 716 }
 717
 718 func (gnbId *e2apEntryGlobalGnbId) set(id *e2ap.GlobalNodeId) error {
 719         if err := gnbId.checkbits(id.NodeId.Bits); err != nil {
 720                 return err
 721         }
 722         gnbId.entry.nodeID.bits = (C.uchar)(id.NodeId.Bits)
 723         gnbId.entry.nodeID.nodeID = (C.uint32_t)(id.NodeId.Id)
 724         return (&e2apEntryPlmnIdentity{entry: &gnbId.entry.pLMNIdentity}).set(&id.PlmnIdentity)
 725 }
 726
 727 func (gnbId *e2apEntryGlobalGnbId) get(id *e2ap.GlobalNodeId) error {
 728         if err := gnbId.checkbits((uint8)(gnbId.entry.nodeID.bits)); err != nil {
 729                 return err
 730         }
 731         id.NodeId.Bits = (uint8)(gnbId.entry.nodeID.bits)
 732         id.NodeId.Id = (uint32)(gnbId.entry.nodeID.nodeID)
 733         return (&e2apEntryPlmnIdentity{entry: &gnbId.entry.pLMNIdentity}).get(&id.PlmnIdentity)
 734 }
 735
 736 //-----------------------------------------------------------------------------
 737 //
 738 //-----------------------------------------------------------------------------
 739 type e2apEntryInterfaceId struct {
 740         entry *C.InterfaceID_t
 741 }
 742
 743 func (indId *e2apEntryInterfaceId) set(id *e2ap.InterfaceId) error {
 744         if id.GlobalEnbId.Present {
 745                 indId.entry.globalENBIDPresent = true
 746                 if err := (&e2apEntryGlobalEnbId{entry: &indId.entry.globalENBID}).set(&id.GlobalEnbId); err != nil {
 747                         return err
 748                 }
 749         }
 750
 751         if id.GlobalGnbId.Present {
 752                 indId.entry.globalGNBIDPresent = true
 753                 if err := (&e2apEntryGlobalGnbId{entry: &indId.entry.globalGNBID}).set(&id.GlobalGnbId); err != nil {
 754                         return err
 755                 }
 756         }
 757         return nil
 758 }
 759
 760 func (indId *e2apEntryInterfaceId) get(id *e2ap.InterfaceId) error {
 761         if indId.entry.globalENBIDPresent == true {
 762                 id.GlobalEnbId.Present = true
 763                 if err := (&e2apEntryGlobalEnbId{entry: &indId.entry.globalENBID}).get(&id.GlobalEnbId); err != nil {
 764                         return err
 765                 }
 766         }
 767
 768         if indId.entry.globalGNBIDPresent == true {
 769                 id.GlobalGnbId.Present = true
 770                 if err := (&e2apEntryGlobalGnbId{entry: &indId.entry.globalGNBID}).get(&id.GlobalGnbId); err != nil {
 771                         return err
 772                 }
 773         }
 774         return nil
 775 }
 776
 777 //-----------------------------------------------------------------------------
 778 //
 779 //-----------------------------------------------------------------------------
 780 type e2apEntryEventTrigger struct {
 781         entry *C.RICEventTriggerDefinition_t
 782 }
 783
 784 func (evtTrig *e2apEntryEventTrigger) set(id *e2ap.EventTriggerDefinition) error {
 785         if id.NBX2EventTriggerDefinitionPresent {
 786                 evtTrig.entry.E2SMgNBX2EventTriggerDefinitionPresent = true
 787                 return (&e2apEntryX2EventTrigger{entry: &evtTrig.entry.e2SMgNBX2eventTriggerDefinition}).set(&id.X2EventTriggerDefinition)
 788
 789         } else if id.NBNRTEventTriggerDefinitionPresent {
 790                 evtTrig.entry.E2SMgNBNRTEventTriggerDefinitionPresent = true
 791                 return (&e2apEntryNRTEventTrigger{entry: &evtTrig.entry.e2SMgNBNRTEventTriggerDefinition}).set(&id.NBNRTEventTriggerDefinition)
 792         }
 793         return fmt.Errorf("Set() empty EventTriggerDefinition")
 794 }
 795
 796 func (evtTrig *e2apEntryEventTrigger) get(id *e2ap.EventTriggerDefinition) error {
 797         if evtTrig.entry.E2SMgNBX2EventTriggerDefinitionPresent {
 798                 id.NBX2EventTriggerDefinitionPresent = true
 799                 return (&e2apEntryX2EventTrigger{entry: &evtTrig.entry.e2SMgNBX2eventTriggerDefinition}).get(&id.X2EventTriggerDefinition)
 800
 801         } else if evtTrig.entry.E2SMgNBNRTEventTriggerDefinitionPresent {
 802                 id.NBNRTEventTriggerDefinitionPresent = true
 803                 return (&e2apEntryNRTEventTrigger{entry: &evtTrig.entry.e2SMgNBNRTEventTriggerDefinition}).get(&id.NBNRTEventTriggerDefinition)
 804         }
 805         return fmt.Errorf("Get() empty EventTriggerDefinition")
 806 }
 807
 808 //-----------------------------------------------------------------------------
 809 //
 810 //-----------------------------------------------------------------------------
 811 type e2apEntryX2EventTrigger struct {
 812         entry *C.E2SMgNBX2eventTriggerDefinition_t
 813 }
 814
 815 func (evtTrig *e2apEntryX2EventTrigger) set(id *e2ap.X2EventTriggerDefinition) error {
 816         evtTrig.entry.interfaceDirection = (C.uint8_t)(id.InterfaceDirection)
 817         evtTrig.entry.interfaceMessageType.procedureCode = (C.uint8_t)(id.ProcedureCode)
 818         evtTrig.entry.interfaceMessageType.typeOfMessage = (C.uint8_t)(id.TypeOfMessage)
 819         return (&e2apEntryInterfaceId{entry: &evtTrig.entry.interfaceID}).set(&id.InterfaceId)
 820 }
 821
 822 func (evtTrig *e2apEntryX2EventTrigger) get(id *e2ap.X2EventTriggerDefinition) error {
 823         id.InterfaceDirection = (uint32)(evtTrig.entry.interfaceDirection)
 824         id.ProcedureCode = (uint32)(evtTrig.entry.interfaceMessageType.procedureCode)
 825         id.TypeOfMessage = (uint64)(evtTrig.entry.interfaceMessageType.typeOfMessage)
 826         return (&e2apEntryInterfaceId{entry: &evtTrig.entry.interfaceID}).get(&id.InterfaceId)
 827 }
 828
 829 //-----------------------------------------------------------------------------
 830 //
 831 //-----------------------------------------------------------------------------
 832 type e2apEntryNRTEventTrigger struct {
 833         entry *C.E2SMgNBNRTEventTriggerDefinition_t
 834 }
 835
 836 func (evtTrig *e2apEntryNRTEventTrigger) set(id *e2ap.NBNRTEventTriggerDefinition) error {
 837         evtTrig.entry.eventDefinitionFormat1.triggerNature = (C.uint8_t)(id.TriggerNature)
 838         return nil
 839 }
 840
 841 func (evtTrig *e2apEntryNRTEventTrigger) get(id *e2ap.NBNRTEventTriggerDefinition) error {
 842         id.TriggerNature = (uint8)(evtTrig.entry.eventDefinitionFormat1.triggerNature)
 843         return nil
 844 }
 845
 846 //-----------------------------------------------------------------------------
 847 //
 848 //-----------------------------------------------------------------------------
 849 type e2apEntryAdmittedList struct {
 850         entry *C.RICActionAdmittedList_t
 851 }
 852
 853 func (item *e2apEntryAdmittedList) set(data *e2ap.ActionAdmittedList) error {
 854
 855         if len(data.Items) > 16 {
 856                 return fmt.Errorf("ActionAdmittedList: too long %d while allowed %d", len(data.Items), 16)
 857         }
 858
 859         item.entry.contentLength = 0
 860         for i := 0; i < len(data.Items); i++ {
 861                 item.entry.ricActionID[item.entry.contentLength] = (C.ulong)(data.Items[i].ActionId)
 862                 item.entry.contentLength++
 863         }
 864         return nil
 865 }
 866
 867 func (item *e2apEntryAdmittedList) get(data *e2ap.ActionAdmittedList) error {
 868         conlen := (int)(item.entry.contentLength)
 869         data.Items = make([]e2ap.ActionAdmittedItem, conlen)
 870         for i := 0; i < conlen; i++ {
 871                 data.Items[i].ActionId = (uint64)(item.entry.ricActionID[i])
 872         }
 873         return nil
 874 }
 875
 876 //-----------------------------------------------------------------------------
 877 //
 878 //-----------------------------------------------------------------------------
 879 type e2apEntryNotAdmittedList struct {
 880         entry *C.RICActionNotAdmittedList_t
 881 }
 882
 883 func (item *e2apEntryNotAdmittedList) set(data *e2ap.ActionNotAdmittedList) error {
 884
 885         if len(data.Items) > 16 {
 886                 return fmt.Errorf("e2apEntryNotAdmittedList: too long %d while allowed %d", len(data.Items), 16)
 887         }
 888
 889         item.entry.contentLength = 0
 890         for i := 0; i < len(data.Items); i++ {
 891                 item.entry.RICActionNotAdmittedItem[item.entry.contentLength].ricActionID = (C.ulong)(data.Items[i].ActionId)
 892                 item.entry.RICActionNotAdmittedItem[item.entry.contentLength].cause.content = (C.uchar)(data.Items[i].Cause.Content)
 893                 item.entry.RICActionNotAdmittedItem[item.entry.contentLength].cause.causeVal = (C.uchar)(data.Items[i].Cause.Value)
 894                 item.entry.contentLength++
 895         }
 896
 897         return nil
 898 }
 899
 900 func (item *e2apEntryNotAdmittedList) get(data *e2ap.ActionNotAdmittedList) error {
 901         conlen := (int)(item.entry.contentLength)
 902         data.Items = make([]e2ap.ActionNotAdmittedItem, conlen)
 903         for i := 0; i < conlen; i++ {
 904                 data.Items[i].ActionId = (uint64)(item.entry.RICActionNotAdmittedItem[i].ricActionID)
 905                 data.Items[i].Cause.Content = (uint8)(item.entry.RICActionNotAdmittedItem[i].cause.content)
 906                 data.Items[i].Cause.Value = (uint8)(item.entry.RICActionNotAdmittedItem[i].cause.causeVal)
 907         }
 908         return nil
 909 }
 910
 911 //-----------------------------------------------------------------------------
 912 //
 913 //-----------------------------------------------------------------------------
 914 type e2apEntryCriticalityDiagnostic struct {
 915         entry *C.CriticalityDiagnostics__t
 916 }
 917
 918 func (item *e2apEntryCriticalityDiagnostic) set(data *e2ap.CriticalityDiagnostics) error {
 919
 920         item.entry.procedureCodePresent = (C.bool)(data.ProcCodePresent)
 921         item.entry.procedureCode = (C.uchar)(data.ProcCode)
 922
 923         item.entry.triggeringMessagePresent = (C.bool)(data.TrigMsgPresent)
 924         item.entry.triggeringMessage = (C.uchar)(data.TrigMsg)
 925
 926         item.entry.procedureCriticalityPresent = (C.bool)(data.ProcCritPresent)
 927         item.entry.procedureCriticality = (C.uchar)(data.ProcCrit)
 928
 929         item.entry.criticalityDiagnosticsIELength = 0
 930         item.entry.iEsCriticalityDiagnosticsPresent = false
 931         for i := 0; i < len(data.CriticalityDiagnosticsIEList.Items); i++ {
 932                 item.entry.criticalityDiagnosticsIEListItem[i].iECriticality = (C.uint8_t)(data.CriticalityDiagnosticsIEList.Items[i].IeCriticality)
 933                 item.entry.criticalityDiagnosticsIEListItem[i].iE_ID = (C.uint32_t)(data.CriticalityDiagnosticsIEList.Items[i].IeID)
 934                 item.entry.criticalityDiagnosticsIEListItem[i].typeOfError = (C.uint8_t)(data.CriticalityDiagnosticsIEList.Items[i].TypeOfError)
 935                 item.entry.criticalityDiagnosticsIELength++
 936                 item.entry.iEsCriticalityDiagnosticsPresent = true
 937         }
 938         return nil
 939 }
 940
 941 func (item *e2apEntryCriticalityDiagnostic) get(data *e2ap.CriticalityDiagnostics) error {
 942
 943         data.ProcCodePresent = (bool)(item.entry.procedureCodePresent)
 944         data.ProcCode = (uint64)(item.entry.procedureCode)
 945
 946         data.TrigMsgPresent = (bool)(item.entry.triggeringMessagePresent)
 947         data.TrigMsg = (uint64)(item.entry.triggeringMessage)
 948
 949         data.ProcCritPresent = (bool)(item.entry.procedureCriticalityPresent)
 950         data.ProcCrit = (uint8)(item.entry.procedureCriticality)
 951
 952         if item.entry.iEsCriticalityDiagnosticsPresent == true {
 953                 conlen := (int)(item.entry.criticalityDiagnosticsIELength)
 954                 data.CriticalityDiagnosticsIEList.Items = make([]e2ap.CriticalityDiagnosticsIEListItem, conlen)
 955                 for i := 0; i < conlen; i++ {
 956                         data.CriticalityDiagnosticsIEList.Items[i].IeCriticality = (uint8)(item.entry.criticalityDiagnosticsIEListItem[i].iECriticality)
 957                         data.CriticalityDiagnosticsIEList.Items[i].IeID = (uint32)(item.entry.criticalityDiagnosticsIEListItem[i].iE_ID)
 958                         data.CriticalityDiagnosticsIEList.Items[i].TypeOfError = (uint8)(item.entry.criticalityDiagnosticsIEListItem[i].typeOfError)
 959                 }
 960         }
 961         return nil
 962 }
 963
 964 /*
 965 //-----------------------------------------------------------------------------
 966 //
 967 //-----------------------------------------------------------------------------
 968 type e2apEntryCallProcessId struct {
 969         entry *C.RICCallProcessID_t
 970 }
 971
 972 func (callProcId *e2apEntryCallProcessId) set(data *e2ap.CallProcessId) error {
 973         callProcId.entry.ricCallProcessIDVal = (C.uint64_t)(data.CallProcessIDVal)
 974         return nil
 975 }
 976
 977 func (callProcId *e2apEntryCallProcessId) get(data *e2ap.CallProcessId) error {
 978         data.CallProcessIDVal = (uint32)(callProcId.entry.ricCallProcessIDVal)
 979         return nil
 980 }
 981 */
 982
 983 //-----------------------------------------------------------------------------
 984 //
 985 //-----------------------------------------------------------------------------
 986
 987 type e2apMessagePacker struct {
 988         expectedInfo C.E2MessageInfo_t
 989         pduMsgInfo   C.E2MessageInfo_t
 990         pdu          *C.e2ap_pdu_ptr_t
 991         lb           []byte
 992         p            unsafe.Pointer
 993         plen         C.size_t
 994 }
 995
 996 func (e2apMsg *e2apMessagePacker) init(minfo C.E2MessageInfo_t) {
 997         e2apMsg.expectedInfo = minfo
 998         e2apMsg.lb = make([]byte, cLogBufferMaxSize)
 999         e2apMsg.lb[0] = 0
1000         e2apMsg.p = C.malloc(C.size_t(cMsgBufferMaxSize))
1001         e2apMsg.plen = C.size_t(cMsgBufferMaxSize) - cMsgBufferExtra
1002 }
1003
1004 func (e2apMsg *e2apMessagePacker) fini() {
1005         C.free(e2apMsg.p)
1006         e2apMsg.plen = 0
1007         e2apMsg.p = nil
1008 }
1009
1010 func (e2apMsg *e2apMessagePacker) lbString() string {
1011         return "logbuffer(" + string(e2apMsg.lb[:strings.Index(string(e2apMsg.lb[:]), "\000")]) + ")"
1012 }
1013
1014 func (e2apMsg *e2apMessagePacker) packeddata() *e2ap.PackedData {
1015         return &e2ap.PackedData{C.GoBytes(e2apMsg.p, C.int(e2apMsg.plen))}
1016 }
1017
1018 func (e2apMsg *e2apMessagePacker) checkerr(errorNro C.uint64_t) error {
1019         if errorNro != C.e2err_OK {
1020                 return fmt.Errorf("e2err(%s) %s", C.GoString(C.getE2ErrorString(errorNro)), e2apMsg.lbString())
1021         }
1022         return nil
1023 }
1024
1025 func (e2apMsg *e2apMessagePacker) unpacktopdu(data *e2ap.PackedData) error {
1026         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)
1027         if e2apMsg.pduMsgInfo.messageType != e2apMsg.expectedInfo.messageType || e2apMsg.pduMsgInfo.messageId != e2apMsg.expectedInfo.messageId {
1028                 return fmt.Errorf("unpack e2ap %s %s", e2apMsg.lbString(), e2apMsg.String())
1029         }
1030         return nil
1031 }
1032
1033 func (e2apMsg *e2apMessagePacker) messageInfoPdu() *e2ap.MessageInfo {
1034         return cMessageInfoToMessageInfo(&e2apMsg.pduMsgInfo)
1035 }
1036
1037 func (e2apMsg *e2apMessagePacker) messageInfoExpected() *e2ap.MessageInfo {
1038         return cMessageInfoToMessageInfo(&e2apMsg.expectedInfo)
1039 }
1040
1041 func (e2apMsg *e2apMessagePacker) String() string {
1042         var ret string
1043         pduInfo := e2apMsg.messageInfoPdu()
1044         if pduInfo != nil {
1045                 ret += "pduinfo(" + pduInfo.String() + ")"
1046         } else {
1047                 ret += "pduinfo(N/A)"
1048         }
1049         expInfo := e2apMsg.messageInfoExpected()
1050         if expInfo != nil {
1051                 ret += " expinfo(" + expInfo.String() + ")"
1052         } else {
1053                 ret += " expinfo(N/A)"
1054         }
1055         return ret
1056 }
1057
1058 //-----------------------------------------------------------------------------
1059 //
1060 //-----------------------------------------------------------------------------
1061
1062 type e2apMsgPackerSubscriptionRequest struct {
1063         e2apMessagePacker
1064         msgC *C.RICSubscriptionRequest_t
1065         msgG *e2ap.E2APSubscriptionRequest
1066 }
1067
1068 func (e2apMsg *e2apMsgPackerSubscriptionRequest) init() {
1069         e2apMsg.e2apMessagePacker.init(C.E2MessageInfo_t{C.cE2InitiatingMessage, C.cRICSubscriptionRequest})
1070         e2apMsg.msgC = &C.RICSubscriptionRequest_t{}
1071         e2apMsg.msgG = &e2ap.E2APSubscriptionRequest{}
1072         C.initSubsRequest(e2apMsg.msgC)
1073 }
1074
1075 func (e2apMsg *e2apMsgPackerSubscriptionRequest) Pack(data *e2ap.E2APSubscriptionRequest) (error, *e2ap.PackedData) {
1076
1077         e2apMsg.init()
1078
1079         defer e2apMsg.fini()
1080         e2apMsg.msgG = data
1081
1082         var dynMemHead C.mem_track_hdr_t
1083         C.mem_track_init(&dynMemHead)
1084         defer C.mem_track_free(&dynMemHead)
1085
1086         e2apMsg.msgC.ranFunctionID = (C.uint16_t)(e2apMsg.msgG.FunctionId)
1087         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&e2apMsg.msgG.RequestId); err != nil {
1088                 return err, nil
1089         }
1090         if err := (&e2apEntryEventTrigger{entry: &e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition}).set(&e2apMsg.msgG.EventTriggerDefinition); err != nil {
1091                 return err, nil
1092         }
1093         if len(e2apMsg.msgG.ActionSetups) > 16 {
1094                 return fmt.Errorf("IndicationMessage.InterfaceMessage: too long %d while allowed %d", len(e2apMsg.msgG.ActionSetups), 16), nil
1095         }
1096         e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength = 0
1097         for i := 0; i < len(e2apMsg.msgG.ActionSetups); i++ {
1098                 item := &e2apEntryActionToBeSetupItem{entry: &e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength]}
1099                 e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength += 1
1100                 if err := item.set(&dynMemHead, &e2apMsg.msgG.ActionSetups[i]); err != nil {
1101                         return err, nil
1102                 }
1103         }
1104         errorNro := C.packRICSubscriptionRequest(&e2apMsg.plen, (*C.uchar)(e2apMsg.p), (*C.char)(unsafe.Pointer(&e2apMsg.lb[0])), e2apMsg.msgC)
1105         if err := e2apMsg.checkerr(errorNro); err != nil {
1106                 return err, nil
1107         }
1108         return nil, e2apMsg.packeddata()
1109 }
1110
1111 func (e2apMsg *e2apMsgPackerSubscriptionRequest) UnPack(msg *e2ap.PackedData) (error, *e2ap.E2APSubscriptionRequest) {
1112
1113         e2apMsg.init()
1114         defer e2apMsg.fini()
1115
1116         if err := e2apMsg.e2apMessagePacker.unpacktopdu(msg); err != nil {
1117                 return err, e2apMsg.msgG
1118         }
1119
1120         var dynMemHead C.mem_track_hdr_t
1121         C.mem_track_init(&dynMemHead)
1122         defer C.mem_track_free(&dynMemHead)
1123
1124         errorNro := C.getRICSubscriptionRequestData(&dynMemHead, e2apMsg.e2apMessagePacker.pdu, e2apMsg.msgC)
1125         if err := e2apMsg.checkerr(errorNro); err != nil {
1126                 return err, e2apMsg.msgG
1127         }
1128
1129         e2apMsg.msgG.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID)
1130         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&e2apMsg.msgG.RequestId); err != nil {
1131                 return err, e2apMsg.msgG
1132         }
1133         if err := (&e2apEntryEventTrigger{entry: &e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition}).get(&e2apMsg.msgG.EventTriggerDefinition); err != nil {
1134                 return err, e2apMsg.msgG
1135         }
1136         conlen := (int)(e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength)
1137         e2apMsg.msgG.ActionSetups = make([]e2ap.ActionToBeSetupItem, conlen)
1138         for i := 0; i < conlen; i++ {
1139                 item := &e2apEntryActionToBeSetupItem{entry: &e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[i]}
1140                 if err := item.get(&e2apMsg.msgG.ActionSetups[i]); err != nil {
1141                         return err, e2apMsg.msgG
1142                 }
1143         }
1144         return nil, e2apMsg.msgG
1145
1146 }
1147
1148 func (e2apMsg *e2apMsgPackerSubscriptionRequest) String() string {
1149         var b bytes.Buffer
1150         fmt.Fprintln(&b, "ricSubscriptionRequest.")
1151         fmt.Fprintln(&b, "  ricRequestID.")
1152         fmt.Fprintln(&b, "     ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
1153         fmt.Fprintln(&b, "     ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
1154         fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
1155         fmt.Fprintln(&b, "  ricSubscriptionDetails.")
1156         fmt.Fprintln(&b, "    ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.")
1157         fmt.Fprintln(&b, "      contentLength =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.octetString.contentLength)
1158         fmt.Fprintln(&b, "      interfaceID.globalENBIDPresent =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBIDPresent)
1159         if e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBIDPresent {
1160                 fmt.Fprintln(&b, "      interfaceID.globalENBID.pLMNIdentity.contentLength =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.contentLength)
1161                 fmt.Fprintln(&b, "      interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[0] =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[0])
1162                 fmt.Fprintln(&b, "      interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[1] =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[1])
1163                 fmt.Fprintln(&b, "      interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[2] =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.pLMNIdentity.pLMNIdentityVal[2])
1164                 fmt.Fprintln(&b, "      interfaceID.globalENBID.nodeID.bits =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.bits)
1165                 fmt.Fprintln(&b, "      interfaceID.globalENBID.nodeID.nodeID =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalENBID.nodeID.nodeID)
1166         }
1167         fmt.Fprintln(&b, "      interfaceID.globalGNBIDPresent =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBIDPresent)
1168         if e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBIDPresent {
1169                 fmt.Fprintln(&b, "      interfaceID.globalGNBID.pLMNIdentity.contentLength =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.contentLength)
1170                 fmt.Fprintln(&b, "      interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[0] =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[0])
1171                 fmt.Fprintln(&b, "      interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[1] =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[1])
1172                 fmt.Fprintln(&b, "      interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[2] =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.pLMNIdentity.pLMNIdentityVal[2])
1173                 fmt.Fprintln(&b, "      interfaceID.globalGNBID.nodeID.bits =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.nodeID.bits)
1174                 fmt.Fprintln(&b, "      interfaceID.globalGNBID.nodeID.nodeID =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceID.globalGNBID.nodeID.nodeID)
1175         }
1176         fmt.Fprintln(&b, "      interfaceDirection = ", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceDirection)
1177         fmt.Fprintln(&b, "      interfaceMessageType.procedureCode =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceMessageType.procedureCode)
1178         fmt.Fprintln(&b, "      interfaceMessageType.typeOfMessage =", e2apMsg.msgC.ricSubscriptionDetails.ricEventTriggerDefinition.e2SMgNBX2eventTriggerDefinition.interfaceMessageType.typeOfMessage)
1179         fmt.Fprintln(&b, "    ricActionToBeSetupItemIEs.")
1180         fmt.Fprintln(&b, "      contentLength =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength)
1181         var index uint8
1182         index = 0
1183         for (C.uchar)(index) < e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.contentLength {
1184                 fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionID =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionID)
1185                 fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionType =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionType)
1186
1187                 fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionDefinitionPresent =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent)
1188                 if e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionPresent {
1189                         fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionDefinitionChoice.actionDefinitionX2Format1Present =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.actionDefinitionX2Format1Present)
1190                         fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionDefinitionChoice.actionDefinitionX2Format2Present =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.actionDefinitionX2Format2Present)
1191                         fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricActionDefinitionChoice.actionDefinitionNRTFormat1Present =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricActionDefinitionChoice.actionDefinitionNRTFormat1Present)
1192                         // Dynamically allocated C-structs are already freed. Can't print those.
1193                 }
1194
1195                 fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricSubsequentActionPresent =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent)
1196                 if e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentActionPresent {
1197                         fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricSubsequentAction.ricSubsequentActionType =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricSubsequentActionType)
1198                         fmt.Fprintln(&b, "      ricActionToBeSetupItem[index].ricSubsequentAction.ricTimeToWait =", e2apMsg.msgC.ricSubscriptionDetails.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[index].ricSubsequentAction.ricTimeToWait)
1199                 }
1200                 index++
1201         }
1202         return b.String()
1203 }
1204
1205 //-----------------------------------------------------------------------------
1206 //
1207 //-----------------------------------------------------------------------------
1208 type e2apMsgPackerSubscriptionResponse struct {
1209         e2apMessagePacker
1210         msgC *C.RICSubscriptionResponse_t
1211         msgG *e2ap.E2APSubscriptionResponse
1212 }
1213
1214 func (e2apMsg *e2apMsgPackerSubscriptionResponse) init() {
1215         e2apMsg.e2apMessagePacker.init(C.E2MessageInfo_t{C.cE2SuccessfulOutcome, C.cRICSubscriptionResponse})
1216         e2apMsg.msgC = &C.RICSubscriptionResponse_t{}
1217         e2apMsg.msgG = &e2ap.E2APSubscriptionResponse{}
1218         C.initSubsResponse(e2apMsg.msgC)
1219 }
1220
1221 func (e2apMsg *e2apMsgPackerSubscriptionResponse) Pack(data *e2ap.E2APSubscriptionResponse) (error, *e2ap.PackedData) {
1222         e2apMsg.init()
1223         defer e2apMsg.fini()
1224         e2apMsg.msgG = data
1225
1226         e2apMsg.msgC.ranFunctionID = (C.uint16_t)(e2apMsg.msgG.FunctionId)
1227         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&e2apMsg.msgG.RequestId); err != nil {
1228                 return err, nil
1229         }
1230         if err := (&e2apEntryAdmittedList{entry: &e2apMsg.msgC.ricActionAdmittedList}).set(&e2apMsg.msgG.ActionAdmittedList); err != nil {
1231                 return err, nil
1232         }
1233         e2apMsg.msgC.ricActionNotAdmittedListPresent = false
1234         if len(e2apMsg.msgG.ActionNotAdmittedList.Items) > 0 {
1235                 e2apMsg.msgC.ricActionNotAdmittedListPresent = true
1236                 if err := (&e2apEntryNotAdmittedList{entry: &e2apMsg.msgC.ricActionNotAdmittedList}).set(&e2apMsg.msgG.ActionNotAdmittedList); err != nil {
1237                         return err, nil
1238                 }
1239         }
1240
1241         errorNro := C.packRICSubscriptionResponse(&e2apMsg.plen, (*C.uchar)(e2apMsg.p), (*C.char)(unsafe.Pointer(&e2apMsg.lb[0])), e2apMsg.msgC)
1242         if err := e2apMsg.checkerr(errorNro); err != nil {
1243                 return err, nil
1244         }
1245         return nil, e2apMsg.packeddata()
1246 }
1247
1248 func (e2apMsg *e2apMsgPackerSubscriptionResponse) UnPack(msg *e2ap.PackedData) (error, *e2ap.E2APSubscriptionResponse) {
1249
1250         e2apMsg.init()
1251         defer e2apMsg.fini()
1252
1253         if err := e2apMsg.e2apMessagePacker.unpacktopdu(msg); err != nil {
1254                 return err, e2apMsg.msgG
1255         }
1256         errorNro := C.getRICSubscriptionResponseData(e2apMsg.e2apMessagePacker.pdu, e2apMsg.msgC)
1257         if err := e2apMsg.checkerr(errorNro); err != nil {
1258                 return err, e2apMsg.msgG
1259         }
1260
1261         e2apMsg.msgG.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID)
1262         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&e2apMsg.msgG.RequestId); err != nil {
1263                 return err, e2apMsg.msgG
1264         }
1265         if err := (&e2apEntryAdmittedList{entry: &e2apMsg.msgC.ricActionAdmittedList}).get(&e2apMsg.msgG.ActionAdmittedList); err != nil {
1266                 return err, e2apMsg.msgG
1267         }
1268         if e2apMsg.msgC.ricActionNotAdmittedListPresent == true {
1269                 if err := (&e2apEntryNotAdmittedList{entry: &e2apMsg.msgC.ricActionNotAdmittedList}).get(&e2apMsg.msgG.ActionNotAdmittedList); err != nil {
1270                         return err, e2apMsg.msgG
1271                 }
1272         }
1273         return nil, e2apMsg.msgG
1274 }
1275
1276 func (e2apMsg *e2apMsgPackerSubscriptionResponse) String() string {
1277         var b bytes.Buffer
1278         fmt.Fprintln(&b, "ricSubscriptionResponse.")
1279         fmt.Fprintln(&b, "  ricRequestID.")
1280         fmt.Fprintln(&b, "    ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
1281         fmt.Fprintln(&b, "    ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
1282         fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
1283         fmt.Fprintln(&b, "  ricActionAdmittedList.")
1284         fmt.Fprintln(&b, "    contentLength =", e2apMsg.msgC.ricActionAdmittedList.contentLength)
1285         var index uint8
1286         index = 0
1287         for (C.uchar)(index) < e2apMsg.msgC.ricActionAdmittedList.contentLength {
1288                 fmt.Fprintln(&b, "    ricActionAdmittedList.ricActionID[index] =", e2apMsg.msgC.ricActionAdmittedList.ricActionID[index])
1289                 index++
1290         }
1291         if e2apMsg.msgC.ricActionNotAdmittedListPresent {
1292                 fmt.Fprintln(&b, "  ricActionNotAdmittedListPresent =", e2apMsg.msgC.ricActionNotAdmittedListPresent)
1293                 fmt.Fprintln(&b, "    ricActionNotAdmittedList.")
1294                 fmt.Fprintln(&b, "    contentLength =", e2apMsg.msgC.ricActionNotAdmittedList.contentLength)
1295                 index = 0
1296                 for (C.uchar)(index) < e2apMsg.msgC.ricActionNotAdmittedList.contentLength {
1297                         fmt.Fprintln(&b, "      RICActionNotAdmittedItem[index].ricActionID =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID)
1298                         fmt.Fprintln(&b, "      RICActionNotAdmittedItem[index].cause.content =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content)
1299                         fmt.Fprintln(&b, "      RICActionNotAdmittedItem[index].cause.causeVal =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal)
1300                         index++
1301                 }
1302         }
1303         return b.String()
1304 }
1305
1306 //-----------------------------------------------------------------------------
1307 //
1308 //-----------------------------------------------------------------------------
1309 type e2apMsgPackerSubscriptionFailure struct {
1310         e2apMessagePacker
1311         msgC *C.RICSubscriptionFailure_t
1312         msgG *e2ap.E2APSubscriptionFailure
1313 }
1314
1315 func (e2apMsg *e2apMsgPackerSubscriptionFailure) init() {
1316         e2apMsg.e2apMessagePacker.init(C.E2MessageInfo_t{C.cE2UnsuccessfulOutcome, C.cRICSubscriptionFailure})
1317         e2apMsg.msgC = &C.RICSubscriptionFailure_t{}
1318         e2apMsg.msgG = &e2ap.E2APSubscriptionFailure{}
1319         C.initSubsFailure(e2apMsg.msgC)
1320 }
1321
1322 func (e2apMsg *e2apMsgPackerSubscriptionFailure) Pack(data *e2ap.E2APSubscriptionFailure) (error, *e2ap.PackedData) {
1323         e2apMsg.init()
1324         defer e2apMsg.fini()
1325         e2apMsg.msgG = data
1326
1327         e2apMsg.msgC.ranFunctionID = (C.uint16_t)(e2apMsg.msgG.FunctionId)
1328         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&e2apMsg.msgG.RequestId); err != nil {
1329                 return err, nil
1330         }
1331         if err := (&e2apEntryNotAdmittedList{entry: &e2apMsg.msgC.ricActionNotAdmittedList}).set(&e2apMsg.msgG.ActionNotAdmittedList); err != nil {
1332                 return err, nil
1333         }
1334         e2apMsg.msgC.criticalityDiagnosticsPresent = false
1335         if e2apMsg.msgG.CriticalityDiagnostics.Present {
1336                 e2apMsg.msgC.criticalityDiagnosticsPresent = true
1337                 if err := (&e2apEntryCriticalityDiagnostic{entry: &e2apMsg.msgC.criticalityDiagnostics}).set(&e2apMsg.msgG.CriticalityDiagnostics); err != nil {
1338                         return err, nil
1339                 }
1340         }
1341
1342         errorNro := C.packRICSubscriptionFailure(&e2apMsg.plen, (*C.uchar)(e2apMsg.p), (*C.char)(unsafe.Pointer(&e2apMsg.lb[0])), e2apMsg.msgC)
1343         if err := e2apMsg.checkerr(errorNro); err != nil {
1344                 return err, nil
1345         }
1346         return nil, e2apMsg.packeddata()
1347 }
1348
1349 func (e2apMsg *e2apMsgPackerSubscriptionFailure) UnPack(msg *e2ap.PackedData) (error, *e2ap.E2APSubscriptionFailure) {
1350         e2apMsg.init()
1351         defer e2apMsg.fini()
1352
1353         if err := e2apMsg.e2apMessagePacker.unpacktopdu(msg); err != nil {
1354                 return err, e2apMsg.msgG
1355         }
1356         errorNro := C.getRICSubscriptionFailureData(e2apMsg.e2apMessagePacker.pdu, e2apMsg.msgC)
1357         if err := e2apMsg.checkerr(errorNro); err != nil {
1358                 return err, e2apMsg.msgG
1359         }
1360
1361         e2apMsg.msgG.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID)
1362         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&e2apMsg.msgG.RequestId); err != nil {
1363                 return err, e2apMsg.msgG
1364         }
1365         if err := (&e2apEntryNotAdmittedList{entry: &e2apMsg.msgC.ricActionNotAdmittedList}).get(&e2apMsg.msgG.ActionNotAdmittedList); err != nil {
1366                 return err, e2apMsg.msgG
1367         }
1368         if e2apMsg.msgC.criticalityDiagnosticsPresent == true {
1369                 e2apMsg.msgG.CriticalityDiagnostics.Present = true
1370                 if err := (&e2apEntryCriticalityDiagnostic{entry: &e2apMsg.msgC.criticalityDiagnostics}).get(&e2apMsg.msgG.CriticalityDiagnostics); err != nil {
1371                         return err, e2apMsg.msgG
1372                 }
1373         }
1374         return nil, e2apMsg.msgG
1375 }
1376
1377 func (e2apMsg *e2apMsgPackerSubscriptionFailure) String() string {
1378         var b bytes.Buffer
1379         fmt.Fprintln(&b, "ricSubscriptionFailure.")
1380         fmt.Fprintln(&b, "  ricRequestID.")
1381         fmt.Fprintln(&b, "    ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
1382         fmt.Fprintln(&b, "    ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
1383         fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
1384         fmt.Fprintln(&b, "  ricActionNotAdmittedList.")
1385         fmt.Fprintln(&b, "    contentLength =", e2apMsg.msgC.ricActionNotAdmittedList.contentLength)
1386         var index uint8
1387         index = 0
1388         for (C.uchar)(index) < e2apMsg.msgC.ricActionNotAdmittedList.contentLength {
1389                 fmt.Fprintln(&b, "    RICActionNotAdmittedItem[index].ricActionID =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].ricActionID)
1390                 fmt.Fprintln(&b, "    RICActionNotAdmittedItem[index].cause.content =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.content)
1391                 fmt.Fprintln(&b, "    RICActionNotAdmittedItem[index].cause.causeVal =", e2apMsg.msgC.ricActionNotAdmittedList.RICActionNotAdmittedItem[index].cause.causeVal)
1392                 index++
1393         }
1394         /* NOT SUPPORTED
1395         if e2apMsg.msgC.criticalityDiagnosticsPresent {
1396                 fmt.Fprintln(&b, "  criticalityDiagnosticsPresent =", e2apMsg.msgC.criticalityDiagnosticsPresent)
1397                 fmt.Fprintln(&b, "    criticalityDiagnostics.")
1398                 fmt.Fprintln(&b, "    procedureCodePresent =", e2apMsg.msgC.criticalityDiagnostics.procedureCodePresent)
1399                 fmt.Fprintln(&b, "      procedureCode =", e2apMsg.msgC.criticalityDiagnostics.procedureCode)
1400                 fmt.Fprintln(&b, "    triggeringMessagePresent =", e2apMsg.msgC.criticalityDiagnostics.triggeringMessagePresent)
1401                 fmt.Fprintln(&b, "      triggeringMessage =", e2apMsg.msgC.criticalityDiagnostics.triggeringMessage)
1402                 fmt.Fprintln(&b, "    procedureCriticalityPresent=", e2apMsg.msgC.criticalityDiagnostics.procedureCriticalityPresent)
1403                 fmt.Fprintln(&b, "      procedureCriticality =", e2apMsg.msgC.criticalityDiagnostics.procedureCriticality)
1404                 fmt.Fprintln(&b, "    iEsCriticalityDiagnosticsPresent =", e2apMsg.msgC.criticalityDiagnostics.iEsCriticalityDiagnosticsPresent)
1405                 fmt.Fprintln(&b, "      criticalityDiagnosticsIELength =", e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIELength)
1406                 var index2 uint16
1407                 index2 = 0
1408                 for (C.ushort)(index2) < e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIELength {
1409                         fmt.Fprintln(&b, "      criticalityDiagnosticsIEListItem[index2].iECriticality =", e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIEListItem[index2].iECriticality)
1410                         fmt.Fprintln(&b, "      criticalityDiagnosticsIEListItem[index2].iE_ID =", e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIEListItem[index2].iE_ID)
1411                         fmt.Fprintln(&b, "      criticalityDiagnosticsIEListItem[index2].typeOfError =", e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIEListItem[index2].typeOfError)
1412                         index2++
1413                 }
1414         }
1415         */
1416         return b.String()
1417 }
1418
1419 //-----------------------------------------------------------------------------
1420 //
1421 //-----------------------------------------------------------------------------
1422 type e2apMsgPackerSubscriptionDeleteRequest struct {
1423         e2apMessagePacker
1424         msgC *C.RICSubscriptionDeleteRequest_t
1425         msgG *e2ap.E2APSubscriptionDeleteRequest
1426 }
1427
1428 func (e2apMsg *e2apMsgPackerSubscriptionDeleteRequest) init() {
1429         e2apMsg.e2apMessagePacker.init(C.E2MessageInfo_t{C.cE2InitiatingMessage, C.cRICSubscriptionDeleteRequest})
1430         e2apMsg.msgC = &C.RICSubscriptionDeleteRequest_t{}
1431         e2apMsg.msgG = &e2ap.E2APSubscriptionDeleteRequest{}
1432         C.initSubsDeleteRequest(e2apMsg.msgC)
1433 }
1434
1435 func (e2apMsg *e2apMsgPackerSubscriptionDeleteRequest) Pack(data *e2ap.E2APSubscriptionDeleteRequest) (error, *e2ap.PackedData) {
1436         e2apMsg.init()
1437         defer e2apMsg.fini()
1438         e2apMsg.msgG = data
1439
1440         e2apMsg.msgC.ranFunctionID = (C.uint16_t)(e2apMsg.msgG.FunctionId)
1441         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&e2apMsg.msgG.RequestId); err != nil {
1442                 return err, nil
1443         }
1444
1445         errorNro := C.packRICSubscriptionDeleteRequest(&e2apMsg.plen, (*C.uchar)(e2apMsg.p), (*C.char)(unsafe.Pointer(&e2apMsg.lb[0])), e2apMsg.msgC)
1446         if err := e2apMsg.checkerr(errorNro); err != nil {
1447                 return err, nil
1448         }
1449         return nil, e2apMsg.packeddata()
1450 }
1451
1452 func (e2apMsg *e2apMsgPackerSubscriptionDeleteRequest) UnPack(msg *e2ap.PackedData) (error, *e2ap.E2APSubscriptionDeleteRequest) {
1453         e2apMsg.init()
1454         defer e2apMsg.fini()
1455
1456         if err := e2apMsg.e2apMessagePacker.unpacktopdu(msg); err != nil {
1457                 return err, e2apMsg.msgG
1458         }
1459         errorNro := C.getRICSubscriptionDeleteRequestData(e2apMsg.e2apMessagePacker.pdu, e2apMsg.msgC)
1460         if err := e2apMsg.checkerr(errorNro); err != nil {
1461                 return err, e2apMsg.msgG
1462         }
1463
1464         e2apMsg.msgG.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID)
1465         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&e2apMsg.msgG.RequestId); err != nil {
1466                 return err, e2apMsg.msgG
1467         }
1468         return nil, e2apMsg.msgG
1469
1470 }
1471
1472 func (e2apMsg *e2apMsgPackerSubscriptionDeleteRequest) String() string {
1473         var b bytes.Buffer
1474         fmt.Fprintln(&b, "ricSubscriptionDeleteRequest.")
1475         fmt.Fprintln(&b, "  ricRequestID.")
1476         fmt.Fprintln(&b, "     ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
1477         fmt.Fprintln(&b, "     ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
1478         fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
1479         return b.String()
1480 }
1481
1482 //-----------------------------------------------------------------------------
1483 //
1484 //-----------------------------------------------------------------------------
1485 type e2apMsgPackerSubscriptionDeleteResponse struct {
1486         e2apMessagePacker
1487         msgC *C.RICSubscriptionDeleteResponse_t
1488         msgG *e2ap.E2APSubscriptionDeleteResponse
1489 }
1490
1491 func (e2apMsg *e2apMsgPackerSubscriptionDeleteResponse) init() {
1492         e2apMsg.e2apMessagePacker.init(C.E2MessageInfo_t{C.cE2SuccessfulOutcome, C.cRICsubscriptionDeleteResponse})
1493         e2apMsg.msgC = &C.RICSubscriptionDeleteResponse_t{}
1494         e2apMsg.msgG = &e2ap.E2APSubscriptionDeleteResponse{}
1495         C.initSubsDeleteResponse(e2apMsg.msgC)
1496 }
1497
1498 func (e2apMsg *e2apMsgPackerSubscriptionDeleteResponse) Pack(data *e2ap.E2APSubscriptionDeleteResponse) (error, *e2ap.PackedData) {
1499         e2apMsg.init()
1500         defer e2apMsg.fini()
1501         e2apMsg.msgG = data
1502
1503         e2apMsg.msgC.ranFunctionID = (C.uint16_t)(e2apMsg.msgG.FunctionId)
1504         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&e2apMsg.msgG.RequestId); err != nil {
1505                 return err, nil
1506         }
1507
1508         errorNro := C.packRICSubscriptionDeleteResponse(&e2apMsg.plen, (*C.uchar)(e2apMsg.p), (*C.char)(unsafe.Pointer(&e2apMsg.lb[0])), e2apMsg.msgC)
1509         if err := e2apMsg.checkerr(errorNro); err != nil {
1510                 return err, nil
1511         }
1512         return nil, e2apMsg.packeddata()
1513 }
1514
1515 func (e2apMsg *e2apMsgPackerSubscriptionDeleteResponse) UnPack(msg *e2ap.PackedData) (error, *e2ap.E2APSubscriptionDeleteResponse) {
1516         e2apMsg.init()
1517         defer e2apMsg.fini()
1518
1519         if err := e2apMsg.e2apMessagePacker.unpacktopdu(msg); err != nil {
1520                 return err, e2apMsg.msgG
1521         }
1522         errorNro := C.getRICSubscriptionDeleteResponseData(e2apMsg.e2apMessagePacker.pdu, e2apMsg.msgC)
1523         if err := e2apMsg.checkerr(errorNro); err != nil {
1524                 return err, e2apMsg.msgG
1525         }
1526
1527         e2apMsg.msgG.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID)
1528         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&e2apMsg.msgG.RequestId); err != nil {
1529                 return err, e2apMsg.msgG
1530         }
1531         return nil, e2apMsg.msgG
1532 }
1533
1534 func (e2apMsg *e2apMsgPackerSubscriptionDeleteResponse) String() string {
1535         var b bytes.Buffer
1536         fmt.Fprintln(&b, "ricSubscriptionDeleteResponse.")
1537         fmt.Fprintln(&b, "  ricRequestID.")
1538         fmt.Fprintln(&b, "    ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
1539         fmt.Fprintln(&b, "    ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
1540         fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
1541         return b.String()
1542 }
1543
1544 //-----------------------------------------------------------------------------
1545 //
1546 //-----------------------------------------------------------------------------
1547 type e2apMsgPackerSubscriptionDeleteFailure struct {
1548         e2apMessagePacker
1549         msgC *C.RICSubscriptionDeleteFailure_t
1550         msgG *e2ap.E2APSubscriptionDeleteFailure
1551 }
1552
1553 func (e2apMsg *e2apMsgPackerSubscriptionDeleteFailure) init() {
1554         e2apMsg.e2apMessagePacker.init(C.E2MessageInfo_t{C.cE2UnsuccessfulOutcome, C.cRICsubscriptionDeleteFailure})
1555         e2apMsg.msgC = &C.RICSubscriptionDeleteFailure_t{}
1556         e2apMsg.msgG = &e2ap.E2APSubscriptionDeleteFailure{}
1557         C.initSubsDeleteFailure(e2apMsg.msgC)
1558 }
1559
1560 func (e2apMsg *e2apMsgPackerSubscriptionDeleteFailure) Pack(data *e2ap.E2APSubscriptionDeleteFailure) (error, *e2ap.PackedData) {
1561         e2apMsg.init()
1562         defer e2apMsg.fini()
1563         e2apMsg.msgG = data
1564
1565         e2apMsg.msgC.ranFunctionID = (C.uint16_t)(e2apMsg.msgG.FunctionId)
1566         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&e2apMsg.msgG.RequestId); err != nil {
1567                 return err, nil
1568         }
1569         e2apMsg.msgC.cause.content = (C.uchar)(e2apMsg.msgG.Cause.Content)
1570         e2apMsg.msgC.cause.causeVal = (C.uchar)(e2apMsg.msgG.Cause.Value)
1571         e2apMsg.msgC.criticalityDiagnosticsPresent = false
1572         if e2apMsg.msgG.CriticalityDiagnostics.Present {
1573                 e2apMsg.msgC.criticalityDiagnosticsPresent = true
1574                 if err := (&e2apEntryCriticalityDiagnostic{entry: &e2apMsg.msgC.criticalityDiagnostics}).set(&e2apMsg.msgG.CriticalityDiagnostics); err != nil {
1575                         return err, nil
1576                 }
1577         }
1578
1579         errorNro := C.packRICSubscriptionDeleteFailure(&e2apMsg.plen, (*C.uchar)(e2apMsg.p), (*C.char)(unsafe.Pointer(&e2apMsg.lb[0])), e2apMsg.msgC)
1580         if err := e2apMsg.checkerr(errorNro); err != nil {
1581                 return err, nil
1582         }
1583         return nil, e2apMsg.packeddata()
1584 }
1585
1586 func (e2apMsg *e2apMsgPackerSubscriptionDeleteFailure) UnPack(msg *e2ap.PackedData) (error, *e2ap.E2APSubscriptionDeleteFailure) {
1587         e2apMsg.init()
1588         defer e2apMsg.fini()
1589
1590         if err := e2apMsg.e2apMessagePacker.unpacktopdu(msg); err != nil {
1591                 return err, e2apMsg.msgG
1592         }
1593         errorNro := C.getRICSubscriptionDeleteFailureData(e2apMsg.e2apMessagePacker.pdu, e2apMsg.msgC)
1594         if err := e2apMsg.checkerr(errorNro); err != nil {
1595                 return err, e2apMsg.msgG
1596         }
1597
1598         e2apMsg.msgG.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID)
1599         if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&e2apMsg.msgG.RequestId); err != nil {
1600                 return err, e2apMsg.msgG
1601         }
1602         e2apMsg.msgG.Cause.Content = (uint8)(e2apMsg.msgC.cause.content)
1603         e2apMsg.msgG.Cause.Value = (uint8)(e2apMsg.msgC.cause.causeVal)
1604         if e2apMsg.msgC.criticalityDiagnosticsPresent == true {
1605                 e2apMsg.msgG.CriticalityDiagnostics.Present = true
1606                 if err := (&e2apEntryCriticalityDiagnostic{entry: &e2apMsg.msgC.criticalityDiagnostics}).get(&e2apMsg.msgG.CriticalityDiagnostics); err != nil {
1607                         return err, e2apMsg.msgG
1608                 }
1609         }
1610         return nil, e2apMsg.msgG
1611 }
1612
1613 func (e2apMsg *e2apMsgPackerSubscriptionDeleteFailure) String() string {
1614         var b bytes.Buffer
1615         fmt.Fprintln(&b, "ricSubscriptionDeleteFailure.")
1616         fmt.Fprintln(&b, "  ricRequestID.")
1617         fmt.Fprintln(&b, "    ricRequestorID =", e2apMsg.msgC.ricRequestID.ricRequestorID)
1618         fmt.Fprintln(&b, "    ricInstanceID =", e2apMsg.msgC.ricRequestID.ricInstanceID)
1619         fmt.Fprintln(&b, "  ranFunctionID =", e2apMsg.msgC.ranFunctionID)
1620         /*      NOT SUPPORTED
1621                 if e2apMsg.msgC.criticalityDiagnosticsPresent {
1622                         fmt.Fprintln(&b, "  criticalityDiagnosticsPresent =", e2apMsg.msgC.criticalityDiagnosticsPresent)
1623                         fmt.Fprintln(&b, "    criticalityDiagnostics.")
1624                         fmt.Fprintln(&b, "    procedureCodePresent =", e2apMsg.msgC.criticalityDiagnostics.procedureCodePresent)
1625                         fmt.Fprintln(&b, "      procedureCode =", e2apMsg.msgC.criticalityDiagnostics.procedureCode)
1626                         fmt.Fprintln(&b, "    triggeringMessagePresent =", e2apMsg.msgC.criticalityDiagnostics.triggeringMessagePresent)
1627                         fmt.Fprintln(&b, "      triggeringMessage =", e2apMsg.msgC.criticalityDiagnostics.triggeringMessage)
1628                         fmt.Fprintln(&b, "    procedureCriticalityPresent=", e2apMsg.msgC.criticalityDiagnostics.procedureCriticalityPresent)
1629                         fmt.Fprintln(&b, "      procedureCriticality =", e2apMsg.msgC.criticalityDiagnostics.procedureCriticality)
1630                         fmt.Fprintln(&b, "    iEsCriticalityDiagnosticsPresent =", e2apMsg.msgC.criticalityDiagnostics.iEsCriticalityDiagnosticsPresent)
1631                         fmt.Fprintln(&b, "      criticalityDiagnosticsIELength =", e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIELength)
1632                         var index2 uint16
1633                         index2 = 0
1634                         for (C.ushort)(index2) < e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIELength {
1635                                 fmt.Fprintln(&b, "      criticalityDiagnosticsIEListItem[index2].iECriticality =", e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIEListItem[index2].iECriticality)
1636                                 fmt.Fprintln(&b, "      criticalityDiagnosticsIEListItem[index2].iE_ID =", e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIEListItem[index2].iE_ID)
1637                                 fmt.Fprintln(&b, "      criticalityDiagnosticsIEListItem[index2].typeOfError =", e2apMsg.msgC.criticalityDiagnostics.criticalityDiagnosticsIEListItem[index2].typeOfError)
1638                                 index2++
1639                         }
1640                 }
1641         */
1642         return b.String()
1643 }
1644
1645 //-----------------------------------------------------------------------------
1646 // Public E2AP packer creators
1647 //-----------------------------------------------------------------------------
1648
1649 type cppasn1E2APPacker struct{}
1650
1651 func (*cppasn1E2APPacker) NewPackerSubscriptionRequest() e2ap.E2APMsgPackerSubscriptionRequestIf {
1652         return &e2apMsgPackerSubscriptionRequest{}
1653 }
1654
1655 func (*cppasn1E2APPacker) NewPackerSubscriptionResponse() e2ap.E2APMsgPackerSubscriptionResponseIf {
1656         return &e2apMsgPackerSubscriptionResponse{}
1657 }
1658
1659 func (*cppasn1E2APPacker) NewPackerSubscriptionFailure() e2ap.E2APMsgPackerSubscriptionFailureIf {
1660         return &e2apMsgPackerSubscriptionFailure{}
1661 }
1662
1663 func (*cppasn1E2APPacker) NewPackerSubscriptionDeleteRequest() e2ap.E2APMsgPackerSubscriptionDeleteRequestIf {
1664         return &e2apMsgPackerSubscriptionDeleteRequest{}
1665 }
1666
1667 func (*cppasn1E2APPacker) NewPackerSubscriptionDeleteResponse() e2ap.E2APMsgPackerSubscriptionDeleteResponseIf {
1668         return &e2apMsgPackerSubscriptionDeleteResponse{}
1669 }
1670
1671 func (*cppasn1E2APPacker) NewPackerSubscriptionDeleteFailure() e2ap.E2APMsgPackerSubscriptionDeleteFailureIf {
1672         return &e2apMsgPackerSubscriptionDeleteFailure{}
1673 }
1674
1675 func NewAsn1E2Packer() e2ap.E2APPackerIf {
1676         return &cppasn1E2APPacker{}
1677 }