Reverts third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/src/google/protobuf/util/message_differencer.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 203 matching lines @@
   // itself and the second will be the actual field in the embedded message
   // that was added/deleted/modified.
   class LIBPROTOBUF_EXPORT Reporter {
    public:
     Reporter();
     virtual ~Reporter();
 
     // Reports that a field has been added into Message2.
     virtual void ReportAdded(
         const Message& message1, const Message& message2,
-        const std::vector<SpecificField>& field_path) = 0;
+        const vector<SpecificField>& field_path) = 0;
 
     // Reports that a field has been deleted from Message1.
     virtual void ReportDeleted(
         const Message& message1,
         const Message& message2,
-        const std::vector<SpecificField>& field_path) = 0;
+        const vector<SpecificField>& field_path) = 0;
 
     // Reports that the value of a field has been modified.
     virtual void ReportModified(
         const Message& message1,
         const Message& message2,
-        const std::vector<SpecificField>& field_path) = 0;
+        const vector<SpecificField>& field_path) = 0;
 
     // Reports that a repeated field has been moved to another location.  This
     // only applies when using TreatAsSet or TreatAsMap()  -- see below. Also
     // note that for any given field, ReportModified and ReportMoved are
     // mutually exclusive. If a field has been both moved and modified, then
     // only ReportModified will be called.
     virtual void ReportMoved(
         const Message& message1,
         const Message& message2,
-        const std::vector<SpecificField>& field_path) { }
+        const vector<SpecificField>& field_path) { }
 
     // Reports that two fields match. Useful for doing side-by-side diffs.
     // This function is mutually exclusive with ReportModified and ReportMoved.
     // Note that you must call set_report_matches(true) before calling Compare
     // to make use of this function.
     virtual void ReportMatched(
         const Message& message1,
         const Message& message2,
-        const std::vector<SpecificField>& field_path) { }
+        const vector<SpecificField>& field_path) { }
 
     // Reports that two fields would have been compared, but the
     // comparison has been skipped because the field was marked as
     // 'ignored' using IgnoreField().  This function is mutually
     // exclusive with all the other Report() functions.
     //
     // The contract of ReportIgnored is slightly different than the
     // other Report() functions, in that |field_path.back().index| is
     // always equal to -1, even if the last field is repeated. This is
     // because while the other Report() functions indicate where in a
     // repeated field the action (Addition, Deletion, etc...)
     // happened, when a repeated field is 'ignored', the differencer
     // simply calls ReportIgnored on the repeated field as a whole and
     // moves on without looking at its individual elements.
     //
     // Furthermore, ReportIgnored() does not indicate whether the
     // fields were in fact equal or not, as Compare() does not inspect
     // these fields at all. It is up to the Reporter to decide whether
     // the fields are equal or not (perhaps with a second call to
     // Compare()), if it cares.
     virtual void ReportIgnored(
         const Message& message1,
         const Message& message2,
-        const std::vector<SpecificField>& field_path) { }
+        const vector<SpecificField>& field_path) { }
 
-    // Report that an unknown field is ignored. (see comment above).
+    // Report that an unkown field is ignored. (see comment above).
     // Note this is a different function since the last SpecificField in field
     // path has a null field.  This could break existing Reporter.
     virtual void ReportUnknownFieldIgnored(
         const Message& message1, const Message& message2,
-        const std::vector<SpecificField>& field_path) {}
+        const vector<SpecificField>& field_path) {}
 
    private:
     GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Reporter);
   };
 
   // MapKeyComparator is used to determine if two elements have the same key
   // when comparing elements of a repeated field as a map.
   class LIBPROTOBUF_EXPORT MapKeyComparator {
    public:
     MapKeyComparator();
     virtual ~MapKeyComparator();
 
-    virtual bool IsMatch(
-        const Message& message1,
-        const Message& message2,
-        const std::vector<SpecificField>& parent_fields) const {
+    virtual bool IsMatch(const Message& message1,
+                         const Message& message2,
+                         const vector<SpecificField>& parent_fields) const {
       GOOGLE_CHECK(false) << "IsMatch() is not implemented.";
       return false;
     }
 
    private:
     GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapKeyComparator);
   };
 
   // Abstract base class from which all IgnoreCriteria derive.
   // By adding IgnoreCriteria more complex ignore logic can be implemented.
   // IgnoreCriteria are registed with AddIgnoreCriteria. For each compared
   // field IsIgnored is called on each added IgnoreCriteria until one returns
   // true or all return false.
   // IsIgnored is called for fields where at least one side has a value.
   class LIBPROTOBUF_EXPORT IgnoreCriteria {
    public:
     IgnoreCriteria();
     virtual ~IgnoreCriteria();
 
     // Returns true if the field should be ignored.
     virtual bool IsIgnored(
         const Message& message1,
         const Message& message2,
         const FieldDescriptor* field,
-        const std::vector<SpecificField>& parent_fields) = 0;
+        const vector<SpecificField>& parent_fields) = 0;
 
     // Returns true if the unknown field should be ignored.
     // Note: This will be called for unknown fields as well in which case
     //       field.field will be null.
     virtual bool IsUnknownFieldIgnored(
         const Message& message1, const Message& message2,
         const SpecificField& field,
-        const std::vector<SpecificField>& parent_fields) {
+        const vector<SpecificField>& parent_fields) {
       return false;
     }
   };
 
   // To add a Reporter, construct default here, then use ReportDifferencesTo or
   // ReportDifferencesToString.
   explicit MessageDifferencer();
 
   ~MessageDifferencer();
 
