Package org.apache.lucene.search.highlight

# Class WeightedSpanTermExtractor

java.lang.Object
org.apache.lucene.search.highlight.WeightedSpanTermExtractor

public class WeightedSpanTermExtractor extends Object
Class used to extract `WeightedSpanTerm`s from a `Query` based on whether `Term`s from the `Query` are contained in a supplied `TokenStream`.

In order to support additional, by default unsupported queries, subclasses can override `extract(Query, float, Map)` for extracting wrapped or delegate queries and `extractUnknownQuery(Query, Map)` to process custom leaf queries:

        WeightedSpanTermExtractor extractor = new WeightedSpanTermExtractor() {
            protected void extract(Query query, float boost, Map<String, WeightedSpanTerm>terms) throws IOException {
              if (query instanceof QueryWrapper) {
                extract(((QueryWrapper)query).getQuery(), boost, terms);
              } else {
                super.extract(query, boost, terms);
              }
            }

            protected void extractUnknownQuery(Query query, Map<String, WeightedSpanTerm> terms) throws IOException {
              if (query instanceOf CustomTermQuery) {
                Term term = ((CustomTermQuery) query).getTerm();
                terms.put(term.field(), new WeightedSpanTerm(1, term.text()));
              }
            }
        };
     }

## Nested Class Summary

Nested Classes
Modifier and Type
Class
Description
`protected static class`
`WeightedSpanTermExtractor.PositionCheckingMap<K>`
This class makes sure that if both position sensitive and insensitive versions of the same term are added, the position insensitive one wins.

## Constructor Summary

Constructors
Constructor
Description
`WeightedSpanTermExtractor()`
`WeightedSpanTermExtractor(String defaultField)`

## Method Summary

Modifier and Type
Method
Description
`protected void`
`collectSpanQueryFields(SpanQuery spanQuery, Set<String> fieldNames)`
`protected void`
`extract(Query query, float boost, Map<String,WeightedSpanTerm> terms)`
Fills a `Map` with `WeightedSpanTerm`s using the terms from the supplied `Query`.
`protected void`
`extractUnknownQuery(Query query, Map<String,WeightedSpanTerm> terms)`
`protected void`
`extractWeightedSpanTerms(Map<String,WeightedSpanTerm> terms, SpanQuery spanQuery, float boost)`
Fills a `Map` with `WeightedSpanTerm`s using the terms from the supplied `SpanQuery`.
`protected void`
`extractWeightedTerms(Map<String,WeightedSpanTerm> terms, Query query, float boost)`
Fills a `Map` with `WeightedSpanTerm`s using the terms from the supplied `Query`.
`protected boolean`
`fieldNameComparator(String fieldNameToCheck)`
Necessary to implement matches for queries against `defaultField`
`boolean`
`getExpandMultiTermQuery()`
`protected LeafReaderContext`
`getLeafContext()`
`TokenStream`
`getTokenStream()`
Returns the tokenStream which may have been wrapped in a CachingTokenFilter.
`Map<String,WeightedSpanTerm>`
`getWeightedSpanTerms(Query query, float boost, TokenStream tokenStream)`
Creates a Map of `WeightedSpanTerms` from the given `Query` and `TokenStream`.
`Map<String,WeightedSpanTerm>`
`getWeightedSpanTerms(Query query, float boost, TokenStream tokenStream, String fieldName)`
Creates a Map of `WeightedSpanTerms` from the given `Query` and `TokenStream`.
`Map<String,WeightedSpanTerm>`
`getWeightedSpanTermsWithScores(Query query, float boost, TokenStream tokenStream, String fieldName, IndexReader reader)`
Creates a Map of `WeightedSpanTerms` from the given `Query` and `TokenStream`.
`boolean`
`isCachedTokenStream()`
`protected boolean`
`isQueryUnsupported(Class<? extends Query> clazz)`
`boolean`
`isUsePayloads()`
`protected boolean`
`mustRewriteQuery(SpanQuery spanQuery)`
`void`
`setExpandMultiTermQuery(boolean expandMultiTermQuery)`
`protected final void`
`setMaxDocCharsToAnalyze(int maxDocCharsToAnalyze)`
A threshold of number of characters to analyze.
`void`
`setUsePayloads(boolean usePayloads)`
`void`
`setWrapIfNotCachingTokenFilter(boolean wrap)`
By default, `TokenStream`s that are not of the type `CachingTokenFilter` are wrapped in a `CachingTokenFilter` to ensure an efficient reset - if you are already using a different caching `TokenStream` impl and you don't want it to be wrapped, set this to false.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Constructor Details

### WeightedSpanTermExtractor

public WeightedSpanTermExtractor()

### WeightedSpanTermExtractor

public WeightedSpanTermExtractor(String defaultField)

## Method Details

### extract

