third_party/protobuf: Update to HEAD (5f65ee6ac7)

third_party/protobuf/src/google/protobuf/io/printer.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 37 matching lines @@
 
 class ZeroCopyOutputStream;     // zero_copy_stream.h
 
 // Records annotations about a Printer's output.
 class LIBPROTOBUF_EXPORT AnnotationCollector {
  public:
   // Records that the bytes in file_path beginning with begin_offset and ending
   // before end_offset are associated with the SourceCodeInfo-style path.
   virtual void AddAnnotation(size_t begin_offset, size_t end_offset,
                              const string& file_path,
-                             const vector<int>& path) = 0;
+                             const std::vector<int>& path) = 0;
 
   virtual ~AnnotationCollector() {}
 };
 
 // Records annotations about a Printer's output to the given protocol buffer,
 // assuming that the buffer has an ::Annotation message exposing path,
 // source_file, begin and end fields.
 template <typename AnnotationProto>
 class AnnotationProtoCollector : public AnnotationCollector {
  public:
   // annotation_proto is the protocol buffer to which new Annotations should be
   // added. It is not owned by the AnnotationProtoCollector.
   explicit AnnotationProtoCollector(AnnotationProto* annotation_proto)
       : annotation_proto_(annotation_proto) {}
 
   // Override for AnnotationCollector::AddAnnotation.
   virtual void AddAnnotation(size_t begin_offset, size_t end_offset,
-                             const string& file_path, const vector<int>& path) {
+                             const string& file_path,
+                             const std::vector<int>& path) {
     typename AnnotationProto::Annotation* annotation =
         annotation_proto_->add_annotation();
     for (int i = 0; i < path.size(); ++i) {
       annotation->add_path(path[i]);
     }
     annotation->set_source_file(file_path);
     annotation->set_begin(begin_offset);
     annotation->set_end(end_offset);
   }
 
@@ skipping 101 matching lines @@
   // begins at begin_varname's value and ends after the last character of the
   // value substituted for end_varname.
   template <typename SomeDescriptor>
   void Annotate(const char* begin_varname, const char* end_varname,
                 const SomeDescriptor* descriptor) {
     if (annotation_collector_ == NULL) {
       // Annotations aren't turned on for this Printer, so don't pay the cost
       // of building the location path.
       return;
     }
-    vector<int> path;
+    std::vector<int> path;
     descriptor->GetLocationPath(&path);
     Annotate(begin_varname, end_varname, descriptor->file()->name(), path);
   }
 
+  // Link a subsitution variable emitted by the last call to Print to the file
+  // with path file_name.
+  void Annotate(const char* varname, const string& file_name) {
+    Annotate(varname, varname, file_name);
+  }
+
+  // Link the output range defined by the substitution variables as emitted by
+  // the last call to Print to the file with path file_name. The range begins
+  // at begin_varname's value and ends after the last character of the value
+  // substituted for end_varname.
+  void Annotate(const char* begin_varname, const char* end_varname,
+                const string& file_name) {
+    if (annotation_collector_ == NULL) {
+      // Annotations aren't turned on for this Printer.
+      return;
+    }
+    std::vector<int> empty_path;
+    Annotate(begin_varname, end_varname, file_name, empty_path);
+  }
+
   // Print some text after applying variable substitutions.  If a particular
   // variable in the text is not defined, this will crash.  Variables to be
   // substituted are identified by their names surrounded by delimiter
   // characters (as given to the constructor).  The variable bindings are
   // defined by the given map.
-  void Print(const map<string, string>& variables, const char* text);
+  void Print(const std::map<string, string>& variables, const char* text);
 
   // Like the first Print(), except the substitutions are given as parameters.
   void Print(const char* text);
   // Like the first Print(), except the substitutions are given as parameters.
   void Print(const char* text, const char* variable, const string& value);
   // Like the first Print(), except the substitutions are given as parameters.
   void Print(const char* text, const char* variable1, const string& value1,
                                const char* variable2, const string& value2);
   // Like the first Print(), except the substitutions are given as parameters.
   void Print(const char* text, const char* variable1, const string& value1,
@@ skipping 62 matching lines @@
   bool failed() const { return failed_; }
 
  private:
   // Link the output range defined by the substitution variables as emitted by
   // the last call to Print to the object found at the SourceCodeInfo-style path
   // in a file with path file_path. The range begins at the start of
   // begin_varname's value and ends after the last character of the value
   // substituted for end_varname. Note that begin_varname and end_varname
   // may refer to the same variable.
   void Annotate(const char* begin_varname, const char* end_varname,
-                const string& file_path, const vector<int>& path);
+                const string& file_path, const std::vector<int>& path);
 
   const char variable_delimiter_;
 
   ZeroCopyOutputStream* const output_;
   char* buffer_;
   int buffer_size_;
   // The current position, in bytes, in the output stream.  This is equivalent
   // to the total number of bytes that have been written so far.  This value is
   // used to calculate annotation ranges in the substitutions_ map below.
   size_t offset_;
 
   string indent_;
   bool at_start_of_line_;
   bool failed_;
 
   // A map from variable name to [start, end) offsets in the output buffer.
   // These refer to the offsets used for a variable after the last call to
   // Print.  If a variable was used more than once, the entry used in
   // this map is set to a negative-length span.  For singly-used variables, the
   // start offset is the beginning of the substitution; the end offset is the
   // last byte of the substitution plus one (such that (end - start) is the
   // length of the substituted string).
-  map<string, pair<size_t, size_t> > substitutions_;
+  std::map<string, std::pair<size_t, size_t> > substitutions_;
 
   // Returns true and sets range to the substitution range in the output for
   // varname if varname was used once in the last call to Print. If varname
   // was not used, or if it was used multiple times, returns false (and
   // fails a debug assertion).
-  bool GetSubstitutionRange(const char* varname, pair<size_t, size_t>* range);
+  bool GetSubstitutionRange(const char* varname,
+                            std::pair<size_t, size_t>* range);
 
   // If non-null, annotation_collector_ is used to store annotations about
   // generated code.
   AnnotationCollector* const annotation_collector_;
 
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Printer);
 };
 
 }  // namespace io
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_IO_PRINTER_H__