## 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
`Weight()`

Method Summary
`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-2011 Apache Software Foundation. All Rights Reserved.