@@ skipping 88 matching lines @@
   // comparison. Those pairs of elements with the same key (with equal value
   // for every field in 'key_fields') will be compared in this step.
   // Time complexity of the first step is O(s * m * n ^ 2) where s is the
   // average size of the fields specified in 'key_fields', m is the number of
   // fields in 'key_fields' and n is the number of elements. If partial
   // matching is enabled, an extra O(n^3) will be incured by the maximum
   // matching algorithm. The second step is O(k * n) where k is the average
   // size of each element.
   void TreatAsMapWithMultipleFieldsAsKey(
       const FieldDescriptor* field,
-      const std::vector<const FieldDescriptor*>& key_fields);
+      const vector<const FieldDescriptor*>& key_fields);
   // Same as TreatAsMapWithMultipleFieldsAsKey, except that each of the field
   // do not necessarily need to be a direct subfield. Each element in
   // key_field_paths indicate a path from the message being compared, listing
   // successive subfield to reach the key field.
   //
   // REQUIRES:
   //   for key_field_path in key_field_paths:
   //     key_field_path[0]->containing_type() == field->message_type()
   //     for i in [0, key_field_path.size() - 1):
   //       key_field_path[i+1]->containing_type() ==
   //           key_field_path[i]->message_type()
   //       key_field_path[i]->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE
   //       !key_field_path[i]->is_repeated()
   void TreatAsMapWithMultipleFieldPathsAsKey(
       const FieldDescriptor* field,
-      const std::vector<std::vector<const FieldDescriptor*> >& key_field_paths);
+      const vector<vector<const FieldDescriptor*> >& key_field_paths);
 
   // Uses a custom MapKeyComparator to determine if two elements have the same
   // key when comparing a repeated field as a map.
   // The caller is responsible to delete the key_comparator.
   // This method varies from TreatAsMapWithMultipleFieldsAsKey only in the
   // first key matching step. Rather than comparing some specified fields, it
   // will invoke the IsMatch method of the given 'key_comparator' to decide if
   // two elements have the same key.
   void TreatAsMapUsingKeyComparator(
       const FieldDescriptor* field,
@@ skipping 72 matching lines @@
   // false otherwise. If this method returns false, any changes between the
   // two messages will be reported if a Reporter was specified via
   // ReportDifferencesTo (see also ReportDifferencesToString).
   //
   // This method REQUIRES that the two messages have the same
   // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
   bool Compare(const Message& message1, const Message& message2);
 
   // Same as above, except comparing only the list of fields specified by the
   // two vectors of FieldDescriptors.
-  bool CompareWithFields(
-      const Message& message1, const Message& message2,
-      const std::vector<const FieldDescriptor*>& message1_fields,
-      const std::vector<const FieldDescriptor*>& message2_fields);
+  bool CompareWithFields(const Message& message1, const Message& message2,
+                         const vector<const FieldDescriptor*>& message1_fields,
+                         const vector<const FieldDescriptor*>& message2_fields);
 
   // Automatically creates a reporter that will output the differences
   // found (if any) to the specified output string pointer. Note that this
   // method must be called before Compare.
   void ReportDifferencesToString(string* output);
 
   // Tells the MessageDifferencer to report differences via the specified
   // reporter. Note that this method must be called before Compare for
   // the reporter to be used. It is the responsibility of the caller to delete
   // this object.
   // If the provided pointer equals NULL, the MessageDifferencer stops reporting
   // differences to any previously set reporters or output strings.
   void ReportDifferencesTo(Reporter* reporter);
 
   // An implementation of the MessageDifferencer Reporter that outputs
   // any differences found in human-readable form to the supplied
   // ZeroCopyOutputStream or Printer. If a printer is used, the delimiter
   // *must* be '$'.
-  //
-  // WARNING: this reporter does not necessarily flush its output until it is
-  // destroyed. As a result, it is not safe to assume the output is valid or
-  // complete until after you destroy the reporter. For example, if you use a
-  // StreamReporter to write to a StringOutputStream, the target string may
-  // contain uninitialized data until the reporter is destroyed.
   class LIBPROTOBUF_EXPORT StreamReporter : public Reporter {
    public:
     explicit StreamReporter(io::ZeroCopyOutputStream* output);
     explicit StreamReporter(io::Printer* printer);  // delimiter '$'
     virtual ~StreamReporter();
 
     // When set to true, the stream reporter will also output aggregates nodes
     // (i.e. messages and groups) whose subfields have been modified. When
     // false, will only report the individual subfields. Defaults to false.
     void set_report_modified_aggregates(bool report) {
       report_modified_aggregates_ = report;
     }
 
     // The following are implementations of the methods described above.
     virtual void ReportAdded(const Message& message1, const Message& message2,
-                             const std::vector<SpecificField>& field_path);
+                             const vector<SpecificField>& field_path);
 
     virtual void ReportDeleted(const Message& message1,
                                const Message& message2,
-                               const std::vector<SpecificField>& field_path);
+                               const vector<SpecificField>& field_path);
 
     virtual void ReportModified(const Message& message1,
                                 const Message& message2,
-                                const std::vector<SpecificField>& field_path);
+                                const vector<SpecificField>& field_path);
 
     virtual void ReportMoved(const Message& message1,
                              const Message& message2,
-                             const std::vector<SpecificField>& field_path);
+                             const vector<SpecificField>& field_path);
 
     virtual void ReportMatched(const Message& message1,
                                const Message& message2,
-                               const std::vector<SpecificField>& field_path);
+                               const vector<SpecificField>& field_path);
 
     virtual void ReportIgnored(const Message& message1,
                                const Message& message2,
-                               const std::vector<SpecificField>& field_path);
+                               const vector<SpecificField>& field_path);
 
     virtual void ReportUnknownFieldIgnored(
         const Message& message1, const Message& message2,
-        const std::vector<SpecificField>& field_path);
+        const vector<SpecificField>& field_path);
 
    protected:
     // Prints the specified path of fields to the buffer.
