Cleanup FSTDataOutputWriter

# Conflicts:
#	lucene/core/src/java/org/apache/lucene/util/fst/FSTCompiler.java
#	lucene/core/src/java/org/apache/lucene/util/fst/FSTDataOutputWriter.java

Author: dungba88

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

@@ -33,6 +33,7 @@
 import java.io.IOException;
 import org.apache.lucene.store.ByteArrayDataOutput;
 import org.apache.lucene.store.DataOutput;
+import org.apache.lucene.util.Accountable;
 import org.apache.lucene.util.ArrayUtil;
 import org.apache.lucene.util.IntsRef;
 import org.apache.lucene.util.IntsRefBuilder;
@@ -135,13 +136,7 @@ public class FSTCompiler<T> {
    */
   // TODO: remove this?  Builder API should be the only entry point?
   public FSTCompiler(FST.INPUT_TYPE inputType, Outputs<T> outputs) {
-    this(
-        inputType,
-        32.0,
-        outputs,
-        true,
-        new FSTDataOutputWriter(getLegacyDataOutput(DEFAULT_BLOCK_BITS)),
-        1f);
+    this(inputType, 32.0, outputs, true, getLegacyDataOutput(DEFAULT_BLOCK_BITS), 1f);
   }
 
   static DataOutput getLegacyDataOutput(int blockBits) {
@@ -153,24 +148,24 @@ private FSTCompiler(
       double suffixRAMLimitMB,
       Outputs<T> outputs,
       boolean allowFixedLengthArcs,
-      FSTDataOutputWriter fstWriter,
+      DataOutput dataOutput,
       float directAddressingMaxOversizingFactor) {
     this.allowFixedLengthArcs = allowFixedLengthArcs;
     this.directAddressingMaxOversizingFactor = directAddressingMaxOversizingFactor;
     // pad: ensure no node gets address 0 which is reserved to mean
     // the stop state w/ no arcs
     try {
-      fstWriter.getDataOutput().writeByte((byte) 0);
+      dataOutput.writeByte((byte) 0);
       numBytesWritten++;
     } catch (IOException e) {
       throw new RuntimeException(e);
     }
-    this.dataOutput = fstWriter.getDataOutput();
+    this.dataOutput = dataOutput;
     fst =
         new FST<>(
             new FST.FSTMetadata<>(inputType, null, -1, VERSION_CURRENT, 0),
             outputs,
-            fstWriter.getReader());
+            toFSTReader(dataOutput));
     if (suffixRAMLimitMB < 0) {
       throw new IllegalArgumentException("ramLimitMB must be >= 0; got: " + suffixRAMLimitMB);
     } else if (suffixRAMLimitMB > 0) {
@@ -188,6 +183,37 @@ private FSTCompiler(
     }
   }
 
+  // Get the respective FSTReader of the DataOutput
+  private FSTReader toFSTReader(DataOutput dataOutput) {
+    if (dataOutput instanceof FSTReader) {
+      return (FSTReader) dataOutput;
+    }
+    return new FSTReader() {
+      @Override
+      public long size() {
+        return numBytesWritten;
+      }
+
+      @Override
+      public FST.BytesReader getReverseBytesReader() {
+        return null;
+      }
+
+      @Override
+      public void writeTo(DataOutput out) {
+        throw new UnsupportedOperationException("writeTo(DataOutput) is not supported");
+      }
+
+      @Override
+      public long ramBytesUsed() {
+        if (dataOutput instanceof Accountable) {
+          return ((Accountable) dataOutput).ramBytesUsed();
+        }
+        return 0;
+      }
+    };
+  }
+
   /**
    * Fluent-style constructor for FST {@link FSTCompiler}.
    *
@@ -309,7 +335,7 @@ public FSTCompiler<T> build() {
               suffixRAMLimitMB,
               outputs,
               allowFixedLengthArcs,
-              new FSTDataOutputWriter(dataOutput),
+              dataOutput,
               directAddressingMaxOversizingFactor);
       return fstCompiler;
     }
@@ -904,6 +930,7 @@ void finish(long newStartNode) {
     }
     fst.metadata.startNode = newStartNode;
     fst.metadata.numBytes = numBytesWritten;
+    scratchBytes.truncate(0);
   }
 
   private boolean validOutput(T output) {

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

@@ -26,6 +26,7 @@
 import java.util.List;
 import java.util.Random;
 import org.apache.lucene.store.DataInput;
+import org.apache.lucene.store.DataOutput;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.InputStreamDataInput;
 import org.apache.lucene.store.OutputStreamDataOutput;
@@ -63,9 +64,7 @@ public void testRandom() throws Exception {
       final int numBytes = TestUtil.nextInt(random(), 1, maxBytes);
       final byte[] expected = new byte[numBytes];
       final ByteArrayOutputStream baos = new ByteArrayOutputStream();
-      final FSTDataOutputWriter fstWriter =
-          new FSTDataOutputWriter(new OutputStreamDataOutput(baos));
-      FSTReader reader = fstWriter.getReader();
+      final DataOutput dataOutput = new OutputStreamDataOutput(baos);
       if (VERBOSE) {
         System.out.println("TEST: iter=" + iter + " numBytes=" + numBytes);
       }
@@ -86,7 +85,7 @@ public void testRandom() throws Exception {
               }
 
               expected[pos++] = b;
-              fstWriter.writeByte(b);
+              dataOutput.writeByte(b);
             }
             break;
 
@@ -100,13 +99,13 @@ public void testRandom() throws Exception {
                 System.out.println("    writeBytes len=" + len + " bytes=" + Arrays.toString(temp));
               }
               System.arraycopy(temp, 0, expected, pos, temp.length);
-              fstWriter.writeBytes(temp, 0, temp.length);
+              dataOutput.writeBytes(temp, 0, temp.length);
               pos += len;
             }
             break;
         }
 
-        assertEquals(pos, reader.size());
+        assertEquals(pos, baos.toByteArray().length);
       }
       for (int i = 0; i < numBytes; i++) {
         assertEquals("byte @ index=" + i, expected[i], baos.toByteArray()[i]);