Remove the FSTWriter interface

Author: dungba88

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

@@ -134,11 +134,12 @@ 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, getLegacyFSTWriter(DEFAULT_BLOCK_BITS), 1f);
+    this(
+        inputType, 32.0, outputs, true, new FSTWriter(getLegacyDataOutput(DEFAULT_BLOCK_BITS)), 1f);
   }
 
-  static FSTWriter getLegacyFSTWriter(int blockBits) {
-    return new DataOutputFSTWriter(new BytesStore(blockBits));
+  static DataOutput getLegacyDataOutput(int blockBits) {
+    return new BytesStore(blockBits);
   }
 
   private FSTCompiler(
@@ -158,7 +159,7 @@ private FSTCompiler(
       throw new RuntimeException(e);
     }
     this.fstWriter = fstWriter;
-    this.fstReader = fstWriter.asReader();
+    this.fstReader = fstWriter.getReader();
     fst =
         new FST<>(
             new FST.FSTMetadata<>(inputType, null, -1, VERSION_CURRENT, 0), outputs, fstReader);
@@ -191,7 +192,7 @@ public static class Builder<T> {
     private final Outputs<T> outputs;
     private double suffixRAMLimitMB = 32.0;
     private boolean allowFixedLengthArcs = true;
-    private FSTWriter fstWriter = getLegacyFSTWriter(DEFAULT_BLOCK_BITS);
+    private DataOutput dataOutput = getLegacyDataOutput(DEFAULT_BLOCK_BITS);
     private float directAddressingMaxOversizingFactor = DIRECT_ADDRESSING_MAX_OVERSIZING_FACTOR;
 
     /**
@@ -255,8 +256,7 @@ public Builder<T> allowFixedLengthArcs(boolean allowFixedLengthArcs) {
      */
     @Deprecated
     public Builder<T> bytesPageBits(int bytesPageBits) {
-      this.fstWriter = getLegacyFSTWriter(bytesPageBits);
-      return this;
+      return dataOutput(getLegacyDataOutput(bytesPageBits));
     }
 
     /**
@@ -271,7 +271,7 @@ public Builder<T> bytesPageBits(int bytesPageBits) {
      * @return this builder
      */
     public Builder<T> dataOutput(DataOutput dataOutput) {
-      this.fstWriter = new DataOutputFSTWriter(dataOutput);
+      this.dataOutput = dataOutput;
       return this;
     }
 
@@ -301,7 +301,7 @@ public FSTCompiler<T> build() {
               suffixRAMLimitMB,
               outputs,
               allowFixedLengthArcs,
-              fstWriter,
+              new FSTWriter(dataOutput),
               directAddressingMaxOversizingFactor);
       return fstCompiler;
     }

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

@@ -16,39 +16,102 @@
  */
 package org.apache.lucene.util.fst;
 
+import java.io.Closeable;
 import java.io.IOException;
+import org.apache.lucene.store.DataOutput;
+import org.apache.lucene.util.Accountable;
+import org.apache.lucene.util.RamUsageEstimator;
 
-/** Abstract class which provides low-level functionality to write to a FST */
-public interface FSTWriter {
+/**
+ * Allow the FST to be written to a {@link DataOutput}. Generally it only supports writing to the
+ * {@link DataOutput} and not reading from it. To read, you must either: 1. construct a
+ * corresponding {@link org.apache.lucene.store.DataInput} and use the {@link FSTStore} to read pr
+ * 2. use a DataOutput which also implements {@link FSTReader}
+ */
+final class FSTWriter {
+
+  private static final long BASE_RAM_BYTES_USED =
+      RamUsageEstimator.shallowSizeOfInstance(FSTWriter.class);
+
+  /** the main DataOutput to store the FST bytes */
+  private final DataOutput dataOutput;
+
+  private long size = 0L;
 
   /**
-   * Write a single byte to the end of this FSTWriter
+   * ctor
+   *
+   * @param dataOutput the data output to write to
+   */
+  public FSTWriter(DataOutput dataOutput) {
+    this.dataOutput = dataOutput;
+  }
+
+  /**
+   * Write a single byte to the end of the DataOutput
    *
    * @param b the byte to write
    */
-  void writeByte(byte b) throws IOException;
+  public void writeByte(byte b) throws IOException {
+    size++;
+    dataOutput.writeByte(b);
+  }
 
   /**
-   * Write a byte array to the end of this FSTWriter
+   * Write a byte array to the end of the DataOutput
    *
    * @param b the byte array to write
    * @param offset the offset of the array
    * @param length the number of bytes to write
    */
-  void writeBytes(byte[] b, int offset, int length) throws IOException;
+  public void writeBytes(byte[] b, int offset, int length) throws IOException {
+    size += length;
+    dataOutput.writeBytes(b, offset, length);
+  }
 
   /**
-   * Called when the FST construction is finished and no more node can be added to it. Freezing,
-   * optimizing the datastructure can be done here
+   * Called when the FST construction is finished and no more node can be added to it.
    *
    * @throws IOException if exception occurred during the operation
    */
-  default void finish() throws IOException {
-    // do nothing by default
+  public void finish() throws IOException {
+    if (dataOutput instanceof Closeable) {
+      ((Closeable) dataOutput).close();
+    }
   }
 
   /**
    * @return The corresponding {@link FSTReader} of this writer
    */
-  FSTReader asReader();
+  public FSTReader getReader() {
+    if (dataOutput instanceof FSTReader) {
+      return (FSTReader) dataOutput;
+    }
+    return new FSTReader() {
+      @Override
+      public long size() {
+        return size;
+      }
+
+      @Override
+      public FST.BytesReader getReverseBytesReader() {
+        return null;
+      }
+
+      @Override
+      public void writeTo(DataOutput out) {
+        throw new UnsupportedOperationException(
+            "writeTo(DataOutput) is not supported by FSTWriter");
+      }
+
+      @Override
+      public long ramBytesUsed() {
+        long size = BASE_RAM_BYTES_USED;
+        if (dataOutput instanceof Accountable) {
+          size += ((Accountable) dataOutput).ramBytesUsed();
+        }
+        return size;
+      }
+    };
+  }
 }

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

@@ -36,7 +36,7 @@
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.IntsRef;
 
-public class TestDataOutputFSTWriter extends LuceneTestCase {
+public class TestFSTWriter extends LuceneTestCase {
 
   private MockDirectoryWrapper dir;
 
@@ -63,8 +63,8 @@ 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 DataOutputFSTWriter fstWriter =
-          new DataOutputFSTWriter(new OutputStreamDataOutput(baos));
+      final FSTWriter fstWriter = new FSTWriter(new OutputStreamDataOutput(baos));
+      FSTReader reader = fstWriter.getReader();
       if (VERBOSE) {
         System.out.println("TEST: iter=" + iter + " numBytes=" + numBytes);
       }
@@ -105,7 +105,7 @@ public void testRandom() throws Exception {
             break;
         }
 
-        assertEquals(pos, fstWriter.size());
+        assertEquals(pos, reader.size());
       }
       for (int i = 0; i < numBytes; i++) {
         assertEquals("byte @ index=" + i, expected[i], baos.toByteArray()[i]);