-    virtual void PrintPath(const std::vector<SpecificField>& field_path,
+    virtual void PrintPath(const vector<SpecificField>& field_path,
                            bool left_side);
 
     // Prints the value of fields to the buffer.  left_side is true if the
     // given message is from the left side of the comparison, false if it
     // was the right.  This is relevant only to decide whether to follow
     // unknown_field_index1 or unknown_field_index2 when an unknown field
     // is encountered in field_path.
     virtual void PrintValue(const Message& message,
-                            const std::vector<SpecificField>& field_path,
+                            const vector<SpecificField>& field_path,
                             bool left_side);
 
     // Prints the specified path of unknown fields to the buffer.
     virtual void PrintUnknownFieldValue(const UnknownField* unknown_field);
 
     // Just print a string
     void Print(const string& str);
 
    private:
     io::Printer* printer_;
@@ skipping 10 matching lines @@
   // class is declared as a nested class of MessageDifferencer.
   class MultipleFieldsMapKeyComparator;
   // Returns true if field1's number() is less than field2's.
   static bool FieldBefore(const FieldDescriptor* field1,
                           const FieldDescriptor* field2);
 
   // Combine the two lists of fields into the combined_fields output vector.
   // All fields present in both lists will always be included in the combined
   // list.  Fields only present in one of the lists will only appear in the
   // combined list if the corresponding fields_scope option is set to FULL.
-  void CombineFields(const std::vector<const FieldDescriptor*>& fields1,
+  void CombineFields(const vector<const FieldDescriptor*>& fields1,
                      Scope fields1_scope,
-                     const std::vector<const FieldDescriptor*>& fields2,
+                     const vector<const FieldDescriptor*>& fields2,
                      Scope fields2_scope,
-                     std::vector<const FieldDescriptor*>* combined_fields);
+                     vector<const FieldDescriptor*>* combined_fields);
 
   // Internal version of the Compare method which performs the actual
   // comparison. The parent_fields vector is a vector containing field
   // descriptors of all fields accessed to get to this comparison operation
   // (i.e. if the current message is an embedded message, the parent_fields
   // vector will contain the field that has this embedded message).
   bool Compare(const Message& message1, const Message& message2,
-               std::vector<SpecificField>* parent_fields);
+               vector<SpecificField>* parent_fields);
 
   // Compares all the unknown fields in two messages.
   bool CompareUnknownFields(const Message& message1, const Message& message2,
                             const google::protobuf::UnknownFieldSet&,
                             const google::protobuf::UnknownFieldSet&,
-                            std::vector<SpecificField>* parent_fields);
+                            vector<SpecificField>* parent_fields);
 
   // Compares the specified messages for the requested field lists. The field
   // lists are modified depending on comparison settings, and then passed to
   // CompareWithFieldsInternal.
   bool CompareRequestedFieldsUsingSettings(
       const Message& message1, const Message& message2,
-      const std::vector<const FieldDescriptor*>& message1_fields,
-      const std::vector<const FieldDescriptor*>& message2_fields,
-      std::vector<SpecificField>* parent_fields);
+      const vector<const FieldDescriptor*>& message1_fields,
+      const vector<const FieldDescriptor*>& message2_fields,
+      vector<SpecificField>* parent_fields);
 
   // Compares the specified messages with the specified field lists.
   bool CompareWithFieldsInternal(
       const Message& message1, const Message& message2,
-      const std::vector<const FieldDescriptor*>& message1_fields,
-      const std::vector<const FieldDescriptor*>& message2_fields,
-      std::vector<SpecificField>* parent_fields);
+      const vector<const FieldDescriptor*>& message1_fields,
+      const vector<const FieldDescriptor*>& message2_fields,
+      vector<SpecificField>* parent_fields);
 
   // Compares the repeated fields, and report the error.
   bool CompareRepeatedField(const Message& message1, const Message& message2,
                             const FieldDescriptor* field,
-                            std::vector<SpecificField>* parent_fields);
+                            vector<SpecificField>* parent_fields);
 
   // Shorthand for CompareFieldValueUsingParentFields with NULL parent_fields.
   bool CompareFieldValue(const Message& message1,
                          const Message& message2,
                          const FieldDescriptor* field,
                          int index1,
                          int index2);
 
   // Compares the specified field on the two messages, returning
   // true if they are the same, false otherwise. For repeated fields,
   // this method only compares the value in the specified index. This method
   // uses Compare functions to recurse into submessages.
   // The parent_fields vector is used in calls to a Reporter instance calls.
   // It can be NULL, in which case the MessageDifferencer will create new
   // list of parent messages if it needs to recursively compare the given field.
   // To avoid confusing users you should not set it to NULL unless you modified
   // Reporter to handle the change of parent_fields correctly.
