third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/compiler/java/java_message_lite.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 102 matching lines @@
     bytecode_estimate +=
         ImmutableMessageLiteGenerator(descriptor_->nested_type(i), context_)
             .GenerateStaticVariableInitializers(printer);
   }
   return bytecode_estimate;
 }
 
 // ===================================================================
 
 void ImmutableMessageLiteGenerator::GenerateInterface(io::Printer* printer) {
+  MaybePrintGeneratedAnnotation(context_, printer, descriptor_,
+                                /* immutable = */ true, "OrBuilder");
   if (descriptor_->extension_range_count() > 0) {
     printer->Print(
-      "public interface $classname$OrBuilder extends \n"
-      "    $extra_interfaces$\n"
-      "     com.google.protobuf.GeneratedMessageLite.\n"
-      "          ExtendableMessageOrBuilder<\n"
-      "              $classname$, $classname$.Builder> {\n",
-      "extra_interfaces", ExtraMessageOrBuilderInterfaces(descriptor_),
-      "classname", descriptor_->name());
+        "public interface $classname$OrBuilder$idend$ extends \n"
+        "    $extra_interfaces$\n"
+        "     com.google.protobuf.GeneratedMessageLite.\n"
+        "          ExtendableMessageOrBuilder<\n"
+        "              $classname$, $classname$.Builder> {\n",
+        "extra_interfaces", ExtraMessageOrBuilderInterfaces(descriptor_),
+        "classname", descriptor_->name(),
+        "idend", "");
   } else {
     printer->Print(
-      "public interface $classname$OrBuilder extends\n"
-      "    $extra_interfaces$\n"
-      "    com.google.protobuf.MessageLiteOrBuilder {\n",
-      "extra_interfaces", ExtraMessageOrBuilderInterfaces(descriptor_),
-      "classname", descriptor_->name());
+        "public interface $classname$OrBuilder$idend$ extends\n"
+        "    $extra_interfaces$\n"
+        "    com.google.protobuf.MessageLiteOrBuilder {\n",
+        "extra_interfaces", ExtraMessageOrBuilderInterfaces(descriptor_),
+        "classname", descriptor_->name(),
+        "idend", "");
   }
+  printer->Annotate("classname", "idend", descriptor_);
 
   printer->Indent();
     for (int i = 0; i < descriptor_->field_count(); i++) {
       printer->Print("\n");
       field_generators_.get(descriptor_->field(i))
                        .GenerateInterfaceMembers(printer);
     }
     for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
       printer->Print(
           "\n"
           "public $classname$.$oneof_capitalized_name$Case "
           "get$oneof_capitalized_name$Case();\n",
           "oneof_capitalized_name",
           context_->GetOneofGeneratorInfo(
               descriptor_->oneof_decl(i))->capitalized_name,
           "classname",
           context_->GetNameResolver()->GetImmutableClassName(descriptor_));
     }
   printer->Outdent();
 
   printer->Print("}\n");
 }
 
 // ===================================================================
 
 void ImmutableMessageLiteGenerator::Generate(io::Printer* printer) {
-  bool is_own_file =
-    descriptor_->containing_type() == NULL &&
-    MultipleJavaFiles(descriptor_->file(), /* immutable = */ true);
+  bool is_own_file = IsOwnFile(descriptor_, /* immutable = */ true);
 
-  map<string, string> variables;
+  std::map<string, string> variables;
   variables["static"] = is_own_file ? " " : " static ";
   variables["classname"] = descriptor_->name();
   variables["extra_interfaces"] = ExtraMessageInterfaces(descriptor_);
 
   WriteMessageDocComment(printer, descriptor_);
+  MaybePrintGeneratedAnnotation(context_, printer, descriptor_,
+                                /* immutable = */ true);
+
 
   // The builder_type stores the super type name of the nested Builder class.
   string builder_type;
   if (descriptor_->extension_range_count() > 0) {
     printer->Print(variables,
       "public $static$final class $classname$ extends\n"
       "    com.google.protobuf.GeneratedMessageLite.ExtendableMessage<\n"
       "      $classname$, $classname$.Builder> implements\n"
       "    $extra_interfaces$\n"
       "    $classname$OrBuilder {\n");
     builder_type = strings::Substitute(
         "com.google.protobuf.GeneratedMessageLite.ExtendableBuilder<$0, ?>",
         name_resolver_->GetImmutableClassName(descriptor_));
   } else {
     printer->Print(variables,
         "public $static$final class $classname$ extends\n"
         "    com.google.protobuf.GeneratedMessageLite<\n"
         "        $classname$, $classname$.Builder> implements\n"
         "    $extra_interfaces$\n"
         "    $classname$OrBuilder {\n");
 
     builder_type = "com.google.protobuf.GeneratedMessageLite.Builder";
   }
   printer->Indent();
 
-
   GenerateConstructor(printer);
 
   // Nested types
   for (int i = 0; i < descriptor_->enum_type_count(); i++) {
     EnumLiteGenerator(descriptor_->enum_type(i), true, context_)
         .Generate(printer);
   }
 
   for (int i = 0; i < descriptor_->nested_type_count(); i++) {
     // Don't generate Java classes for map entry messages.
@@ skipping 12 matching lines @@
           .GetNumBitsForMessage();
     }
     int totalInts = (totalBits + 31) / 32;
     for (int i = 0; i < totalInts; i++) {
       printer->Print("private int $bit_field_name$;\n",
         "bit_field_name", GetBitFieldName(i));
     }
   }
 
   // oneof
