mc-core/mc/local_datasource/rrctransfer.pb-c.c

   1 /* Generated by the protocol buffer compiler.  DO NOT EDIT! */
   2 /* Generated from: rrctransfer.proto */
   3
   4 /* Do not generate deprecated warnings for self */
   5 #ifndef PROTOBUF_C__NO_DEPRECATED
   6 #define PROTOBUF_C__NO_DEPRECATED
   7 #endif
   8
   9 #include "rrctransfer.pb-c.h"
  10 void   streaming_protobufs__uenrmeasurement__ext_ies__init
  11                      (StreamingProtobufs__UENRMeasurementExtIEs         *message)
  12 {
  13   static const StreamingProtobufs__UENRMeasurementExtIEs init_value = STREAMING_PROTOBUFS__UENRMEASUREMENT__EXT_IES__INIT;
  14   *message = init_value;
  15 }
  16 size_t streaming_protobufs__uenrmeasurement__ext_ies__get_packed_size
  17                      (const StreamingProtobufs__UENRMeasurementExtIEs *message)
  18 {
  19   assert(message->base.descriptor == &streaming_protobufs__uenrmeasurement__ext_ies__descriptor);
  20   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  21 }
  22 size_t streaming_protobufs__uenrmeasurement__ext_ies__pack
  23                      (const StreamingProtobufs__UENRMeasurementExtIEs *message,
  24                       uint8_t       *out)
  25 {
  26   assert(message->base.descriptor == &streaming_protobufs__uenrmeasurement__ext_ies__descriptor);
  27   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  28 }
  29 size_t streaming_protobufs__uenrmeasurement__ext_ies__pack_to_buffer
  30                      (const StreamingProtobufs__UENRMeasurementExtIEs *message,
  31                       ProtobufCBuffer *buffer)
  32 {
  33   assert(message->base.descriptor == &streaming_protobufs__uenrmeasurement__ext_ies__descriptor);
  34   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  35 }
  36 StreamingProtobufs__UENRMeasurementExtIEs *
  37        streaming_protobufs__uenrmeasurement__ext_ies__unpack
  38                      (ProtobufCAllocator  *allocator,
  39                       size_t               len,
  40                       const uint8_t       *data)
  41 {
  42   return (StreamingProtobufs__UENRMeasurementExtIEs *)
  43      protobuf_c_message_unpack (&streaming_protobufs__uenrmeasurement__ext_ies__descriptor,
  44                                 allocator, len, data);
  45 }
  46 void   streaming_protobufs__uenrmeasurement__ext_ies__free_unpacked
  47                      (StreamingProtobufs__UENRMeasurementExtIEs *message,
  48                       ProtobufCAllocator *allocator)
  49 {
  50   if(!message)
  51     return;
  52   assert(message->base.descriptor == &streaming_protobufs__uenrmeasurement__ext_ies__descriptor);
  53   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  54 }
  55 void   streaming_protobufs__uenrmeasurement__init
  56                      (StreamingProtobufs__UENRMeasurement         *message)
  57 {
  58   static const StreamingProtobufs__UENRMeasurement init_value = STREAMING_PROTOBUFS__UENRMEASUREMENT__INIT;
  59   *message = init_value;
  60 }
  61 size_t streaming_protobufs__uenrmeasurement__get_packed_size
  62                      (const StreamingProtobufs__UENRMeasurement *message)
  63 {
  64   assert(message->base.descriptor == &streaming_protobufs__uenrmeasurement__descriptor);
  65   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  66 }
  67 size_t streaming_protobufs__uenrmeasurement__pack
  68                      (const StreamingProtobufs__UENRMeasurement *message,
  69                       uint8_t       *out)
  70 {
  71   assert(message->base.descriptor == &streaming_protobufs__uenrmeasurement__descriptor);
  72   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  73 }
  74 size_t streaming_protobufs__uenrmeasurement__pack_to_buffer
  75                      (const StreamingProtobufs__UENRMeasurement *message,
  76                       ProtobufCBuffer *buffer)
  77 {
  78   assert(message->base.descriptor == &streaming_protobufs__uenrmeasurement__descriptor);
  79   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  80 }
  81 StreamingProtobufs__UENRMeasurement *
  82        streaming_protobufs__uenrmeasurement__unpack
  83                      (ProtobufCAllocator  *allocator,
  84                       size_t               len,
  85                       const uint8_t       *data)
  86 {
  87   return (StreamingProtobufs__UENRMeasurement *)
  88      protobuf_c_message_unpack (&streaming_protobufs__uenrmeasurement__descriptor,
  89                                 allocator, len, data);
  90 }
  91 void   streaming_protobufs__uenrmeasurement__free_unpacked
  92                      (StreamingProtobufs__UENRMeasurement *message,
  93                       ProtobufCAllocator *allocator)
  94 {
  95   if(!message)
  96     return;
  97   assert(message->base.descriptor == &streaming_protobufs__uenrmeasurement__descriptor);
  98   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  99 }
 100 void   streaming_protobufs__split_srb__ext_ies__init
 101                      (StreamingProtobufs__SplitSRBExtIEs         *message)
 102 {
 103   static const StreamingProtobufs__SplitSRBExtIEs init_value = STREAMING_PROTOBUFS__SPLIT_SRB__EXT_IES__INIT;
 104   *message = init_value;
 105 }
 106 size_t streaming_protobufs__split_srb__ext_ies__get_packed_size
 107                      (const StreamingProtobufs__SplitSRBExtIEs *message)
 108 {
 109   assert(message->base.descriptor == &streaming_protobufs__split_srb__ext_ies__descriptor);
 110   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 111 }
 112 size_t streaming_protobufs__split_srb__ext_ies__pack
 113                      (const StreamingProtobufs__SplitSRBExtIEs *message,
 114                       uint8_t       *out)
 115 {
 116   assert(message->base.descriptor == &streaming_protobufs__split_srb__ext_ies__descriptor);
 117   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 118 }
 119 size_t streaming_protobufs__split_srb__ext_ies__pack_to_buffer
 120                      (const StreamingProtobufs__SplitSRBExtIEs *message,
 121                       ProtobufCBuffer *buffer)
 122 {
 123   assert(message->base.descriptor == &streaming_protobufs__split_srb__ext_ies__descriptor);
 124   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 125 }
 126 StreamingProtobufs__SplitSRBExtIEs *
 127        streaming_protobufs__split_srb__ext_ies__unpack
 128                      (ProtobufCAllocator  *allocator,
 129                       size_t               len,
 130                       const uint8_t       *data)
 131 {
 132   return (StreamingProtobufs__SplitSRBExtIEs *)
 133      protobuf_c_message_unpack (&streaming_protobufs__split_srb__ext_ies__descriptor,
 134                                 allocator, len, data);
 135 }
 136 void   streaming_protobufs__split_srb__ext_ies__free_unpacked
 137                      (StreamingProtobufs__SplitSRBExtIEs *message,
 138                       ProtobufCAllocator *allocator)
 139 {
 140   if(!message)
 141     return;
 142   assert(message->base.descriptor == &streaming_protobufs__split_srb__ext_ies__descriptor);
 143   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 144 }
 145 void   streaming_protobufs__delivery_status__ext_ies__init
 146                      (StreamingProtobufs__DeliveryStatusExtIEs         *message)
 147 {
 148   static const StreamingProtobufs__DeliveryStatusExtIEs init_value = STREAMING_PROTOBUFS__DELIVERY_STATUS__EXT_IES__INIT;
 149   *message = init_value;
 150 }
 151 size_t streaming_protobufs__delivery_status__ext_ies__get_packed_size
 152                      (const StreamingProtobufs__DeliveryStatusExtIEs *message)
 153 {
 154   assert(message->base.descriptor == &streaming_protobufs__delivery_status__ext_ies__descriptor);
 155   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 156 }
 157 size_t streaming_protobufs__delivery_status__ext_ies__pack
 158                      (const StreamingProtobufs__DeliveryStatusExtIEs *message,
 159                       uint8_t       *out)
 160 {
 161   assert(message->base.descriptor == &streaming_protobufs__delivery_status__ext_ies__descriptor);
 162   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 163 }
 164 size_t streaming_protobufs__delivery_status__ext_ies__pack_to_buffer
 165                      (const StreamingProtobufs__DeliveryStatusExtIEs *message,
 166                       ProtobufCBuffer *buffer)
 167 {
 168   assert(message->base.descriptor == &streaming_protobufs__delivery_status__ext_ies__descriptor);
 169   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 170 }
 171 StreamingProtobufs__DeliveryStatusExtIEs *
 172        streaming_protobufs__delivery_status__ext_ies__unpack
 173                      (ProtobufCAllocator  *allocator,
 174                       size_t               len,
 175                       const uint8_t       *data)
 176 {
 177   return (StreamingProtobufs__DeliveryStatusExtIEs *)
 178      protobuf_c_message_unpack (&streaming_protobufs__delivery_status__ext_ies__descriptor,
 179                                 allocator, len, data);
 180 }
 181 void   streaming_protobufs__delivery_status__ext_ies__free_unpacked
 182                      (StreamingProtobufs__DeliveryStatusExtIEs *message,
 183                       ProtobufCAllocator *allocator)
 184 {
 185   if(!message)
 186     return;
 187   assert(message->base.descriptor == &streaming_protobufs__delivery_status__ext_ies__descriptor);
 188   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 189 }
 190 void   streaming_protobufs__delivery_status__init
 191                      (StreamingProtobufs__DeliveryStatus         *message)
 192 {
 193   static const StreamingProtobufs__DeliveryStatus init_value = STREAMING_PROTOBUFS__DELIVERY_STATUS__INIT;
 194   *message = init_value;
 195 }
 196 size_t streaming_protobufs__delivery_status__get_packed_size
 197                      (const StreamingProtobufs__DeliveryStatus *message)
 198 {
 199   assert(message->base.descriptor == &streaming_protobufs__delivery_status__descriptor);
 200   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 201 }
 202 size_t streaming_protobufs__delivery_status__pack
 203                      (const StreamingProtobufs__DeliveryStatus *message,
 204                       uint8_t       *out)
 205 {
 206   assert(message->base.descriptor == &streaming_protobufs__delivery_status__descriptor);
 207   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 208 }
 209 size_t streaming_protobufs__delivery_status__pack_to_buffer
 210                      (const StreamingProtobufs__DeliveryStatus *message,
 211                       ProtobufCBuffer *buffer)
 212 {
 213   assert(message->base.descriptor == &streaming_protobufs__delivery_status__descriptor);
 214   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 215 }
 216 StreamingProtobufs__DeliveryStatus *
 217        streaming_protobufs__delivery_status__unpack
 218                      (ProtobufCAllocator  *allocator,
 219                       size_t               len,
 220                       const uint8_t       *data)
 221 {
 222   return (StreamingProtobufs__DeliveryStatus *)
 223      protobuf_c_message_unpack (&streaming_protobufs__delivery_status__descriptor,
 224                                 allocator, len, data);
 225 }
 226 void   streaming_protobufs__delivery_status__free_unpacked
 227                      (StreamingProtobufs__DeliveryStatus *message,
 228                       ProtobufCAllocator *allocator)
 229 {
 230   if(!message)
 231     return;
 232   assert(message->base.descriptor == &streaming_protobufs__delivery_status__descriptor);
 233   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 234 }
 235 void   streaming_protobufs__split_srb__init
 236                      (StreamingProtobufs__SplitSRB         *message)
 237 {
 238   static const StreamingProtobufs__SplitSRB init_value = STREAMING_PROTOBUFS__SPLIT_SRB__INIT;
 239   *message = init_value;
 240 }
 241 size_t streaming_protobufs__split_srb__get_packed_size
 242                      (const StreamingProtobufs__SplitSRB *message)
 243 {
 244   assert(message->base.descriptor == &streaming_protobufs__split_srb__descriptor);
 245   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 246 }
 247 size_t streaming_protobufs__split_srb__pack
 248                      (const StreamingProtobufs__SplitSRB *message,
 249                       uint8_t       *out)
 250 {
 251   assert(message->base.descriptor == &streaming_protobufs__split_srb__descriptor);
 252   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 253 }
 254 size_t streaming_protobufs__split_srb__pack_to_buffer
 255                      (const StreamingProtobufs__SplitSRB *message,
 256                       ProtobufCBuffer *buffer)
 257 {
 258   assert(message->base.descriptor == &streaming_protobufs__split_srb__descriptor);
 259   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 260 }
 261 StreamingProtobufs__SplitSRB *
 262        streaming_protobufs__split_srb__unpack
 263                      (ProtobufCAllocator  *allocator,
 264                       size_t               len,
 265                       const uint8_t       *data)
 266 {
 267   return (StreamingProtobufs__SplitSRB *)
 268      protobuf_c_message_unpack (&streaming_protobufs__split_srb__descriptor,
 269                                 allocator, len, data);
 270 }
 271 void   streaming_protobufs__split_srb__free_unpacked
 272                      (StreamingProtobufs__SplitSRB *message,
 273                       ProtobufCAllocator *allocator)
 274 {
 275   if(!message)
 276     return;
 277   assert(message->base.descriptor == &streaming_protobufs__split_srb__descriptor);
 278   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 279 }
 280 void   streaming_protobufs__rrctransfer__ies__init
 281                      (StreamingProtobufs__RRCTransferIEs         *message)
 282 {
 283   static const StreamingProtobufs__RRCTransferIEs init_value = STREAMING_PROTOBUFS__RRCTRANSFER__IES__INIT;
 284   *message = init_value;
 285 }
 286 size_t streaming_protobufs__rrctransfer__ies__get_packed_size
 287                      (const StreamingProtobufs__RRCTransferIEs *message)
 288 {
 289   assert(message->base.descriptor == &streaming_protobufs__rrctransfer__ies__descriptor);
 290   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 291 }
 292 size_t streaming_protobufs__rrctransfer__ies__pack
 293                      (const StreamingProtobufs__RRCTransferIEs *message,
 294                       uint8_t       *out)
 295 {
 296   assert(message->base.descriptor == &streaming_protobufs__rrctransfer__ies__descriptor);
 297   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 298 }
 299 size_t streaming_protobufs__rrctransfer__ies__pack_to_buffer
 300                      (const StreamingProtobufs__RRCTransferIEs *message,
 301                       ProtobufCBuffer *buffer)
 302 {
 303   assert(message->base.descriptor == &streaming_protobufs__rrctransfer__ies__descriptor);
 304   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 305 }
 306 StreamingProtobufs__RRCTransferIEs *
 307        streaming_protobufs__rrctransfer__ies__unpack
 308                      (ProtobufCAllocator  *allocator,
 309                       size_t               len,
 310                       const uint8_t       *data)
 311 {
 312   return (StreamingProtobufs__RRCTransferIEs *)
 313      protobuf_c_message_unpack (&streaming_protobufs__rrctransfer__ies__descriptor,
 314                                 allocator, len, data);
 315 }
 316 void   streaming_protobufs__rrctransfer__ies__free_unpacked
 317                      (StreamingProtobufs__RRCTransferIEs *message,
 318                       ProtobufCAllocator *allocator)
 319 {
 320   if(!message)
 321     return;
 322   assert(message->base.descriptor == &streaming_protobufs__rrctransfer__ies__descriptor);
 323   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 324 }
 325 void   streaming_protobufs__rrctransfer__init
 326                      (StreamingProtobufs__RRCTransfer         *message)
 327 {
 328   static const StreamingProtobufs__RRCTransfer init_value = STREAMING_PROTOBUFS__RRCTRANSFER__INIT;
 329   *message = init_value;
 330 }
 331 size_t streaming_protobufs__rrctransfer__get_packed_size
 332                      (const StreamingProtobufs__RRCTransfer *message)
 333 {
 334   assert(message->base.descriptor == &streaming_protobufs__rrctransfer__descriptor);
 335   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 336 }
 337 size_t streaming_protobufs__rrctransfer__pack
 338                      (const StreamingProtobufs__RRCTransfer *message,
 339                       uint8_t       *out)
 340 {
 341   assert(message->base.descriptor == &streaming_protobufs__rrctransfer__descriptor);
 342   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 343 }
 344 size_t streaming_protobufs__rrctransfer__pack_to_buffer
 345                      (const StreamingProtobufs__RRCTransfer *message,
 346                       ProtobufCBuffer *buffer)
 347 {
 348   assert(message->base.descriptor == &streaming_protobufs__rrctransfer__descriptor);
 349   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 350 }
 351 StreamingProtobufs__RRCTransfer *
 352        streaming_protobufs__rrctransfer__unpack
 353                      (ProtobufCAllocator  *allocator,
 354                       size_t               len,
 355                       const uint8_t       *data)
 356 {
 357   return (StreamingProtobufs__RRCTransfer *)
 358      protobuf_c_message_unpack (&streaming_protobufs__rrctransfer__descriptor,
 359                                 allocator, len, data);
 360 }
 361 void   streaming_protobufs__rrctransfer__free_unpacked
 362                      (StreamingProtobufs__RRCTransfer *message,
 363                       ProtobufCAllocator *allocator)
 364 {
 365   if(!message)
 366     return;
 367   assert(message->base.descriptor == &streaming_protobufs__rrctransfer__descriptor);
 368   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 369 }
 370 #define streaming_protobufs__uenrmeasurement__ext_ies__field_descriptors NULL
 371 #define streaming_protobufs__uenrmeasurement__ext_ies__field_indices_by_name NULL
 372 #define streaming_protobufs__uenrmeasurement__ext_ies__number_ranges NULL
 373 const ProtobufCMessageDescriptor streaming_protobufs__uenrmeasurement__ext_ies__descriptor =
 374 {
 375   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 376   "streaming_protobufs.UENRMeasurement_ExtIEs",
 377   "UENRMeasurementExtIEs",
 378   "StreamingProtobufs__UENRMeasurementExtIEs",
 379   "streaming_protobufs",
 380   sizeof(StreamingProtobufs__UENRMeasurementExtIEs),
 381   0,
 382   streaming_protobufs__uenrmeasurement__ext_ies__field_descriptors,
 383   streaming_protobufs__uenrmeasurement__ext_ies__field_indices_by_name,
 384   0,  streaming_protobufs__uenrmeasurement__ext_ies__number_ranges,
 385   (ProtobufCMessageInit) streaming_protobufs__uenrmeasurement__ext_ies__init,
 386   NULL,NULL,NULL    /* reserved[123] */
 387 };
 388 static const ProtobufCFieldDescriptor streaming_protobufs__uenrmeasurement__field_descriptors[2] =
 389 {
 390   {
 391     "uENRMeasurements",
 392     1,
 393     PROTOBUF_C_LABEL_NONE,
 394     PROTOBUF_C_TYPE_MESSAGE,
 395     0,   /* quantifier_offset */
 396     offsetof(StreamingProtobufs__UENRMeasurement, uenrmeasurements),
 397     &streaming_protobufs__rrccontainer__descriptor,
 398     NULL,
 399     0,             /* flags */
 400     0,NULL,NULL    /* reserved1,reserved2, etc */
 401   },
 402   {
 403     "iE_Extensions",
 404     2,
 405     PROTOBUF_C_LABEL_REPEATED,
 406     PROTOBUF_C_TYPE_MESSAGE,
 407     offsetof(StreamingProtobufs__UENRMeasurement, n_ie_extensions),
 408     offsetof(StreamingProtobufs__UENRMeasurement, ie_extensions),
 409     &streaming_protobufs__uenrmeasurement__ext_ies__descriptor,
 410     NULL,
 411     0,             /* flags */
 412     0,NULL,NULL    /* reserved1,reserved2, etc */
 413   },
 414 };
 415 static const unsigned streaming_protobufs__uenrmeasurement__field_indices_by_name[] = {
 416   1,   /* field[1] = iE_Extensions */
 417   0,   /* field[0] = uENRMeasurements */
 418 };
 419 static const ProtobufCIntRange streaming_protobufs__uenrmeasurement__number_ranges[1 + 1] =
 420 {
 421   { 1, 0 },
 422   { 0, 2 }
 423 };
 424 const ProtobufCMessageDescriptor streaming_protobufs__uenrmeasurement__descriptor =
 425 {
 426   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 427   "streaming_protobufs.UENRMeasurement",
 428   "UENRMeasurement",
 429   "StreamingProtobufs__UENRMeasurement",
 430   "streaming_protobufs",
 431   sizeof(StreamingProtobufs__UENRMeasurement),
 432   2,
 433   streaming_protobufs__uenrmeasurement__field_descriptors,
 434   streaming_protobufs__uenrmeasurement__field_indices_by_name,
 435   1,  streaming_protobufs__uenrmeasurement__number_ranges,
 436   (ProtobufCMessageInit) streaming_protobufs__uenrmeasurement__init,
 437   NULL,NULL,NULL    /* reserved[123] */
 438 };
 439 #define streaming_protobufs__split_srb__ext_ies__field_descriptors NULL
 440 #define streaming_protobufs__split_srb__ext_ies__field_indices_by_name NULL
 441 #define streaming_protobufs__split_srb__ext_ies__number_ranges NULL
 442 const ProtobufCMessageDescriptor streaming_protobufs__split_srb__ext_ies__descriptor =
 443 {
 444   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 445   "streaming_protobufs.SplitSRB_ExtIEs",
 446   "SplitSRBExtIEs",
 447   "StreamingProtobufs__SplitSRBExtIEs",
 448   "streaming_protobufs",
 449   sizeof(StreamingProtobufs__SplitSRBExtIEs),
 450   0,
 451   streaming_protobufs__split_srb__ext_ies__field_descriptors,
 452   streaming_protobufs__split_srb__ext_ies__field_indices_by_name,
 453   0,  streaming_protobufs__split_srb__ext_ies__number_ranges,
 454   (ProtobufCMessageInit) streaming_protobufs__split_srb__ext_ies__init,
 455   NULL,NULL,NULL    /* reserved[123] */
 456 };
 457 #define streaming_protobufs__delivery_status__ext_ies__field_descriptors NULL
 458 #define streaming_protobufs__delivery_status__ext_ies__field_indices_by_name NULL
 459 #define streaming_protobufs__delivery_status__ext_ies__number_ranges NULL
 460 const ProtobufCMessageDescriptor streaming_protobufs__delivery_status__ext_ies__descriptor =
 461 {
 462   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 463   "streaming_protobufs.DeliveryStatus_ExtIEs",
 464   "DeliveryStatusExtIEs",
 465   "StreamingProtobufs__DeliveryStatusExtIEs",
 466   "streaming_protobufs",
 467   sizeof(StreamingProtobufs__DeliveryStatusExtIEs),
 468   0,
 469   streaming_protobufs__delivery_status__ext_ies__field_descriptors,
 470   streaming_protobufs__delivery_status__ext_ies__field_indices_by_name,
 471   0,  streaming_protobufs__delivery_status__ext_ies__number_ranges,
 472   (ProtobufCMessageInit) streaming_protobufs__delivery_status__ext_ies__init,
 473   NULL,NULL,NULL    /* reserved[123] */
 474 };
 475 static const ProtobufCFieldDescriptor streaming_protobufs__delivery_status__field_descriptors[2] =
 476 {
 477   {
 478     "highestSuccessDeliveredPDCPSN",
 479     1,
 480     PROTOBUF_C_LABEL_NONE,
 481     PROTOBUF_C_TYPE_UINT32,
 482     0,   /* quantifier_offset */
 483     offsetof(StreamingProtobufs__DeliveryStatus, highestsuccessdeliveredpdcpsn),
 484     NULL,
 485     NULL,
 486     0,             /* flags */
 487     0,NULL,NULL    /* reserved1,reserved2, etc */
 488   },
 489   {
 490     "iE_Extensions",
 491     2,
 492     PROTOBUF_C_LABEL_REPEATED,
 493     PROTOBUF_C_TYPE_MESSAGE,
 494     offsetof(StreamingProtobufs__DeliveryStatus, n_ie_extensions),
 495     offsetof(StreamingProtobufs__DeliveryStatus, ie_extensions),
 496     &streaming_protobufs__delivery_status__ext_ies__descriptor,
 497     NULL,
 498     0,             /* flags */
 499     0,NULL,NULL    /* reserved1,reserved2, etc */
 500   },
 501 };
 502 static const unsigned streaming_protobufs__delivery_status__field_indices_by_name[] = {
 503   0,   /* field[0] = highestSuccessDeliveredPDCPSN */
 504   1,   /* field[1] = iE_Extensions */
 505 };
 506 static const ProtobufCIntRange streaming_protobufs__delivery_status__number_ranges[1 + 1] =
 507 {
 508   { 1, 0 },
 509   { 0, 2 }
 510 };
 511 const ProtobufCMessageDescriptor streaming_protobufs__delivery_status__descriptor =
 512 {
 513   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 514   "streaming_protobufs.DeliveryStatus",
 515   "DeliveryStatus",
 516   "StreamingProtobufs__DeliveryStatus",
 517   "streaming_protobufs",
 518   sizeof(StreamingProtobufs__DeliveryStatus),
 519   2,
 520   streaming_protobufs__delivery_status__field_descriptors,
 521   streaming_protobufs__delivery_status__field_indices_by_name,
 522   1,  streaming_protobufs__delivery_status__number_ranges,
 523   (ProtobufCMessageInit) streaming_protobufs__delivery_status__init,
 524   NULL,NULL,NULL    /* reserved[123] */
 525 };
 526 static const ProtobufCEnumValue streaming_protobufs__split_srb__srbtype__enum_values_by_number[3] =
 527 {
 528   { "protobuf_unspecified", "STREAMING_PROTOBUFS__SPLIT_SRB__SRBTYPE__protobuf_unspecified", 0 },
 529   { "srb1", "STREAMING_PROTOBUFS__SPLIT_SRB__SRBTYPE__srb1", 1 },
 530   { "srb2", "STREAMING_PROTOBUFS__SPLIT_SRB__SRBTYPE__srb2", 2 },
 531 };
 532 static const ProtobufCIntRange streaming_protobufs__split_srb__srbtype__value_ranges[] = {
 533 {0, 0},{0, 3}
 534 };
 535 static const ProtobufCEnumValueIndex streaming_protobufs__split_srb__srbtype__enum_values_by_name[3] =
 536 {
 537   { "protobuf_unspecified", 0 },
 538   { "srb1", 1 },
 539   { "srb2", 2 },
 540 };
 541 const ProtobufCEnumDescriptor streaming_protobufs__split_srb__srbtype__descriptor =
 542 {
 543   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
 544   "streaming_protobufs.SplitSRB.SRBType",
 545   "SRBType",
 546   "StreamingProtobufs__SplitSRB__SRBType",
 547   "streaming_protobufs",
 548   3,
 549   streaming_protobufs__split_srb__srbtype__enum_values_by_number,
 550   3,
 551   streaming_protobufs__split_srb__srbtype__enum_values_by_name,
 552   1,
 553   streaming_protobufs__split_srb__srbtype__value_ranges,
 554   NULL,NULL,NULL,NULL   /* reserved[1234] */
 555 };
 556 static const ProtobufCFieldDescriptor streaming_protobufs__split_srb__field_descriptors[4] =
 557 {
 558   {
 559     "rrcContainer",
 560     1,
 561     PROTOBUF_C_LABEL_NONE,
 562     PROTOBUF_C_TYPE_MESSAGE,
 563     0,   /* quantifier_offset */
 564     offsetof(StreamingProtobufs__SplitSRB, rrccontainer),
 565     &streaming_protobufs__rrccontainer__descriptor,
 566     NULL,
 567     0,             /* flags */
 568     0,NULL,NULL    /* reserved1,reserved2, etc */
 569   },
 570   {
 571     "srbType",
 572     2,
 573     PROTOBUF_C_LABEL_NONE,
 574     PROTOBUF_C_TYPE_ENUM,
 575     0,   /* quantifier_offset */
 576     offsetof(StreamingProtobufs__SplitSRB, srbtype),
 577     &streaming_protobufs__split_srb__srbtype__descriptor,
 578     NULL,
 579     0,             /* flags */
 580     0,NULL,NULL    /* reserved1,reserved2, etc */
 581   },
 582   {
 583     "deliveryStatus",
 584     3,
 585     PROTOBUF_C_LABEL_NONE,
 586     PROTOBUF_C_TYPE_MESSAGE,
 587     0,   /* quantifier_offset */
 588     offsetof(StreamingProtobufs__SplitSRB, deliverystatus),
 589     &streaming_protobufs__delivery_status__descriptor,
 590     NULL,
 591     0,             /* flags */
 592     0,NULL,NULL    /* reserved1,reserved2, etc */
 593   },
 594   {
 595     "iE_Extensions",
 596     4,
 597     PROTOBUF_C_LABEL_REPEATED,
 598     PROTOBUF_C_TYPE_MESSAGE,
 599     offsetof(StreamingProtobufs__SplitSRB, n_ie_extensions),
 600     offsetof(StreamingProtobufs__SplitSRB, ie_extensions),
 601     &streaming_protobufs__split_srb__ext_ies__descriptor,
 602     NULL,
 603     0,             /* flags */
 604     0,NULL,NULL    /* reserved1,reserved2, etc */
 605   },
 606 };
 607 static const unsigned streaming_protobufs__split_srb__field_indices_by_name[] = {
 608   2,   /* field[2] = deliveryStatus */
 609   3,   /* field[3] = iE_Extensions */
 610   0,   /* field[0] = rrcContainer */
 611   1,   /* field[1] = srbType */
 612 };
 613 static const ProtobufCIntRange streaming_protobufs__split_srb__number_ranges[1 + 1] =
 614 {
 615   { 1, 0 },
 616   { 0, 4 }
 617 };
 618 const ProtobufCMessageDescriptor streaming_protobufs__split_srb__descriptor =
 619 {
 620   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 621   "streaming_protobufs.SplitSRB",
 622   "SplitSRB",
 623   "StreamingProtobufs__SplitSRB",
 624   "streaming_protobufs",
 625   sizeof(StreamingProtobufs__SplitSRB),
 626   4,
 627   streaming_protobufs__split_srb__field_descriptors,
 628   streaming_protobufs__split_srb__field_indices_by_name,
 629   1,  streaming_protobufs__split_srb__number_ranges,
 630   (ProtobufCMessageInit) streaming_protobufs__split_srb__init,
 631   NULL,NULL,NULL    /* reserved[123] */
 632 };
 633 static const ProtobufCFieldDescriptor streaming_protobufs__rrctransfer__ies__field_descriptors[5] =
 634 {
 635   {
 636     "id_MeNB_UE_X2AP_ID",
 637     1,
 638     PROTOBUF_C_LABEL_NONE,
 639     PROTOBUF_C_TYPE_UINT32,
 640     0,   /* quantifier_offset */
 641     offsetof(StreamingProtobufs__RRCTransferIEs, id_menb_ue_x2ap_id),
 642     NULL,
 643     NULL,
 644     0,             /* flags */
 645     0,NULL,NULL    /* reserved1,reserved2, etc */
 646   },
 647   {
 648     "id_SgNB_UE_X2AP_ID",
 649     2,
 650     PROTOBUF_C_LABEL_NONE,
 651     PROTOBUF_C_TYPE_UINT32,
 652     0,   /* quantifier_offset */
 653     offsetof(StreamingProtobufs__RRCTransferIEs, id_sgnb_ue_x2ap_id),
 654     NULL,
 655     NULL,
 656     0,             /* flags */
 657     0,NULL,NULL    /* reserved1,reserved2, etc */
 658   },
 659   {
 660     "id_SplitSRB",
 661     3,
 662     PROTOBUF_C_LABEL_NONE,
 663     PROTOBUF_C_TYPE_MESSAGE,
 664     0,   /* quantifier_offset */
 665     offsetof(StreamingProtobufs__RRCTransferIEs, id_splitsrb),
 666     &streaming_protobufs__split_srb__descriptor,
 667     NULL,
 668     0,             /* flags */
 669     0,NULL,NULL    /* reserved1,reserved2, etc */
 670   },
 671   {
 672     "id_UENRMeasurement",
 673     4,
 674     PROTOBUF_C_LABEL_NONE,
 675     PROTOBUF_C_TYPE_MESSAGE,
 676     0,   /* quantifier_offset */
 677     offsetof(StreamingProtobufs__RRCTransferIEs, id_uenrmeasurement),
 678     &streaming_protobufs__uenrmeasurement__descriptor,
 679     NULL,
 680     0,             /* flags */
 681     0,NULL,NULL    /* reserved1,reserved2, etc */
 682   },
 683   {
 684     "id_MeNB_UE_X2AP_ID_Extension",
 685     5,
 686     PROTOBUF_C_LABEL_NONE,
 687     PROTOBUF_C_TYPE_MESSAGE,
 688     0,   /* quantifier_offset */
 689     offsetof(StreamingProtobufs__RRCTransferIEs, id_menb_ue_x2ap_id_extension),
 690     &google__protobuf__uint32_value__descriptor,
 691     NULL,
 692     0,             /* flags */
 693     0,NULL,NULL    /* reserved1,reserved2, etc */
 694   },
 695 };
 696 static const unsigned streaming_protobufs__rrctransfer__ies__field_indices_by_name[] = {
 697   0,   /* field[0] = id_MeNB_UE_X2AP_ID */
 698   4,   /* field[4] = id_MeNB_UE_X2AP_ID_Extension */
 699   1,   /* field[1] = id_SgNB_UE_X2AP_ID */
 700   2,   /* field[2] = id_SplitSRB */
 701   3,   /* field[3] = id_UENRMeasurement */
 702 };
 703 static const ProtobufCIntRange streaming_protobufs__rrctransfer__ies__number_ranges[1 + 1] =
 704 {
 705   { 1, 0 },
 706   { 0, 5 }
 707 };
 708 const ProtobufCMessageDescriptor streaming_protobufs__rrctransfer__ies__descriptor =
 709 {
 710   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 711   "streaming_protobufs.RRCTransfer_IEs",
 712   "RRCTransferIEs",
 713   "StreamingProtobufs__RRCTransferIEs",
 714   "streaming_protobufs",
 715   sizeof(StreamingProtobufs__RRCTransferIEs),
 716   5,
 717   streaming_protobufs__rrctransfer__ies__field_descriptors,
 718   streaming_protobufs__rrctransfer__ies__field_indices_by_name,
 719   1,  streaming_protobufs__rrctransfer__ies__number_ranges,
 720   (ProtobufCMessageInit) streaming_protobufs__rrctransfer__ies__init,
 721   NULL,NULL,NULL    /* reserved[123] */
 722 };
 723 static const ProtobufCFieldDescriptor streaming_protobufs__rrctransfer__field_descriptors[1] =
 724 {
 725   {
 726     "rrcTransfer_IEs",
 727     1,
 728     PROTOBUF_C_LABEL_NONE,
 729     PROTOBUF_C_TYPE_MESSAGE,
 730     0,   /* quantifier_offset */
 731     offsetof(StreamingProtobufs__RRCTransfer, rrctransfer_ies),
 732     &streaming_protobufs__rrctransfer__ies__descriptor,
 733     NULL,
 734     0,             /* flags */
 735     0,NULL,NULL    /* reserved1,reserved2, etc */
 736   },
 737 };
 738 static const unsigned streaming_protobufs__rrctransfer__field_indices_by_name[] = {
 739   0,   /* field[0] = rrcTransfer_IEs */
 740 };
 741 static const ProtobufCIntRange streaming_protobufs__rrctransfer__number_ranges[1 + 1] =
 742 {
 743   { 1, 0 },
 744   { 0, 1 }
 745 };
 746 const ProtobufCMessageDescriptor streaming_protobufs__rrctransfer__descriptor =
 747 {
 748   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 749   "streaming_protobufs.RRCTransfer",
 750   "RRCTransfer",
 751   "StreamingProtobufs__RRCTransfer",
 752   "streaming_protobufs",
 753   sizeof(StreamingProtobufs__RRCTransfer),
 754   1,
 755   streaming_protobufs__rrctransfer__field_descriptors,
 756   streaming_protobufs__rrctransfer__field_indices_by_name,
 757   1,  streaming_protobufs__rrctransfer__number_ranges,
 758   (ProtobufCMessageInit) streaming_protobufs__rrctransfer__init,
 759   NULL,NULL,NULL    /* reserved[123] */
 760 };