-  bool CompareFieldValueUsingParentFields(
-      const Message& message1,
-      const Message& message2,
-      const FieldDescriptor* field,
-      int index1,
-      int index2,
-      std::vector<SpecificField>* parent_fields);
+  bool CompareFieldValueUsingParentFields(const Message& message1,
+                                          const Message& message2,
+                                          const FieldDescriptor* field,
+                                          int index1,
+                                          int index2,
+                                          vector<SpecificField>* parent_fields);
 
   // Compares the specified field on the two messages, returning comparison
   // result, as returned by appropriate FieldComparator.
   FieldComparator::ComparisonResult GetFieldComparisonResult(
       const Message& message1, const Message& message2,
       const FieldDescriptor* field, int index1, int index2,
       const FieldContext* field_context);
 
   // Check if the two elements in the repeated field are match to each other.
   // if the key_comprator is NULL, this function returns true when the two
   // elements are equal.
   bool IsMatch(const FieldDescriptor* repeated_field,
                const MapKeyComparator* key_comparator,
                const Message* message1, const Message* message2,
-               const std::vector<SpecificField>& parent_fields,
+               const vector<SpecificField>& parent_fields,
                int index1, int index2);
 
   // Returns true when this repeated field has been configured to be treated
   // as a set.
   bool IsTreatedAsSet(const FieldDescriptor* field);
 
   // Returns true when this repeated field is to be compared as a subset, ie.
   // has been configured to be treated as a set or map and scope is set to
   // PARTIAL.
   bool IsTreatedAsSubset(const FieldDescriptor* field);
 
   // Returns true if this field is to be ignored when this
   // MessageDifferencer compares messages.
   bool IsIgnored(
       const Message& message1,
       const Message& message2,
       const FieldDescriptor* field,
-      const std::vector<SpecificField>& parent_fields);
+      const vector<SpecificField>& parent_fields);
 
   // Returns true if this unknown field is to be ignored when this
   // MessageDifferencer compares messages.
   bool IsUnknownFieldIgnored(const Message& message1, const Message& message2,
                              const SpecificField& field,
-                             const std::vector<SpecificField>& parent_fields);
+                             const vector<SpecificField>& parent_fields);
 
   // Returns MapKeyComparator* when this field has been configured to
   // be treated as a map.  If not, returns NULL.
   const MapKeyComparator* GetMapKeyComparator(const FieldDescriptor* field);
 
   // Attempts to match indices of a repeated field, so that the contained values
   // match. Clears output vectors and sets their values to indices of paired
   // messages, ie. if message1[0] matches message2[1], then match_list1[0] == 1
   // and match_list2[1] == 0. The unmatched indices are indicated by -1.
   // This method returns false if the match failed. However, it doesn't mean
   // that the comparison succeeds when this method returns true (you need to
   // double-check in this case).