-  map<string, string> vars;
+  std::map<string, string> vars;
   for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
-    vars["oneof_name"] = context_->GetOneofGeneratorInfo(
-        descriptor_->oneof_decl(i))->name;
+    const OneofDescriptor* oneof = descriptor_->oneof_decl(i);
+    vars["oneof_name"] = context_->GetOneofGeneratorInfo(oneof)->name;
     vars["oneof_capitalized_name"] = context_->GetOneofGeneratorInfo(
-        descriptor_->oneof_decl(i))->capitalized_name;
-    vars["oneof_index"] = SimpleItoa(descriptor_->oneof_decl(i)->index());
+        oneof)->capitalized_name;
+    vars["oneof_index"] = SimpleItoa(oneof->index());
     // oneofCase_ and oneof_
     printer->Print(vars,
       "private int $oneof_name$Case_ = 0;\n"
       "private java.lang.Object $oneof_name$_;\n");
     // OneofCase enum
     printer->Print(vars,
       "public enum $oneof_capitalized_name$Case\n"
       "    implements com.google.protobuf.Internal.EnumLite {\n");
     printer->Indent();
-    for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
-      const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
+    for (int j = 0; j < oneof->field_count(); j++) {
+      const FieldDescriptor* field = oneof->field(j);
       printer->Print(
         "$field_name$($field_number$),\n",
         "field_name",
         ToUpper(field->name()),
         "field_number",
         SimpleItoa(field->number()));
     }
     printer->Print(
       "$cap_oneof_name$_NOT_SET(0);\n",
       "cap_oneof_name",
       ToUpper(vars["oneof_name"]));
     printer->Print(vars,
       "private final int value;\n"
       "private $oneof_capitalized_name$Case(int value) {\n"
       "  this.value = value;\n"
       "}\n");
     printer->Print(vars,
       "/**\n"
       " * @deprecated Use {@link #forNumber(int)} instead.\n"
       " */\n"
       "@java.lang.Deprecated\n"
       "public static $oneof_capitalized_name$Case valueOf(int value) {\n"
       "  return forNumber(value);\n"
       "}\n"
       "\n"
       "public static $oneof_capitalized_name$Case forNumber(int value) {\n"
       "  switch (value) {\n");
