org.apache.lucene.search

## Class Weight

- java.lang.Object
- - org.apache.lucene.search.Weight

- All Implemented Interfaces:
    java.io.Serializable
  Direct Known Subclasses:
    BooleanQuery.BooleanWeight, ConstantScoreQuery.ConstantWeight, DisjunctionMaxQuery.DisjunctionMaxWeight, SpanWeight

      public abstract class Weight
      extends java.lang.Object
      implements java.io.Serializable

  Expert: Calculate query weights and build query scorers.

  The purpose of `Weight` is to ensure searching does not modify a `Query`, so that a `Query` instance can be reused.
  `Searcher` dependent state of the query should reside in the `Weight`.
  `IndexReader` dependent state should reside in the `Scorer`.

  A `Weight` is used in the following way:

  1. A `Weight` is constructed by a top-level query, given a `Searcher` (`Query.createWeight(Searcher)`).
  2. The `sumOfSquaredWeights()` method is called on the `Weight` to compute the query normalization factor `Similarity.queryNorm(float)` of the query clauses contained in the query.
  3. The query normalization factor is passed to `normalize(float)`. At this point the weighting is complete.
  4. A `Scorer` is constructed by `scorer(IndexReader,boolean,boolean)`.
  Since:
    2.9
  See Also:
    Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `Weight()`

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `abstract Explanation` | `explain(IndexReader reader, int doc)` An explanation of the score computation for the named document.
    `abstract Query` | `getQuery()` The query that this concerns.
    `abstract float` | `getValue()` The weight for this query.
    `abstract void` | `normalize(float norm)` Assigns the query normalization factor to this.
    `abstract Scorer` | `scorer(IndexReader reader, boolean scoreDocsInOrder, boolean topScorer)` Returns a `Scorer` which scores documents in/out-of order according to `scoreDocsInOrder`.
    `boolean` | `scoresDocsOutOfOrder()` Returns true iff this implementation scores docs only out of order.
    `abstract float` | `sumOfSquaredWeights()` The sum of squared weights of contained query clauses.

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

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

- - ### Constructor Detail

    - #### Weight

          public Weight()

  - ### Method Detail

    - #### explain

          public abstract Explanation explain(IndexReader reader,
                                              int doc)
                                       throws java.io.IOException

      An explanation of the score computation for the named document.
      Parameters:
        `reader` - sub-reader containing the give doc
        `doc` -
      Returns:
        an Explanation for the score
      Throws:
        `java.io.IOException`

    - #### getQuery

          public abstract Query getQuery()

      The query that this concerns.

    - #### getValue

          public abstract float getValue()

      The weight for this query.

    - #### normalize

          public abstract void normalize(float norm)

      Assigns the query normalization factor to this.

    - #### scorer

          public abstract Scorer scorer(IndexReader reader,
                                        boolean scoreDocsInOrder,
                                        boolean topScorer)
                                 throws java.io.IOException

      Returns a `Scorer` which scores documents in/out-of order according to `scoreDocsInOrder`.

      NOTE: even if `scoreDocsInOrder` is false, it is recommended to check whether the returned `Scorer` indeed scores documents out of order (i.e., call `scoresDocsOutOfOrder()`), as some `Scorer` implementations will always return documents in-order.
      NOTE: null can be returned if no documents will be scored by this query.

      Parameters:
        `reader` - the `IndexReader` for which to return the `Scorer`.
        `scoreDocsInOrder` - specifies whether in-order scoring of documents is required. Note that if set to false (i.e., out-of-order scoring is required), this method can return whatever scoring mode it supports, as every in-order scorer is also an out-of-order one. However, an out-of-order scorer may not support `DocIdSetIterator.nextDoc()` and/or `DocIdSetIterator.advance(int)`, therefore it is recommended to request an in-order scorer if use of these methods is required.
        `topScorer` - if true, `Scorer.score(Collector)` will be called; if false, `DocIdSetIterator.nextDoc()` and/or `DocIdSetIterator.advance(int)` will be called.
      Returns:
        a `Scorer` which scores documents in/out-of order.
      Throws:
        `java.io.IOException`

    - #### sumOfSquaredWeights

          public abstract float sumOfSquaredWeights()
                                             throws java.io.IOException

      The sum of squared weights of contained query clauses.
      Throws:
        `java.io.IOException`

    - #### scoresDocsOutOfOrder

          public boolean scoresDocsOutOfOrder()

      Returns true iff this implementation scores docs only out of order. This method is used in conjunction with `Collector`'s `acceptsDocsOutOfOrder` and `scorer(org.apache.lucene.index.IndexReader, boolean, boolean)` to create a matching `Scorer` instance for a given `Collector`, or vice versa.

      NOTE: the default implementation returns `false`, i.e. the `Scorer` scores documents in-order.

Copyright © 2000-2016 Apache Software Foundation. All Rights Reserved.