third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/descriptor_database.h

 // 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 @@
   // extendee_type, and appends them to output in an undefined
   // order. This method is best-effort: it's not guaranteed that the
   // database will find all extensions, and it's not guaranteed that
   // FindFileContainingExtension will return true on all of the found
   // numbers. Returns true if the search was successful, otherwise
   // returns false and leaves output unchanged.
   //
   // This method has a default implementation that always returns
   // false.
   virtual bool FindAllExtensionNumbers(const string& /* extendee_type */,
-                                       vector<int>* /* output */) {
+                                       std::vector<int>* /* output */) {
     return false;
   }
 
 
  private:
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DescriptorDatabase);
 };
 
 // A DescriptorDatabase into which you can insert files manually.
 //
@@ skipping 32 matching lines @@
 
   // implements DescriptorDatabase -----------------------------------
   bool FindFileByName(const string& filename,
                       FileDescriptorProto* output);
   bool FindFileContainingSymbol(const string& symbol_name,
                                 FileDescriptorProto* output);
   bool FindFileContainingExtension(const string& containing_type,
                                    int field_number,
                                    FileDescriptorProto* output);
   bool FindAllExtensionNumbers(const string& extendee_type,
-                               vector<int>* output);
+                               std::vector<int>* output);
 
  private:
   // So that it can use DescriptorIndex.
   friend class EncodedDescriptorDatabase;
 
   // An index mapping file names, symbol names, and extension numbers to
   // some sort of values.
   template <typename Value>
   class DescriptorIndex {
    public:
     // Helpers to recursively add particular descriptors and all their contents
     // to the index.
     bool AddFile(const FileDescriptorProto& file,
                  Value value);
     bool AddSymbol(const string& name, Value value);
     bool AddNestedExtensions(const DescriptorProto& message_type,
                              Value value);
     bool AddExtension(const FieldDescriptorProto& field,
                       Value value);
 
     Value FindFile(const string& filename);
     Value FindSymbol(const string& name);
     Value FindExtension(const string& containing_type, int field_number);
     bool FindAllExtensionNumbers(const string& containing_type,
-                                 vector<int>* output);
+                                 std::vector<int>* output);
 
    private:
-    map<string, Value> by_name_;
-    map<string, Value> by_symbol_;
-    map<pair<string, int>, Value> by_extension_;
+    std::map<string, Value> by_name_;
+    std::map<string, Value> by_symbol_;
+    std::map<std::pair<string, int>, Value> by_extension_;
 
     // Invariant:  The by_symbol_ map does not contain any symbols which are
     // prefixes of other symbols in the map.  For example, "foo.bar" is a
     // prefix of "foo.bar.baz" (but is not a prefix of "foo.barbaz").
     //
     // This invariant is important because it means that given a symbol name,
     // we can find a key in the map which is a prefix of the symbol in O(lg n)
     // time, and we know that there is at most one such key.
     //
     // The prefix lookup algorithm works like so:
@@ skipping 34 matching lines @@
     // 9) Therefore, the found key must match the match key.
     //
     // The above proof assumes the match key exists.  In the case that the
     // match key does not exist, then step (1) will return some other symbol.
     // That symbol cannot be a super-symbol of the search key since if it were,
     // then it would be a match, and we're assuming the match key doesn't exist.
     // Therefore, step 2 will correctly return no match.
 
     // Find the last entry in the by_symbol_ map whose key is less than or
     // equal to the given name.
-    typename map<string, Value>::iterator FindLastLessOrEqual(
+    typename std::map<string, Value>::iterator FindLastLessOrEqual(
         const string& name);
 
     // True if either the arguments are equal or super_symbol identifies a
     // parent symbol of sub_symbol (e.g. "foo.bar" is a parent of
     // "foo.bar.baz", but not a parent of "foo.barbaz").
     bool IsSubSymbol(const string& sub_symbol, const string& super_symbol);
 
     // Returns true if and only if all characters in the name are alphanumerics,
     // underscores, or periods.
     bool ValidateSymbolName(const string& name);
   };
 
 
   DescriptorIndex<const FileDescriptorProto*> index_;
