← Back to branch summary

~statik/debian/sid/protobuf/B

« back to all changes in this revision

Viewing changes to src/google/protobuf/generated_message_reflection.cc

  • Committer: Bazaar Package Importer
  • Author(s): Dirk Eddelbuettel
  • Date: 2009-11-18 21:47:41 UTC
  • mfrom: (1.1.4 upstream) (3.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20091118214741-iqv6m4f95faob583
Tags: 2.2.0a-0.1
http://bugs.debian.org/556563
* Non-maintainer upload 
* New upstream release made this evening correction major SONAME
* debian/control: Updated major version to 5            (Closes: #556563)
* debian/rules: Updated two links to use libproto*5 
* debian/libprotobuf5.shlibs: Added
* debian/libprotoc5.shlibs: Added

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/google/protobuf/generated_message_reflection.cc
38
38
#include <google/protobuf/descriptor.pb.h>
39
39
#include <google/protobuf/repeated_field.h>
40
40
#include <google/protobuf/extension_set.h>
 
41
#include <google/protobuf/generated_message_util.h>
41
42
#include <google/protobuf/stubs/common.h>
42
43
 
43
44
namespace google {
220
221
    const FieldDescriptor* field = descriptor_->field(i);
221
222
 
222
223
    if (field->is_repeated()) {
223
 
      total_size += GetRaw<GenericRepeatedField>(message, field)
224
 
                      .GenericSpaceUsedExcludingSelf();
 
224
      switch (field->cpp_type()) {
 
225
#define HANDLE_TYPE(UPPERCASE, LOWERCASE)                                     \
 
226
        case FieldDescriptor::CPPTYPE_##UPPERCASE :                           \
 
227
          total_size += GetRaw<RepeatedField<LOWERCASE> >(message, field)     \
 
228
                          .SpaceUsedExcludingSelf();                          \
 
229
          break
 
230
 
 
231
        HANDLE_TYPE( INT32,  int32);
 
232
        HANDLE_TYPE( INT64,  int64);
 
233
        HANDLE_TYPE(UINT32, uint32);
 
234
        HANDLE_TYPE(UINT64, uint64);
 
235
        HANDLE_TYPE(DOUBLE, double);
 
236
        HANDLE_TYPE( FLOAT,  float);
 
237
        HANDLE_TYPE(  BOOL,   bool);
 
238
        HANDLE_TYPE(  ENUM,    int);
 
239
#undef HANDLE_TYPE
 
240
 
 
241
        case FieldDescriptor::CPPTYPE_STRING:
 
242
            total_size += GetRaw<RepeatedPtrField<string> >(message, field)
 
243
                            .SpaceUsedExcludingSelf();
 
244
          break;
 
245
 
 
246
        case FieldDescriptor::CPPTYPE_MESSAGE:
 
247
          // We don't know which subclass of RepeatedPtrFieldBase the type is,
 
248
          // so we use RepeatedPtrFieldBase directly.
 
249
          total_size +=
 
250
              GetRaw<RepeatedPtrFieldBase>(message, field)
 
251
                .SpaceUsedExcludingSelf<GenericTypeHandler<Message> >();
 
252
          break;
 
253
      }
225
254
    } else {
226
255
      switch (field->cpp_type()) {
227
256
        case FieldDescriptor::CPPTYPE_INT32 :
269
298
  return total_size;
270
299
}
271
300
 
 
301
void GeneratedMessageReflection::Swap(
 
302
    Message* message1,
 
303
    Message* message2) const {
 
304
  if (message1 == message2) return;
 
305
 
 
306
  // TODO(kenton):  Other Reflection methods should probably check this too.
 
307
  GOOGLE_CHECK_EQ(message1->GetReflection(), this)
 
308
    << "First argument to Swap() (of type \""
 
309
    << message1->GetDescriptor()->full_name()
 
310
    << "\") is not compatible with this reflection object (which is for type \""
 
311
    << descriptor_->full_name()
 
312
    << "\").  Note that the exact same class is required; not just the same "
 
313
       "descriptor.";
 
314
  GOOGLE_CHECK_EQ(message2->GetReflection(), this)
 
315
    << "Second argument to Swap() (of type \""
 
316
    << message1->GetDescriptor()->full_name()
 
317
    << "\") is not compatible with this reflection object (which is for type \""
 
318
    << descriptor_->full_name()
 
319
    << "\").  Note that the exact same class is required; not just the same "
 
320
       "descriptor.";
 
321
 
 
322
  uint32* has_bits1 = MutableHasBits(message1);
 
323
  uint32* has_bits2 = MutableHasBits(message2);
 
324
  int has_bits_size = (descriptor_->field_count() + 31) / 32;
 
325
 
 
326
  for (int i = 0; i < has_bits_size; i++) {
 
327
    swap(has_bits1[i], has_bits2[i]);
 
328
  }
 
329
 
 
330
  for (int i = 0; i < descriptor_->field_count(); i++) {
 
331
    const FieldDescriptor* field = descriptor_->field(i);
 
332
    if (field->is_repeated()) {
 
333
      switch (field->cpp_type()) {
 
334
#define SWAP_ARRAYS(CPPTYPE, TYPE)                                           \
 
335
        case FieldDescriptor::CPPTYPE_##CPPTYPE:                             \
 
336
          MutableRaw<RepeatedField<TYPE> >(message1, field)->Swap(           \
 
337
              MutableRaw<RepeatedField<TYPE> >(message2, field));            \
 
338
          break;
 
339
 
 
340
          SWAP_ARRAYS(INT32 , int32 );
 
341
          SWAP_ARRAYS(INT64 , int64 );
 
342
          SWAP_ARRAYS(UINT32, uint32);
 
343
          SWAP_ARRAYS(UINT64, uint64);
 
344
          SWAP_ARRAYS(FLOAT , float );
 
345
          SWAP_ARRAYS(DOUBLE, double);
 
346
          SWAP_ARRAYS(BOOL  , bool  );
 
347
          SWAP_ARRAYS(ENUM  , int   );
 
348
#undef SWAP_ARRAYS
 
349
 
 
350
        case FieldDescriptor::CPPTYPE_STRING:
 
351
        case FieldDescriptor::CPPTYPE_MESSAGE:
 
352
          MutableRaw<RepeatedPtrFieldBase>(message1, field)->Swap(
 
353
              MutableRaw<RepeatedPtrFieldBase>(message2, field));
 
354
          break;
 
355
 
 
356
        default:
 
357
          GOOGLE_LOG(FATAL) << "Unimplemented type: " << field->cpp_type();
 
358
      }
 
359
    } else {
 
360
      switch (field->cpp_type()) {
 
361
#define SWAP_VALUES(CPPTYPE, TYPE)                                           \
 
362
        case FieldDescriptor::CPPTYPE_##CPPTYPE:                             \
 
363
          swap(*MutableRaw<TYPE>(message1, field),                           \
 
364
               *MutableRaw<TYPE>(message2, field));                          \
 
365
          break;
 
366
 
 
367
          SWAP_VALUES(INT32 , int32 );
 
368
          SWAP_VALUES(INT64 , int64 );
 
369
          SWAP_VALUES(UINT32, uint32);
 
370
          SWAP_VALUES(UINT64, uint64);
 
371
          SWAP_VALUES(FLOAT , float );
 
372
          SWAP_VALUES(DOUBLE, double);
 
373
          SWAP_VALUES(BOOL  , bool  );
 
374
          SWAP_VALUES(ENUM  , int   );
 
375
          SWAP_VALUES(MESSAGE, Message*);
 
376
#undef SWAP_VALUES
 
377
 
 
378
        case FieldDescriptor::CPPTYPE_STRING:
 
379
            swap(*MutableRaw<string*>(message1, field),
 
380
                 *MutableRaw<string*>(message2, field));
 
381
          break;
 
382
 
 
383
        default:
 
384
          GOOGLE_LOG(FATAL) << "Unimplemented type: " << field->cpp_type();
 
385
      }
 
386
    }
 
387
  }
 
388
 
 
389
  if (extensions_offset_ != -1) {
 
390
    MutableExtensionSet(message1)->Swap(MutableExtensionSet(message2));
 
391
  }
 
392
 
 
393
  MutableUnknownFields(message1)->Swap(MutableUnknownFields(message2));
 
394
}
 
395
 
272
396
// -------------------------------------------------------------------
273
397
 
274
398
bool GeneratedMessageReflection::HasField(const Message& message,
285
409
 
286
410
int GeneratedMessageReflection::FieldSize(const Message& message,
287
411
                                          const FieldDescriptor* field) const {
288
 
  USAGE_CHECK_MESSAGE_TYPE(HasField);
289
 
  USAGE_CHECK_REPEATED(HasField);
 
412
  USAGE_CHECK_MESSAGE_TYPE(FieldSize);
 
413
  USAGE_CHECK_REPEATED(FieldSize);
290
414
 
291
415
  if (field->is_extension()) {
292
416
    return GetExtensionSet(message).ExtensionSize(field->number());
293
417
  } else {
294
 
    return GetRaw<GenericRepeatedField>(message, field).GenericSize();
 
418
    switch (field->cpp_type()) {
 
419
#define HANDLE_TYPE(UPPERCASE, LOWERCASE)                                     \
 
420
      case FieldDescriptor::CPPTYPE_##UPPERCASE :                             \
 
421
        return GetRaw<RepeatedField<LOWERCASE> >(message, field).size()
 
422
 
 
423
      HANDLE_TYPE( INT32,  int32);
 
424
      HANDLE_TYPE( INT64,  int64);
 
425
      HANDLE_TYPE(UINT32, uint32);
 
426
      HANDLE_TYPE(UINT64, uint64);
 
427
      HANDLE_TYPE(DOUBLE, double);
 
428
      HANDLE_TYPE( FLOAT,  float);
 
429
      HANDLE_TYPE(  BOOL,   bool);
 
430
      HANDLE_TYPE(  ENUM,    int);
 
431
#undef HANDLE_TYPE
 
432
 
 
433
      case FieldDescriptor::CPPTYPE_STRING:
 
434
      case FieldDescriptor::CPPTYPE_MESSAGE:
 
435
        return GetRaw<RepeatedPtrFieldBase>(message, field).size();
 
436
    }
 
437
 
 
438
    GOOGLE_LOG(FATAL) << "Can't get here.";
 
439
    return 0;
295
440
  }
296
441
}
297
442
 
346
491
      }
347
492
    }
348
493
  } else {
349
 
    MutableRaw<GenericRepeatedField>(message, field)->GenericClear();
 
494
    switch (field->cpp_type()) {
 
495
#define HANDLE_TYPE(UPPERCASE, LOWERCASE)                                     \
 
496
      case FieldDescriptor::CPPTYPE_##UPPERCASE :                             \
 
497
        MutableRaw<RepeatedField<LOWERCASE> >(message, field)->Clear();       \
 
498
        break
 
499
 
 
500
      HANDLE_TYPE( INT32,  int32);
 
501
      HANDLE_TYPE( INT64,  int64);
 
502
      HANDLE_TYPE(UINT32, uint32);
 
503
      HANDLE_TYPE(UINT64, uint64);
 
504
      HANDLE_TYPE(DOUBLE, double);
 
505
      HANDLE_TYPE( FLOAT,  float);
 
506
      HANDLE_TYPE(  BOOL,   bool);
 
507
      HANDLE_TYPE(  ENUM,    int);
 
508
#undef HANDLE_TYPE
 
509
 
 
510
      case FieldDescriptor::CPPTYPE_STRING: {
 
511
          MutableRaw<RepeatedPtrField<string> >(message, field)->Clear();
 
512
        break;
 
513
      }
 
514
 
 
515
      case FieldDescriptor::CPPTYPE_MESSAGE: {
 
516
        // We don't know which subclass of RepeatedPtrFieldBase the type is,
 
517
        // so we use RepeatedPtrFieldBase directly.
 
518
        MutableRaw<RepeatedPtrFieldBase>(message, field)
 
519
            ->Clear<GenericTypeHandler<Message> >();
 
520
        break;
 
521
      }
 
522
    }
 
523
  }
 
524
}
 
525
 
 
526
void GeneratedMessageReflection::RemoveLast(
 
527
    Message* message,
 
528
    const FieldDescriptor* field) const {
 
529
  USAGE_CHECK_MESSAGE_TYPE(RemoveLast);
 
530
  USAGE_CHECK_REPEATED(RemoveLast);
 
531
 
 
532
  if (field->is_extension()) {
 
533
    MutableExtensionSet(message)->RemoveLast(field->number());
 
534
  } else {
 
535
    switch (field->cpp_type()) {
 
536
#define HANDLE_TYPE(UPPERCASE, LOWERCASE)                                     \
 
537
      case FieldDescriptor::CPPTYPE_##UPPERCASE :                             \
 
538
        MutableRaw<RepeatedField<LOWERCASE> >(message, field)->RemoveLast();  \
 
539
        break
 
540
 
 
541
      HANDLE_TYPE( INT32,  int32);
 
542
      HANDLE_TYPE( INT64,  int64);
 
543
      HANDLE_TYPE(UINT32, uint32);
 
544
      HANDLE_TYPE(UINT64, uint64);
 
545
      HANDLE_TYPE(DOUBLE, double);
 
546
      HANDLE_TYPE( FLOAT,  float);
 
547
      HANDLE_TYPE(  BOOL,   bool);
 
548
      HANDLE_TYPE(  ENUM,    int);
 
549
#undef HANDLE_TYPE
 
550
 
 
551
      case FieldDescriptor::CPPTYPE_STRING:
 
552
          MutableRaw<RepeatedPtrField<string> >(message, field)->RemoveLast();
 
553
        break;
 
554
 
 
555
      case FieldDescriptor::CPPTYPE_MESSAGE:
 
556
        MutableRaw<RepeatedPtrFieldBase>(message, field)
 
557
            ->RemoveLast<GenericTypeHandler<Message> >();
 
558
        break;
 
559
    }
 
560
  }
 
561
}
 
562
 
 
563
void GeneratedMessageReflection::SwapElements(
 
564
    Message* message,
 
565
    const FieldDescriptor* field,
 
566
    int index1,
 
567
    int index2) const {
 
568
  USAGE_CHECK_MESSAGE_TYPE(Swap);
 
569
  USAGE_CHECK_REPEATED(Swap);
 
570
 
 
571
  if (field->is_extension()) {
 
572
    MutableExtensionSet(message)->SwapElements(field->number(), index1, index2);
 
573
  } else {
 
574
    switch (field->cpp_type()) {
 
575
#define HANDLE_TYPE(UPPERCASE, LOWERCASE)                                     \
 
576
      case FieldDescriptor::CPPTYPE_##UPPERCASE :                             \
 
577
        MutableRaw<RepeatedField<LOWERCASE> >(message, field)                 \
 
578
            ->SwapElements(index1, index2);                                   \
 
579
        break
 
580
 
 
581
      HANDLE_TYPE( INT32,  int32);
 
582
      HANDLE_TYPE( INT64,  int64);
 
583
      HANDLE_TYPE(UINT32, uint32);
 
584
      HANDLE_TYPE(UINT64, uint64);
 
585
      HANDLE_TYPE(DOUBLE, double);
 
586
      HANDLE_TYPE( FLOAT,  float);
 
587
      HANDLE_TYPE(  BOOL,   bool);
 
588
      HANDLE_TYPE(  ENUM,    int);
 
589
#undef HANDLE_TYPE
 
590
 
 
591
      case FieldDescriptor::CPPTYPE_STRING:
 
592
      case FieldDescriptor::CPPTYPE_MESSAGE:
 
593
        MutableRaw<RepeatedPtrFieldBase>(message, field)
 
594
            ->SwapElements(index1, index2);
 
595
        break;
 
596
    }
350
597
  }
351
598
}
352
599
 
371
618
  for (int i = 0; i < descriptor_->field_count(); i++) {
372
619
    const FieldDescriptor* field = descriptor_->field(i);
373
620
    if (field->is_repeated()) {
374
 
      if (GetRaw<GenericRepeatedField>(message, field).GenericSize() > 0) {
 
621
      if (FieldSize(message, field) > 0) {
375
622
        output->push_back(field);
376
623
      }
377
624
    } else {
512
759
  if (field->is_extension()) {
513
760
    return GetExtensionSet(message).GetRepeatedString(field->number(), index);
514
761
  } else {
515
 
    return GetRepeatedField<string>(message, field, index);
 
762
    return GetRepeatedPtrField<string>(message, field, index);
516
763
  }
517
764
}
518
765
 
523
770
  if (field->is_extension()) {
524
771
    return GetExtensionSet(message).GetRepeatedString(field->number(), index);
525
772
  } else {
526
 
    return GetRepeatedField<string>(message, field, index);
 
773
    return GetRepeatedPtrField<string>(message, field, index);
527
774
  }
528
775
}
529
776
 
536
783
    MutableExtensionSet(message)->SetRepeatedString(
537
784
      field->number(), index, value);
538
785
  } else {
539
 
    SetRepeatedField<string>(message, field, index, value);
 
786
    *MutableRepeatedField<string>(message, field, index) = value;
540
787
  }
541
788
}
542
789
 
