third_party/protobuf: Update to HEAD (5f65ee6ac7)

third_party/protobuf/java/util/src/main/java/com/google/protobuf/util/FieldMaskTree.java

 // 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 20 matching lines @@
 package com.google.protobuf.util;
 
 import com.google.protobuf.Descriptors.Descriptor;
 import com.google.protobuf.Descriptors.FieldDescriptor;
 import com.google.protobuf.FieldMask;
 import com.google.protobuf.Message;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map.Entry;
+import java.util.SortedMap;
 import java.util.TreeMap;
 import java.util.logging.Logger;
 
 /**
  * A tree representation of a FieldMask. Each leaf node in this tree represent
  * a field path in the FieldMask.
  *
  * <p>For example, FieldMask "foo.bar,foo.baz,bar.baz" as a tree will be:
  * <pre>
  *   [root] -+- foo -+- bar
  *           |       |
  *           |       +- baz
  *           |
  *           +- bar --- baz
  * </pre>
  *
  * <p>By representing FieldMasks with this tree structure we can easily convert
  * a FieldMask to a canonical form, merge two FieldMasks, calculate the
  * intersection to two FieldMasks and traverse all fields specified by the
  * FieldMask in a message tree.
  */
-class FieldMaskTree {
+final class FieldMaskTree {
   private static final Logger logger = Logger.getLogger(FieldMaskTree.class.getName());
 
   private static final String FIELD_PATH_SEPARATOR_REGEX = "\\.";
 
-  private static class Node {
-    public TreeMap<String, Node> children = new TreeMap<String, Node>();
+  private static final class Node {
+    final SortedMap<String, Node> children = new TreeMap<String, Node>();
   }
 
   private final Node root = new Node();
 
-  /** Creates an empty FieldMaskTree. */
-  public FieldMaskTree() {}
+  /**
+   * Creates an empty FieldMaskTree.
+   */
+  FieldMaskTree() {}
 
-  /** Creates a FieldMaskTree for a given FieldMask. */
-  public FieldMaskTree(FieldMask mask) {
+  /**
+   * Creates a FieldMaskTree for a given FieldMask.
+   */
+  FieldMaskTree(FieldMask mask) {
     mergeFromFieldMask(mask);
   }
 
   @Override
   public String toString() {
     return FieldMaskUtil.toString(toFieldMask());
   }
 
   /**
    * Adds a field path to the tree. In a FieldMask, every field path matches the
    * specified field as well as all its sub-fields. For example, a field path
    * "foo.bar" matches field "foo.bar" and also "foo.bar.baz", etc. When adding
    * a field path to the tree, redundant sub-paths will be removed. That is,
    * after adding "foo.bar" to the tree, "foo.bar.baz" will be removed if it
    * exists, which will turn the tree node for "foo.bar" to a leaf node.
    * Likewise, if the field path to add is a sub-path of an existing leaf node,
    * nothing will be changed in the tree.
    */
-  public FieldMaskTree addFieldPath(String path) {
+  FieldMaskTree addFieldPath(String path) {
     String[] parts = path.split(FIELD_PATH_SEPARATOR_REGEX);
     if (parts.length == 0) {
       return this;
     }
     Node node = root;
     boolean createNewBranch = false;
     // Find the matching node in the tree.
     for (String part : parts) {
       // Check whether the path matches an existing leaf node.
       if (!createNewBranch && node != root && node.children.isEmpty()) {
@@ skipping 10 matching lines @@
       }
     }
     // Turn the matching node into a leaf node (i.e., remove sub-paths).
     node.children.clear();
     return this;
   }
 
   /**
    * Merges all field paths in a FieldMask into this tree.
    */
-  public FieldMaskTree mergeFromFieldMask(FieldMask mask) {
+  FieldMaskTree mergeFromFieldMask(FieldMask mask) {
     for (String path : mask.getPathsList()) {
       addFieldPath(path);
     }
     return this;
   }
 
-  /** Converts this tree to a FieldMask. */
-  public FieldMask toFieldMask() {
+  /**
+   * Converts this tree to a FieldMask.
+   */
+  FieldMask toFieldMask() {
     if (root.children.isEmpty()) {
       return FieldMask.getDefaultInstance();
     }
     List<String> paths = new ArrayList<String>();
     getFieldPaths(root, "", paths);
     return FieldMask.newBuilder().addAllPaths(paths).build();
   }
 
-  /** Gathers all field paths in a sub-tree. */
+  /**
+   * Gathers all field paths in a sub-tree.
+   */
   private void getFieldPaths(Node node, String path, List<String> paths) {
     if (node.children.isEmpty()) {
       paths.add(path);
       return;
     }
     for (Entry<String, Node> entry : node.children.entrySet()) {
       String childPath = path.isEmpty() ? entry.getKey() : path + "." + entry.getKey();
       getFieldPaths(entry.getValue(), childPath, paths);
     }
   }
 
   /**
-   * Adds the intersection of this tree with the given {@code path} to
-   * {@code output}.
+   * Adds the intersection of this tree with the given {@code path} to {@code output}.
    */
-  public void intersectFieldPath(String path, FieldMaskTree output) {
+  void intersectFieldPath(String path, FieldMaskTree output) {
     if (root.children.isEmpty()) {
       return;
     }
     String[] parts = path.split(FIELD_PATH_SEPARATOR_REGEX);
     if (parts.length == 0) {
       return;
     }
     Node node = root;
     for (String part : parts) {
       if (node != root && node.children.isEmpty()) {
@@ skipping 10 matching lines @@
     // We found a matching node for the path. All leaf children of this matching
     // node is in the intersection.
     List<String> paths = new ArrayList<String>();
     getFieldPaths(node, path, paths);
     for (String value : paths) {
       output.addFieldPath(value);
     }
   }
 
   /**
-   * Merges all fields specified by this FieldMaskTree from {@code source} to
-   * {@code destination}.
+   * Merges all fields specified by this FieldMaskTree from {@code source} to {@code destination}.
    */
-  public void merge(
-      Message source, Message.Builder destination, FieldMaskUtil.MergeOptions options) {
+  void merge(Message source, Message.Builder destination, FieldMaskUtil.MergeOptions options) {
     if (source.getDescriptorForType() != destination.getDescriptorForType()) {
       throw new IllegalArgumentException("Cannot merge messages of different types.");
     }
     if (root.children.isEmpty()) {
       return;
     }
     merge(root, "", source, destination, options);
   }
 
-  /** Merges all fields specified by a sub-tree from {@code source} to
-   * {@code destination}.
+  /**
+   * Merges all fields specified by a sub-tree from {@code source} to {@code destination}.
    */
   private void merge(
       Node node,
       String path,
       Message source,
       Message.Builder destination,
       FieldMaskUtil.MergeOptions options) {
-    assert source.getDescriptorForType() == destination.getDescriptorForType();
+    if (source.getDescriptorForType() != destination.getDescriptorForType()) {
+      throw new IllegalArgumentException(
+          String.format(
+              "source (%s) and destination (%s) descriptor must be equal",
+              source.getDescriptorForType(), destination.getDescriptorForType()));
+    }
 
     Descriptor descriptor = source.getDescriptorForType();
     for (Entry<String, Node> entry : node.children.entrySet()) {
       FieldDescriptor field = descriptor.findFieldByName(entry.getKey());
       if (field == null) {
         logger.warning(
             "Cannot find field \""
                 + entry.getKey()
                 + "\" in message type "
                 + descriptor.getFullName());
@@ skipping 42 matching lines @@
           if (source.hasField(field) || !options.replacePrimitiveFields()) {
             destination.setField(field, source.getField(field));
           } else {
             destination.clearField(field);
           }
         }
       }
     }
   }
 }