third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/extension_set.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 58 matching lines @@
       return false;
 
     // Do not add a default statement. Let the compiler complain when someone
     // adds a new wire type.
   }
   GOOGLE_LOG(FATAL) << "can't reach here.";
   return false;
 }
 
 // Registry stuff.
-typedef hash_map<pair<const MessageLite*, int>,
+typedef hash_map<std::pair<const MessageLite*, int>,
                  ExtensionInfo> ExtensionRegistry;
 ExtensionRegistry* registry_ = NULL;
 GOOGLE_PROTOBUF_DECLARE_ONCE(registry_init_);
 
 void DeleteRegistry() {
   delete registry_;
   registry_ = NULL;
 }
 
 void InitRegistry() {
@@ skipping 80 matching lines @@
         type == WireFormatLite::TYPE_GROUP);
   ExtensionInfo info(type, is_repeated, is_packed);
   info.message_prototype = prototype;
   Register(containing_type, number, info);
 }
 
 
 // ===================================================================
 // Constructors and basic methods.
 
-ExtensionSet::ExtensionSet(::google::protobuf::Arena* arena) : arena_(arena) {
+ExtensionSet::ExtensionSet(::google::protobuf::Arena* arena)
+    : arena_(arena) {
   if (arena_ != NULL) {
     arena_->OwnDestructor(&extensions_);
   }
 }
 
 ExtensionSet::ExtensionSet() : arena_(NULL) {}
 
 ExtensionSet::~ExtensionSet() {
   // Deletes all allocated extensions.
   if (arena_ == NULL) {
-    for (map<int, Extension>::iterator iter = extensions_.begin();
+    for (ExtensionMap::iterator iter = extensions_.begin();
          iter != extensions_.end(); ++iter) {
       iter->second.Free();
     }
   }
 }
 
 // Defined in extension_set_heavy.cc.
 // void ExtensionSet::AppendToList(const Descriptor* containing_type,
 //                                 const DescriptorPool* pool,
 //                                 vector<const FieldDescriptor*>* output) const
 
 bool ExtensionSet::Has(int number) const {
-  map<int, Extension>::const_iterator iter = extensions_.find(number);
+  ExtensionMap::const_iterator iter = extensions_.find(number);
   if (iter == extensions_.end()) return false;
   GOOGLE_DCHECK(!iter->second.is_repeated);
   return !iter->second.is_cleared;
 }
 
 int ExtensionSet::NumExtensions() const {
   int result = 0;
-  for (map<int, Extension>::const_iterator iter = extensions_.begin();
+  for (ExtensionMap::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     if (!iter->second.is_cleared) {
       ++result;
     }
   }
   return result;
 }
 
 int ExtensionSet::ExtensionSize(int number) const {
-  map<int, Extension>::const_iterator iter = extensions_.find(number);
+  ExtensionMap::const_iterator iter = extensions_.find(number);
   if (iter == extensions_.end()) return false;
   return iter->second.GetSize();
 }
 
 FieldType ExtensionSet::ExtensionType(int number) const {
-  map<int, Extension>::const_iterator iter = extensions_.find(number);
+  ExtensionMap::const_iterator iter = extensions_.find(number);
   if (iter == extensions_.end()) {
     GOOGLE_LOG(DFATAL) << "Don't lookup extension types if they aren't present (1). ";
     return 0;
   }
   if (iter->second.is_cleared) {
     GOOGLE_LOG(DFATAL) << "Don't lookup extension types if they aren't present (2). ";
   }
   return iter->second.type;
 }
 
 void ExtensionSet::ClearExtension(int number) {
-  map<int, Extension>::iterator iter = extensions_.find(number);
+  ExtensionMap::iterator iter = extensions_.find(number);
   if (iter == extensions_.end()) return;
   iter->second.Clear();
 }
 
 // ===================================================================
 // Field accessors
 
 namespace {
 
 enum Cardinality {
   REPEATED,
   OPTIONAL
 };
 
 }  // namespace
 
 #define GOOGLE_DCHECK_TYPE(EXTENSION, LABEL, CPPTYPE)                             \
   GOOGLE_DCHECK_EQ((EXTENSION).is_repeated ? REPEATED : OPTIONAL, LABEL);         \
   GOOGLE_DCHECK_EQ(cpp_type((EXTENSION).type), WireFormatLite::CPPTYPE_##CPPTYPE)
 
 // -------------------------------------------------------------------
 // Primitives
 
 #define PRIMITIVE_ACCESSORS(UPPERCASE, LOWERCASE, CAMELCASE)                   \
                                                                                \
 LOWERCASE ExtensionSet::Get##CAMELCASE(int number,                             \
                                        LOWERCASE default_value) 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) {                  \
     return default_value;                                                      \
   } else {                                                                     \
     GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, UPPERCASE);                            \
     return iter->second.LOWERCASE##_value;                                     \
   }                                                                            \
 }                                                                              \
                                                                                \
 void ExtensionSet::Set##CAMELCASE(int number, FieldType type,                  \
                                   LOWERCASE value,                             \
                                   const FieldDescriptor* descriptor) {         \
   Extension* extension;                                                        \
   if (MaybeNewExtension(number, descriptor, &extension)) {                     \
     extension->type = type;                                                    \
     GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_##UPPERCASE); \
     extension->is_repeated = false;                                            \
   } else {                                                                     \
     GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, UPPERCASE);                              \
   }                                                                            \
   extension->is_cleared = false;                                               \
   extension->LOWERCASE##_value = value;                                        \
 }                                                                              \
                                                                                \
 LOWERCASE ExtensionSet::GetRepeated##CAMELCASE(int number, int index) const {  \
