benwtrent commented on code in PR #14154:
URL: https://github.com/apache/lucene/pull/14154#discussion_r1939910069


##########
lucene/core/src/java/org/apache/lucene/analysis/AnalyzerWrapper.java:
##########
@@ -151,4 +157,78 @@ protected final Reader initReaderForNormalization(String 
fieldName, Reader reade
   protected final AttributeFactory attributeFactory(String fieldName) {
     return getWrappedAnalyzer(fieldName).attributeFactory(fieldName);
   }
+
+  /**
+   * A {@link org.apache.lucene.analysis.Analyzer.ReuseStrategy} that checks 
the wrapped analyzer's
+   * strategy for reusability. If the wrapped analyzer's strategy returns 
null, components need to
+   * be re-created.
+   */
+  public static final class UnwrappingReuseStrategy extends ReuseStrategy {
+    private final ReuseStrategy reuseStrategy;
+
+    public UnwrappingReuseStrategy(ReuseStrategy reuseStrategy) {
+      this.reuseStrategy = reuseStrategy;
+    }
+
+    @Override
+    public TokenStreamComponents getReusableComponents(Analyzer analyzer, 
String fieldName) {
+      if (analyzer instanceof AnalyzerWrapper wrapper) {
+        final Analyzer wrappedAnalyzer = wrapper.getWrappedAnalyzer(fieldName);
+        if 
(wrappedAnalyzer.getReuseStrategy().getReusableComponents(wrappedAnalyzer, 
fieldName)
+            == null) {
+          return null;
+        }
+      }
+      return reuseStrategy.getReusableComponents(analyzer, fieldName);
+    }
+
+    @Override
+    public void setReusableComponents(
+        Analyzer analyzer, String fieldName, TokenStreamComponents components) 
{
+      reuseStrategy.setReusableComponents(analyzer, fieldName, components);
+      if (analyzer instanceof AnalyzerWrapper wrapper
+          && components instanceof TokenStreamComponentsWrapper 
wrapperComponents) {

Review Comment:
   could we add an assertion where if its passed an `AnalyzerWrapper` that the 
components are indeed `instanceof TokenStreamComponentsWrapper`?



##########
lucene/core/src/java/org/apache/lucene/analysis/AnalyzerWrapper.java:
##########
@@ -151,4 +157,78 @@ protected final Reader initReaderForNormalization(String 
fieldName, Reader reade
   protected final AttributeFactory attributeFactory(String fieldName) {
     return getWrappedAnalyzer(fieldName).attributeFactory(fieldName);
   }
+
+  /**
+   * A {@link org.apache.lucene.analysis.Analyzer.ReuseStrategy} that checks 
the wrapped analyzer's
+   * strategy for reusability. If the wrapped analyzer's strategy returns 
null, components need to
+   * be re-created.
+   */
+  public static final class UnwrappingReuseStrategy extends ReuseStrategy {
+    private final ReuseStrategy reuseStrategy;
+
+    public UnwrappingReuseStrategy(ReuseStrategy reuseStrategy) {
+      this.reuseStrategy = reuseStrategy;
+    }
+
+    @Override
+    public TokenStreamComponents getReusableComponents(Analyzer analyzer, 
String fieldName) {
+      if (analyzer instanceof AnalyzerWrapper wrapper) {
+        final Analyzer wrappedAnalyzer = wrapper.getWrappedAnalyzer(fieldName);
+        if 
(wrappedAnalyzer.getReuseStrategy().getReusableComponents(wrappedAnalyzer, 
fieldName)
+            == null) {
+          return null;
+        }
+      }
+      return reuseStrategy.getReusableComponents(analyzer, fieldName);
+    }
+
+    @Override
+    public void setReusableComponents(
+        Analyzer analyzer, String fieldName, TokenStreamComponents components) 
{
+      reuseStrategy.setReusableComponents(analyzer, fieldName, components);
+      if (analyzer instanceof AnalyzerWrapper wrapper
+          && components instanceof TokenStreamComponentsWrapper 
wrapperComponents) {
+        final Analyzer wrappedAnalyzer = wrapper.getWrappedAnalyzer(fieldName);
+        wrappedAnalyzer
+            .getReuseStrategy()
+            .setReusableComponents(
+                wrappedAnalyzer, fieldName, 
wrapperComponents.getWrappedComponents());
+      }
+    }
+  }
+
+  /**
+   * A {@link Analyzer.TokenStreamComponents} that decorates the wrapper with 
access to the wrapped
+   * components.
+   */
+  public static final class TokenStreamComponentsWrapper extends 
TokenStreamComponents {

Review Comment:
   Does this need to be public? Could it maybe be package private?



##########
lucene/core/src/java/org/apache/lucene/analysis/AnalyzerWrapper.java:
##########
@@ -151,4 +157,78 @@ protected final Reader initReaderForNormalization(String 
fieldName, Reader reade
   protected final AttributeFactory attributeFactory(String fieldName) {
     return getWrappedAnalyzer(fieldName).attributeFactory(fieldName);
   }
+
+  /**
+   * A {@link org.apache.lucene.analysis.Analyzer.ReuseStrategy} that checks 
the wrapped analyzer's
+   * strategy for reusability. If the wrapped analyzer's strategy returns 
null, components need to
+   * be re-created.
+   */
+  public static final class UnwrappingReuseStrategy extends ReuseStrategy {
+    private final ReuseStrategy reuseStrategy;
+
+    public UnwrappingReuseStrategy(ReuseStrategy reuseStrategy) {
+      this.reuseStrategy = reuseStrategy;
+    }
+
+    @Override
+    public TokenStreamComponents getReusableComponents(Analyzer analyzer, 
String fieldName) {
+      if (analyzer instanceof AnalyzerWrapper wrapper) {
+        final Analyzer wrappedAnalyzer = wrapper.getWrappedAnalyzer(fieldName);
+        if 
(wrappedAnalyzer.getReuseStrategy().getReusableComponents(wrappedAnalyzer, 
fieldName)
+            == null) {
+          return null;
+        }
+      }
+      return reuseStrategy.getReusableComponents(analyzer, fieldName);
+    }
+
+    @Override
+    public void setReusableComponents(
+        Analyzer analyzer, String fieldName, TokenStreamComponents components) 
{
+      reuseStrategy.setReusableComponents(analyzer, fieldName, components);
+      if (analyzer instanceof AnalyzerWrapper wrapper
+          && components instanceof TokenStreamComponentsWrapper 
wrapperComponents) {
+        final Analyzer wrappedAnalyzer = wrapper.getWrappedAnalyzer(fieldName);
+        wrappedAnalyzer
+            .getReuseStrategy()
+            .setReusableComponents(
+                wrappedAnalyzer, fieldName, 
wrapperComponents.getWrappedComponents());
+      }
+    }
+  }
+
+  /**
+   * A {@link Analyzer.TokenStreamComponents} that decorates the wrapper with 
access to the wrapped
+   * components.
+   */
+  public static final class TokenStreamComponentsWrapper extends 
TokenStreamComponents {
+    private final TokenStreamComponents wrapped;
+    private final TokenStreamComponents wrapper;
+
+    public TokenStreamComponentsWrapper(
+        TokenStreamComponents wrapper, TokenStreamComponents wrapped) {
+      super(wrapper.getSource(), wrapper.getTokenStream());
+      this.wrapper = wrapper;
+      this.wrapped = wrapped;
+    }
+
+    public TokenStreamComponents getWrappedComponents() {
+      return wrapped;
+    }
+
+    @Override
+    protected void setReader(final Reader reader) {
+      wrapper.setReader(reader);
+    }

Review Comment:
   I wonder, do we need to override this? Isn't the default behavior simply 
setting the `source` which we already correctly provide via 
`wrapper.getSource()`?



##########
lucene/core/src/java/org/apache/lucene/analysis/Analyzer.java:
##########
@@ -387,7 +387,7 @@ public TokenStreamComponents(final Tokenizer tokenizer) {
      *
      * @param reader a reader to reset the source component
      */
-    private void setReader(final Reader reader) {
+    void setReader(final Reader reader) {

Review Comment:
   see comment about if we actually need to override this.



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org

For queries about this service, please contact Infrastructure at:
us...@infra.apache.org


---------------------------------------------------------------------
To unsubscribe, e-mail: issues-unsubscr...@lucene.apache.org
For additional commands, e-mail: issues-h...@lucene.apache.org

Reply via email to