549
796
    MutableExtensionSet(message)->AddString(field->number(),
550
797
                                            field->type(), value);
551
798
  } else {
552
 
    AddField<string>(message, field, value);
 
799
    *AddField<string>(message, field) = value;
553
800
  }
554
801
}
555
802
 
640
887
  USAGE_CHECK_ALL(GetMessage, SINGULAR, MESSAGE);
641
888
 
642
889
  if (field->is_extension()) {
643
 
    return GetExtensionSet(message).GetMessage(field->number(),
644
 
                                               field->message_type(),
645
 
                                               message_factory_);
 
890
    return static_cast<const Message&>(
 
891
      GetExtensionSet(message).GetMessage(field->number(),
 
892
                                          field->message_type(),
 
893
                                          message_factory_));
646
894
  } else {
647
895
    const Message* result = GetRaw<const Message*>(message, field);
648
896
    if (result == NULL) {
657
905
  USAGE_CHECK_ALL(MutableMessage, SINGULAR, MESSAGE);
658
906
 
659
907
  if (field->is_extension()) {
660
 
    return MutableExtensionSet(message)->MutableMessage(field->number(),
661
 
                                                        field->type(),
662
 
                                                        field->message_type(),
663
 
                                                        message_factory_);
 
908
    return static_cast<Message*>(
 
909
        MutableExtensionSet(message)->MutableMessage(field->number(),
 
910
                                                     field->type(),
 
911
                                                     field->message_type(),
 
912
                                                     message_factory_));
664
913
  } else {
665
914
    Message** result = MutableField<Message*>(message, field);
666
915
    if (*result == NULL) {
676
925
  USAGE_CHECK_ALL(GetRepeatedMessage, REPEATED, MESSAGE);
677
926
 
678
927
  if (field->is_extension()) {
679
 
    return GetExtensionSet(message).GetRepeatedMessage(field->number(), index);
 
928
    return static_cast<const Message&>(
 
929
        GetExtensionSet(message).GetRepeatedMessage(field->number(), index));
680
930
  } else {
681
 
    return GetRepeatedField<Message>(message, field, index);
 
931
    return GetRaw<RepeatedPtrFieldBase>(message, field)
 
932
        .Get<GenericTypeHandler<Message> >(index);
682
933
  }
683
934
}
684
935
 
687
938
  USAGE_CHECK_ALL(MutableRepeatedMessage, REPEATED, MESSAGE);
688
939
 
689
940
  if (field->is_extension()) {
690
 
    return MutableExtensionSet(message)->MutableRepeatedMessage(
691
 
      field->number(), index);
 
941
    return static_cast<Message*>(
 
942
        MutableExtensionSet(message)->MutableRepeatedMessage(
 
943
          field->number(), index));
692
944
  } else {
693
 
    return MutableRepeatedField<Message>(message, field, index);
 
945
    return MutableRaw<RepeatedPtrFieldBase>(message, field)
 
946
        ->Mutable<GenericTypeHandler<Message> >(index);
694
947
  }
695
948
}
696
949
 
699
952
  USAGE_CHECK_ALL(AddMessage, REPEATED, MESSAGE);
700
953
 
701
954
  if (field->is_extension()) {
702
 
    return MutableExtensionSet(message)->AddMessage(field->number(),
703
 
                                                    field->type(),
704
 
                                                    field->message_type(),
705
 
                                                    message_factory_);
 
955
    return static_cast<Message*>(
 
956
        MutableExtensionSet(message)->AddMessage(field->number(),
 
957
                                                 field->type(),
 
958
                                                 field->message_type(),
 
959
                                                 message_factory_));
706
960
  } else {
707
 
    return AddField<Message>(message, field);
 
961
    // We can't use AddField<Message>() because RepeatedPtrFieldBase doesn't
 
962
    // know how to allocate one.
 
963
    RepeatedPtrFieldBase* repeated =
 
964
      MutableRaw<RepeatedPtrFieldBase>(message, field);
 
965
    Message* result = repeated->AddFromCleared<GenericTypeHandler<Message> >();
 
966
    if (result == NULL) {
 
967
      // We must allocate a new object.
 
968
      const Message* prototype;
 
969
      if (repeated->size() == 0) {
 
970
        prototype = message_factory_->GetPrototype(field->message_type());
 
971
      } else {
 
972
        prototype = &repeated->Get<GenericTypeHandler<Message> >(0);
 
973
      }
 
974
      result = prototype->New();
 
975
      repeated->AddAllocated<GenericTypeHandler<Message> >(result);
 
976
    }
 
977
    return result;
708
978
  }
709
979
}
710
980
 
840
1110
}
841
1111
 