-    for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
-      const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
+    for (int j = 0; j < oneof->field_count(); j++) {
+      const FieldDescriptor* field = oneof->field(j);
       printer->Print(
         "    case $field_number$: return $field_name$;\n",
         "field_number",
         SimpleItoa(field->number()),
         "field_name",
         ToUpper(field->name()));
     }
     printer->Print(
       "    case 0: return $cap_oneof_name$_NOT_SET;\n"
       "    default: return null;\n"
@@ skipping 164 matching lines @@
   printer->Print("}\n\n");
 }
 
 // ===================================================================
 
 void ImmutableMessageLiteGenerator::
 GenerateMessageSerializationMethods(io::Printer* printer) {
   google::protobuf::scoped_array<const FieldDescriptor * > sorted_fields(
       SortFieldsByNumber(descriptor_));
 
-  vector<const Descriptor::ExtensionRange*> sorted_extensions;
+  std::vector<const Descriptor::ExtensionRange*> sorted_extensions;
   for (int i = 0; i < descriptor_->extension_range_count(); ++i) {
     sorted_extensions.push_back(descriptor_->extension_range(i));
   }
   std::sort(sorted_extensions.begin(), sorted_extensions.end(),
             ExtensionRangeOrdering());
 
   printer->Print(
     "public void writeTo(com.google.protobuf.CodedOutputStream output)\n"
     "                    throws java.io.IOException {\n");
   printer->Indent();
@@ skipping 35 matching lines @@
     } else if (j == sorted_extensions.size()) {
       GenerateSerializeOneField(printer, sorted_fields[i++]);
     } else if (sorted_fields[i]->number() < sorted_extensions[j]->start) {
       GenerateSerializeOneField(printer, sorted_fields[i++]);
     } else {
       GenerateSerializeOneExtensionRange(printer, sorted_extensions[j++]);
     }
   }
 
   if (PreserveUnknownFields(descriptor_)) {
-    printer->Print(
-      "unknownFields.writeTo(output);\n");
+    if (descriptor_->options().message_set_wire_format()) {
+      printer->Print(
+        "unknownFields.writeAsMessageSetTo(output);\n");
+    } else {
+      printer->Print(
+        "unknownFields.writeTo(output);\n");
+    }
   }
 
   printer->Outdent();
   printer->Print(
     "}\n"
     "\n"
     "public int getSerializedSize() {\n"
     "  int size = memoizedSerializedSize;\n"
     "  if (size != -1) return size;\n"
     "\n"
     "  size = 0;\n");
   printer->Indent();
 
   for (int i = 0; i < descriptor_->field_count(); i++) {
     field_generators_.get(sorted_fields[i]).GenerateSerializedSizeCode(printer);
   }
 
   if (descriptor_->extension_range_count() > 0) {
     if (descriptor_->options().message_set_wire_format()) {
       printer->Print(
         "size += extensionsSerializedSizeAsMessageSet();\n");
     } else {
       printer->Print(
         "size += extensionsSerializedSize();\n");
     }
   }
 
   if (PreserveUnknownFields(descriptor_)) {
-    printer->Print(
-      "size += unknownFields.getSerializedSize();\n");
+    if (descriptor_->options().message_set_wire_format()) {
+      printer->Print(
+        "size += unknownFields.getSerializedSizeAsMessageSet();\n");
+    } else {
+      printer->Print(
+        "size += unknownFields.getSerializedSize();\n");
+    }
   }
 
   printer->Outdent();
   printer->Print(
     "  memoizedSerializedSize = size;\n"
     "  return size;\n"
     "}\n"
     "\n");
 }
 
