Add some javadoc

Author: dungba88

lucene/core/src/java/org/apache/lucene/util/fst/NodeHash.java

@@ -51,6 +51,8 @@ final class NodeHash<T> {
 
   private final FSTCompiler<T> fstCompiler;
   private final FST.Arc<T> scratchArc = new FST.Arc<>();
+  // store the last fallback table node length in getFallback()
+  private int lastFallbackNodeLength;
 
   /**
    * ramLimitMB is the max RAM we can use for recording suffixes. If we hit this limit, the least
@@ -73,24 +75,25 @@ public NodeHash(FSTCompiler<T> fstCompiler, double ramLimitMB) {
     this.fstCompiler = fstCompiler;
   }
 
-  private NodeAddressAndLength getFallback(FSTCompiler.UnCompiledNode<T> nodeIn, long hash)
-      throws IOException {
+  private long getFallback(FSTCompiler.UnCompiledNode<T> nodeIn, long hash) throws IOException {
     if (fallbackTable == null) {
       // no fallback yet (primary table is not yet large enough to swap)
-      return null;
+      return 0;
     }
     long pos = hash & fallbackTable.mask;
     int c = 0;
     while (true) {
       long node = fallbackTable.get(pos);
       if (node == 0) {
         // not found
-        return null;
+        return 0;
       } else {
         int length = fallbackTable.getMatchedNodeLength(nodeIn, node, pos);
         if (length != -1) {
+          // store the node length for further use
+          this.lastFallbackNodeLength = length;
           // frozen version of this node is already here
-          return new NodeAddressAndLength(node, length);
+          return node;
         }
       }
 
@@ -99,16 +102,6 @@ private NodeAddressAndLength getFallback(FSTCompiler.UnCompiledNode<T> nodeIn, l
     }
   }
 
-  static class NodeAddressAndLength {
-    private final long address;
-    private final int length;
-
-    NodeAddressAndLength(long address, int length) {
-      this.address = address;
-      this.length = length;
-    }
-  }
-
   public long add(FSTCompiler.UnCompiledNode<T> nodeIn) throws IOException {
 
     long hash = hash(nodeIn);
@@ -121,12 +114,11 @@ public long add(FSTCompiler.UnCompiledNode<T> nodeIn) throws IOException {
       long node = primaryTable.get(pos);
       if (node == 0) {
         // node is not in primary table; is it in fallback table?
-        NodeAddressAndLength addressAndLength = getFallback(nodeIn, hash);
-        if (addressAndLength != null) {
-          node = addressAndLength.address;
+        node = getFallback(nodeIn, hash);
+        if (node != 0) {
           // it was already in fallback -- promote to primary
           // TODO: Copy directly between 2 ByteBlockPool to avoid double-copy
-          primaryTable.set(pos, node, fallbackTable.getBytes(pos, addressAndLength.length));
+          primaryTable.set(pos, node, fallbackTable.getBytes(pos, lastFallbackNodeLength));
         } else {
           // not in fallback either -- freeze & add the incoming node
 
@@ -151,7 +143,7 @@ public long add(FSTCompiler.UnCompiledNode<T> nodeIn) throws IOException {
         // how many bytes would be used if we had "perfect" hashing:
         //  - x2 for fstNodeAddress for FST node address
         //  - x2 for copiedNodeAddress for copied node address
-        // each account for approximate hash table overhead halfway between 33.3%
+        // each account for approximate hash table overhead halfway between 33.3% and 66.6%
         // note that some of the copiedNodes are shared between fallback and primary tables so this
         // computation is pessimistic
         long ramBytesUsed =
@@ -266,8 +258,8 @@ public void set(long index, long pointer, byte[] bytes) {
       count++;
       copiedNodes.append(new BytesRef(bytes));
       copiedBytes += bytes.length;
-      copiedNodeAddress.set(
-          index, copiedBytes - 1); // write the offset, which is the last offset of the node
+      // write the offset, which is the last offset of the node
+      copiedNodeAddress.set(index, copiedBytes - 1);
     }
 
     private void rehash(long lastNodeAddress) throws IOException {
@@ -334,8 +326,7 @@ private long hash(long node, long pos) throws IOException {
 
     /**
      * Compares an unfrozen node (UnCompiledNode) with a frozen node at byte location address
-     * (long), returning the local copiedNodes start address if the two nodes are matched, or -1
-     * otherwise
+     * (long), returning the node length if the two nodes are matched, or -1 otherwise
      */
     private int getMatchedNodeLength(FSTCompiler.UnCompiledNode<T> node, long address, long pos)
         throws IOException {