third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/extension_set_heavy.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 77 matching lines @@
  private:
   const DescriptorPool* pool_;
   MessageFactory* factory_;
   const Descriptor* containing_type_;
 };
 
 void ExtensionSet::AppendToList(
     const Descriptor* containing_type,
     const DescriptorPool* pool,
     std::vector<const FieldDescriptor*>* output) const {
-  for (map<int, Extension>::const_iterator iter = extensions_.begin();
+  for (ExtensionMap::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     bool has = false;
     if (iter->second.is_repeated) {
       has = iter->second.GetSize() > 0;
     } else {
       has = !iter->second.is_cleared;
     }
 
     if (has) {
       // TODO(kenton): Looking up each field by number is somewhat unfortunate.
@@ skipping 28 matching lines @@
 
 #define GOOGLE_DCHECK_TYPE(EXTENSION, LABEL, CPPTYPE)                            \
   GOOGLE_DCHECK_EQ((EXTENSION).is_repeated ? FieldDescriptor::LABEL_REPEATED     \
                                   : FieldDescriptor::LABEL_OPTIONAL,      \
             FieldDescriptor::LABEL_##LABEL);                              \
   GOOGLE_DCHECK_EQ(cpp_type((EXTENSION).type), FieldDescriptor::CPPTYPE_##CPPTYPE)
 
 const MessageLite& ExtensionSet::GetMessage(int number,
                                             const Descriptor* message_type,
                                             MessageFactory* factory) const {
-  map<int, Extension>::const_iterator iter = extensions_.find(number);
+  ExtensionMap::const_iterator iter = extensions_.find(number);
   if (iter == extensions_.end() || iter->second.is_cleared) {
     // Not present.  Return the default value.
     return *factory->GetPrototype(message_type);
   } else {
     GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE);
     if (iter->second.is_lazy) {
       return iter->second.lazymessage_value->GetMessage(
           *factory->GetPrototype(message_type));
     } else {
       return *iter->second.message_value;
@@ skipping 22 matching lines @@
       return extension->lazymessage_value->MutableMessage(
           *factory->GetPrototype(descriptor->message_type()));
     } else {
       return extension->message_value;
     }
   }
 }
 
 MessageLite* ExtensionSet::ReleaseMessage(const FieldDescriptor* descriptor,
                                           MessageFactory* factory) {
-  map<int, Extension>::iterator iter = extensions_.find(descriptor->number());
+  ExtensionMap::iterator iter = extensions_.find(descriptor->number());
   if (iter == extensions_.end()) {
     // Not present.  Return NULL.
     return NULL;
   } else {
     GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE);
     MessageLite* ret = NULL;
     if (iter->second.is_lazy) {
       ret = iter->second.lazymessage_value->ReleaseMessage(
           *factory->GetPrototype(descriptor->message_type()));
       if (arena_ == NULL) {
         delete iter->second.lazymessage_value;
       }
     } else {
       if (arena_ != NULL) {
         ret = (iter->second.message_value)->New();
         ret->CheckTypeAndMergeFrom(*(iter->second.message_value));
       } else {
         ret = iter->second.message_value;
       }
     }
     extensions_.erase(descriptor->number());
     return ret;
   }
 }
 
+MessageLite* ExtensionSet::UnsafeArenaReleaseMessage(
+    const FieldDescriptor* descriptor, MessageFactory* factory) {
+  ExtensionMap::iterator iter = extensions_.find(descriptor->number());
+  if (iter == extensions_.end()) {
+    // Not present.  Return NULL.
+    return NULL;
+  } else {
+    GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE);
+    MessageLite* ret = NULL;
+    if (iter->second.is_lazy) {
+      ret = iter->second.lazymessage_value->UnsafeArenaReleaseMessage(
+          *factory->GetPrototype(descriptor->message_type()));
+      if (arena_ == NULL) {
+        delete iter->second.lazymessage_value;
+      }
+    } else {
+      ret = iter->second.message_value;
+    }
+    extensions_.erase(descriptor->number());
+    return ret;
+  }
+}
+
 ExtensionSet::Extension* ExtensionSet::MaybeNewRepeatedExtension(const FieldDescriptor* descriptor) {
   Extension* extension;
   if (MaybeNewExtension(descriptor->number(), descriptor, &extension)) {
     extension->type = descriptor->type();
     GOOGLE_DCHECK_EQ(cpp_type(extension->type), FieldDescriptor::CPPTYPE_MESSAGE);
     extension->is_repeated = true;
     extension->repeated_message_value =
         ::google::protobuf::Arena::CreateMessage<RepeatedPtrField<MessageLite> >(arena_);
   } else {
     GOOGLE_DCHECK_TYPE(*extension, REPEATED, MESSAGE);
@@ skipping 85 matching lines @@
   } else {
     DescriptorPoolExtensionFinder finder(input->GetExtensionPool(),
                                          input->GetExtensionFactory(),
                                          containing_type->GetDescriptor());
     return ParseMessageSet(input, &finder, &skipper);
   }
 }
 
 int ExtensionSet::SpaceUsedExcludingSelf() const {
   int total_size =
-      extensions_.size() * sizeof(map<int, Extension>::value_type);
-  for (map<int, Extension>::const_iterator iter = extensions_.begin(),
+      extensions_.size() * sizeof(ExtensionMap::value_type);
+  for (ExtensionMap::const_iterator iter = extensions_.begin(),
        end = extensions_.end();
        iter != end;
        ++iter) {
     total_size += iter->second.SpaceUsedExcludingSelf();
   }
   return total_size;
 }
 
 inline int ExtensionSet::RepeatedMessage_SpaceUsedExcludingSelf(
     RepeatedPtrFieldBase* field) {
@@ skipping 46 matching lines @@
       default:
         // No extra storage costs for primitive types.
         break;
     }
   }
   return total_size;
 }
 
 // The Serialize*ToArray methods are only needed in the heavy library, as
 // the lite library only generates SerializeWithCachedSizes.
-uint8* ExtensionSet::SerializeWithCachedSizesToArray(
+uint8* ExtensionSet::SerializeWithCachedSizesToArray(int start_field_number,
+                                                     int end_field_number,
+                                                     uint8* target) const {
+  return InternalSerializeWithCachedSizesToArray(
+      start_field_number, end_field_number, false, target);
+}
+
+uint8* ExtensionSet::SerializeMessageSetWithCachedSizesToArray(
+    uint8* target) const {
+  return InternalSerializeMessageSetWithCachedSizesToArray(false, target);
+}
+
+uint8* ExtensionSet::InternalSerializeWithCachedSizesToArray(
     int start_field_number, int end_field_number,
-    uint8* target) const {
-  map<int, Extension>::const_iterator iter;
+    bool deterministic, uint8* target) const {
+  ExtensionMap::const_iterator iter;
   for (iter = extensions_.lower_bound(start_field_number);
        iter != extensions_.end() && iter->first < end_field_number;
        ++iter) {
-    target = iter->second.SerializeFieldWithCachedSizesToArray(iter->first,
-                                                               target);
+    target = iter->second.InternalSerializeFieldWithCachedSizesToArray(
+        iter->first, deterministic, target);
   }
   return target;
 }
 
-uint8* ExtensionSet::SerializeMessageSetWithCachedSizesToArray(
-    uint8* target) const {
-  map<int, Extension>::const_iterator iter;
+uint8* ExtensionSet::InternalSerializeMessageSetWithCachedSizesToArray(
+    bool deterministic, uint8* target) const {
+  ExtensionMap::const_iterator iter;
   for (iter = extensions_.begin(); iter != extensions_.end(); ++iter) {
-    target = iter->second.SerializeMessageSetItemWithCachedSizesToArray(
-        iter->first, target);
+    target = iter->second.InternalSerializeMessageSetItemWithCachedSizesToArray(
+        iter->first, deterministic, target);
   }
   return target;
 }
 
-uint8* ExtensionSet::Extension::SerializeFieldWithCachedSizesToArray(
-    int number, uint8* target) const {
+uint8* ExtensionSet::Extension::InternalSerializeFieldWithCachedSizesToArray(
+    int number, bool deterministic, uint8* target) const {
   if (is_repeated) {
     if (is_packed) {
       if (cached_size == 0) return target;
 
       target = WireFormatLite::WriteTagToArray(number,
           WireFormatLite::WIRETYPE_LENGTH_DELIMITED, target);
       target = WireFormatLite::WriteInt32NoTagToArray(cached_size, target);
 
       switch (real_type(type)) {
 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE)                        \
@@ skipping 46 matching lines @@
         HANDLE_TYPE( FIXED32,  Fixed32,  uint32);
         HANDLE_TYPE( FIXED64,  Fixed64,  uint64);
         HANDLE_TYPE(SFIXED32, SFixed32,   int32);
         HANDLE_TYPE(SFIXED64, SFixed64,   int64);
         HANDLE_TYPE(   FLOAT,    Float,   float);
         HANDLE_TYPE(  DOUBLE,   Double,  double);
         HANDLE_TYPE(    BOOL,     Bool,    bool);
         HANDLE_TYPE(  STRING,   String,  string);
         HANDLE_TYPE(   BYTES,    Bytes,  string);
         HANDLE_TYPE(    ENUM,     Enum,    enum);
+#undef HANDLE_TYPE
+#define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE)                        \
+        case FieldDescriptor::TYPE_##UPPERCASE:                             \
+          for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) {  \
+            target = WireFormatLite::InternalWrite##CAMELCASE##ToArray(     \
+                      number, repeated_##LOWERCASE##_value->Get(i),         \
+                      deterministic, target);                               \
+          }                                                                 \
+          break
+
         HANDLE_TYPE(   GROUP,    Group, message);
         HANDLE_TYPE( MESSAGE,  Message, message);
 #undef HANDLE_TYPE
       }
     }
   } else if (!is_cleared) {
     switch (real_type(type)) {
 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, VALUE)                 \
       case FieldDescriptor::TYPE_##UPPERCASE:                    \
         target = WireFormatLite::Write##CAMELCASE##ToArray(      \
@@ skipping 13 matching lines @@
       HANDLE_TYPE(   FLOAT,    Float,    float_value);
       HANDLE_TYPE(  DOUBLE,   Double,   double_value);
       HANDLE_TYPE(    BOOL,     Bool,     bool_value);
       HANDLE_TYPE(  STRING,   String,  *string_value);
       HANDLE_TYPE(   BYTES,    Bytes,  *string_value);
       HANDLE_TYPE(    ENUM,     Enum,     enum_value);
       HANDLE_TYPE(   GROUP,    Group, *message_value);
 #undef HANDLE_TYPE
       case FieldDescriptor::TYPE_MESSAGE:
         if (is_lazy) {
-          target = lazymessage_value->WriteMessageToArray(number, target);
+          target = lazymessage_value->InternalWriteMessageToArray(
+              number, deterministic, target);
         } else {
-          target = WireFormatLite::WriteMessageToArray(
-              number, *message_value, target);
+          target = WireFormatLite::InternalWriteMessageToArray(
+              number, *message_value, deterministic, target);
         }
         break;
     }
   }
   return target;
 }
 
-uint8* ExtensionSet::Extension::SerializeMessageSetItemWithCachedSizesToArray(
-    int number,
-    uint8* target) const {
+uint8*
+ExtensionSet::Extension::InternalSerializeMessageSetItemWithCachedSizesToArray(
+    int number, bool deterministic, uint8* target) const {
   if (type != WireFormatLite::TYPE_MESSAGE || is_repeated) {
     // Not a valid MessageSet extension, but serialize it the normal way.
     GOOGLE_LOG(WARNING) << "Invalid message set extension.";
-    return SerializeFieldWithCachedSizesToArray(number, target);
+    return InternalSerializeFieldWithCachedSizesToArray(number, deterministic,
+                                                        target);
   }
 
   if (is_cleared) return target;
 
   // Start group.
   target = io::CodedOutputStream::WriteTagToArray(
       WireFormatLite::kMessageSetItemStartTag, target);
   // Write type ID.
   target = WireFormatLite::WriteUInt32ToArray(
       WireFormatLite::kMessageSetTypeIdNumber, number, target);
@@ skipping 61 matching lines @@
   //   required int32 type_id = 2;
   //   required data message = 3;
 
   uint32 last_type_id = 0;
 
   // If we see message data before the type_id, we'll append it to this so
   // we can parse it later.
   string message_data;
 
   while (true) {
-    const uint32 tag = input->ReadTag();
+    const uint32 tag = input->ReadTagNoLastTag();
     if (tag == 0) return false;
 
     switch (tag) {
       case WireFormatLite::kMessageSetTypeIdTag: {
         uint32 type_id;
         if (!input->ReadVarint32(&type_id)) return false;
         last_type_id = type_id;
 
         if (!message_data.empty()) {
           // We saw some message data before the type_id.  Have to parse it
@@ skipping 72 matching lines @@
     WireFormatLite::WriteMessageMaybeToArray(
         WireFormatLite::kMessageSetMessageNumber,
         *message_value,
         output);
   }
 
   // End group.
   output->WriteTag(WireFormatLite::kMessageSetItemEndTag);
 }
 
-int ExtensionSet::Extension::MessageSetItemByteSize(int number) const {
+size_t ExtensionSet::Extension::MessageSetItemByteSize(int number) const {
   if (type != WireFormatLite::TYPE_MESSAGE || is_repeated) {
     // Not a valid MessageSet extension, but compute the byte size for it the
     // normal way.
     return ByteSize(number);
   }
 
   if (is_cleared) return 0;
 
-  int our_size = WireFormatLite::kMessageSetItemTagsSize;
+  size_t our_size = WireFormatLite::kMessageSetItemTagsSize;
 
   // type_id
   our_size += io::CodedOutputStream::VarintSize32(number);
 
   // message
-  int message_size = 0;
+  size_t message_size = 0;
   if (is_lazy) {
     message_size = lazymessage_value->ByteSize();
   } else {
     message_size = message_value->ByteSize();
   }
 
   our_size += io::CodedOutputStream::VarintSize32(message_size);
   our_size += message_size;
 
   return our_size;
 }
 
 void ExtensionSet::SerializeMessageSetWithCachedSizes(
     io::CodedOutputStream* output) const {
-  for (map<int, Extension>::const_iterator iter = extensions_.begin();
+  for (ExtensionMap::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     iter->second.SerializeMessageSetItemWithCachedSizes(iter->first, output);
   }
 }
 
-int ExtensionSet::MessageSetByteSize() const {
-  int total_size = 0;
+size_t ExtensionSet::MessageSetByteSize() const {
+  size_t total_size = 0;
 
-  for (map<int, Extension>::const_iterator iter = extensions_.begin();
+  for (ExtensionMap::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     total_size += iter->second.MessageSetItemByteSize(iter->first);
   }
 
   return total_size;
 }
 
 }  // namespace internal
 }  // namespace protobuf
 }  // namespace google