Remove ListProof class as redundant [ECR-3429] (#1089)

Author: MakarovS

exonum-java-binding/common/src/main/java/com/exonum/binding/common/proofs/list/ListProof.java

@@ -23,20 +23,17 @@
 import com.exonum.binding.common.hash.HashFunction;
 import com.exonum.binding.common.hash.Hashing;
 import com.exonum.binding.common.hash.PrimitiveSink;
-import com.exonum.binding.common.serialization.CheckingSerializerDecorator;
-import com.exonum.binding.common.serialization.Serializer;
 import com.google.common.annotations.VisibleForTesting;
+import com.google.protobuf.ByteString;
 
 import java.util.NavigableMap;
 import java.util.Optional;
 import java.util.TreeMap;
 
 /**
  * List proof hash calculator.
- *
- * @param <E> the type of elements in the corresponding list
  */
-final class ListProofHashCalculator<E> implements ListProofVisitor {
+final class ListProofHashCalculator implements ListProofVisitor {
 
   @VisibleForTesting
   static final byte BLOB_PREFIX = 0x00;
@@ -45,11 +42,9 @@ final class ListProofHashCalculator<E> implements ListProofVisitor {
   @VisibleForTesting
   static final byte LIST_ROOT_PREFIX = 0x02;
 
-  private final CheckingSerializerDecorator<E> serializer;
-
   private final HashFunction hashFunction;
 
-  private final NavigableMap<Long, E> elements;
+  private final NavigableMap<Long, ByteString> elements;
 
   private long index;
 
@@ -58,26 +53,24 @@ final class ListProofHashCalculator<E> implements ListProofVisitor {
   /**
    * Creates a new ListProofHashCalculator.
    *
-   * @param serializer a serializer of list elements
+   * @param rootNode the root node of the proof tree
+   * @param length the length of the corresponding index
    */
-  ListProofHashCalculator(ListProof listProof, Serializer<E> serializer) {
-    this(listProof, serializer, Hashing.defaultHashFunction());
+  ListProofHashCalculator(ListProofNode rootNode, long length) {
+    this(rootNode, length, Hashing.defaultHashFunction());
   }
 
-  private ListProofHashCalculator(ListProof listProof, Serializer<E> serializer,
-                                  HashFunction hashFunction) {
-    this.serializer = CheckingSerializerDecorator.from(serializer);
+  private ListProofHashCalculator(ListProofNode rootNode, long length, HashFunction hashFunction) {
     this.hashFunction = checkNotNull(hashFunction);
     elements = new TreeMap<>();
     index = 0;
     hash = null;
 
-    ListProofNode rootNode = listProof.getRootNode();
     rootNode.accept(this);
 
     hash = hashFunction.newHasher()
         .putByte(LIST_ROOT_PREFIX)
-        .putLong(listProof.getLength())
+        .putLong(length)
         .putObject(hash, hashCodeFunnel())
         .hash();
   }
@@ -107,7 +100,7 @@ public void visit(ListProofElement value) {
         "Error: already an element by such index in the map: i=" + index
             + ", e=" + elements.get(index);
 
-    E element = serializer.fromBytes(value.getElement().toByteArray());
+    ByteString element = value.getElement();
     elements.put(index, element);
     hash = hashFunction.newHasher()
         .putByte(BLOB_PREFIX)
@@ -136,7 +129,7 @@ private Optional<HashCode> visitRight(ListProofBranch branch, long parentIndex)
   /**
    * Returns a collection of list entries: index-element pairs, ordered by indices.
    */
-  NavigableMap<Long, E> getElements() {
+  NavigableMap<Long, ByteString> getElements() {
     return elements;
   }
 

exonum-java-binding/common/src/main/java/com/exonum/binding/common/proofs/list/ListProofHashCalculator.java

@@ -28,7 +28,7 @@ public interface UncheckedListProof {
   CheckedListProof check();
 
   /**
-   * Returns raw source proof of this UncheckedListProof.
+   * Returns the root node of the corresponding proof tree of this UncheckedListProof.
    */
-  ListProof getListProof();
+  ListProofNode getListProofRootNode();
 }

exonum-java-binding/common/src/main/java/com/exonum/binding/common/proofs/list/UncheckedListProof.java

@@ -16,37 +16,34 @@
 
 package com.exonum.binding.common.proofs.list;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+
 import com.exonum.binding.common.hash.HashCode;
-import com.exonum.binding.common.serialization.Serializer;
-import com.google.common.base.Preconditions;
 
 /**
  * An Adapter class used to simplify work with ListProof interfaces.
  */
-public class UncheckedListProofAdapter<E> implements UncheckedListProof {
+public class UncheckedListProofAdapter implements UncheckedListProof {
 
-  private final ListProof listProof;
+  private final ListProofNode rootNode;
 
   private final ListProofStructureValidator listProofStructureValidator;
 
-  private final ListProofHashCalculator<E> listProofHashCalculator;
+  private final ListProofHashCalculator listProofHashCalculator;
 
   /**
    * Creates UncheckedListProofAdapter for convenient usage of ListProof interfaces.
    *
    * <p>UncheckedListProofAdapter {@link #check()} method will return CheckedListProof containing
    * results of list proof verification.
    *
-   * @param listProof source list proof with index length
-   * @param serializer proof elements serializer
+   * @param rootNode the root node of the proof tree
+   * @param length the length of the corresponding index (needed for index hash calculation)
    */
-  public UncheckedListProofAdapter(ListProof listProof, Serializer<E> serializer) {
-    Preconditions.checkNotNull(listProof, "ListProof node must be not null");
-    Preconditions.checkNotNull(serializer, "Serializer must be not null");
-
-    this.listProof = listProof;
-    this.listProofStructureValidator = new ListProofStructureValidator(listProof.getRootNode());
-    this.listProofHashCalculator = new ListProofHashCalculator<>(listProof, serializer);
+  public UncheckedListProofAdapter(ListProofNode rootNode, long length) {
+    this.rootNode = checkNotNull(rootNode);
+    this.listProofStructureValidator = new ListProofStructureValidator(rootNode);
+    this.listProofHashCalculator = new ListProofHashCalculator(rootNode, length);
   }
 
   @Override
@@ -59,7 +56,7 @@ public CheckedListProof check() {
   }
 
   @Override
-  public ListProof getListProof() {
-    return listProof;
+  public ListProofNode getListProofRootNode() {
+    return rootNode;
   }
 }

exonum-java-binding/common/src/main/java/com/exonum/binding/common/proofs/list/UncheckedListProofAdapter.java

@@ -19,53 +19,52 @@
 import static com.exonum.binding.common.proofs.list.ListProofUtils.getBranchHashCode;
 import static com.exonum.binding.common.proofs.list.ListProofUtils.getNodeHashCode;
 import static com.exonum.binding.common.proofs.list.ListProofUtils.getProofListHash;
-import static com.exonum.binding.common.proofs.list.ListProofUtils.leafOf;
 import static com.google.common.collect.ImmutableMap.of;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import com.exonum.binding.common.hash.HashCode;
-import com.exonum.binding.common.serialization.StandardSerializers;
+import com.google.protobuf.ByteString;
 import org.junit.jupiter.api.Test;
 
 class ListProofHashCalculatorTest {
 
-  private static final String V1 = "v1";
-  private static final String V2 = "v2";
-  private static final String V3 = "v3";
-  private static final String V4 = "v4";
+  private static final ByteString V1 = ByteString.copyFromUtf8("v1");
+  private static final ByteString V2 = ByteString.copyFromUtf8("v2");
+  private static final ByteString V3 = ByteString.copyFromUtf8("v3");
+  private static final ByteString V4 = ByteString.copyFromUtf8("v4");
 
   private static final HashCode H1 = HashCode.fromString("a1");
   private static final HashCode H2 = HashCode.fromString("a2");
 
-  private ListProofHashCalculator<String> calculator;
+  private ListProofHashCalculator calculator;
 
   @Test
   void visit_SingletonListProof() {
-    ListProofNode root = leafOf(V1);
+    ListProofNode root = new ListProofElement(V1);
 
-    ListProof listProof = new ListProof(root, 1);
-    calculator = createListProofCalculator(listProof);
+    long length = 1;
+    calculator = new ListProofHashCalculator(root, length);
 
-    HashCode expectedProofListHash = getProofListHash(getNodeHashCode(V1), listProof.getLength());
+    HashCode expectedProofListHash = getProofListHash(getNodeHashCode(V1), length);
 
     assertThat(calculator.getElements(), equalTo(of(0L, V1)));
     assertEquals(expectedProofListHash, calculator.getHash());
   }
 
   @Test
   void visit_FullProof2elements() {
-    ListProofElement left = leafOf(V1);
-    ListProofElement right = leafOf(V2);
+    ListProofElement left = new ListProofElement(V1);
+    ListProofElement right = new ListProofElement(V2);
     ListProofBranch root = new ListProofBranch(left, right);
 
-    ListProof listProof = new ListProof(root, 2);
-    calculator = createListProofCalculator(listProof);
+    long length = 2;
+    calculator = new ListProofHashCalculator(root, length);
 
     // Calculate expected proof list hash
     HashCode expectedRootHash = getBranchHashCode(getNodeHashCode(V1), getNodeHashCode(V2));
-    HashCode expectedProofListHash = getProofListHash(expectedRootHash, listProof.getLength());
+    HashCode expectedProofListHash = getProofListHash(expectedRootHash, length);
 
     assertThat(calculator.getElements(), equalTo(of(0L, V1,
         1L, V2)));
@@ -76,23 +75,23 @@ void visit_FullProof2elements() {
   void visit_FullProof4elements() {
     ListProofBranch root = new ListProofBranch(
         new ListProofBranch(
-            leafOf(V1),
-            leafOf(V2)
+            new ListProofElement(V1),
+            new ListProofElement(V2)
         ),
         new ListProofBranch(
-            leafOf(V3),
-            leafOf(V4)
+            new ListProofElement(V3),
+            new ListProofElement(V4)
         )
     );
 
-    ListProof listProof = new ListProof(root, 4);
-    calculator = createListProofCalculator(listProof);
+    long length = 4;
+    calculator = new ListProofHashCalculator(root, length);
 
     // Calculate expected proof list hash
     HashCode leftBranchHash = getBranchHashCode(getNodeHashCode(V1), getNodeHashCode(V2));
     HashCode rightBranchHash = getBranchHashCode(getNodeHashCode(V3), getNodeHashCode(V4));
     HashCode expectedRootHash = getBranchHashCode(leftBranchHash, rightBranchHash);
-    HashCode expectedProofListHash = getProofListHash(expectedRootHash, listProof.getLength());
+    HashCode expectedProofListHash = getProofListHash(expectedRootHash, length);
 
 
     assertThat(calculator.getElements(),
@@ -105,15 +104,15 @@ void visit_FullProof4elements() {
 
   @Test
   void visit_ProofLeftValue() {
-    ListProofNode left = leafOf(V1);
+    ListProofNode left = new ListProofElement(V1);
     ListProofNode right = new ListProofHashNode(H2);
     ListProofBranch root = new ListProofBranch(left, right);
 
-    ListProof listProof = new ListProof(root, 2);
-    calculator = createListProofCalculator(listProof);
+    long length = 2;
+    calculator = new ListProofHashCalculator(root, length);
 
     HashCode expectedRootHash = getBranchHashCode(getNodeHashCode(V1), H2);
-    HashCode expectedProofListHash = getProofListHash(expectedRootHash, listProof.getLength());
+    HashCode expectedProofListHash = getProofListHash(expectedRootHash, length);
 
     assertThat(calculator.getElements(), equalTo(of(0L, V1)));
     assertEquals(expectedProofListHash, calculator.getHash());
@@ -122,14 +121,14 @@ void visit_ProofLeftValue() {
   @Test
   void visit_ProofRightValue() {
     ListProofNode left = new ListProofHashNode(H1);
-    ListProofNode right = leafOf(V2);
+    ListProofNode right = new ListProofElement(V2);
     ListProofBranch root = new ListProofBranch(left, right);
 
-    ListProof listProof = new ListProof(root, 2);
-    calculator = createListProofCalculator(listProof);
+    long length = 2;
+    calculator = new ListProofHashCalculator(root, length);
 
     HashCode expectedRootHash = getBranchHashCode(H1, getNodeHashCode(V2));
-    HashCode expectedProofListHash = getProofListHash(expectedRootHash, listProof.getLength());
+    HashCode expectedProofListHash = getProofListHash(expectedRootHash, length);
 
     assertThat(calculator.getElements(), equalTo(of(1L, V2)));
     assertEquals(expectedProofListHash, calculator.getHash());
@@ -139,22 +138,22 @@ void visit_ProofRightValue() {
   void visit_FullProof3elements() {
     ListProofBranch root = new ListProofBranch(
         new ListProofBranch(
-            leafOf(V1),
-            leafOf(V2)
+            new ListProofElement(V1),
+            new ListProofElement(V2)
         ),
         new ListProofBranch(
-            leafOf(V3),
+            new ListProofElement(V3),
             null
         )
     );
 
-    ListProof listProof = new ListProof(root, 3);
-    calculator = createListProofCalculator(listProof);
+    long length = 3;
+    calculator = new ListProofHashCalculator(root, length);
 
     HashCode leftBranchHash = getBranchHashCode(getNodeHashCode(V1), getNodeHashCode(V2));
     HashCode rightBranchHash = getBranchHashCode(getNodeHashCode(V3), null);
     HashCode expectedRootHash = getBranchHashCode(leftBranchHash, rightBranchHash);
-    HashCode expectedProofListHash = getProofListHash(expectedRootHash, listProof.getLength());
+    HashCode expectedProofListHash = getProofListHash(expectedRootHash, length);
 
     assertThat(calculator.getElements(),
         equalTo(of(
@@ -164,8 +163,4 @@ void visit_FullProof3elements() {
     );
     assertEquals(expectedProofListHash, calculator.getHash());
   }
-
-  private ListProofHashCalculator<String> createListProofCalculator(ListProof listProof) {
-    return new ListProofHashCalculator<>(listProof, StandardSerializers.string());
-  }
 }