third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/descriptor_database.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 79 matching lines @@
   // If the symbol name is invalid it could break our lookup algorithm (which
   // relies on the fact that '.' sorts before all other characters that are
   // valid in symbol names).
   if (!ValidateSymbolName(name)) {
     GOOGLE_LOG(ERROR) << "Invalid symbol name: " << name;
     return false;
   }
 
   // Try to look up the symbol to make sure a super-symbol doesn't already
   // exist.
-  typename map<string, Value>::iterator iter = FindLastLessOrEqual(name);
+  typename std::map<string, Value>::iterator iter = FindLastLessOrEqual(name);
 
   if (iter == by_symbol_.end()) {
     // Apparently the map is currently empty.  Just insert and be done with it.
-    by_symbol_.insert(typename map<string, Value>::value_type(name, value));
+    by_symbol_.insert(
+        typename std::map<string, Value>::value_type(name, value));
     return true;
   }
 
   if (IsSubSymbol(iter->first, name)) {
     GOOGLE_LOG(ERROR) << "Symbol name \"" << name << "\" conflicts with the existing "
                   "symbol \"" << iter->first << "\".";
     return false;
   }
 
   // OK, that worked.  Now we have to make sure that no symbol in the map is
   // a sub-symbol of the one we are inserting.  The only symbol which could
   // be so is the first symbol that is greater than the new symbol.  Since
   // |iter| points at the last symbol that is less than or equal, we just have
   // to increment it.
   ++iter;
 
   if (iter != by_symbol_.end() && IsSubSymbol(name, iter->first)) {
     GOOGLE_LOG(ERROR) << "Symbol name \"" << name << "\" conflicts with the existing "
                   "symbol \"" << iter->first << "\".";
     return false;
   }
 
   // OK, no conflicts.
 
   // Insert the new symbol using the iterator as a hint, the new entry will
   // appear immediately before the one the iterator is pointing at.
