third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/compiler/cpp/cpp_enum.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 52 matching lines @@
                              const Options& options)
   : descriptor_(descriptor),
     classname_(ClassName(descriptor, false)),
     options_(options),
     generate_array_size_(ShouldGenerateArraySize(descriptor)) {
 }
 
 EnumGenerator::~EnumGenerator() {}
 
 void EnumGenerator::FillForwardDeclaration(
-    map<string, const EnumDescriptor*>* enum_names) {
+    std::map<string, const EnumDescriptor*>* enum_names) {
   if (!options_.proto_h) {
     return;
   }
   (*enum_names)[classname_] = descriptor_;
 }
 
 void EnumGenerator::GenerateDefinition(io::Printer* printer) {
-  map<string, string> vars;
+  std::map<string, string> vars;
   vars["classname"] = classname_;
   vars["short_name"] = descriptor_->name();
   vars["enumbase"] = classname_ + (options_.proto_h ? " : int" : "");
 
   printer->Print(vars, "enum $enumbase$ {\n");
   printer->Annotate("enumbase", descriptor_);
   printer->Indent();
 
   const EnumValueDescriptor* min_value = descriptor_->value(0);
   const EnumValueDescriptor* max_value = descriptor_->value(0);
@@ skipping 81 matching lines @@
     printer->Print(
       "template <>\n"
       "inline const EnumDescriptor* GetEnumDescriptor< $classname$>() {\n"
       "  return $classname$_descriptor();\n"
       "}\n",
       "classname", ClassName(descriptor_, true));
   }
 }
 
 void EnumGenerator::GenerateSymbolImports(io::Printer* printer) {
-  map<string, string> vars;
+  std::map<string, string> vars;
   vars["nested_name"] = descriptor_->name();
   vars["classname"] = classname_;
   vars["constexpr"] = options_.proto_h ? "constexpr " : "";
   printer->Print(vars, "typedef $classname$ $nested_name$;\n");
 
   for (int j = 0; j < descriptor_->value_count(); j++) {
     vars["tag"] = EnumValueName(descriptor_->value(j));
     vars["deprecated_attr"] = descriptor_->value(j)->options().deprecated() ?
-      "PROTOBUF_DEPRECATED_ATTR " : "";
+      "GOOGLE_PROTOBUF_DEPRECATED_ATTR " : "";
     printer->Print(vars,
       "$deprecated_attr$static $constexpr$const $nested_name$ $tag$ =\n"
       "  $classname$_$tag$;\n");
   }
 
   printer->Print(vars,
     "static inline bool $nested_name$_IsValid(int value) {\n"
     "  return $classname$_IsValid(value);\n"
     "}\n"
     "static const $nested_name$ $nested_name$_MIN =\n"
@@ skipping 19 matching lines @@
                    "  return $classname$_Name(value);\n"
                    "}\n");
     printer->Print(vars,
       "static inline bool $nested_name$_Parse(const ::std::string& name,\n"
       "    $nested_name$* value) {\n"
       "  return $classname$_Parse(name, value);\n"
       "}\n");
   }
 }
 
-void EnumGenerator::GenerateDescriptorInitializer(
-    io::Printer* printer, int index) {
-  map<string, string> vars;
-  vars["classname"] = classname_;
-  vars["index"] = SimpleItoa(index);
+void EnumGenerator::GenerateDescriptorInitializer(io::Printer* printer) {
+  std::map<string, string> vars;
+  vars["index"] = SimpleItoa(descriptor_->index());
+  vars["index_in_metadata"] = SimpleItoa(index_in_metadata_);
 
   if (descriptor_->containing_type() == NULL) {
     printer->Print(vars,
-      "$classname$_descriptor_ = file->enum_type($index$);\n");
+                   "file_level_enum_descriptors[$index_in_metadata$] = "
+                   "file->enum_type($index$);\n");
   } else {
     vars["parent"] = ClassName(descriptor_->containing_type(), false);
     printer->Print(vars,
-      "$classname$_descriptor_ = $parent$_descriptor_->enum_type($index$);\n");
+                   "file_level_enum_descriptors[$index_in_metadata$] = "
+                   "$parent$_descriptor->enum_type($index$);\n");
   }
 }
 
 void EnumGenerator::GenerateMethods(io::Printer* printer) {
-  map<string, string> vars;
+  std::map<string, string> vars;
   vars["classname"] = classname_;
+  vars["index_in_metadata"] = SimpleItoa(index_in_metadata_);
   vars["constexpr"] = options_.proto_h ? "constexpr " : "";
 
   if (HasDescriptorMethods(descriptor_->file(), options_)) {
-    printer->Print(vars,
-      "const ::google::protobuf::EnumDescriptor* $classname$_descriptor() {\n"
-      "  protobuf_AssignDescriptorsOnce();\n"
-      "  return $classname$_descriptor_;\n"
-      "}\n");
+    printer->Print(
+        vars,
+        "const ::google::protobuf::EnumDescriptor* $classname$_descriptor() {\n"
+        "  protobuf_AssignDescriptorsOnce();\n"
+        "  return file_level_enum_descriptors[$index_in_metadata$];\n"
+        "}\n");
   }
 
   printer->Print(vars,
     "bool $classname$_IsValid(int value) {\n"
-    "  switch(value) {\n");
+    "  switch (value) {\n");
 
   // Multiple values may have the same number.  Make sure we only cover
   // each number once by first constructing a set containing all valid
   // numbers, then printing a case statement for each element.
 
-  set<int> numbers;
+  std::set<int> numbers;
   for (int j = 0; j < descriptor_->value_count(); j++) {
     const EnumValueDescriptor* value = descriptor_->value(j);
     numbers.insert(value->number());
   }
 
-  for (set<int>::iterator iter = numbers.begin();
+  for (std::set<int>::iterator iter = numbers.begin();
        iter != numbers.end(); ++iter) {
     printer->Print(
       "    case $number$:\n",
       "number", Int32ToString(*iter));
   }
 
   printer->Print(vars,
     "      return true;\n"
     "    default:\n"
     "      return false;\n"
@@ skipping 24 matching lines @@
     }
 
     printer->Print("#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900\n");
   }
 }
 
 }  // namespace cpp
 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google