-  bool MatchRepeatedFieldIndices(
-      const Message& message1,
-      const Message& message2,
-      const FieldDescriptor* repeated_field,
-      const std::vector<SpecificField>& parent_fields,
-      std::vector<int>* match_list1,
-      std::vector<int>* match_list2);
+  bool MatchRepeatedFieldIndices(const Message& message1,
+                                 const Message& message2,
+                                 const FieldDescriptor* repeated_field,
+                                 const vector<SpecificField>& parent_fields,
+                                 vector<int>* match_list1,
+                                 vector<int>* match_list2);
 
   // If "any" is of type google.protobuf.Any, extract its payload using
   // DynamicMessageFactory and store in "data".
   bool UnpackAny(const Message& any, google::protobuf::scoped_ptr<Message>* data);
 
   // Checks if index is equal to new_index in all the specific fields.
-  static bool CheckPathChanged(const std::vector<SpecificField>& parent_fields);
+  static bool CheckPathChanged(const vector<SpecificField>& parent_fields);
 
   // Defines a map between field descriptors and their MapKeyComparators.
   // Used for repeated fields when they are configured as TreatAsMap.
-  typedef std::map<const FieldDescriptor*,
+  typedef map<const FieldDescriptor*,
               const MapKeyComparator*> FieldKeyComparatorMap;
 
   // Defines a set to store field descriptors.  Used for repeated fields when
   // they are configured as TreatAsSet.
-  typedef std::set<const FieldDescriptor*> FieldSet;
+  typedef set<const FieldDescriptor*> FieldSet;
 
   Reporter* reporter_;
   DefaultFieldComparator default_field_comparator_;
   FieldComparator* field_comparator_;
   MessageFieldComparison message_field_comparison_;
   Scope scope_;
   RepeatedFieldComparison repeated_field_comparison_;
 
   FieldSet set_fields_;
   FieldSet list_fields_;
   // Keeps track of MapKeyComparators that are created within
   // MessageDifferencer. These MapKeyComparators should be deleted
   // before MessageDifferencer is destroyed.
   // When TreatAsMap or TreatAsMapWithMultipleFieldsAsKey is called, we don't
   // store the supplied FieldDescriptors directly. Instead, a new
   // MapKeyComparator is created for comparison purpose.
-  std::vector<MapKeyComparator*> owned_key_comparators_;
+  vector<MapKeyComparator*> owned_key_comparators_;
   FieldKeyComparatorMap map_field_key_comparator_;
-  std::vector<IgnoreCriteria*> ignore_criteria_;
+  vector<IgnoreCriteria*> ignore_criteria_;
 
   FieldSet ignored_fields_;
 
+  bool compare_unknown_fields_;
   bool report_matches_;
 
   string* output_string_;
 
   google::protobuf::scoped_ptr<DynamicMessageFactory> dynamic_message_factory_;
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageDifferencer);
 };
 
 // This class provides extra information to the FieldComparator::Compare
 // function.
 class LIBPROTOBUF_EXPORT FieldContext {
  public:
   explicit FieldContext(
-      std::vector<MessageDifferencer::SpecificField>* parent_fields)
+      vector<MessageDifferencer::SpecificField>* parent_fields)
       : parent_fields_(parent_fields) {}
 
-  std::vector<MessageDifferencer::SpecificField>* parent_fields() const {
+  vector<MessageDifferencer::SpecificField>* parent_fields() const {
     return parent_fields_;
   }
 
  private:
-  std::vector<MessageDifferencer::SpecificField>* parent_fields_;
+  vector<MessageDifferencer::SpecificField>* parent_fields_;
 };
 
 }
 }
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_UTIL_MESSAGE_DIFFERENCER_H__