protected void extract(Query query, float boost, Map<String,WeightedSpanTerm> terms) throws IOException
Fills a `Map` with `WeightedSpanTerm`s using the terms from the supplied `Query`.

Parameters:
  `query` - Query to extract Terms from
  `terms` - Map to place created WeightedSpanTerms in
Throws:
  `IOException` - If there is a low-level I/O error

### isQueryUnsupported

protected boolean isQueryUnsupported(Class<? extends Query> clazz)

### extractUnknownQuery

protected void extractUnknownQuery(Query query, Map<String,WeightedSpanTerm> terms) throws IOException

Throws:
  `IOException`

### extractWeightedSpanTerms

protected void extractWeightedSpanTerms(Map<String,WeightedSpanTerm> terms, SpanQuery spanQuery, float boost) throws IOException
Fills a `Map` with `WeightedSpanTerm`s using the terms from the supplied `SpanQuery`.

Parameters:
  `terms` - Map to place created WeightedSpanTerms in
  `spanQuery` - SpanQuery to extract Terms from
Throws:
  `IOException` - If there is a low-level I/O error

### extractWeightedTerms

protected void extractWeightedTerms(Map<String,WeightedSpanTerm> terms, Query query, float boost) throws IOException
Fills a `Map` with `WeightedSpanTerm`s using the terms from the supplied `Query`.

Parameters:
  `terms` - Map to place created WeightedSpanTerms in
  `query` - Query to extract Terms from
Throws:
  `IOException` - If there is a low-level I/O error

### fieldNameComparator

protected boolean fieldNameComparator(String fieldNameToCheck)
Necessary to implement matches for queries against `defaultField`

### getLeafContext

protected LeafReaderContext getLeafContext() throws IOException

Throws:
  `IOException`

### getWeightedSpanTerms

public Map<String,WeightedSpanTerm> getWeightedSpanTerms(Query query, float boost, TokenStream tokenStream) throws IOException
Creates a Map of `WeightedSpanTerms` from the given `Query` and `TokenStream`.

Parameters:
  `query` - that caused hit
  `tokenStream` - of text to be highlighted
Returns:
  Map containing WeightedSpanTerms
Throws:
  `IOException` - If there is a low-level I/O error

### getWeightedSpanTerms

public Map<String,WeightedSpanTerm> getWeightedSpanTerms(Query query, float boost, TokenStream tokenStream, String fieldName) throws IOException
Creates a Map of `WeightedSpanTerms` from the given `Query` and `TokenStream`.

Parameters:
  `query` - that caused hit
  `tokenStream` - of text to be highlighted
  `fieldName` - restricts Term's used based on field name
Returns:
  Map containing WeightedSpanTerms
Throws:
  `IOException` - If there is a low-level I/O error

### getWeightedSpanTermsWithScores

public Map<String,WeightedSpanTerm> getWeightedSpanTermsWithScores(Query query, float boost, TokenStream tokenStream, String fieldName, IndexReader reader) throws IOException
Creates a Map of `WeightedSpanTerms` from the given `Query` and `TokenStream`. Uses a supplied `IndexReader` to properly weight terms (for gradient highlighting).

Parameters:
  `query` - that caused hit
  `tokenStream` - of text to be highlighted
  `fieldName` - restricts Term's used based on field name
  `reader` - to use for scoring
Returns:
  Map of WeightedSpanTerms with quasi tf/idf scores
Throws:
  `IOException` - If there is a low-level I/O error

### collectSpanQueryFields

protected void collectSpanQueryFields(SpanQuery spanQuery, Set<String> fieldNames)

### mustRewriteQuery

protected boolean mustRewriteQuery(SpanQuery spanQuery)

### getExpandMultiTermQuery

public boolean getExpandMultiTermQuery()

### setExpandMultiTermQuery

public void setExpandMultiTermQuery(boolean expandMultiTermQuery)

### isUsePayloads

public boolean isUsePayloads()

### setUsePayloads

public void setUsePayloads(boolean usePayloads)

### isCachedTokenStream

public boolean isCachedTokenStream()

### getTokenStream

public TokenStream getTokenStream()
Returns the tokenStream which may have been wrapped in a CachingTokenFilter. getWeightedSpanTerms* sets the tokenStream, so don't call this before.

### setWrapIfNotCachingTokenFilter

public void setWrapIfNotCachingTokenFilter(boolean wrap)
By default, `TokenStream`s that are not of the type `CachingTokenFilter` are wrapped in a `CachingTokenFilter` to ensure an efficient reset - if you are already using a different caching `TokenStream` impl and you don't want it to be wrapped, set this to false. This setting is ignored when a term vector based TokenStream is supplied, since it can be reset efficiently.

### setMaxDocCharsToAnalyze

protected final void setMaxDocCharsToAnalyze(int maxDocCharsToAnalyze)
A threshold of number of characters to analyze. When a TokenStream based on term vectors with offsets and positions are supplied, this setting does not apply.