third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/src/google/protobuf/compiler/java/java_helpers.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 83 matching lines @@
     // Append a trailing "#" to indicate that the name should be decorated to
     // avoid collision with other names.
     field_name += "#";
   }
   return field_name;
 }
 
 
 }  // namespace
 
+void PrintGeneratedAnnotation(io::Printer* printer, char delimiter,
+                              const string& annotation_file) {
+  if (annotation_file.empty()) {
+    return;
+  }
+  string ptemplate =
+      "@javax.annotation.Generated(value=\"protoc\", comments=\"annotations:";
+  ptemplate.push_back(delimiter);
+  ptemplate.append("annotation_file");
+  ptemplate.push_back(delimiter);
+  ptemplate.append("\")\n");
+  printer->Print(ptemplate.c_str(), "annotation_file", annotation_file);
+}
+
 string UnderscoresToCamelCase(const string& input, bool cap_next_letter) {
   string result;
   // Note:  I distrust ctype.h due to locales.
   for (int i = 0; i < input.size(); i++) {
     if ('a' <= input[i] && input[i] <= 'z') {
       if (cap_next_letter) {
         result += input[i] + ('A' - 'a');
       } else {
         result += input[i];
       }
@@ skipping 225 matching lines @@
     case JAVATYPE_MESSAGE: return NULL;
 
     // No default because we want the compiler to complain if any new
     // JavaTypes are added.
   }
 
   GOOGLE_LOG(FATAL) << "Can't get here.";
   return NULL;
 }
 
+
 const char* FieldTypeName(FieldDescriptor::Type field_type) {
   switch (field_type) {
     case FieldDescriptor::TYPE_INT32   : return "INT32";
     case FieldDescriptor::TYPE_UINT32  : return "UINT32";
     case FieldDescriptor::TYPE_SINT32  : return "SINT32";
     case FieldDescriptor::TYPE_FIXED32 : return "FIXED32";
     case FieldDescriptor::TYPE_SFIXED32: return "SFIXED32";
     case FieldDescriptor::TYPE_INT64   : return "INT64";
     case FieldDescriptor::TYPE_UINT64  : return "UINT64";
     case FieldDescriptor::TYPE_SINT64  : return "SINT64";
@@ skipping 35 matching lines @@
     case FieldDescriptor::CPPTYPE_UINT32:
       // Need to print as a signed int since Java has no unsigned.
       return SimpleItoa(static_cast<int32>(field->default_value_uint32()));
     case FieldDescriptor::CPPTYPE_INT64:
       return SimpleItoa(field->default_value_int64()) + "L";
     case FieldDescriptor::CPPTYPE_UINT64:
       return SimpleItoa(static_cast<int64>(field->default_value_uint64())) +
              "L";
     case FieldDescriptor::CPPTYPE_DOUBLE: {
       double value = field->default_value_double();
-      if (value == numeric_limits<double>::infinity()) {
+      if (value == std::numeric_limits<double>::infinity()) {
         return "Double.POSITIVE_INFINITY";
-      } else if (value == -numeric_limits<double>::infinity()) {
+      } else if (value == -std::numeric_limits<double>::infinity()) {
         return "Double.NEGATIVE_INFINITY";
       } else if (value != value) {
         return "Double.NaN";
       } else {
         return SimpleDtoa(value) + "D";
       }
     }
     case FieldDescriptor::CPPTYPE_FLOAT: {
       float value = field->default_value_float();
-      if (value == numeric_limits<float>::infinity()) {
+      if (value == std::numeric_limits<float>::infinity()) {
         return "Float.POSITIVE_INFINITY";
-      } else if (value == -numeric_limits<float>::infinity()) {
+      } else if (value == -std::numeric_limits<float>::infinity()) {
         return "Float.NEGATIVE_INFINITY";
       } else if (value != value) {
         return "Float.NaN";
       } else {
         return SimpleFtoa(value) + "F";
       }
     }
     case FieldDescriptor::CPPTYPE_BOOL:
       return field->default_value_bool() ? "true" : "false";
     case FieldDescriptor::CPPTYPE_STRING:
@@ skipping 45 matching lines @@
     case FieldDescriptor::CPPTYPE_INT64:
       return field->default_value_int64() == 0L;
     case FieldDescriptor::CPPTYPE_UINT64:
       return field->default_value_uint64() == 0L;
     case FieldDescriptor::CPPTYPE_DOUBLE:
       return field->default_value_double() == 0.0;
     case FieldDescriptor::CPPTYPE_FLOAT:
       return field->default_value_float() == 0.0;
     case FieldDescriptor::CPPTYPE_BOOL:
       return field->default_value_bool() == false;
-
+    case FieldDescriptor::CPPTYPE_ENUM:
+      return field->default_value_enum()->number() == 0;
     case FieldDescriptor::CPPTYPE_STRING:
-    case FieldDescriptor::CPPTYPE_ENUM:
     case FieldDescriptor::CPPTYPE_MESSAGE:
       return false;
 
     // No default because we want the compiler to complain if any new
     // types are added.
   }
 
   GOOGLE_LOG(FATAL) << "Can't get here.";
   return false;
 }
 
+bool IsByteStringWithCustomDefaultValue(const FieldDescriptor* field) {
+  return GetJavaType(field) == JAVATYPE_BYTES &&
+         field->default_value_string() != "";
+}
+
 const char* bit_masks[] = {
   "0x00000001",
   "0x00000002",
   "0x00000004",
   "0x00000008",
   "0x00000010",
   "0x00000020",
   "0x00000040",
   "0x00000080",
 
@@ skipping 240 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 }  // namespace java
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google