third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/util/field_mask_util.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 27 matching lines @@
 namespace util {
 
 using google::protobuf::FieldMask;
 
 string FieldMaskUtil::ToString(const FieldMask& mask) {
   return Join(mask.paths(), ",");
 }
 
 void FieldMaskUtil::FromString(StringPiece str, FieldMask* out) {
   out->Clear();
-  vector<string> paths = Split(str, ",");
+  std::vector<string> paths = Split(str, ",");
   for (int i = 0; i < paths.size(); ++i) {
     if (paths[i].empty()) continue;
     out->add_paths(paths[i]);
   }
 }
 
 bool FieldMaskUtil::SnakeCaseToCamelCase(StringPiece input, string* output) {
   output->clear();
   bool after_underscore = false;
   for (int i = 0; i < input.size(); ++i) {
@@ skipping 50 matching lines @@
     if (i > 0) {
       out->push_back(',');
     }
     out->append(camelcase_path);
   }
   return true;
 }
 
 bool FieldMaskUtil::FromJsonString(StringPiece str, FieldMask* out) {
   out->Clear();
-  vector<string> paths = Split(str, ",");
+  std::vector<string> paths = Split(str, ",");
   for (int i = 0; i < paths.size(); ++i) {
     if (paths[i].empty()) continue;
     string snakecase_path;
     if (!CamelCaseToSnakeCase(paths[i], &snakecase_path)) {
       return false;
     }
     out->add_paths(snakecase_path);
   }
   return true;
 }
 
-bool FieldMaskUtil::InternalIsValidPath(const Descriptor* descriptor,
-                                        StringPiece path) {
-  vector<string> parts = Split(path, ".");
+bool FieldMaskUtil::GetFieldDescriptors(
+    const Descriptor* descriptor, StringPiece path,
+    std::vector<const FieldDescriptor*>* field_descriptors) {
+  if (field_descriptors != NULL) {
+    field_descriptors->clear();
+  }
+  std::vector<string> parts = Split(path, ".");
   for (int i = 0; i < parts.size(); ++i) {
     const string& field_name = parts[i];
     if (descriptor == NULL) {
       return false;
     }
     const FieldDescriptor* field = descriptor->FindFieldByName(field_name);
     if (field == NULL) {
       return false;
     }
+    if (field_descriptors != NULL) {
+      field_descriptors->push_back(field);
+    }
     if (!field->is_repeated() &&
         field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
       descriptor = field->message_type();
     } else {
       descriptor = NULL;
     }
   }
   return true;
 }
 
@@ skipping 40 matching lines @@
   void MergeMessage(const Message& source,
                     const FieldMaskUtil::MergeOptions& options,
                     Message* destination) {
     // Do nothing if the tree is empty.
     if (root_.children.empty()) {
       return;
     }
     MergeMessage(&root_, source, options, destination);
   }
 
+  // Trims all fields not specified by this tree from the given message.
+  void TrimMessage(Message* message) {
+    // Do nothing if the tree is empty.
+    if (root_.children.empty()) {
+      return;
+    }
+    TrimMessage(&root_, message);
+  }
+
  private:
   struct Node {
     Node() {}
 
     ~Node() { ClearChildren(); }
 
     void ClearChildren() {
-      for (map<string, Node*>::iterator it = children.begin();
+      for (std::map<string, Node*>::iterator it = children.begin();
            it != children.end(); ++it) {
         delete it->second;
       }
       children.clear();
     }
 
-    map<string, Node*> children;
+    std::map<string, Node*> children;
 
    private:
     GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Node);
   };
 
   // Merge a sub-tree to mask. This method adds the field paths represented
   // by all leaf nodes descended from "node" to mask.
   void MergeToFieldMask(const string& prefix, const Node* node, FieldMask* out);
 
   // Merge all leaf nodes of a sub-tree to another tree.
   void MergeLeafNodesToTree(const string& prefix, const Node* node,
                             FieldMaskTree* out);
 
   // Merge all fields specified by a sub-tree from one message to another.
   void MergeMessage(const Node* node, const Message& source,
                     const FieldMaskUtil::MergeOptions& options,
                     Message* destination);
 
+  // Trims all fields not specified by this sub-tree from the given message.
+  void TrimMessage(const Node* node, Message* message);
+
   Node root_;
 
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldMaskTree);
 };
 
 FieldMaskTree::FieldMaskTree() {}
 
 FieldMaskTree::~FieldMaskTree() {}
 
 void FieldMaskTree::MergeFromFieldMask(const FieldMask& mask) {
   for (int i = 0; i < mask.paths_size(); ++i) {
     AddPath(mask.paths(i));
   }
 }
 
 void FieldMaskTree::MergeToFieldMask(FieldMask* mask) {
   MergeToFieldMask("", &root_, mask);
 }
 
 void FieldMaskTree::MergeToFieldMask(const string& prefix, const Node* node,
                                      FieldMask* out) {
   if (node->children.empty()) {
     if (prefix.empty()) {
       // This is the root node.
       return;
     }
     out->add_paths(prefix);
     return;
   }
-  for (map<string, Node*>::const_iterator it = node->children.begin();
+  for (std::map<string, Node*>::const_iterator it = node->children.begin();
        it != node->children.end(); ++it) {
     string current_path = prefix.empty() ? it->first : prefix + "." + it->first;
     MergeToFieldMask(current_path, it->second, out);
   }
 }
 
 void FieldMaskTree::AddPath(const string& path) {
-  vector<string> parts = Split(path, ".");
+  std::vector<string> parts = Split(path, ".");
   if (parts.empty()) {
     return;
   }
   bool new_branch = false;
   Node* node = &root_;
   for (int i = 0; i < parts.size(); ++i) {
     if (!new_branch && node != &root_ && node->children.empty()) {
       // Path matches an existing leaf node. This means the path is already
       // coverred by this tree (for example, adding "foo.bar.baz" to a tree
       // which already contains "foo.bar").
       return;
     }
     const string& node_name = parts[i];
     Node*& child = node->children[node_name];
     if (child == NULL) {
       new_branch = true;
       child = new Node();
     }
     node = child;
   }
   if (!node->children.empty()) {
     node->ClearChildren();
   }
 }
 
 void FieldMaskTree::IntersectPath(const string& path, FieldMaskTree* out) {
-  vector<string> parts = Split(path, ".");
+  std::vector<string> parts = Split(path, ".");
   if (parts.empty()) {
     return;
   }
   const Node* node = &root_;
   for (int i = 0; i < parts.size(); ++i) {
     if (node->children.empty()) {
       if (node != &root_) {
         out->AddPath(path);
       }
       return;
     }
     const string& node_name = parts[i];
     const Node* result = FindPtrOrNull(node->children, node_name);
     if (result == NULL) {
       // No intersection found.
       return;
     }
     node = result;
   }
   // Now we found a matching node with the given path. Add all leaf nodes
   // to out.
   MergeLeafNodesToTree(path, node, out);
 }
 
 void FieldMaskTree::MergeLeafNodesToTree(const string& prefix, const Node* node,
                                          FieldMaskTree* out) {
   if (node->children.empty()) {
     out->AddPath(prefix);
   }
-  for (map<string, Node*>::const_iterator it = node->children.begin();
+  for (std::map<string, Node*>::const_iterator it = node->children.begin();
        it != node->children.end(); ++it) {
     string current_path = prefix.empty() ? it->first : prefix + "." + it->first;
     MergeLeafNodesToTree(current_path, it->second, out);
   }
 }
 
 void FieldMaskTree::MergeMessage(const Node* node, const Message& source,
                                  const FieldMaskUtil::MergeOptions& options,
                                  Message* destination) {
   GOOGLE_DCHECK(!node->children.empty());
   const Reflection* source_reflection = source.GetReflection();
   const Reflection* destination_reflection = destination->GetReflection();
   const Descriptor* descriptor = source.GetDescriptor();
-  for (map<string, Node*>::const_iterator it = node->children.begin();
+  for (std::map<string, Node*>::const_iterator it = node->children.begin();
        it != node->children.end(); ++it) {
     const string& field_name = it->first;
     const Node* child = it->second;
     const FieldDescriptor* field = descriptor->FindFieldByName(field_name);
     if (field == NULL) {
       GOOGLE_LOG(ERROR) << "Cannot find field \"" << field_name << "\" in message "
                  << descriptor->full_name();
       continue;
     }
     if (!child->children.empty()) {
       // Sub-paths are only allowed for singular message fields.
       if (field->is_repeated() ||
           field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) {
         GOOGLE_LOG(ERROR) << "Field \"" << field_name << "\" in message "
                    << descriptor->full_name()
                    << " is not a singular message field and cannot "
                    << "have sub-fields.";
         continue;
       }
       MergeMessage(child, source_reflection->GetMessage(source, field), options,
                    destination_reflection->MutableMessage(destination, field));
       continue;
     }
     if (!field->is_repeated()) {
       switch (field->cpp_type()) {
-#define COPY_VALUE(TYPE, Name)                                            \
-  case FieldDescriptor::CPPTYPE_##TYPE: {                                 \
-    destination_reflection->Set##Name(                                    \
-        destination, field, source_reflection->Get##Name(source, field)); \
-    break;                                                                \
+#define COPY_VALUE(TYPE, Name)                                              \
+  case FieldDescriptor::CPPTYPE_##TYPE: {                                   \
+    if (source_reflection->HasField(source, field)) {                       \
+      destination_reflection->Set##Name(                                    \
+          destination, field, source_reflection->Get##Name(source, field)); \
+    } else {                                                                \
+      destination_reflection->ClearField(destination, field);               \
+    }                                                                       \
+    break;                                                                  \
   }
         COPY_VALUE(BOOL, Bool)
         COPY_VALUE(INT32, Int32)
         COPY_VALUE(INT64, Int64)
         COPY_VALUE(UINT32, UInt32)
         COPY_VALUE(UINT64, UInt64)
         COPY_VALUE(FLOAT, Float)
         COPY_VALUE(DOUBLE, Double)
         COPY_VALUE(ENUM, Enum)
         COPY_VALUE(STRING, String)
@@ skipping 41 matching lines @@
                 ->MergeFrom(
                     source_reflection->GetRepeatedMessage(source, field, i));
           }
           break;
         }
       }
     }
   }
 }
 