@@ skipping 173 matching lines @@
             "      memoizedIsInitialized = 0;\n"
             "    }\n"
             "    return null;\n"
             "  }\n"
             "}\n",
             "name", info->capitalized_name);
           break;
         case FieldDescriptor::LABEL_REPEATED:
           if (IsMapEntry(field->message_type())) {
             printer->Print(
-              "for ($type$ item : get$name$().values()) {\n"
+              "for ($type$ item : get$name$Map().values()) {\n"
               "  if (!item.isInitialized()) {\n"
               "    if (shouldMemoize) {\n"
               "      memoizedIsInitialized = 0;\n"
               "    }\n"
               "    return null;\n"
               "  }\n"
               "}\n",
               "type", MapValueImmutableClassdName(field->message_type(),
                                                   name_resolver_),
               "name", info->capitalized_name);
@@ skipping 170 matching lines @@
     "switch (tag) {\n");
   printer->Indent();
 
   printer->Print(
     "case 0:\n"          // zero signals EOF / limit reached
     "  done = true;\n"
     "  break;\n");
 
   if (PreserveUnknownFields(descriptor_)) {
     if (descriptor_->extension_range_count() > 0) {
-      printer->Print(
-        "default: {\n"
-        "  if (!parseUnknownField(getDefaultInstanceForType(),\n"
-        "                         input, extensionRegistry, tag)) {\n"
-        "    done = true;\n"  // it's an endgroup tag
-        "  }\n"
-        "  break;\n"
-        "}\n");
+      if (descriptor_->options().message_set_wire_format()) {
+        printer->Print(
+            "default: {\n"
+            "  if (!parseUnknownFieldAsMessageSet(\n"
+            "      getDefaultInstanceForType(), input, extensionRegistry,\n"
+            "      tag)) {\n"
+            "    done = true;\n"  // it's an endgroup tag
+            "  }\n"
+            "  break;\n"
+            "}\n");
+      } else {
+        printer->Print(
+            "default: {\n"
+            "  if (!parseUnknownField(getDefaultInstanceForType(),\n"
+            "      input, extensionRegistry, tag)) {\n"
+            "    done = true;\n"  // it's an endgroup tag
+            "  }\n"
+            "  break;\n"
+            "}\n");
+      }
     } else {
       printer->Print(
         "default: {\n"
         "  if (!parseUnknownField(tag, input)) {\n"
         "    done = true;\n"  // it's an endgroup tag
         "  }\n"
         "  break;\n"
         "}\n");
     }
   } else {
     printer->Print(
       "default: {\n"
       "  if (!input.skipField(tag)) {\n"
       "    done = true;\n"  // it's an endgroup tag
       "  }\n"
       "  break;\n"
       "}\n");
   }
 
   google::protobuf::scoped_array<const FieldDescriptor * > sorted_fields(
       SortFieldsByNumber(descriptor_));
   for (int i = 0; i < descriptor_->field_count(); i++) {
     const FieldDescriptor* field = sorted_fields[i];
     uint32 tag = WireFormatLite::MakeTag(field->number(),
       WireFormat::WireTypeForFieldType(field->type()));
 
     printer->Print(
       "case $tag$: {\n",
-      "tag", SimpleItoa(tag));
+      "tag", SimpleItoa(static_cast<int32>(tag)));
     printer->Indent();
 
     field_generators_.get(field).GenerateParsingCode(printer);
 
     printer->Outdent();
     printer->Print(
       "  break;\n"
       "}\n");
 
     if (field->is_packable()) {
       // To make packed = true wire compatible, we generate parsing code from a
       // packed version of this field regardless of field->options().packed().
       uint32 packed_tag = WireFormatLite::MakeTag(field->number(),
         WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
       printer->Print(
         "case $tag$: {\n",
-        "tag", SimpleItoa(packed_tag));
+        "tag", SimpleItoa(static_cast<int32>(packed_tag)));
       printer->Indent();
 
       field_generators_.get(field).GenerateParsingCodeFromPacked(printer);
 
       printer->Outdent();
       printer->Print(
         "  break;\n"
         "}\n");
     }
   }
@@ skipping 84 matching lines @@
       field_generators_.get(descriptor_->field(i))
           .GenerateInitializationCode(printer);
     }
   }
 }
 
 }  // namespace java
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google