Update third_party/protobuf to protobuf-v3.0.0-beta-3

third_party/protobuf/src/google/protobuf/compiler/cpp/cpp_map_field.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 31 matching lines @@
 bool IsProto3Field(const FieldDescriptor* field_descriptor) {
   const FileDescriptor* file_descriptor = field_descriptor->file();
   return file_descriptor->syntax() == FileDescriptor::SYNTAX_PROTO3;
 }
 
 void SetMessageVariables(const FieldDescriptor* descriptor,
                          map<string, string>* variables,
                          const Options& options) {
   SetCommonFieldVariables(descriptor, variables, options);
   (*variables)["type"] = FieldMessageTypeName(descriptor);
-  (*variables)["stream_writer"] = (*variables)["declared_type"] +
-      (HasFastArraySerialization(descriptor->message_type()->file()) ?
-       "MaybeToArray" :
-       "");
+  (*variables)["stream_writer"] =
+      (*variables)["declared_type"] +
+      (HasFastArraySerialization(descriptor->message_type()->file(), options)
+           ? "MaybeToArray"
+           : "");
   (*variables)["full_name"] = descriptor->full_name();
 
   const FieldDescriptor* key =
       descriptor->message_type()->FindFieldByName("key");
   const FieldDescriptor* val =
       descriptor->message_type()->FindFieldByName("value");
   (*variables)["key_cpp"] = PrimitiveTypeName(key->cpp_type());
   switch (val->cpp_type()) {
     case FieldDescriptor::CPPTYPE_MESSAGE:
       (*variables)["val_cpp"] = FieldMessageTypeName(val);
@@ skipping 10 matching lines @@
   (*variables)["key_wire_type"] =
       "::google::protobuf::internal::WireFormatLite::TYPE_" +
       ToUpper(DeclaredTypeMethodName(key->type()));
   (*variables)["val_wire_type"] =
       "::google::protobuf::internal::WireFormatLite::TYPE_" +
       ToUpper(DeclaredTypeMethodName(val->type()));
   (*variables)["map_classname"] = ClassName(descriptor->message_type(), false);
   (*variables)["number"] = SimpleItoa(descriptor->number());
   (*variables)["tag"] = SimpleItoa(internal::WireFormat::MakeTag(descriptor));
 
-  if (HasDescriptorMethods(descriptor->file())) {
+  if (HasDescriptorMethods(descriptor->file(), options)) {
     (*variables)["lite"] = "";
   } else {
     (*variables)["lite"] = "Lite";
   }
 
   if (!IsProto3Field(descriptor) &&
       val->type() == FieldDescriptor::TYPE_ENUM) {
     const EnumValueDescriptor* default_value = val->default_value_enum();
     (*variables)["default_enum_value"] = Int32ToString(default_value->number());
   } else {
     (*variables)["default_enum_value"] = "0";
   }
 }
 
-MapFieldGenerator::
-MapFieldGenerator(const FieldDescriptor* descriptor,
-                  const Options& options)
-    : descriptor_(descriptor),
+MapFieldGenerator::MapFieldGenerator(const FieldDescriptor* descriptor,
+                                     const Options& options)
+    : FieldGenerator(options),
+      descriptor_(descriptor),
       dependent_field_(options.proto_h && IsFieldDependent(descriptor)) {
   SetMessageVariables(descriptor, &variables_, options);
 }
 
 MapFieldGenerator::~MapFieldGenerator() {}
 
 void MapFieldGenerator::
 GeneratePrivateMembers(io::Printer* printer) const {
   printer->Print(variables_,
       "typedef ::google::protobuf::internal::MapEntryLite<\n"
       "    $key_cpp$, $val_cpp$,\n"
       "    $key_wire_type$,\n"
       "    $val_wire_type$,\n"
       "    $default_enum_value$ >\n"
       "    $map_classname$;\n"
       "::google::protobuf::internal::MapField$lite$<\n"
       "    $key_cpp$, $val_cpp$,\n"
       "    $key_wire_type$,\n"
       "    $val_wire_type$,\n"
       "    $default_enum_value$ > $name$_;\n");
 }
 
 void MapFieldGenerator::
 GenerateAccessorDeclarations(io::Printer* printer) const {
   printer->Print(variables_,
-      "const ::google::protobuf::Map< $key_cpp$, $val_cpp$ >&\n"
-      "    $name$() const$deprecation$;\n"
-      "::google::protobuf::Map< $key_cpp$, $val_cpp$ >*\n"
-      "    mutable_$name$()$deprecation$;\n");
+      "$deprecated_attr$const ::google::protobuf::Map< $key_cpp$, $val_cpp$ >&\n"
+      "    $name$() const;\n"
+      "$deprecated_attr$::google::protobuf::Map< $key_cpp$, $val_cpp$ >*\n"
+      "    mutable_$name$();\n");
 }
 
 void MapFieldGenerator::
 GenerateInlineAccessorDefinitions(io::Printer* printer,
                                   bool is_inline) const {
   map<string, string> variables(variables_);
   variables["inline"] = is_inline ? "inline" : "";
   printer->Print(variables,
       "$inline$ const ::google::protobuf::Map< $key_cpp$, $val_cpp$ >&\n"
       "$classname$::$name$() const {\n"
@@ skipping 19 matching lines @@
   printer->Print(variables_, "$name$_.MergeFrom(from.$name$_);\n");
 }
 
 void MapFieldGenerator::
 GenerateSwappingCode(io::Printer* printer) const {
   printer->Print(variables_, "$name$_.Swap(&other->$name$_);\n");
 }
 
 void MapFieldGenerator::
 GenerateConstructorCode(io::Printer* printer) const {
-  if (HasDescriptorMethods(descriptor_->file())) {
+  if (HasDescriptorMethods(descriptor_->file(), options_)) {
     printer->Print(variables_,
         "$name$_.SetAssignDescriptorCallback(\n"
         "    protobuf_AssignDescriptorsOnce);\n"
         "$name$_.SetEntryDescriptor(\n"
         "    &$type$_descriptor_);\n");
   }
 }
 
 void MapFieldGenerator::
 GenerateMergeFromCodedStream(io::Printer* printer) const {
@@ skipping 26 matching lines @@
   } else {
     printer->Print(variables_,
         "{\n"
         "  ::std::string data;\n"
         "  DO_(::google::protobuf::internal::WireFormatLite::ReadString(input, &data));\n"
         "  DO_(entry->ParseFromString(data));\n"
         "  if ($val_cpp$_IsValid(*entry->mutable_value())) {\n"
         "    (*mutable_$name$())[entry->key()] =\n"
         "        static_cast< $val_cpp$ >(*entry->mutable_value());\n"
         "  } else {\n");
-    if (HasDescriptorMethods(descriptor_->file())) {
+    if (HasDescriptorMethods(descriptor_->file(), options_)) {
       printer->Print(variables_,
           "    mutable_unknown_fields()"
           "->AddLengthDelimited($number$, data);\n");
     } else {
       printer->Print(variables_,
           "    unknown_fields_stream.WriteVarint32($tag$);\n"
           "    unknown_fields_stream.WriteVarint32(data.size());\n"
           "    unknown_fields_stream.WriteString(data);\n");
     }
 
 
     printer->Print(variables_,
         "  }\n"
         "}\n");
   }
 
   const FieldDescriptor* key_field =
       descriptor_->message_type()->FindFieldByName("key");
   if (key_field->type() == FieldDescriptor::TYPE_STRING) {
     GenerateUtf8CheckCodeForString(
-        key_field, true, variables_,
+        key_field, options_, true, variables_,
         "entry->key().data(), entry->key().length(),\n", printer);
   }
   if (value_field->type() == FieldDescriptor::TYPE_STRING) {
-    GenerateUtf8CheckCodeForString(
-        value_field, true, variables_,
-        "entry->mutable_value()->data(),\n"
-        "entry->mutable_value()->length(),\n", printer);
+    GenerateUtf8CheckCodeForString(value_field, options_, true, variables_,
+                                   "entry->mutable_value()->data(),\n"
+                                   "entry->mutable_value()->length(),\n",
+                                   printer);
   }
 
   // If entry is allocated by arena, its desctructor should be avoided.
   if (SupportsArenas(descriptor_)) {
     printer->Print(variables_,
         "if (entry->GetArena() != NULL) entry.release();\n");
   }
 }
 
 void MapFieldGenerator::
@@ skipping 19 matching lines @@
       "        $number$, *entry, output);\n");
 
   printer->Indent();
   printer->Indent();
 
   const FieldDescriptor* key_field =
       descriptor_->message_type()->FindFieldByName("key");
   const FieldDescriptor* value_field =
       descriptor_->message_type()->FindFieldByName("value");
   if (key_field->type() == FieldDescriptor::TYPE_STRING) {
-    GenerateUtf8CheckCodeForString(
-        key_field, false, variables_,
-        "it->first.data(), it->first.length(),\n", printer);
+    GenerateUtf8CheckCodeForString(key_field, options_, false, variables_,
+                                   "it->first.data(), it->first.length(),\n",
+                                   printer);
   }
   if (value_field->type() == FieldDescriptor::TYPE_STRING) {
-    GenerateUtf8CheckCodeForString(
-        value_field, false, variables_,
-        "it->second.data(), it->second.length(),\n", printer);
+    GenerateUtf8CheckCodeForString(value_field, options_, false, variables_,
+                                   "it->second.data(), it->second.length(),\n",
+                                   printer);
   }
 
   printer->Outdent();
   printer->Outdent();
 
   printer->Print(
       "  }\n");
 
   // If entry is allocated by arena, its desctructor should be avoided.
   if (SupportsArenas(descriptor_)) {
@@ skipping 30 matching lines @@
       "            $number$, *entry, target);\n");
 
   printer->Indent();
   printer->Indent();
 
   const FieldDescriptor* key_field =
       descriptor_->message_type()->FindFieldByName("key");
   const FieldDescriptor* value_field =
       descriptor_->message_type()->FindFieldByName("value");
   if (key_field->type() == FieldDescriptor::TYPE_STRING) {
-    GenerateUtf8CheckCodeForString(
-        key_field, false, variables_,
-        "it->first.data(), it->first.length(),\n", printer);
+    GenerateUtf8CheckCodeForString(key_field, options_, false, variables_,
+                                   "it->first.data(), it->first.length(),\n",
+                                   printer);
   }
   if (value_field->type() == FieldDescriptor::TYPE_STRING) {
-    GenerateUtf8CheckCodeForString(
-        value_field, false, variables_,
-        "it->second.data(), it->second.length(),\n", printer);
+    GenerateUtf8CheckCodeForString(value_field, options_, false, variables_,
+                                   "it->second.data(), it->second.length(),\n",
+                                   printer);
   }
 
   printer->Outdent();
   printer->Outdent();
   printer->Print(
       "  }\n");
 
   // If entry is allocated by arena, its desctructor should be avoided.
   if (SupportsArenas(descriptor_)) {
     printer->Print(variables_,
@@ skipping 37 matching lines @@
         "  }\n");
   }
 
   printer->Print("}\n");
 }
 
 }  // namespace cpp
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google