-  vector<const FileDescriptorProto*> files_to_delete_;
+  std::vector<const FileDescriptorProto*> files_to_delete_;
 
   // If file is non-NULL, copy it into *output and return true, otherwise
   // return false.
   bool MaybeCopy(const FileDescriptorProto* file,
                  FileDescriptorProto* output);
 
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SimpleDescriptorDatabase);
 };
 
 // Very similar to SimpleDescriptorDatabase, but stores all the descriptors
@@ skipping 24 matching lines @@
 
   // implements DescriptorDatabase -----------------------------------
   bool FindFileByName(const string& filename,
                       FileDescriptorProto* output);
   bool FindFileContainingSymbol(const string& symbol_name,
                                 FileDescriptorProto* output);
   bool FindFileContainingExtension(const string& containing_type,
                                    int field_number,
                                    FileDescriptorProto* output);
   bool FindAllExtensionNumbers(const string& extendee_type,
-                               vector<int>* output);
+                               std::vector<int>* output);
 
  private:
-  SimpleDescriptorDatabase::DescriptorIndex<pair<const void*, int> > index_;
-  vector<void*> files_to_delete_;
+  SimpleDescriptorDatabase::DescriptorIndex<std::pair<const void*, int> >
+      index_;
+  std::vector<void*> files_to_delete_;
 
   // If encoded_file.first is non-NULL, parse the data into *output and return
   // true, otherwise return false.
-  bool MaybeParse(pair<const void*, int> encoded_file,
+  bool MaybeParse(std::pair<const void*, int> encoded_file,
                   FileDescriptorProto* output);
 
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EncodedDescriptorDatabase);
 };
 
 // A DescriptorDatabase that fetches files from a given pool.
 class LIBPROTOBUF_EXPORT DescriptorPoolDatabase : public DescriptorDatabase {
  public:
   explicit DescriptorPoolDatabase(const DescriptorPool& pool);
   ~DescriptorPoolDatabase();
 
   // implements DescriptorDatabase -----------------------------------
   bool FindFileByName(const string& filename,
                       FileDescriptorProto* output);
   bool FindFileContainingSymbol(const string& symbol_name,
                                 FileDescriptorProto* output);
   bool FindFileContainingExtension(const string& containing_type,
                                    int field_number,
                                    FileDescriptorProto* output);
   bool FindAllExtensionNumbers(const string& extendee_type,
-                               vector<int>* output);
+                               std::vector<int>* output);
 
  private:
   const DescriptorPool& pool_;
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DescriptorPoolDatabase);
 };
 
 // A DescriptorDatabase that wraps two or more others.  It first searches the
 // first database and, if that fails, tries the second, and so on.
 class LIBPROTOBUF_EXPORT MergedDescriptorDatabase : public DescriptorDatabase {
  public:
   // Merge just two databases.  The sources remain property of the caller.
   MergedDescriptorDatabase(DescriptorDatabase* source1,
                            DescriptorDatabase* source2);
   // Merge more than two databases.  The sources remain property of the caller.
   // The vector may be deleted after the constructor returns but the
   // DescriptorDatabases need to stick around.
-  explicit MergedDescriptorDatabase(const vector<DescriptorDatabase*>& sources);
+  explicit MergedDescriptorDatabase(
+      const std::vector<DescriptorDatabase*>& sources);
   ~MergedDescriptorDatabase();
 
   // implements DescriptorDatabase -----------------------------------
   bool FindFileByName(const string& filename,
                       FileDescriptorProto* output);
   bool FindFileContainingSymbol(const string& symbol_name,
                                 FileDescriptorProto* output);
   bool FindFileContainingExtension(const string& containing_type,
                                    int field_number,
                                    FileDescriptorProto* output);
   // Merges the results of calling all databases. Returns true iff any
   // of the databases returned true.
   bool FindAllExtensionNumbers(const string& extendee_type,
-                               vector<int>* output);
+                               std::vector<int>* output);
 
 
  private:
-  vector<DescriptorDatabase*> sources_;
+  std::vector<DescriptorDatabase*> sources_;
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MergedDescriptorDatabase);
 };
 
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_DESCRIPTOR_DATABASE_H__