-  by_symbol_.insert(iter, typename map<string, Value>::value_type(name, value));
+  by_symbol_.insert(iter,
+                    typename std::map<string, Value>::value_type(name, value));
 
   return true;
 }
 
 template <typename Value>
 bool SimpleDescriptorDatabase::DescriptorIndex<Value>::AddNestedExtensions(
     const DescriptorProto& message_type,
     Value value) {
   for (int i = 0; i < message_type.nested_type_size(); i++) {
     if (!AddNestedExtensions(message_type.nested_type(i), value)) return false;
@@ skipping 30 matching lines @@
 
 template <typename Value>
 Value SimpleDescriptorDatabase::DescriptorIndex<Value>::FindFile(
     const string& filename) {
   return FindWithDefault(by_name_, filename, Value());
 }
 
 template <typename Value>
 Value SimpleDescriptorDatabase::DescriptorIndex<Value>::FindSymbol(
     const string& name) {
-  typename map<string, Value>::iterator iter = FindLastLessOrEqual(name);
+  typename std::map<string, Value>::iterator iter = FindLastLessOrEqual(name);
 
   return (iter != by_symbol_.end() && IsSubSymbol(iter->first, name)) ?
          iter->second : Value();
 }
 
 template <typename Value>
 Value SimpleDescriptorDatabase::DescriptorIndex<Value>::FindExtension(
     const string& containing_type,
     int field_number) {
   return FindWithDefault(
       by_extension_, std::make_pair(containing_type, field_number), Value());
 }
 
 template <typename Value>
 bool SimpleDescriptorDatabase::DescriptorIndex<Value>::FindAllExtensionNumbers(
     const string& containing_type,
-    vector<int>* output) {
-  typename map<pair<string, int>, Value>::const_iterator it =
+    std::vector<int>* output) {
+  typename std::map<pair<string, int>, Value>::const_iterator it =
       by_extension_.lower_bound(std::make_pair(containing_type, 0));
   bool success = false;
 
   for (; it != by_extension_.end() && it->first.first == containing_type;
        ++it) {
     output->push_back(it->first.second);
     success = true;
   }
 
   return success;
 }
 
 template <typename Value>
 typename map<string, Value>::iterator
 SimpleDescriptorDatabase::DescriptorIndex<Value>::FindLastLessOrEqual(
     const string& name) {
   // Find the last key in the map which sorts less than or equal to the
   // symbol name.  Since upper_bound() returns the *first* key that sorts
   // *greater* than the input, we want the element immediately before that.
-  typename map<string, Value>::iterator iter = by_symbol_.upper_bound(name);
+  typename std::map<string, Value>::iterator iter =
+      by_symbol_.upper_bound(name);
   if (iter != by_symbol_.begin()) --iter;
   return iter;
 }
 
 template <typename Value>
 bool SimpleDescriptorDatabase::DescriptorIndex<Value>::IsSubSymbol(
     const string& sub_symbol, const string& super_symbol) {
   return sub_symbol == super_symbol ||
          (HasPrefixString(super_symbol, sub_symbol) &&
              super_symbol[sub_symbol.size()] == '.');
@@ skipping 46 matching lines @@
 
 bool SimpleDescriptorDatabase::FindFileContainingExtension(
     const string& containing_type,
     int field_number,
     FileDescriptorProto* output) {
   return MaybeCopy(index_.FindExtension(containing_type, field_number), output);
 }
 
 bool SimpleDescriptorDatabase::FindAllExtensionNumbers(
     const string& extendee_type,
-    vector<int>* output) {
+    std::vector<int>* output) {
   return index_.FindAllExtensionNumbers(extendee_type, output);
 }
 
 
 bool SimpleDescriptorDatabase::MaybeCopy(const FileDescriptorProto* file,
                                          FileDescriptorProto* output) {
   if (file == NULL) return false;
   output->CopyFrom(*file);
   return true;
 }
@@ skipping 35 matching lines @@
 
 bool EncodedDescriptorDatabase::FindFileContainingSymbol(
     const string& symbol_name,
     FileDescriptorProto* output) {
   return MaybeParse(index_.FindSymbol(symbol_name), output);
 }
 
 bool EncodedDescriptorDatabase::FindNameOfFileContainingSymbol(
     const string& symbol_name,
     string* output) {
-  pair<const void*, int> encoded_file = index_.FindSymbol(symbol_name);
+  std::pair<const void*, int> encoded_file = index_.FindSymbol(symbol_name);
   if (encoded_file.first == NULL) return false;
 
   // Optimization:  The name should be the first field in the encoded message.
   //   Try to just read it directly.
   io::CodedInputStream input(reinterpret_cast<const uint8*>(encoded_file.first),
                              encoded_file.second);
 
   const uint32 kNameTag = internal::WireFormatLite::MakeTag(
       FileDescriptorProto::kNameFieldNumber,
       internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
 
-  if (input.ReadTag() == kNameTag) {
+  if (input.ReadTagNoLastTag() == kNameTag) {
     // Success!
     return internal::WireFormatLite::ReadString(&input, output);
   } else {
     // Slow path.  Parse whole message.
     FileDescriptorProto file_proto;
     if (!file_proto.ParseFromArray(encoded_file.first, encoded_file.second)) {
       return false;
     }
     *output = file_proto.name();
     return true;
   }
 }
 
 bool EncodedDescriptorDatabase::FindFileContainingExtension(
     const string& containing_type,
     int field_number,
     FileDescriptorProto* output) {
   return MaybeParse(index_.FindExtension(containing_type, field_number),
                     output);
 }
 
 bool EncodedDescriptorDatabase::FindAllExtensionNumbers(
     const string& extendee_type,
-    vector<int>* output) {
+    std::vector<int>* output) {
   return index_.FindAllExtensionNumbers(extendee_type, output);
 }
 
 bool EncodedDescriptorDatabase::MaybeParse(
-    pair<const void*, int> encoded_file,
+    std::pair<const void*, int> encoded_file,
     FileDescriptorProto* output) {
   if (encoded_file.first == NULL) return false;
   return output->ParseFromArray(encoded_file.first, encoded_file.second);
 }
 
 // ===================================================================
 
 DescriptorPoolDatabase::DescriptorPoolDatabase(const DescriptorPool& pool)
   : pool_(pool) {}
 DescriptorPoolDatabase::~DescriptorPoolDatabase() {}
@@ skipping 29 matching lines @@
     pool_.FindExtensionByNumber(extendee, field_number);
   if (extension == NULL) return false;
 
   output->Clear();
   extension->file()->CopyTo(output);
   return true;
 }
 
 bool DescriptorPoolDatabase::FindAllExtensionNumbers(
     const string& extendee_type,
-    vector<int>* output) {
+    std::vector<int>* output) {
   const Descriptor* extendee = pool_.FindMessageTypeByName(extendee_type);
   if (extendee == NULL) return false;
 
-  vector<const FieldDescriptor*> extensions;
+  std::vector<const FieldDescriptor*> extensions;
   pool_.FindAllExtensions(extendee, &extensions);
 
   for (int i = 0; i < extensions.size(); ++i) {
     output->push_back(extensions[i]->number());
   }
 
   return true;
 }
 
 // ===================================================================
 
 MergedDescriptorDatabase::MergedDescriptorDatabase(
     DescriptorDatabase* source1,
     DescriptorDatabase* source2) {
   sources_.push_back(source1);
   sources_.push_back(source2);
 }
 MergedDescriptorDatabase::MergedDescriptorDatabase(
-    const vector<DescriptorDatabase*>& sources)
+    const std::vector<DescriptorDatabase*>& sources)
   : sources_(sources) {}
 MergedDescriptorDatabase::~MergedDescriptorDatabase() {}
 
 bool MergedDescriptorDatabase::FindFileByName(
     const string& filename,
     FileDescriptorProto* output) {
   for (int i = 0; i < sources_.size(); i++) {
     if (sources_[i]->FindFileByName(filename, output)) {
       return true;
     }
@@ skipping 42 matching lines @@
         }
       }
       return true;
     }
   }
   return false;
 }
 
 bool MergedDescriptorDatabase::FindAllExtensionNumbers(
     const string& extendee_type,
-    vector<int>* output) {
-  set<int> merged_results;
-  vector<int> results;
+    std::vector<int>* output) {
+  std::set<int> merged_results;
+  std::vector<int> results;
   bool success = false;
 
   for (int i = 0; i < sources_.size(); i++) {
     if (sources_[i]->FindAllExtensionNumbers(extendee_type, &results)) {
-      std::copy(
-          results.begin(), results.end(),
-          insert_iterator<set<int> >(merged_results, merged_results.begin()));
+      std::copy(results.begin(), results.end(),
+                std::insert_iterator<std::set<int> >(merged_results,
+                                                     merged_results.begin()));
       success = true;
     }
     results.clear();
   }
 
   std::copy(merged_results.begin(), merged_results.end(),
-            insert_iterator<vector<int> >(*output, output->end()));
+            std::insert_iterator<std::vector<int> >(*output, output->end()));
 
   return success;
 }
 
 
 }  // namespace protobuf
 }  // namespace google