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

   1 /* Generated by the protocol buffer compiler.  DO NOT EDIT! */
   2 /* Generated from: common_types.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 "common_types.pb-c.h"
  10 void   streaming_protobufs__null__init
  11                      (StreamingProtobufs__Null         *message)
  12 {
  13   static const StreamingProtobufs__Null init_value = STREAMING_PROTOBUFS__NULL__INIT;
  14   *message = init_value;
  15 }
  16 size_t streaming_protobufs__null__get_packed_size
  17                      (const StreamingProtobufs__Null *message)
  18 {
  19   assert(message->base.descriptor == &streaming_protobufs__null__descriptor);
  20   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  21 }
  22 size_t streaming_protobufs__null__pack
  23                      (const StreamingProtobufs__Null *message,
  24                       uint8_t       *out)
  25 {
  26   assert(message->base.descriptor == &streaming_protobufs__null__descriptor);
  27   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  28 }
  29 size_t streaming_protobufs__null__pack_to_buffer
  30                      (const StreamingProtobufs__Null *message,
  31                       ProtobufCBuffer *buffer)
  32 {
  33   assert(message->base.descriptor == &streaming_protobufs__null__descriptor);
  34   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  35 }
  36 StreamingProtobufs__Null *
  37        streaming_protobufs__null__unpack
  38                      (ProtobufCAllocator  *allocator,
  39                       size_t               len,
  40                       const uint8_t       *data)
  41 {
  42   return (StreamingProtobufs__Null *)
  43      protobuf_c_message_unpack (&streaming_protobufs__null__descriptor,
  44                                 allocator, len, data);
  45 }
  46 void   streaming_protobufs__null__free_unpacked
  47                      (StreamingProtobufs__Null *message,
  48                       ProtobufCAllocator *allocator)
  49 {
  50   if(!message)
  51     return;
  52   assert(message->base.descriptor == &streaming_protobufs__null__descriptor);
  53   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  54 }
  55 void   streaming_protobufs__configured_opt__init
  56                      (StreamingProtobufs__ConfiguredOpt         *message)
  57 {
  58   static const StreamingProtobufs__ConfiguredOpt init_value = STREAMING_PROTOBUFS__CONFIGURED_OPT__INIT;
  59   *message = init_value;
  60 }
  61 size_t streaming_protobufs__configured_opt__get_packed_size
  62                      (const StreamingProtobufs__ConfiguredOpt *message)
  63 {
  64   assert(message->base.descriptor == &streaming_protobufs__configured_opt__descriptor);
  65   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
  66 }
  67 size_t streaming_protobufs__configured_opt__pack
  68                      (const StreamingProtobufs__ConfiguredOpt *message,
  69                       uint8_t       *out)
  70 {
  71   assert(message->base.descriptor == &streaming_protobufs__configured_opt__descriptor);
  72   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
  73 }
  74 size_t streaming_protobufs__configured_opt__pack_to_buffer
  75                      (const StreamingProtobufs__ConfiguredOpt *message,
  76                       ProtobufCBuffer *buffer)
  77 {
  78   assert(message->base.descriptor == &streaming_protobufs__configured_opt__descriptor);
  79   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
  80 }
  81 StreamingProtobufs__ConfiguredOpt *
  82        streaming_protobufs__configured_opt__unpack
  83                      (ProtobufCAllocator  *allocator,
  84                       size_t               len,
  85                       const uint8_t       *data)
  86 {
  87   return (StreamingProtobufs__ConfiguredOpt *)
  88      protobuf_c_message_unpack (&streaming_protobufs__configured_opt__descriptor,
  89                                 allocator, len, data);
  90 }
  91 void   streaming_protobufs__configured_opt__free_unpacked
  92                      (StreamingProtobufs__ConfiguredOpt *message,
  93                       ProtobufCAllocator *allocator)
  94 {
  95   if(!message)
  96     return;
  97   assert(message->base.descriptor == &streaming_protobufs__configured_opt__descriptor);
  98   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
  99 }
 100 void   streaming_protobufs__true_opt__init
 101                      (StreamingProtobufs__TrueOpt         *message)
 102 {
 103   static const StreamingProtobufs__TrueOpt init_value = STREAMING_PROTOBUFS__TRUE_OPT__INIT;
 104   *message = init_value;
 105 }
 106 size_t streaming_protobufs__true_opt__get_packed_size
 107                      (const StreamingProtobufs__TrueOpt *message)
 108 {
 109   assert(message->base.descriptor == &streaming_protobufs__true_opt__descriptor);
 110   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 111 }
 112 size_t streaming_protobufs__true_opt__pack
 113                      (const StreamingProtobufs__TrueOpt *message,
 114                       uint8_t       *out)
 115 {
 116   assert(message->base.descriptor == &streaming_protobufs__true_opt__descriptor);
 117   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 118 }
 119 size_t streaming_protobufs__true_opt__pack_to_buffer
 120                      (const StreamingProtobufs__TrueOpt *message,
 121                       ProtobufCBuffer *buffer)
 122 {
 123   assert(message->base.descriptor == &streaming_protobufs__true_opt__descriptor);
 124   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 125 }
 126 StreamingProtobufs__TrueOpt *
 127        streaming_protobufs__true_opt__unpack
 128                      (ProtobufCAllocator  *allocator,
 129                       size_t               len,
 130                       const uint8_t       *data)
 131 {
 132   return (StreamingProtobufs__TrueOpt *)
 133      protobuf_c_message_unpack (&streaming_protobufs__true_opt__descriptor,
 134                                 allocator, len, data);
 135 }
 136 void   streaming_protobufs__true_opt__free_unpacked
 137                      (StreamingProtobufs__TrueOpt *message,
 138                       ProtobufCAllocator *allocator)
 139 {
 140   if(!message)
 141     return;
 142   assert(message->base.descriptor == &streaming_protobufs__true_opt__descriptor);
 143   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 144 }
 145 void   streaming_protobufs__false_opt__init
 146                      (StreamingProtobufs__FalseOpt         *message)
 147 {
 148   static const StreamingProtobufs__FalseOpt init_value = STREAMING_PROTOBUFS__FALSE_OPT__INIT;
 149   *message = init_value;
 150 }
 151 size_t streaming_protobufs__false_opt__get_packed_size
 152                      (const StreamingProtobufs__FalseOpt *message)
 153 {
 154   assert(message->base.descriptor == &streaming_protobufs__false_opt__descriptor);
 155   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 156 }
 157 size_t streaming_protobufs__false_opt__pack
 158                      (const StreamingProtobufs__FalseOpt *message,
 159                       uint8_t       *out)
 160 {
 161   assert(message->base.descriptor == &streaming_protobufs__false_opt__descriptor);
 162   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 163 }
 164 size_t streaming_protobufs__false_opt__pack_to_buffer
 165                      (const StreamingProtobufs__FalseOpt *message,
 166                       ProtobufCBuffer *buffer)
 167 {
 168   assert(message->base.descriptor == &streaming_protobufs__false_opt__descriptor);
 169   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 170 }
 171 StreamingProtobufs__FalseOpt *
 172        streaming_protobufs__false_opt__unpack
 173                      (ProtobufCAllocator  *allocator,
 174                       size_t               len,
 175                       const uint8_t       *data)
 176 {
 177   return (StreamingProtobufs__FalseOpt *)
 178      protobuf_c_message_unpack (&streaming_protobufs__false_opt__descriptor,
 179                                 allocator, len, data);
 180 }
 181 void   streaming_protobufs__false_opt__free_unpacked
 182                      (StreamingProtobufs__FalseOpt *message,
 183                       ProtobufCAllocator *allocator)
 184 {
 185   if(!message)
 186     return;
 187   assert(message->base.descriptor == &streaming_protobufs__false_opt__descriptor);
 188   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 189 }
 190 void   streaming_protobufs__enabled_opt__init
 191                      (StreamingProtobufs__EnabledOpt         *message)
 192 {
 193   static const StreamingProtobufs__EnabledOpt init_value = STREAMING_PROTOBUFS__ENABLED_OPT__INIT;
 194   *message = init_value;
 195 }
 196 size_t streaming_protobufs__enabled_opt__get_packed_size
 197                      (const StreamingProtobufs__EnabledOpt *message)
 198 {
 199   assert(message->base.descriptor == &streaming_protobufs__enabled_opt__descriptor);
 200   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 201 }
 202 size_t streaming_protobufs__enabled_opt__pack
 203                      (const StreamingProtobufs__EnabledOpt *message,
 204                       uint8_t       *out)
 205 {
 206   assert(message->base.descriptor == &streaming_protobufs__enabled_opt__descriptor);
 207   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 208 }
 209 size_t streaming_protobufs__enabled_opt__pack_to_buffer
 210                      (const StreamingProtobufs__EnabledOpt *message,
 211                       ProtobufCBuffer *buffer)
 212 {
 213   assert(message->base.descriptor == &streaming_protobufs__enabled_opt__descriptor);
 214   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 215 }
 216 StreamingProtobufs__EnabledOpt *
 217        streaming_protobufs__enabled_opt__unpack
 218                      (ProtobufCAllocator  *allocator,
 219                       size_t               len,
 220                       const uint8_t       *data)
 221 {
 222   return (StreamingProtobufs__EnabledOpt *)
 223      protobuf_c_message_unpack (&streaming_protobufs__enabled_opt__descriptor,
 224                                 allocator, len, data);
 225 }
 226 void   streaming_protobufs__enabled_opt__free_unpacked
 227                      (StreamingProtobufs__EnabledOpt *message,
 228                       ProtobufCAllocator *allocator)
 229 {
 230   if(!message)
 231     return;
 232   assert(message->base.descriptor == &streaming_protobufs__enabled_opt__descriptor);
 233   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 234 }
 235 void   streaming_protobufs__disabled_opt__init
 236                      (StreamingProtobufs__DisabledOpt         *message)
 237 {
 238   static const StreamingProtobufs__DisabledOpt init_value = STREAMING_PROTOBUFS__DISABLED_OPT__INIT;
 239   *message = init_value;
 240 }
 241 size_t streaming_protobufs__disabled_opt__get_packed_size
 242                      (const StreamingProtobufs__DisabledOpt *message)
 243 {
 244   assert(message->base.descriptor == &streaming_protobufs__disabled_opt__descriptor);
 245   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 246 }
 247 size_t streaming_protobufs__disabled_opt__pack
 248                      (const StreamingProtobufs__DisabledOpt *message,
 249                       uint8_t       *out)
 250 {
 251   assert(message->base.descriptor == &streaming_protobufs__disabled_opt__descriptor);
 252   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 253 }
 254 size_t streaming_protobufs__disabled_opt__pack_to_buffer
 255                      (const StreamingProtobufs__DisabledOpt *message,
 256                       ProtobufCBuffer *buffer)
 257 {
 258   assert(message->base.descriptor == &streaming_protobufs__disabled_opt__descriptor);
 259   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 260 }
 261 StreamingProtobufs__DisabledOpt *
 262        streaming_protobufs__disabled_opt__unpack
 263                      (ProtobufCAllocator  *allocator,
 264                       size_t               len,
 265                       const uint8_t       *data)
 266 {
 267   return (StreamingProtobufs__DisabledOpt *)
 268      protobuf_c_message_unpack (&streaming_protobufs__disabled_opt__descriptor,
 269                                 allocator, len, data);
 270 }
 271 void   streaming_protobufs__disabled_opt__free_unpacked
 272                      (StreamingProtobufs__DisabledOpt *message,
 273                       ProtobufCAllocator *allocator)
 274 {
 275   if(!message)
 276     return;
 277   assert(message->base.descriptor == &streaming_protobufs__disabled_opt__descriptor);
 278   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 279 }
 280 void   streaming_protobufs__enabled_disabled_opt__init
 281                      (StreamingProtobufs__EnabledDisabledOpt         *message)
 282 {
 283   static const StreamingProtobufs__EnabledDisabledOpt init_value = STREAMING_PROTOBUFS__ENABLED_DISABLED_OPT__INIT;
 284   *message = init_value;
 285 }
 286 size_t streaming_protobufs__enabled_disabled_opt__get_packed_size
 287                      (const StreamingProtobufs__EnabledDisabledOpt *message)
 288 {
 289   assert(message->base.descriptor == &streaming_protobufs__enabled_disabled_opt__descriptor);
 290   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 291 }
 292 size_t streaming_protobufs__enabled_disabled_opt__pack
 293                      (const StreamingProtobufs__EnabledDisabledOpt *message,
 294                       uint8_t       *out)
 295 {
 296   assert(message->base.descriptor == &streaming_protobufs__enabled_disabled_opt__descriptor);
 297   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 298 }
 299 size_t streaming_protobufs__enabled_disabled_opt__pack_to_buffer
 300                      (const StreamingProtobufs__EnabledDisabledOpt *message,
 301                       ProtobufCBuffer *buffer)
 302 {
 303   assert(message->base.descriptor == &streaming_protobufs__enabled_disabled_opt__descriptor);
 304   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 305 }
 306 StreamingProtobufs__EnabledDisabledOpt *
 307        streaming_protobufs__enabled_disabled_opt__unpack
 308                      (ProtobufCAllocator  *allocator,
 309                       size_t               len,
 310                       const uint8_t       *data)
 311 {
 312   return (StreamingProtobufs__EnabledDisabledOpt *)
 313      protobuf_c_message_unpack (&streaming_protobufs__enabled_disabled_opt__descriptor,
 314                                 allocator, len, data);
 315 }
 316 void   streaming_protobufs__enabled_disabled_opt__free_unpacked
 317                      (StreamingProtobufs__EnabledDisabledOpt *message,
 318                       ProtobufCAllocator *allocator)
 319 {
 320   if(!message)
 321     return;
 322   assert(message->base.descriptor == &streaming_protobufs__enabled_disabled_opt__descriptor);
 323   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 324 }
 325 void   streaming_protobufs__on_off_opt__init
 326                      (StreamingProtobufs__OnOffOpt         *message)
 327 {
 328   static const StreamingProtobufs__OnOffOpt init_value = STREAMING_PROTOBUFS__ON_OFF_OPT__INIT;
 329   *message = init_value;
 330 }
 331 size_t streaming_protobufs__on_off_opt__get_packed_size
 332                      (const StreamingProtobufs__OnOffOpt *message)
 333 {
 334   assert(message->base.descriptor == &streaming_protobufs__on_off_opt__descriptor);
 335   return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
 336 }
 337 size_t streaming_protobufs__on_off_opt__pack
 338                      (const StreamingProtobufs__OnOffOpt *message,
 339                       uint8_t       *out)
 340 {
 341   assert(message->base.descriptor == &streaming_protobufs__on_off_opt__descriptor);
 342   return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
 343 }
 344 size_t streaming_protobufs__on_off_opt__pack_to_buffer
 345                      (const StreamingProtobufs__OnOffOpt *message,
 346                       ProtobufCBuffer *buffer)
 347 {
 348   assert(message->base.descriptor == &streaming_protobufs__on_off_opt__descriptor);
 349   return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
 350 }
 351 StreamingProtobufs__OnOffOpt *
 352        streaming_protobufs__on_off_opt__unpack
 353                      (ProtobufCAllocator  *allocator,
 354                       size_t               len,
 355                       const uint8_t       *data)
 356 {
 357   return (StreamingProtobufs__OnOffOpt *)
 358      protobuf_c_message_unpack (&streaming_protobufs__on_off_opt__descriptor,
 359                                 allocator, len, data);
 360 }
 361 void   streaming_protobufs__on_off_opt__free_unpacked
 362                      (StreamingProtobufs__OnOffOpt *message,
 363                       ProtobufCAllocator *allocator)
 364 {
 365   if(!message)
 366     return;
 367   assert(message->base.descriptor == &streaming_protobufs__on_off_opt__descriptor);
 368   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 369 }
 370 #define streaming_protobufs__null__field_descriptors NULL
 371 #define streaming_protobufs__null__field_indices_by_name NULL
 372 #define streaming_protobufs__null__number_ranges NULL
 373 const ProtobufCMessageDescriptor streaming_protobufs__null__descriptor =
 374 {
 375   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 376   "streaming_protobufs.Null",
 377   "Null",
 378   "StreamingProtobufs__Null",
 379   "streaming_protobufs",
 380   sizeof(StreamingProtobufs__Null),
 381   0,
 382   streaming_protobufs__null__field_descriptors,
 383   streaming_protobufs__null__field_indices_by_name,
 384   0,  streaming_protobufs__null__number_ranges,
 385   (ProtobufCMessageInit) streaming_protobufs__null__init,
 386   NULL,NULL,NULL    /* reserved[123] */
 387 };
 388 static const ProtobufCEnumValue streaming_protobufs__configured_opt__value__enum_values_by_number[2] =
 389 {
 390   { "protobuf_unspecified", "STREAMING_PROTOBUFS__CONFIGURED_OPT__VALUE__protobuf_unspecified", 0 },
 391   { "configured", "STREAMING_PROTOBUFS__CONFIGURED_OPT__VALUE__configured", 1 },
 392 };
 393 static const ProtobufCIntRange streaming_protobufs__configured_opt__value__value_ranges[] = {
 394 {0, 0},{0, 2}
 395 };
 396 static const ProtobufCEnumValueIndex streaming_protobufs__configured_opt__value__enum_values_by_name[2] =
 397 {
 398   { "configured", 1 },
 399   { "protobuf_unspecified", 0 },
 400 };
 401 const ProtobufCEnumDescriptor streaming_protobufs__configured_opt__value__descriptor =
 402 {
 403   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
 404   "streaming_protobufs.ConfiguredOpt.Value",
 405   "Value",
 406   "StreamingProtobufs__ConfiguredOpt__Value",
 407   "streaming_protobufs",
 408   2,
 409   streaming_protobufs__configured_opt__value__enum_values_by_number,
 410   2,
 411   streaming_protobufs__configured_opt__value__enum_values_by_name,
 412   1,
 413   streaming_protobufs__configured_opt__value__value_ranges,
 414   NULL,NULL,NULL,NULL   /* reserved[1234] */
 415 };
 416 static const ProtobufCFieldDescriptor streaming_protobufs__configured_opt__field_descriptors[1] =
 417 {
 418   {
 419     "value",
 420     1,
 421     PROTOBUF_C_LABEL_NONE,
 422     PROTOBUF_C_TYPE_ENUM,
 423     0,   /* quantifier_offset */
 424     offsetof(StreamingProtobufs__ConfiguredOpt, value),
 425     &streaming_protobufs__configured_opt__value__descriptor,
 426     NULL,
 427     0,             /* flags */
 428     0,NULL,NULL    /* reserved1,reserved2, etc */
 429   },
 430 };
 431 static const unsigned streaming_protobufs__configured_opt__field_indices_by_name[] = {
 432   0,   /* field[0] = value */
 433 };
 434 static const ProtobufCIntRange streaming_protobufs__configured_opt__number_ranges[1 + 1] =
 435 {
 436   { 1, 0 },
 437   { 0, 1 }
 438 };
 439 const ProtobufCMessageDescriptor streaming_protobufs__configured_opt__descriptor =
 440 {
 441   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 442   "streaming_protobufs.ConfiguredOpt",
 443   "ConfiguredOpt",
 444   "StreamingProtobufs__ConfiguredOpt",
 445   "streaming_protobufs",
 446   sizeof(StreamingProtobufs__ConfiguredOpt),
 447   1,
 448   streaming_protobufs__configured_opt__field_descriptors,
 449   streaming_protobufs__configured_opt__field_indices_by_name,
 450   1,  streaming_protobufs__configured_opt__number_ranges,
 451   (ProtobufCMessageInit) streaming_protobufs__configured_opt__init,
 452   NULL,NULL,NULL    /* reserved[123] */
 453 };
 454 static const ProtobufCEnumValue streaming_protobufs__true_opt__value__enum_values_by_number[2] =
 455 {
 456   { "protobuf_unspecified", "STREAMING_PROTOBUFS__TRUE_OPT__VALUE__protobuf_unspecified", 0 },
 457   { "true", "STREAMING_PROTOBUFS__TRUE_OPT__VALUE__true", 1 },
 458 };
 459 static const ProtobufCIntRange streaming_protobufs__true_opt__value__value_ranges[] = {
 460 {0, 0},{0, 2}
 461 };
 462 static const ProtobufCEnumValueIndex streaming_protobufs__true_opt__value__enum_values_by_name[2] =
 463 {
 464   { "protobuf_unspecified", 0 },
 465   { "true", 1 },
 466 };
 467 const ProtobufCEnumDescriptor streaming_protobufs__true_opt__value__descriptor =
 468 {
 469   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
 470   "streaming_protobufs.TrueOpt.Value",
 471   "Value",
 472   "StreamingProtobufs__TrueOpt__Value",
 473   "streaming_protobufs",
 474   2,
 475   streaming_protobufs__true_opt__value__enum_values_by_number,
 476   2,
 477   streaming_protobufs__true_opt__value__enum_values_by_name,
 478   1,
 479   streaming_protobufs__true_opt__value__value_ranges,
 480   NULL,NULL,NULL,NULL   /* reserved[1234] */
 481 };
 482 static const ProtobufCFieldDescriptor streaming_protobufs__true_opt__field_descriptors[1] =
 483 {
 484   {
 485     "value",
 486     1,
 487     PROTOBUF_C_LABEL_NONE,
 488     PROTOBUF_C_TYPE_ENUM,
 489     0,   /* quantifier_offset */
 490     offsetof(StreamingProtobufs__TrueOpt, value),
 491     &streaming_protobufs__true_opt__value__descriptor,
 492     NULL,
 493     0,             /* flags */
 494     0,NULL,NULL    /* reserved1,reserved2, etc */
 495   },
 496 };
 497 static const unsigned streaming_protobufs__true_opt__field_indices_by_name[] = {
 498   0,   /* field[0] = value */
 499 };
 500 static const ProtobufCIntRange streaming_protobufs__true_opt__number_ranges[1 + 1] =
 501 {
 502   { 1, 0 },
 503   { 0, 1 }
 504 };
 505 const ProtobufCMessageDescriptor streaming_protobufs__true_opt__descriptor =
 506 {
 507   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 508   "streaming_protobufs.TrueOpt",
 509   "TrueOpt",
 510   "StreamingProtobufs__TrueOpt",
 511   "streaming_protobufs",
 512   sizeof(StreamingProtobufs__TrueOpt),
 513   1,
 514   streaming_protobufs__true_opt__field_descriptors,
 515   streaming_protobufs__true_opt__field_indices_by_name,
 516   1,  streaming_protobufs__true_opt__number_ranges,
 517   (ProtobufCMessageInit) streaming_protobufs__true_opt__init,
 518   NULL,NULL,NULL    /* reserved[123] */
 519 };
 520 static const ProtobufCEnumValue streaming_protobufs__false_opt__value__enum_values_by_number[2] =
 521 {
 522   { "protobuf_unspecified", "STREAMING_PROTOBUFS__FALSE_OPT__VALUE__protobuf_unspecified", 0 },
 523   { "false", "STREAMING_PROTOBUFS__FALSE_OPT__VALUE__false", 1 },
 524 };
 525 static const ProtobufCIntRange streaming_protobufs__false_opt__value__value_ranges[] = {
 526 {0, 0},{0, 2}
 527 };
 528 static const ProtobufCEnumValueIndex streaming_protobufs__false_opt__value__enum_values_by_name[2] =
 529 {
 530   { "false", 1 },
 531   { "protobuf_unspecified", 0 },
 532 };
 533 const ProtobufCEnumDescriptor streaming_protobufs__false_opt__value__descriptor =
 534 {
 535   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
 536   "streaming_protobufs.FalseOpt.Value",
 537   "Value",
 538   "StreamingProtobufs__FalseOpt__Value",
 539   "streaming_protobufs",
 540   2,
 541   streaming_protobufs__false_opt__value__enum_values_by_number,
 542   2,
 543   streaming_protobufs__false_opt__value__enum_values_by_name,
 544   1,
 545   streaming_protobufs__false_opt__value__value_ranges,
 546   NULL,NULL,NULL,NULL   /* reserved[1234] */
 547 };
 548 static const ProtobufCFieldDescriptor streaming_protobufs__false_opt__field_descriptors[1] =
 549 {
 550   {
 551     "value",
 552     1,
 553     PROTOBUF_C_LABEL_NONE,
 554     PROTOBUF_C_TYPE_ENUM,
 555     0,   /* quantifier_offset */
 556     offsetof(StreamingProtobufs__FalseOpt, value),
 557     &streaming_protobufs__false_opt__value__descriptor,
 558     NULL,
 559     0,             /* flags */
 560     0,NULL,NULL    /* reserved1,reserved2, etc */
 561   },
 562 };
 563 static const unsigned streaming_protobufs__false_opt__field_indices_by_name[] = {
 564   0,   /* field[0] = value */
 565 };
 566 static const ProtobufCIntRange streaming_protobufs__false_opt__number_ranges[1 + 1] =
 567 {
 568   { 1, 0 },
 569   { 0, 1 }
 570 };
 571 const ProtobufCMessageDescriptor streaming_protobufs__false_opt__descriptor =
 572 {
 573   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 574   "streaming_protobufs.FalseOpt",
 575   "FalseOpt",
 576   "StreamingProtobufs__FalseOpt",
 577   "streaming_protobufs",
 578   sizeof(StreamingProtobufs__FalseOpt),
 579   1,
 580   streaming_protobufs__false_opt__field_descriptors,
 581   streaming_protobufs__false_opt__field_indices_by_name,
 582   1,  streaming_protobufs__false_opt__number_ranges,
 583   (ProtobufCMessageInit) streaming_protobufs__false_opt__init,
 584   NULL,NULL,NULL    /* reserved[123] */
 585 };
 586 static const ProtobufCEnumValue streaming_protobufs__enabled_opt__value__enum_values_by_number[2] =
 587 {
 588   { "protobuf_unspecified", "STREAMING_PROTOBUFS__ENABLED_OPT__VALUE__protobuf_unspecified", 0 },
 589   { "enabled", "STREAMING_PROTOBUFS__ENABLED_OPT__VALUE__enabled", 1 },
 590 };
 591 static const ProtobufCIntRange streaming_protobufs__enabled_opt__value__value_ranges[] = {
 592 {0, 0},{0, 2}
 593 };
 594 static const ProtobufCEnumValueIndex streaming_protobufs__enabled_opt__value__enum_values_by_name[2] =
 595 {
 596   { "enabled", 1 },
 597   { "protobuf_unspecified", 0 },
 598 };
 599 const ProtobufCEnumDescriptor streaming_protobufs__enabled_opt__value__descriptor =
 600 {
 601   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
 602   "streaming_protobufs.EnabledOpt.Value",
 603   "Value",
 604   "StreamingProtobufs__EnabledOpt__Value",
 605   "streaming_protobufs",
 606   2,
 607   streaming_protobufs__enabled_opt__value__enum_values_by_number,
 608   2,
 609   streaming_protobufs__enabled_opt__value__enum_values_by_name,
 610   1,
 611   streaming_protobufs__enabled_opt__value__value_ranges,
 612   NULL,NULL,NULL,NULL   /* reserved[1234] */
 613 };
 614 static const ProtobufCFieldDescriptor streaming_protobufs__enabled_opt__field_descriptors[1] =
 615 {
 616   {
 617     "value",
 618     1,
 619     PROTOBUF_C_LABEL_NONE,
 620     PROTOBUF_C_TYPE_ENUM,
 621     0,   /* quantifier_offset */
 622     offsetof(StreamingProtobufs__EnabledOpt, value),
 623     &streaming_protobufs__enabled_opt__value__descriptor,
 624     NULL,
 625     0,             /* flags */
 626     0,NULL,NULL    /* reserved1,reserved2, etc */
 627   },
 628 };
 629 static const unsigned streaming_protobufs__enabled_opt__field_indices_by_name[] = {
 630   0,   /* field[0] = value */
 631 };
 632 static const ProtobufCIntRange streaming_protobufs__enabled_opt__number_ranges[1 + 1] =
 633 {
 634   { 1, 0 },
 635   { 0, 1 }
 636 };
 637 const ProtobufCMessageDescriptor streaming_protobufs__enabled_opt__descriptor =
 638 {
 639   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 640   "streaming_protobufs.EnabledOpt",
 641   "EnabledOpt",
 642   "StreamingProtobufs__EnabledOpt",
 643   "streaming_protobufs",
 644   sizeof(StreamingProtobufs__EnabledOpt),
 645   1,
 646   streaming_protobufs__enabled_opt__field_descriptors,
 647   streaming_protobufs__enabled_opt__field_indices_by_name,
 648   1,  streaming_protobufs__enabled_opt__number_ranges,
 649   (ProtobufCMessageInit) streaming_protobufs__enabled_opt__init,
 650   NULL,NULL,NULL    /* reserved[123] */
 651 };
 652 static const ProtobufCEnumValue streaming_protobufs__disabled_opt__value__enum_values_by_number[2] =
 653 {
 654   { "protobuf_unspecified", "STREAMING_PROTOBUFS__DISABLED_OPT__VALUE__protobuf_unspecified", 0 },
 655   { "disabled", "STREAMING_PROTOBUFS__DISABLED_OPT__VALUE__disabled", 1 },
 656 };
 657 static const ProtobufCIntRange streaming_protobufs__disabled_opt__value__value_ranges[] = {
 658 {0, 0},{0, 2}
 659 };
 660 static const ProtobufCEnumValueIndex streaming_protobufs__disabled_opt__value__enum_values_by_name[2] =
 661 {
 662   { "disabled", 1 },
 663   { "protobuf_unspecified", 0 },
 664 };
 665 const ProtobufCEnumDescriptor streaming_protobufs__disabled_opt__value__descriptor =
 666 {
 667   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
 668   "streaming_protobufs.DisabledOpt.Value",
 669   "Value",
 670   "StreamingProtobufs__DisabledOpt__Value",
 671   "streaming_protobufs",
 672   2,
 673   streaming_protobufs__disabled_opt__value__enum_values_by_number,
 674   2,
 675   streaming_protobufs__disabled_opt__value__enum_values_by_name,
 676   1,
 677   streaming_protobufs__disabled_opt__value__value_ranges,
 678   NULL,NULL,NULL,NULL   /* reserved[1234] */
 679 };
 680 static const ProtobufCFieldDescriptor streaming_protobufs__disabled_opt__field_descriptors[1] =
 681 {
 682   {
 683     "value",
 684     1,
 685     PROTOBUF_C_LABEL_NONE,
 686     PROTOBUF_C_TYPE_ENUM,
 687     0,   /* quantifier_offset */
 688     offsetof(StreamingProtobufs__DisabledOpt, value),
 689     &streaming_protobufs__disabled_opt__value__descriptor,
 690     NULL,
 691     0,             /* flags */
 692     0,NULL,NULL    /* reserved1,reserved2, etc */
 693   },
 694 };
 695 static const unsigned streaming_protobufs__disabled_opt__field_indices_by_name[] = {
 696   0,   /* field[0] = value */
 697 };
 698 static const ProtobufCIntRange streaming_protobufs__disabled_opt__number_ranges[1 + 1] =
 699 {
 700   { 1, 0 },
 701   { 0, 1 }
 702 };
 703 const ProtobufCMessageDescriptor streaming_protobufs__disabled_opt__descriptor =
 704 {
 705   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 706   "streaming_protobufs.DisabledOpt",
 707   "DisabledOpt",
 708   "StreamingProtobufs__DisabledOpt",
 709   "streaming_protobufs",
 710   sizeof(StreamingProtobufs__DisabledOpt),
 711   1,
 712   streaming_protobufs__disabled_opt__field_descriptors,
 713   streaming_protobufs__disabled_opt__field_indices_by_name,
 714   1,  streaming_protobufs__disabled_opt__number_ranges,
 715   (ProtobufCMessageInit) streaming_protobufs__disabled_opt__init,
 716   NULL,NULL,NULL    /* reserved[123] */
 717 };
 718 static const ProtobufCEnumValue streaming_protobufs__enabled_disabled_opt__value__enum_values_by_number[3] =
 719 {
 720   { "protobuf_unspecified", "STREAMING_PROTOBUFS__ENABLED_DISABLED_OPT__VALUE__protobuf_unspecified", 0 },
 721   { "enabled", "STREAMING_PROTOBUFS__ENABLED_DISABLED_OPT__VALUE__enabled", 1 },
 722   { "disabled", "STREAMING_PROTOBUFS__ENABLED_DISABLED_OPT__VALUE__disabled", 2 },
 723 };
 724 static const ProtobufCIntRange streaming_protobufs__enabled_disabled_opt__value__value_ranges[] = {
 725 {0, 0},{0, 3}
 726 };
 727 static const ProtobufCEnumValueIndex streaming_protobufs__enabled_disabled_opt__value__enum_values_by_name[3] =
 728 {
 729   { "disabled", 2 },
 730   { "enabled", 1 },
 731   { "protobuf_unspecified", 0 },
 732 };
 733 const ProtobufCEnumDescriptor streaming_protobufs__enabled_disabled_opt__value__descriptor =
 734 {
 735   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
 736   "streaming_protobufs.EnabledDisabledOpt.Value",
 737   "Value",
 738   "StreamingProtobufs__EnabledDisabledOpt__Value",
 739   "streaming_protobufs",
 740   3,
 741   streaming_protobufs__enabled_disabled_opt__value__enum_values_by_number,
 742   3,
 743   streaming_protobufs__enabled_disabled_opt__value__enum_values_by_name,
 744   1,
 745   streaming_protobufs__enabled_disabled_opt__value__value_ranges,
 746   NULL,NULL,NULL,NULL   /* reserved[1234] */
 747 };
 748 static const ProtobufCFieldDescriptor streaming_protobufs__enabled_disabled_opt__field_descriptors[1] =
 749 {
 750   {
 751     "value",
 752     1,
 753     PROTOBUF_C_LABEL_NONE,
 754     PROTOBUF_C_TYPE_ENUM,
 755     0,   /* quantifier_offset */
 756     offsetof(StreamingProtobufs__EnabledDisabledOpt, value),
 757     &streaming_protobufs__enabled_disabled_opt__value__descriptor,
 758     NULL,
 759     0,             /* flags */
 760     0,NULL,NULL    /* reserved1,reserved2, etc */
 761   },
 762 };
 763 static const unsigned streaming_protobufs__enabled_disabled_opt__field_indices_by_name[] = {
 764   0,   /* field[0] = value */
 765 };
 766 static const ProtobufCIntRange streaming_protobufs__enabled_disabled_opt__number_ranges[1 + 1] =
 767 {
 768   { 1, 0 },
 769   { 0, 1 }
 770 };
 771 const ProtobufCMessageDescriptor streaming_protobufs__enabled_disabled_opt__descriptor =
 772 {
 773   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 774   "streaming_protobufs.EnabledDisabledOpt",
 775   "EnabledDisabledOpt",
 776   "StreamingProtobufs__EnabledDisabledOpt",
 777   "streaming_protobufs",
 778   sizeof(StreamingProtobufs__EnabledDisabledOpt),
 779   1,
 780   streaming_protobufs__enabled_disabled_opt__field_descriptors,
 781   streaming_protobufs__enabled_disabled_opt__field_indices_by_name,
 782   1,  streaming_protobufs__enabled_disabled_opt__number_ranges,
 783   (ProtobufCMessageInit) streaming_protobufs__enabled_disabled_opt__init,
 784   NULL,NULL,NULL    /* reserved[123] */
 785 };
 786 static const ProtobufCEnumValue streaming_protobufs__on_off_opt__value__enum_values_by_number[3] =
 787 {
 788   { "protobuf_unspecified", "STREAMING_PROTOBUFS__ON_OFF_OPT__VALUE__protobuf_unspecified", 0 },
 789   { "on", "STREAMING_PROTOBUFS__ON_OFF_OPT__VALUE__on", 1 },
 790   { "off", "STREAMING_PROTOBUFS__ON_OFF_OPT__VALUE__off", 2 },
 791 };
 792 static const ProtobufCIntRange streaming_protobufs__on_off_opt__value__value_ranges[] = {
 793 {0, 0},{0, 3}
 794 };
 795 static const ProtobufCEnumValueIndex streaming_protobufs__on_off_opt__value__enum_values_by_name[3] =
 796 {
 797   { "off", 2 },
 798   { "on", 1 },
 799   { "protobuf_unspecified", 0 },
 800 };
 801 const ProtobufCEnumDescriptor streaming_protobufs__on_off_opt__value__descriptor =
 802 {
 803   PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
 804   "streaming_protobufs.OnOffOpt.Value",
 805   "Value",
 806   "StreamingProtobufs__OnOffOpt__Value",
 807   "streaming_protobufs",
 808   3,
 809   streaming_protobufs__on_off_opt__value__enum_values_by_number,
 810   3,
 811   streaming_protobufs__on_off_opt__value__enum_values_by_name,
 812   1,
 813   streaming_protobufs__on_off_opt__value__value_ranges,
 814   NULL,NULL,NULL,NULL   /* reserved[1234] */
 815 };
 816 static const ProtobufCFieldDescriptor streaming_protobufs__on_off_opt__field_descriptors[1] =
 817 {
 818   {
 819     "value",
 820     1,
 821     PROTOBUF_C_LABEL_NONE,
 822     PROTOBUF_C_TYPE_ENUM,
 823     0,   /* quantifier_offset */
 824     offsetof(StreamingProtobufs__OnOffOpt, value),
 825     &streaming_protobufs__on_off_opt__value__descriptor,
 826     NULL,
 827     0,             /* flags */
 828     0,NULL,NULL    /* reserved1,reserved2, etc */
 829   },
 830 };
 831 static const unsigned streaming_protobufs__on_off_opt__field_indices_by_name[] = {
 832   0,   /* field[0] = value */
 833 };
 834 static const ProtobufCIntRange streaming_protobufs__on_off_opt__number_ranges[1 + 1] =
 835 {
 836   { 1, 0 },
 837   { 0, 1 }
 838 };
 839 const ProtobufCMessageDescriptor streaming_protobufs__on_off_opt__descriptor =
 840 {
 841   PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
 842   "streaming_protobufs.OnOffOpt",
 843   "OnOffOpt",
 844   "StreamingProtobufs__OnOffOpt",
 845   "streaming_protobufs",
 846   sizeof(StreamingProtobufs__OnOffOpt),
 847   1,
 848   streaming_protobufs__on_off_opt__field_descriptors,
 849   streaming_protobufs__on_off_opt__field_indices_by_name,
 850   1,  streaming_protobufs__on_off_opt__number_ranges,
 851   (ProtobufCMessageInit) streaming_protobufs__on_off_opt__init,
 852   NULL,NULL,NULL    /* reserved[123] */
 853 };