+void FieldMaskTree::TrimMessage(const Node* node, Message* message) {
+  GOOGLE_DCHECK(!node->children.empty());
+  const Reflection* reflection = message->GetReflection();
+  const Descriptor* descriptor = message->GetDescriptor();
+  const int32 field_count = descriptor->field_count();
+  for (int index = 0; index < field_count; ++index) {
+    const FieldDescriptor* field = descriptor->field(index);
+    map<string, Node*>::const_iterator it = node->children.find(field->name());
+    if (it == node->children.end()) {
+      reflection->ClearField(message, field);
+    } else {
+      if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
+        Node* child = it->second;
+        if (!child->children.empty()) {
+          TrimMessage(child, reflection->MutableMessage(message, field));
+        }
+      }
+    }
+  }
+}
+
 }  // namespace
 
 void FieldMaskUtil::ToCanonicalForm(const FieldMask& mask, FieldMask* out) {
   FieldMaskTree tree;
   tree.MergeFromFieldMask(mask);
   out->Clear();
   tree.MergeToFieldMask(out);
 }
 
 void FieldMaskUtil::Union(const FieldMask& mask1, const FieldMask& mask2,
@@ skipping 36 matching lines @@
                                    const MergeOptions& options,
                                    Message* destination) {
   GOOGLE_CHECK(source.GetDescriptor() == destination->GetDescriptor());
   // Build a FieldMaskTree and walk through the tree to merge all specified
   // fields.
   FieldMaskTree tree;
   tree.MergeFromFieldMask(mask);
   tree.MergeMessage(source, options, destination);
 }
 
+void FieldMaskUtil::TrimMessage(const FieldMask& mask, Message* destination) {
+  // Build a FieldMaskTree and walk through the tree to merge all specified
+  // fields.
+  FieldMaskTree tree;
+  tree.MergeFromFieldMask(mask);
+  tree.TrimMessage(GOOGLE_CHECK_NOTNULL(destination));
+}
+
 }  // namespace util
 }  // namespace protobuf
 }  // namespace google