-  map<int, Extension>::const_iterator iter = extensions_.find(number);         \
+  ExtensionMap::const_iterator iter = extensions_.find(number);                \
   GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty)."; \
   GOOGLE_DCHECK_TYPE(iter->second, REPEATED, UPPERCASE);                              \
   return iter->second.repeated_##LOWERCASE##_value->Get(index);                \
 }                                                                              \
                                                                                \
 void ExtensionSet::SetRepeated##CAMELCASE(                                     \
     int number, int index, LOWERCASE value) {                                  \
-  map<int, Extension>::iterator iter = extensions_.find(number);               \
+  ExtensionMap::iterator iter = extensions_.find(number);                      \
   GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty)."; \
   GOOGLE_DCHECK_TYPE(iter->second, REPEATED, UPPERCASE);                              \
   iter->second.repeated_##LOWERCASE##_value->Set(index, value);                \
 }                                                                              \
                                                                                \
 void ExtensionSet::Add##CAMELCASE(int number, FieldType type,                  \
                                   bool packed, LOWERCASE value,                \
                                   const FieldDescriptor* descriptor) {         \
   Extension* extension;                                                        \
   if (MaybeNewExtension(number, descriptor, &extension)) {                     \
@@ skipping 15 matching lines @@
 PRIMITIVE_ACCESSORS(UINT32, uint32, UInt32)
 PRIMITIVE_ACCESSORS(UINT64, uint64, UInt64)
 PRIMITIVE_ACCESSORS( FLOAT,  float,  Float)
 PRIMITIVE_ACCESSORS(DOUBLE, double, Double)
 PRIMITIVE_ACCESSORS(  BOOL,   bool,   Bool)
 
 #undef PRIMITIVE_ACCESSORS
 
 const void* ExtensionSet::GetRawRepeatedField(int number,
                                               const void* default_value) const {
-  map<int, Extension>::const_iterator iter = extensions_.find(number);
+  ExtensionMap::const_iterator iter = extensions_.find(number);
   if (iter == extensions_.end()) {
     return default_value;
   }
   // We assume that all the RepeatedField<>* pointers have the same
   // size and alignment within the anonymous union in Extension.
   return iter->second.repeated_int32_value;
 }
 
 void* ExtensionSet::MutableRawRepeatedField(int number, FieldType field_type,
                                             bool packed,
@@ skipping 53 matching lines @@
   }
 
   // We assume that all the RepeatedField<>* pointers have the same
   // size and alignment within the anonymous union in Extension.
   return extension->repeated_int32_value;
 }
 
 // Compatible version using old call signature. Does not create extensions when
 // the don't already exist; instead, just GOOGLE_CHECK-fails.
 void* ExtensionSet::MutableRawRepeatedField(int number) {
-  map<int, Extension>::iterator iter = extensions_.find(number);
+  ExtensionMap::iterator iter = extensions_.find(number);
   GOOGLE_CHECK(iter == extensions_.end()) << "Extension not found.";
   // We assume that all the RepeatedField<>* pointers have the same
   // size and alignment within the anonymous union in Extension.
   return iter->second.repeated_int32_value;
 }
 
 
 // -------------------------------------------------------------------
 // Enums
 
 int ExtensionSet::GetEnum(int number, int default_value) 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 default_value;
   } else {
     GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, ENUM);
     return iter->second.enum_value;
   }
 }
 
 void ExtensionSet::SetEnum(int number, FieldType type, int value,
                            const FieldDescriptor* descriptor) {
   Extension* extension;
   if (MaybeNewExtension(number, descriptor, &extension)) {
     extension->type = type;
     GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_ENUM);
     extension->is_repeated = false;
   } else {
     GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, ENUM);
   }
   extension->is_cleared = false;
   extension->enum_value = value;
 }
 
 int ExtensionSet::GetRepeatedEnum(int number, int index) const {
-  map<int, Extension>::const_iterator iter = extensions_.find(number);
+  ExtensionMap::const_iterator iter = extensions_.find(number);
   GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
   GOOGLE_DCHECK_TYPE(iter->second, REPEATED, ENUM);
   return iter->second.repeated_enum_value->Get(index);
 }
 
 void ExtensionSet::SetRepeatedEnum(int number, int index, int value) {
-  map<int, Extension>::iterator iter = extensions_.find(number);
+  ExtensionMap::iterator iter = extensions_.find(number);
   GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
   GOOGLE_DCHECK_TYPE(iter->second, REPEATED, ENUM);
   iter->second.repeated_enum_value->Set(index, value);
 }
 
 void ExtensionSet::AddEnum(int number, FieldType type,
                            bool packed, int value,
                            const FieldDescriptor* descriptor) {
   Extension* extension;
   if (MaybeNewExtension(number, descriptor, &extension)) {
     extension->type = type;
     GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_ENUM);
     extension->is_repeated = true;
     extension->is_packed = packed;
     extension->repeated_enum_value =
         Arena::CreateMessage<RepeatedField<int> >(arena_);
   } else {
     GOOGLE_DCHECK_TYPE(*extension, REPEATED, ENUM);
     GOOGLE_DCHECK_EQ(extension->is_packed, packed);
   }
   extension->repeated_enum_value->Add(value);
 }
 
 // -------------------------------------------------------------------
 // Strings
 
 const string& ExtensionSet::GetString(int number,
                                       const string& default_value) 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 default_value;
   } else {
     GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, STRING);
     return *iter->second.string_value;
   }
 }
 
 string* ExtensionSet::MutableString(int number, FieldType type,
                                     const FieldDescriptor* descriptor) {
   Extension* extension;
   if (MaybeNewExtension(number, descriptor, &extension)) {
     extension->type = type;
     GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_STRING);
     extension->is_repeated = false;
     extension->string_value = Arena::Create<string>(arena_);
   } else {
     GOOGLE_DCHECK_TYPE(*extension, OPTIONAL, STRING);
   }
   extension->is_cleared = false;
   return extension->string_value;
 }
 
 const string& ExtensionSet::GetRepeatedString(int number, int index) const {
-  map<int, Extension>::const_iterator iter = extensions_.find(number);
+  ExtensionMap::const_iterator iter = extensions_.find(number);
   GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
   GOOGLE_DCHECK_TYPE(iter->second, REPEATED, STRING);
   return iter->second.repeated_string_value->Get(index);
 }
 
 string* ExtensionSet::MutableRepeatedString(int number, int index) {
-  map<int, Extension>::iterator iter = extensions_.find(number);
+  ExtensionMap::iterator iter = extensions_.find(number);
   GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
   GOOGLE_DCHECK_TYPE(iter->second, REPEATED, STRING);
   return iter->second.repeated_string_value->Mutable(index);
 }
 
 string* ExtensionSet::AddString(int number, FieldType type,
                                 const FieldDescriptor* descriptor) {
   Extension* extension;
   if (MaybeNewExtension(number, descriptor, &extension)) {
     extension->type = type;
     GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_STRING);
     extension->is_repeated = true;
     extension->is_packed = false;
     extension->repeated_string_value =
         Arena::CreateMessage<RepeatedPtrField<string> >(arena_);
   } else {
     GOOGLE_DCHECK_TYPE(*extension, REPEATED, STRING);
   }
   return extension->repeated_string_value->Add();
 }
 
 // -------------------------------------------------------------------
 // Messages
 
 const MessageLite& ExtensionSet::GetMessage(
     int number, const MessageLite& default_value) const {
-  map<int, Extension>::const_iterator iter = extensions_.find(number);
+  ExtensionMap::const_iterator iter = extensions_.find(number);
   if (iter == extensions_.end()) {
     // Not present.  Return the default value.
     return default_value;
   } else {
     GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE);
     if (iter->second.is_lazy) {
       return iter->second.lazymessage_value->GetMessage(default_value);
     } else {
       return *iter->second.message_value;
     }
@@ skipping 102 matching lines @@
       }
       extension->message_value = message;
     }
   }
   extension->is_cleared = false;
 }
 
 
 MessageLite* ExtensionSet::ReleaseMessage(int number,
                                           const MessageLite& prototype) {
-  map<int, Extension>::iterator iter = extensions_.find(number);
+  ExtensionMap::iterator iter = extensions_.find(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(prototype);
       if (arena_ == NULL) {
         delete iter->second.lazymessage_value;
       }
     } else {
       if (arena_ == NULL) {
         ret = iter->second.message_value;
       } else {
         // ReleaseMessage() always returns a heap-allocated message, and we are
         // on an arena, so we need to make a copy of this message to return.
         ret = (iter->second.message_value)->New();
         ret->CheckTypeAndMergeFrom(*iter->second.message_value);
       }
     }
     extensions_.erase(number);
     return ret;
   }
 }
 
 MessageLite* ExtensionSet::UnsafeArenaReleaseMessage(
     int number, const MessageLite& prototype) {
-  map<int, Extension>::iterator iter = extensions_.find(number);
+  ExtensionMap::iterator iter = extensions_.find(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(prototype);
       if (arena_ == NULL) {
         delete iter->second.lazymessage_value;
       }
     } else {
       ret = iter->second.message_value;
     }
     extensions_.erase(number);
     return ret;
   }
 }
 
 // Defined in extension_set_heavy.cc.
 // MessageLite* ExtensionSet::ReleaseMessage(const FieldDescriptor* descriptor,
 //                                           MessageFactory* factory);
 
 const MessageLite& ExtensionSet::GetRepeatedMessage(
     int number, int index) const {
-  map<int, Extension>::const_iterator iter = extensions_.find(number);
+  ExtensionMap::const_iterator iter = extensions_.find(number);
   GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
   GOOGLE_DCHECK_TYPE(iter->second, REPEATED, MESSAGE);
   return iter->second.repeated_message_value->Get(index);
 }
 
 MessageLite* ExtensionSet::MutableRepeatedMessage(int number, int index) {
-  map<int, Extension>::iterator iter = extensions_.find(number);
+  ExtensionMap::iterator iter = extensions_.find(number);
   GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
   GOOGLE_DCHECK_TYPE(iter->second, REPEATED, MESSAGE);
   return iter->second.repeated_message_value->Mutable(index);
 }
 
 MessageLite* ExtensionSet::AddMessage(int number, FieldType type,
                                       const MessageLite& prototype,
                                       const FieldDescriptor* descriptor) {
   Extension* extension;
   if (MaybeNewExtension(number, descriptor, &extension)) {
@@ skipping 18 matching lines @@
 }
 
 // Defined in extension_set_heavy.cc.
 // MessageLite* ExtensionSet::AddMessage(int number, FieldType type,
 //                                       const Descriptor* message_type,
 //                                       MessageFactory* factory)
 
 #undef GOOGLE_DCHECK_TYPE
 
 void ExtensionSet::RemoveLast(int number) {
-  map<int, Extension>::iterator iter = extensions_.find(number);
+  ExtensionMap::iterator iter = extensions_.find(number);
   GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
 
   Extension* extension = &iter->second;
   GOOGLE_DCHECK(extension->is_repeated);
 
   switch(cpp_type(extension->type)) {
     case WireFormatLite::CPPTYPE_INT32:
       extension->repeated_int32_value->RemoveLast();
       break;
     case WireFormatLite::CPPTYPE_INT64:
@@ skipping 20 matching lines @@
     case WireFormatLite::CPPTYPE_STRING:
       extension->repeated_string_value->RemoveLast();
       break;
     case WireFormatLite::CPPTYPE_MESSAGE:
       extension->repeated_message_value->RemoveLast();
       break;
   }
 }
 
 MessageLite* ExtensionSet::ReleaseLast(int number) {
-  map<int, Extension>::iterator iter = extensions_.find(number);
+  ExtensionMap::iterator iter = extensions_.find(number);
   GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
 
   Extension* extension = &iter->second;
   GOOGLE_DCHECK(extension->is_repeated);
   GOOGLE_DCHECK(cpp_type(extension->type) == WireFormatLite::CPPTYPE_MESSAGE);
   return extension->repeated_message_value->ReleaseLast();
 }
 
 void ExtensionSet::SwapElements(int number, int index1, int index2) {
-  map<int, Extension>::iterator iter = extensions_.find(number);
+  ExtensionMap::iterator iter = extensions_.find(number);
   GOOGLE_CHECK(iter != extensions_.end()) << "Index out-of-bounds (field is empty).";
 
   Extension* extension = &iter->second;
   GOOGLE_DCHECK(extension->is_repeated);
 
   switch(cpp_type(extension->type)) {
     case WireFormatLite::CPPTYPE_INT32:
       extension->repeated_int32_value->SwapElements(index1, index2);
       break;
     case WireFormatLite::CPPTYPE_INT64:
@@ skipping 22 matching lines @@
       break;
     case WireFormatLite::CPPTYPE_MESSAGE:
       extension->repeated_message_value->SwapElements(index1, index2);
       break;
   }
 }
 
 // ===================================================================
 
 void ExtensionSet::Clear() {
-  for (map<int, Extension>::iterator iter = extensions_.begin();
+  for (ExtensionMap::iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     iter->second.Clear();
   }
 }
 
 void ExtensionSet::MergeFrom(const ExtensionSet& other) {
-  for (map<int, Extension>::const_iterator iter = other.extensions_.begin();
+  for (ExtensionMap::const_iterator iter = other.extensions_.begin();
        iter != other.extensions_.end(); ++iter) {
     const Extension& other_extension = iter->second;
     InternalExtensionMergeFrom(iter->first, other_extension);
   }
 }
 
 void ExtensionSet::InternalExtensionMergeFrom(
   int number, const Extension& other_extension) {
   if (other_extension.is_repeated) {
     Extension* extension;
@@ skipping 143 matching lines @@
     x->Clear();
     x->MergeFrom(*this);
     Clear();
     MergeFrom(extension_set);
   }
 }
 
 void ExtensionSet::SwapExtension(ExtensionSet* other,
                                  int number) {
   if (this == other) return;
-  map<int, Extension>::iterator this_iter = extensions_.find(number);
-  map<int, Extension>::iterator other_iter = other->extensions_.find(number);
+  ExtensionMap::iterator this_iter = extensions_.find(number);
+  ExtensionMap::iterator other_iter = other->extensions_.find(number);
 
   if (this_iter == extensions_.end() &&
       other_iter == other->extensions_.end()) {
     return;
   }
 
   if (this_iter != extensions_.end() &&
       other_iter != other->extensions_.end()) {
     if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
       using std::swap;
       swap(this_iter->second, other_iter->second);
     } else {
       // TODO(cfallin, rohananil): We could further optimize these cases,
       // especially avoid creation of ExtensionSet, and move MergeFrom logic
       // into Extensions itself (which takes arena as an argument).
       // We do it this way to reuse the copy-across-arenas logic already
       // implemented in ExtensionSet's MergeFrom.
       ExtensionSet temp;
       temp.InternalExtensionMergeFrom(number, other_iter->second);
-      map<int, Extension>::iterator temp_iter = temp.extensions_.find(number);
+      ExtensionMap::iterator temp_iter = temp.extensions_.find(number);
       other_iter->second.Clear();
       other->InternalExtensionMergeFrom(number, this_iter->second);
       this_iter->second.Clear();
       InternalExtensionMergeFrom(number, temp_iter->second);
     }
     return;
   }
 
   if (this_iter == extensions_.end()) {
     if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
@@ skipping 12 matching lines @@
       other->InternalExtensionMergeFrom(number, this_iter->second);
     }
     extensions_.erase(number);
     return;
   }
 }
 
 bool ExtensionSet::IsInitialized() const {
   // Extensions are never required.  However, we need to check that all
   // embedded messages are initialized.
-  for (map<int, Extension>::const_iterator iter = extensions_.begin();
+  for (ExtensionMap::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     const Extension& extension = iter->second;
     if (cpp_type(extension.type) == WireFormatLite::CPPTYPE_MESSAGE) {
       if (extension.is_repeated) {
         for (int i = 0; i < extension.repeated_message_value->size(); i++) {
           if (!extension.repeated_message_value->Get(i).IsInitialized()) {
             return false;
           }
         }
       } else {
@@ skipping 239 matching lines @@
 //                               UnknownFieldSet* unknown_fields)
 
 // Defined in extension_set_heavy.cc.
 // bool ExtensionSet::ParseMessageSet(io::CodedInputStream* input,
 //                                    const MessageLite* containing_type,
 //                                    UnknownFieldSet* unknown_fields);
 
 void ExtensionSet::SerializeWithCachedSizes(
     int start_field_number, int end_field_number,
     io::CodedOutputStream* output) const {
-  map<int, Extension>::const_iterator iter;
+  ExtensionMap::const_iterator iter;
   for (iter = extensions_.lower_bound(start_field_number);
        iter != extensions_.end() && iter->first < end_field_number;
        ++iter) {
     iter->second.SerializeFieldWithCachedSizes(iter->first, output);
   }
 }
 
-int ExtensionSet::ByteSize() const {
-  int total_size = 0;
+size_t ExtensionSet::ByteSize() 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.ByteSize(iter->first);
   }
 
   return total_size;
 }
 
 // Defined in extension_set_heavy.cc.
 // int ExtensionSet::SpaceUsedExcludingSelf() const
 
 bool ExtensionSet::MaybeNewExtension(int number,
                                      const FieldDescriptor* descriptor,
                                      Extension** result) {
-  pair<map<int, Extension>::iterator, bool> insert_result =
+  std::pair<ExtensionMap::iterator, bool> insert_result =
       extensions_.insert(std::make_pair(number, Extension()));
   *result = &insert_result.first->second;
   (*result)->descriptor = descriptor;
   return insert_result.second;
 }
 
 // ===================================================================
 // Methods of ExtensionSet::Extension
 
 void ExtensionSet::Extension::Clear() {
@@ skipping 144 matching lines @@
         if (is_lazy) {
           lazymessage_value->WriteMessage(number, output);
         } else {
           WireFormatLite::WriteMessage(number, *message_value, output);
         }
         break;
     }
   }
 }
 
-int ExtensionSet::Extension::ByteSize(int number) const {
-  int result = 0;
+size_t ExtensionSet::Extension::ByteSize(int number) const {
+  size_t result = 0;
 
   if (is_repeated) {
     if (is_packed) {
       switch (real_type(type)) {
 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE)                        \
         case WireFormatLite::TYPE_##UPPERCASE:                              \
           for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) {  \
             result += WireFormatLite::CAMELCASE##Size(                      \
               repeated_##LOWERCASE##_value->Get(i));                        \
           }                                                                 \
           break
 
         HANDLE_TYPE(   INT32,    Int32,   int32);
         HANDLE_TYPE(   INT64,    Int64,   int64);
         HANDLE_TYPE(  UINT32,   UInt32,  uint32);
         HANDLE_TYPE(  UINT64,   UInt64,  uint64);
         HANDLE_TYPE(  SINT32,   SInt32,   int32);
         HANDLE_TYPE(  SINT64,   SInt64,   int64);
         HANDLE_TYPE(    ENUM,     Enum,    enum);
 #undef HANDLE_TYPE
 
         // Stuff with fixed size.
 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE)                        \
         case WireFormatLite::TYPE_##UPPERCASE:                              \
           result += WireFormatLite::k##CAMELCASE##Size *                    \
-                    repeated_##LOWERCASE##_value->size();                   \
+                    FromIntSize(repeated_##LOWERCASE##_value->size());      \
           break
         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);
 #undef HANDLE_TYPE
 
         case WireFormatLite::TYPE_STRING:
         case WireFormatLite::TYPE_BYTES:
         case WireFormatLite::TYPE_GROUP:
         case WireFormatLite::TYPE_MESSAGE:
           GOOGLE_LOG(FATAL) << "Non-primitive types can't be packed.";
           break;
       }
 
-      cached_size = result;
+      cached_size = ToCachedSize(result);
       if (result > 0) {
         result += io::CodedOutputStream::VarintSize32(result);
         result += io::CodedOutputStream::VarintSize32(
             WireFormatLite::MakeTag(number,
                 WireFormatLite::WIRETYPE_LENGTH_DELIMITED));
       }
     } else {
-      int tag_size = WireFormatLite::TagSize(number, real_type(type));
+      size_t tag_size = WireFormatLite::TagSize(number, real_type(type));
 
       switch (real_type(type)) {
 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE)                        \
         case WireFormatLite::TYPE_##UPPERCASE:                              \
-          result += tag_size * repeated_##LOWERCASE##_value->size();        \
+          result += tag_size *                                              \
+                    FromIntSize(repeated_##LOWERCASE##_value->size());      \
           for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) {  \
             result += WireFormatLite::CAMELCASE##Size(                      \
               repeated_##LOWERCASE##_value->Get(i));                        \
           }                                                                 \
           break
 
         HANDLE_TYPE(   INT32,    Int32,   int32);
         HANDLE_TYPE(   INT64,    Int64,   int64);
         HANDLE_TYPE(  UINT32,   UInt32,  uint32);
         HANDLE_TYPE(  UINT64,   UInt64,  uint64);
         HANDLE_TYPE(  SINT32,   SInt32,   int32);
         HANDLE_TYPE(  SINT64,   SInt64,   int64);
         HANDLE_TYPE(  STRING,   String,  string);
         HANDLE_TYPE(   BYTES,    Bytes,  string);
         HANDLE_TYPE(    ENUM,     Enum,    enum);
         HANDLE_TYPE(   GROUP,    Group, message);
         HANDLE_TYPE( MESSAGE,  Message, message);
 #undef HANDLE_TYPE
 
         // Stuff with fixed size.
 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE)                        \
         case WireFormatLite::TYPE_##UPPERCASE:                              \
           result += (tag_size + WireFormatLite::k##CAMELCASE##Size) *       \
-                    repeated_##LOWERCASE##_value->size();                   \
+                    FromIntSize(repeated_##LOWERCASE##_value->size());      \
           break
         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);
 #undef HANDLE_TYPE
       }
@@ skipping 12 matching lines @@
       HANDLE_TYPE(  UINT64,   UInt64,   uint64_value);
       HANDLE_TYPE(  SINT32,   SInt32,    int32_value);
       HANDLE_TYPE(  SINT64,   SInt64,    int64_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 WireFormatLite::TYPE_MESSAGE: {
         if (is_lazy) {
-          int size = lazymessage_value->ByteSize();
+          size_t size = lazymessage_value->ByteSize();
           result += io::CodedOutputStream::VarintSize32(size) + size;
         } else {
           result += WireFormatLite::MessageSize(*message_value);
         }
         break;
       }
 
       // Stuff with fixed size.
 #define HANDLE_TYPE(UPPERCASE, CAMELCASE)                                 \
       case WireFormatLite::TYPE_##UPPERCASE:                              \
@@ skipping 141 matching lines @@
 const RepeatedField<bool>*
 RepeatedPrimitiveGenericTypeTraits::default_repeated_field_bool_ = NULL;
 const RepeatedStringTypeTraits::RepeatedFieldType*
 RepeatedStringTypeTraits::default_repeated_field_ = NULL;
 const RepeatedMessageGenericTypeTraits::RepeatedFieldType*
 RepeatedMessageGenericTypeTraits::default_repeated_field_ = NULL;
 
 }  // namespace internal
 }  // namespace protobuf
 }  // namespace google