third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/generated_message_reflection.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 155 matching lines @@
 #define USAGE_CHECK_ALL(METHOD, LABEL, CPPTYPE)                       \
     USAGE_CHECK_MESSAGE_TYPE(METHOD);                                 \
     USAGE_CHECK_##LABEL(METHOD);                                      \
     USAGE_CHECK_TYPE(METHOD, CPPTYPE)
 
 }  // namespace
 
 // ===================================================================
 
 GeneratedMessageReflection::GeneratedMessageReflection(
-    const Descriptor* descriptor,
-    const Message* default_instance,
-    const int offsets[],
-    int has_bits_offset,
-    int unknown_fields_offset,
-    int extensions_offset,
-    const DescriptorPool* descriptor_pool,
-    MessageFactory* factory,
-    int object_size,
-    int arena_offset,
-    int is_default_instance_offset)
-  : descriptor_       (descriptor),
-    default_instance_ (default_instance),
-    offsets_          (offsets),
-    has_bits_offset_  (has_bits_offset),
-    unknown_fields_offset_(unknown_fields_offset),
-    extensions_offset_(extensions_offset),
-    arena_offset_     (arena_offset),
-    is_default_instance_offset_(is_default_instance_offset),
-    object_size_      (object_size),
-    descriptor_pool_  ((descriptor_pool == NULL) ?
-                         DescriptorPool::generated_pool() :
-                         descriptor_pool),
-    message_factory_  (factory) {
-}
+    const Descriptor* descriptor, const Message* default_instance,
+    const int offsets[], int has_bits_offset, int unknown_fields_offset,
+    int extensions_offset, const DescriptorPool* descriptor_pool,
+    MessageFactory* factory, int object_size, int arena_offset)
+    : descriptor_(descriptor),
+      default_instance_(default_instance),
+      offsets_(offsets),
+      has_bits_offset_(has_bits_offset),
+      unknown_fields_offset_(unknown_fields_offset),
+      extensions_offset_(extensions_offset),
+      arena_offset_(arena_offset),
+      object_size_(object_size),
+      descriptor_pool_((descriptor_pool == NULL)
+                           ? DescriptorPool::generated_pool()
+                           : descriptor_pool),
+      message_factory_(factory) {}
 
 GeneratedMessageReflection::GeneratedMessageReflection(
-    const Descriptor* descriptor,
-    const Message* default_instance,
-    const int offsets[],
-    int has_bits_offset,
-    int unknown_fields_offset,
-    int extensions_offset,
-    const void* default_oneof_instance,
-    int oneof_case_offset,
-    const DescriptorPool* descriptor_pool,
-    MessageFactory* factory,
-    int object_size,
-    int arena_offset,
-    int is_default_instance_offset)
-  : descriptor_       (descriptor),
-    default_instance_ (default_instance),
-    default_oneof_instance_ (default_oneof_instance),
-    offsets_          (offsets),
-    has_bits_offset_  (has_bits_offset),
-    oneof_case_offset_(oneof_case_offset),
-    unknown_fields_offset_(unknown_fields_offset),
-    extensions_offset_(extensions_offset),
-    arena_offset_     (arena_offset),
-    is_default_instance_offset_(is_default_instance_offset),
-    object_size_      (object_size),
-    descriptor_pool_  ((descriptor_pool == NULL) ?
-                         DescriptorPool::generated_pool() :
-                         descriptor_pool),
-    message_factory_  (factory) {
-}
+    const Descriptor* descriptor, const Message* default_instance,
+    const int offsets[], int has_bits_offset, int unknown_fields_offset,
+    int extensions_offset, const void* default_oneof_instance,
+    int oneof_case_offset, const DescriptorPool* descriptor_pool,
+    MessageFactory* factory, int object_size, int arena_offset)
+    : descriptor_(descriptor),
+      default_instance_(default_instance),
+      default_oneof_instance_(default_oneof_instance),
+      offsets_(offsets),
+      has_bits_offset_(has_bits_offset),
+      oneof_case_offset_(oneof_case_offset),
+      unknown_fields_offset_(unknown_fields_offset),
+      extensions_offset_(extensions_offset),
+      arena_offset_(arena_offset),
+      object_size_(object_size),
+      descriptor_pool_((descriptor_pool == NULL)
+                           ? DescriptorPool::generated_pool()
+                           : descriptor_pool),
+      message_factory_(factory) {}
 
 GeneratedMessageReflection::~GeneratedMessageReflection() {}
 
 namespace {
 UnknownFieldSet* empty_unknown_field_set_ = NULL;
 GOOGLE_PROTOBUF_DECLARE_ONCE(empty_unknown_field_set_once_);
 
 void DeleteEmptyUnknownFieldSet() {
   delete empty_unknown_field_set_;
   empty_unknown_field_set_ = NULL;
@@ skipping 777 matching lines @@
 }
 
 namespace {
 // Comparison functor for sorting FieldDescriptors by field number.
 struct FieldNumberSorter {
   bool operator()(const FieldDescriptor* left,
                   const FieldDescriptor* right) const {
     return left->number() < right->number();
   }
 };
+
+inline bool IsIndexInHasBitSet(const uint32* has_bit_set, uint32 index) {
+  return ((has_bit_set[index / 32] >> (index % 32)) & static_cast<uint32>(1))
+      != 0;
+}
 }  // namespace
 
 void GeneratedMessageReflection::ListFields(
     const Message& message,
     vector<const FieldDescriptor*>* output) const {
   output->clear();
 
   // Optimization:  The default instance never has any fields set.
   if (&message == default_instance_) return;
 
+  // Optimization: Avoid calling GetHasBits() and HasOneofField() many times
+  // within the field loop.
+  const uint32* const has_bits = GetHasBits(message);
+  const uint32* const oneof_case_array = reinterpret_cast<const uint32*>(
+      reinterpret_cast<const uint8*>(&message) + oneof_case_offset_);
+
   output->reserve(descriptor_->field_count());
   for (int i = 0; i < descriptor_->field_count(); i++) {
     const FieldDescriptor* field = descriptor_->field(i);
     if (field->is_repeated()) {
       if (FieldSize(message, field) > 0) {
         output->push_back(field);
       }
     } else {
-      if (field->containing_oneof()) {
-        if (HasOneofField(message, field)) {
+      const OneofDescriptor* containing_oneof = field->containing_oneof();
+      if (containing_oneof) {
+        // Equivalent to: HasOneofField(message, field)
+        if (oneof_case_array[containing_oneof->index()] == field->number()) {
           output->push_back(field);
         }
-      } else if (HasBit(message, field)) {
+      } else if (has_bits) {
+        // Equivalent to: HasBit(message, field)
+        if (IsIndexInHasBitSet(has_bits, i)) {
+          output->push_back(field);
+        }
+      } else if (HasBit(message, field)) {  // Fall back on proto3-style HasBit.
         output->push_back(field);
       }
     }
   }
 
   if (extensions_offset_ != -1) {
     GetExtensionSet(message).AppendToList(descriptor_, descriptor_pool_,
                                           output);
   }
 
@@ skipping 510 matching lines @@
 Message* GeneratedMessageReflection::UnsafeArenaReleaseMessage(
     Message* message,
     const FieldDescriptor* field,
     MessageFactory* factory) const {
   USAGE_CHECK_ALL(ReleaseMessage, SINGULAR, MESSAGE);
 
   if (factory == NULL) factory = message_factory_;
 
   if (field->is_extension()) {
     return static_cast<Message*>(
-        MutableExtensionSet(message)->ReleaseMessage(field, factory));
+        MutableExtensionSet(message)->UnsafeArenaReleaseMessage(field,
+                                                                factory));
   } else {
     ClearBit(message, field);
     if (field->containing_oneof()) {
       if (HasOneofField(*message, field)) {
         *MutableOneofCase(message, field->containing_oneof()) = 0;
       } else {
         return NULL;
       }
     }
     Message** result = MutableRaw<Message*>(message, field);
@@ skipping 400 matching lines @@
 inline InternalMetadataWithArena*
 GeneratedMessageReflection::MutableInternalMetadataWithArena(
     Message* message) const {
   void* ptr = reinterpret_cast<uint8*>(message) + arena_offset_;
   return reinterpret_cast<InternalMetadataWithArena*>(ptr);
 }
 
 inline bool
 GeneratedMessageReflection::GetIsDefaultInstance(
     const Message& message) const {
-  if (is_default_instance_offset_ == kHasNoDefaultInstanceField) {
-    return false;
-  }
-  const void* ptr = reinterpret_cast<const uint8*>(&message) +
-      is_default_instance_offset_;
-  return *reinterpret_cast<const bool*>(ptr);
+  return &message == default_instance_;
 }
 
 // Simple accessors for manipulating has_bits_.
 inline bool GeneratedMessageReflection::HasBit(
     const Message& message, const FieldDescriptor* field) const {
   if (has_bits_offset_ == -1) {
     // proto3: no has-bits. All fields present except messages, which are
     // present only if their message-field pointer is non-NULL.
     if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
       return !GetIsDefaultInstance(message) &&
@@ skipping 36 matching lines @@
           return GetRaw<double>(message, field) != 0.0;
         case FieldDescriptor::CPPTYPE_ENUM:
           return GetRaw<int>(message, field) != 0;
         case FieldDescriptor::CPPTYPE_MESSAGE:
           // handled above; avoid warning
           GOOGLE_LOG(FATAL) << "Reached impossible case in HasBit().";
           break;
       }
     }
   }
-  return GetHasBits(message)[field->index() / 32] &
-    (1 << (field->index() % 32));
+  return IsIndexInHasBitSet(GetHasBits(message), field->index());
 }
 
 inline void GeneratedMessageReflection::SetBit(
     Message* message, const FieldDescriptor* field) const {
   if (has_bits_offset_ == -1) {
     return;
   }
-  MutableHasBits(message)[field->index() / 32] |= (1 << (field->index() % 32));
+  const uint32 index = static_cast<uint32>(field->index());
+  MutableHasBits(message)[index / 32] |=
+      (static_cast<uint32>(1) << (index % 32));
 }
 
 inline void GeneratedMessageReflection::ClearBit(
     Message* message, const FieldDescriptor* field) const {
   if (has_bits_offset_ == -1) {
     return;
   }
-  MutableHasBits(message)[field->index() / 32] &= ~(1 << (field->index() % 32));
+  const uint32 index = static_cast<uint32>(field->index());
+  MutableHasBits(message)[index / 32] &=
+      ~(static_cast<uint32>(1) << (index % 32));
 }
 
 inline void GeneratedMessageReflection::SwapBit(
     Message* message1, Message* message2, const FieldDescriptor* field) const {
   if (has_bits_offset_ == -1) {
     return;
   }
   bool temp_has_bit = HasBit(*message1, field);
   if (HasBit(*message2, field)) {
     SetBit(message1, field);
@@ skipping 25 matching lines @@
 inline void GeneratedMessageReflection::ClearOneofField(
     Message* message, const FieldDescriptor* field) const {
   if (HasOneofField(*message, field)) {
     ClearOneof(message, field->containing_oneof());
   }
 }
 
 inline void GeneratedMessageReflection::ClearOneof(
     Message* message, const OneofDescriptor* oneof_descriptor) const {
   // TODO(jieluo): Consider to cache the unused object instead of deleting
-  // it. It will be much faster if an aplication switches a lot from
+  // it. It will be much faster if an application switches a lot from
   // a few oneof fields.  Time/space tradeoff
   uint32 oneof_case = GetOneofCase(*message, oneof_descriptor);
   if (oneof_case > 0) {
     const FieldDescriptor* field = descriptor_->FindFieldByNumber(oneof_case);
     if (GetArena(message) == NULL) {
       switch (field->cpp_type()) {
         case FieldDescriptor::CPPTYPE_STRING: {
           switch (field->options().ctype()) {
             default:  // TODO(kenton):  Support other string reps.
             case FieldOptions::STRING: {
@@ skipping 128 matching lines @@
     const Message* default_instance,
     const int offsets[],
     int has_bits_offset,
     int unknown_fields_offset,
     int extensions_offset,
     const void* default_oneof_instance,
     int oneof_case_offset,
     int object_size,
     int arena_offset,
     int is_default_instance_offset) {
-  return new GeneratedMessageReflection(descriptor,
-                                        default_instance,
-                                        offsets,
-                                        has_bits_offset,
-                                        unknown_fields_offset,
-                                        extensions_offset,
-                                        default_oneof_instance,
-                                        oneof_case_offset,
-                                        DescriptorPool::generated_pool(),
-                                        MessageFactory::generated_factory(),
-                                        object_size,
-                                        arena_offset,
-                                        is_default_instance_offset);
+  return new GeneratedMessageReflection(
+      descriptor, default_instance, offsets, has_bits_offset,
+      unknown_fields_offset, extensions_offset, default_oneof_instance,
+      oneof_case_offset, DescriptorPool::generated_pool(),
+      MessageFactory::generated_factory(), object_size, arena_offset);
 }
 
 GeneratedMessageReflection*
 GeneratedMessageReflection::NewGeneratedMessageReflection(
     const Descriptor* descriptor,
     const Message* default_instance,
     const int offsets[],
     int has_bits_offset,
     int unknown_fields_offset,
     int extensions_offset,
     int object_size,
     int arena_offset,
     int is_default_instance_offset) {
-  return new GeneratedMessageReflection(descriptor,
-                                        default_instance,
-                                        offsets,
-                                        has_bits_offset,
-                                        unknown_fields_offset,
-                                        extensions_offset,
-                                        DescriptorPool::generated_pool(),
-                                        MessageFactory::generated_factory(),
-                                        object_size,
-                                        arena_offset,
-                                        is_default_instance_offset);
+  return new GeneratedMessageReflection(
+      descriptor, default_instance, offsets, has_bits_offset,
+      unknown_fields_offset, extensions_offset,
+      DescriptorPool::generated_pool(), MessageFactory::generated_factory(),
+      object_size, arena_offset);
 }
 
 }  // namespace internal
 }  // namespace protobuf
 }  // namespace google