842
1112
template <typename Type>
843
 
inline const Type& GeneratedMessageReflection::GetRepeatedField(
844
 
    const Message& message, const FieldDescriptor* field, int index) const {
845
 
  return *reinterpret_cast<const Type*>(
846
 
    GetRaw<GenericRepeatedField>(message, field).GenericGet(index));
 
1113
inline Type GeneratedMessageReflection::GetRepeatedField(
 
1114
    const Message& message, const FieldDescriptor* field, int index) const {
 
1115
  return GetRaw<RepeatedField<Type> >(message, field).Get(index);
 
1116
}
 
1117
 
 
1118
template <typename Type>
 
1119
inline const Type& GeneratedMessageReflection::GetRepeatedPtrField(
 
1120
    const Message& message, const FieldDescriptor* field, int index) const {
 
1121
  return GetRaw<RepeatedPtrField<Type> >(message, field).Get(index);
847
1122
}
848
1123
 
849
1124
template <typename Type>
850
1125
inline void GeneratedMessageReflection::SetRepeatedField(
851
1126
    Message* message, const FieldDescriptor* field,
852
 
    int index, const Type& value) const {
853
 
  GenericRepeatedField* repeated =
854
 
    MutableRaw<GenericRepeatedField>(message, field);
855
 
  *reinterpret_cast<Type*>(repeated->GenericMutable(index)) = value;
 
1127
    int index, Type value) const {
 
1128
  MutableRaw<RepeatedField<Type> >(message, field)->Set(index, value);
856
1129
}
857
1130
 
858
1131
template <typename Type>
859
1132
inline Type* GeneratedMessageReflection::MutableRepeatedField(
860
1133
    Message* message, const FieldDescriptor* field, int index) const {
861
 
  GenericRepeatedField* repeated =
862
 
    MutableRaw<GenericRepeatedField>(message, field);
863
 
  return reinterpret_cast<Type*>(repeated->GenericMutable(index));
 
1134
  RepeatedPtrField<Type>* repeated =
 
1135
    MutableRaw<RepeatedPtrField<Type> >(message, field);
 
1136
  return repeated->Mutable(index);
864
1137
}
865
1138
 
866
1139
template <typename Type>
867
1140
inline void GeneratedMessageReflection::AddField(
868
 
    Message* message, const FieldDescriptor* field, const Type& value) const {
869
 
  GenericRepeatedField* repeated =
870
 
    MutableRaw<GenericRepeatedField>(message, field);
871
 
  *reinterpret_cast<Type*>(repeated->GenericAdd()) = value;
 
1141
    Message* message, const FieldDescriptor* field, Type value) const {
 
1142
  MutableRaw<RepeatedField<Type> >(message, field)->Add(value);
872
1143
}
873
1144
 
874
1145
template <typename Type>
875
1146
inline Type* GeneratedMessageReflection::AddField(
876
1147
    Message* message, const FieldDescriptor* field) const {
877
 
  GenericRepeatedField* repeated =
878
 
    MutableRaw<GenericRepeatedField>(message, field);
879
 
  return reinterpret_cast<Type*>(repeated->GenericAdd());
 
1148
  RepeatedPtrField<Type>* repeated =
 
1149
    MutableRaw<RepeatedPtrField<Type> >(message, field);
 
1150
  return repeated->Add();
880
1151
}
881
1152
 
882
 
 
883
1153
}  // namespace internal
884
1154
}  // namespace protobuf
885
1155
}  // namespace google