Split IOContext into separate implementations

Author: thecoop

lucene/core/src/java/org/apache/lucene/index/DocumentsWriterPerThread.java

@@ -415,7 +415,7 @@ FlushedSegment flush(DocumentsWriter.FlushNotifications flushNotifications) thro
             segmentInfo,
             fieldInfos.finish(),
             pendingUpdates,
-            new IOContext(new FlushInfo(numDocsInRAM, lastCommittedBytesUsed)));
+            IOContext.flush(new FlushInfo(numDocsInRAM, lastCommittedBytesUsed)));
     final double startMBUsed = lastCommittedBytesUsed / 1024. / 1024.;
 
     // Apply delete-by-docID now (delete-byDocID only
@@ -599,7 +599,7 @@ void sealFlushedSegment(
     IndexWriter.setDiagnostics(newSegment.info, IndexWriter.SOURCE_FLUSH);
 
     IOContext context =
-        new IOContext(new FlushInfo(newSegment.info.maxDoc(), newSegment.sizeInBytes()));
+        IOContext.flush(new FlushInfo(newSegment.info.maxDoc(), newSegment.sizeInBytes()));
 
     boolean success = false;
     try {

lucene/core/src/java/org/apache/lucene/index/IndexWriter.java

@@ -3058,7 +3058,7 @@ public long addIndexes(Directory... dirs) throws IOException {
             }
 
             IOContext context =
-                new IOContext(new FlushInfo(info.info.maxDoc(), info.sizeInBytes()));
+                IOContext.flush(new FlushInfo(info.info.maxDoc(), info.sizeInBytes()));
 
             FieldInfos fis = readFieldInfos(info);
             for (FieldInfo fi : fis) {
@@ -3400,7 +3400,7 @@ public void addIndexesReaderMerge(MergePolicy.OneMerge merge) throws IOException
     testReserveDocs(numDocs);
 
     final IOContext context =
-        new IOContext(
+        IOContext.merge(
             new MergeInfo(Math.toIntExact(numDocs), -1, false, UNBOUNDED_MAX_MERGE_SEGMENTS));
 
     TrackingDirectoryWrapper trackingDir = new TrackingDirectoryWrapper(mergeDirectory);
@@ -3950,7 +3950,7 @@ public void setMergeInfo(SegmentCommitInfo info) {
       boolean closeReaders = true;
       try {
         for (MergePolicy.OneMerge merge : pointInTimeMerges.merges) {
-          IOContext context = new IOContext(merge.getStoreMergeInfo());
+          IOContext context = IOContext.merge(merge.getStoreMergeInfo());
           merge.initMergeReaders(
               sci -> {
                 final ReadersAndUpdates rld = getPooledInstance(sci, true);
@@ -5139,7 +5139,7 @@ private int mergeMiddle(MergePolicy.OneMerge merge, MergePolicy mergePolicy) thr
     merge.checkAborted();
 
     Directory mergeDirectory = mergeScheduler.wrapForMerge(merge, directory);
-    IOContext context = new IOContext(merge.getStoreMergeInfo());
+    IOContext context = IOContext.merge(merge.getStoreMergeInfo());
 
     final TrackingDirectoryWrapper dirWrapper = new TrackingDirectoryWrapper(mergeDirectory);
 

lucene/core/src/java/org/apache/lucene/index/ReadersAndUpdates.java

@@ -321,7 +321,7 @@ private synchronized void handleDVUpdates(
       }
       final long nextDocValuesGen = info.getNextDocValuesGen();
       final String segmentSuffix = Long.toString(nextDocValuesGen, Character.MAX_RADIX);
-      final IOContext updatesContext = new IOContext(new FlushInfo(info.info.maxDoc(), bytes));
+      final IOContext updatesContext = IOContext.flush(new FlushInfo(info.info.maxDoc(), bytes));
       final FieldInfo fieldInfo = infos.fieldInfo(field);
       assert fieldInfo != null;
       fieldInfo.setDocValuesGen(nextDocValuesGen);
@@ -536,7 +536,7 @@ private synchronized Set<String> writeFieldInfosGen(
     // HEADER + FOOTER: 40
     // 90 bytes per-field (over estimating long name and attributes map)
     final long estInfosSize = 40 + 90L * fieldInfos.size();
-    final IOContext infosContext = new IOContext(new FlushInfo(info.info.maxDoc(), estInfosSize));
+    final IOContext infosContext = IOContext.flush(new FlushInfo(info.info.maxDoc(), estInfosSize));
     // separately also track which files were created for this gen
     final TrackingDirectoryWrapper trackingDir = new TrackingDirectoryWrapper(dir);
     infosFormat.write(trackingDir, info.info, segmentSuffix, fieldInfos, infosContext);

lucene/core/src/java/org/apache/lucene/index/SortingTermVectorsConsumer.java

@@ -86,7 +86,7 @@ void flush(
   @Override
   void initTermVectorsWriter() throws IOException {
     if (writer == null) {
-      IOContext context = new IOContext(new FlushInfo(lastDocID, bytesUsed.get()));
+      IOContext context = IOContext.flush(new FlushInfo(lastDocID, bytesUsed.get()));
       tmpDirectory = new TrackingTmpOutputDirectoryWrapper(directory);
       writer = TEMP_TERM_VECTORS_FORMAT.vectorsWriter(tmpDirectory, info, context);
       lastDocID = 0;

lucene/core/src/java/org/apache/lucene/index/TermVectorsConsumer.java

@@ -102,7 +102,7 @@ void fill(int docID) throws IOException {
 
   void initTermVectorsWriter() throws IOException {
     if (writer == null) {
-      IOContext context = new IOContext(new FlushInfo(lastDocID, bytesUsed.get()));
+      IOContext context = IOContext.flush(new FlushInfo(lastDocID, bytesUsed.get()));
       writer = codec.termVectorsFormat().vectorsWriter(directory, info, context);
       lastDocID = 0;
       accountable = writer;

lucene/core/src/java/org/apache/lucene/store/DefaultIOContext.java

@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.lucene.store;
+
+import java.util.Arrays;
+import java.util.Objects;
+
+record DefaultIOContext(ReadAdvice readAdvice) implements IOContext {
+
+  public DefaultIOContext {
+    Objects.requireNonNull(readAdvice);
+  }
+
+  @Override
+  public Context context() {
+    return Context.DEFAULT;
+  }
+
+  @Override
+  public MergeInfo mergeInfo() {
+    return null;
+  }
+
+  @Override
+  public FlushInfo flushInfo() {
+    return null;
+  }
+
+  private static final DefaultIOContext[] READADVICE_TO_IOCONTEXT =
+      Arrays.stream(ReadAdvice.values())
+          .map(DefaultIOContext::new)
+          .toArray(DefaultIOContext[]::new);
+
+  @Override
+  public DefaultIOContext withReadAdvice(ReadAdvice advice) {
+    return READADVICE_TO_IOCONTEXT[advice.ordinal()];
+  }
+}

lucene/core/src/java/org/apache/lucene/store/FlushIOContext.java

@@ -0,0 +1,45 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.lucene.store;
+
+import java.util.Objects;
+
+record FlushIOContext(FlushInfo flushInfo) implements IOContext {
+  public FlushIOContext {
+    Objects.requireNonNull(flushInfo);
+  }
+
+  @Override
+  public Context context() {
+    return Context.FLUSH;
+  }
+
+  @Override
+  public MergeInfo mergeInfo() {
+    return null;
+  }
+
+  @Override
+  public ReadAdvice readAdvice() {
+    return ReadAdvice.SEQUENTIAL;
+  }
+
+  @Override
+  public IOContext withReadAdvice(ReadAdvice advice) {
+    return this;
+  }
+}

lucene/core/src/java/org/apache/lucene/store/IOContext.java

@@ -16,26 +16,18 @@
  */
 package org.apache.lucene.store;
 
-import java.util.Arrays;
-import java.util.Objects;
 import org.apache.lucene.util.Constants;
 
 /**
  * IOContext holds additional details on the merge/search context. An IOContext object can never be
  * passed as a {@code null} parameter to either {@link
  * org.apache.lucene.store.Directory#openInput(String, IOContext)} or {@link
  * org.apache.lucene.store.Directory#createOutput(String, IOContext)}
- *
- * @param context An object of a enumerator Context type
- * @param mergeInfo must be given when {@code context == MERGE}
- * @param flushInfo must be given when {@code context == FLUSH}
- * @param readAdvice Advice regarding the read access pattern
  */
-public record IOContext(
-    Context context, MergeInfo mergeInfo, FlushInfo flushInfo, ReadAdvice readAdvice) {
+public interface IOContext {
 
   /** Context is an enumerator which specifies the context in which the Directory is being used. */
-  public enum Context {
+  enum Context {
     /** Context for reads and writes that are associated with a merge. */
     MERGE,
     /** Context for writes that are associated with a segment flush. */
@@ -51,64 +43,44 @@ public enum Context {
    * <p>It will use {@link ReadAdvice#RANDOM} by default, unless set by system property {@code
    * org.apache.lucene.store.defaultReadAdvice}.
    */
-  public static final IOContext DEFAULT = new IOContext(Constants.DEFAULT_READADVICE);
+  IOContext DEFAULT = new DefaultIOContext(Constants.DEFAULT_READADVICE);
 
   /**
    * A default context for reads with {@link ReadAdvice#SEQUENTIAL}.
    *
    * <p>This context should only be used when the read operations will be performed in the same
    * thread as the thread that opens the underlying storage.
    */
-  public static final IOContext READONCE = new IOContext(ReadAdvice.SEQUENTIAL);
+  IOContext READONCE = new DefaultIOContext(ReadAdvice.SEQUENTIAL);
 
-  @SuppressWarnings("incomplete-switch")
-  public IOContext {
-    Objects.requireNonNull(context, "context must not be null");
-    Objects.requireNonNull(readAdvice, "readAdvice must not be null");
-    switch (context) {
-      case MERGE ->
-          Objects.requireNonNull(mergeInfo, "mergeInfo must not be null if context is MERGE");
-      case FLUSH ->
-          Objects.requireNonNull(flushInfo, "flushInfo must not be null if context is FLUSH");
-    }
-    if ((context == Context.FLUSH || context == Context.MERGE)
-        && readAdvice != ReadAdvice.SEQUENTIAL) {
-      throw new IllegalArgumentException(
-          "The FLUSH and MERGE contexts must use the SEQUENTIAL read access advice");
-    }
+  /** Returns an {@link IOContext} for merging with the specified {@link MergeInfo} */
+  static IOContext merge(MergeInfo mergeInfo) {
+    return new MergeIOContext(mergeInfo);
   }
 
-  /** Creates a default {@link IOContext} for reading/writing with the given {@link ReadAdvice} */
-  private IOContext(ReadAdvice accessAdvice) {
-    this(Context.DEFAULT, null, null, accessAdvice);
+  /** Returns an {@link IOContext} for flushing with the specified {@link FlushInfo} */
+  static IOContext flush(FlushInfo flushInfo) {
+    return new FlushIOContext(flushInfo);
   }
 
-  /** Creates an {@link IOContext} for flushing. */
-  public IOContext(FlushInfo flushInfo) {
-    this(Context.FLUSH, null, flushInfo, ReadAdvice.SEQUENTIAL);
-  }
+  /** The {@link Context} this context is for */
+  Context context();
 
-  /** Creates an {@link IOContext} for merging. */
-  public IOContext(MergeInfo mergeInfo) {
-    // Merges read input segments sequentially.
-    this(Context.MERGE, mergeInfo, null, ReadAdvice.SEQUENTIAL);
-  }
+  /** Merge info, if {@link #context()} is {@link Context#MERGE} */
+  MergeInfo mergeInfo();
 
-  private static final IOContext[] READADVICE_TO_IOCONTEXT =
-      Arrays.stream(ReadAdvice.values()).map(IOContext::new).toArray(IOContext[]::new);
+  /** Flush info, if {@link #context()} is {@link Context#FLUSH} */
+  FlushInfo flushInfo();
+
+  /** Advice on the expected read access pattern */
+  ReadAdvice readAdvice();
 
   /**
-   * Return an updated {@link IOContext} that has the provided {@link ReadAdvice} if the {@link
-   * Context} is a {@link Context#DEFAULT} context, otherwise return this existing instance. This
+   * Return an updated {@link IOContext} that has the provided {@link ReadAdvice}, if the provided
+   * advice is compatible with the current context, otherwise return this existing instance. This
    * helps preserve a {@link ReadAdvice#SEQUENTIAL} advice for merging, which is always the right
    * choice, while allowing {@link IndexInput}s open for searching to use arbitrary {@link
    * ReadAdvice}s.
    */
-  public IOContext withReadAdvice(ReadAdvice advice) {
-    if (context == Context.DEFAULT) {
-      return READADVICE_TO_IOCONTEXT[advice.ordinal()];
-    } else {
-      return this;
-    }
-  }
+  IOContext withReadAdvice(ReadAdvice advice);
 }

lucene/core/src/java/org/apache/lucene/store/MergeIOContext.java

@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.lucene.store;
+
+import java.util.Objects;
+
+record MergeIOContext(MergeInfo mergeInfo) implements IOContext {
+
+  public MergeIOContext {
+    Objects.requireNonNull(mergeInfo);
+  }
+
+  @Override
+  public Context context() {
+    return Context.MERGE;
+  }
+
+  @Override
+  public FlushInfo flushInfo() {
+    return null;
+  }
+
+  @Override
+  public ReadAdvice readAdvice() {
+    return ReadAdvice.SEQUENTIAL;
+  }
+
+  @Override
+  public IOContext withReadAdvice(ReadAdvice advice) {
+    return this;
+  }
+}

lucene/core/src/test/org/apache/lucene/index/TestDoc.java

@@ -210,7 +210,7 @@ private SegmentCommitInfo merge(
       String merged,
       boolean useCompoundFile)
       throws Exception {
-    IOContext context = newIOContext(random(), new IOContext(new MergeInfo(-1, -1, false, -1)));
+    IOContext context = newIOContext(random(), IOContext.merge(new MergeInfo(-1, -1, false, -1)));
     SegmentReader r1 = new SegmentReader(si1, Version.LATEST.major, context);
     SegmentReader r2 = new SegmentReader(si2, Version.LATEST.major, context);