Java 类org.apache.lucene.search.ConstantScoreWeight 实例源码

@Override
public Weight createWeight(IndexSearcher searcher, boolean needsScores) throws IOException {
    if (!needsScores) {
        // If scores are not needed simply return a constant score on all docs
        return new ConstantScoreWeight(this) {
            @Override
            public Scorer scorer(LeafReaderContext context) throws IOException {
                return new ConstantScoreScorer(this, score(), DocIdSetIterator.all(context.reader().maxDoc()));
            }
        };
    }
    List<Weight> weights = new ArrayList<>(queries.size());
    for (Query q : queries) {
        weights.add(searcher.createWeight(q, needsScores));
    }
    return new RankerWeight(weights);
}

@Override
public Weight createWeight(IndexSearcher searcher, boolean needsScores) throws IOException {
    return new ConstantScoreWeight(this) {
        @Override
        public Scorer scorer(LeafReaderContext context) throws IOException {
            final DocIdSet disi = build(context.reader());
            final DocIdSetIterator leafIt = disi.iterator();
            return new ConstantScoreScorer(this, score(), leafIt);
        }
    };
}

@Override
public Weight createWeight(IndexSearcher searcher, boolean needsScores)
        throws IOException {
    return new ConstantScoreWeight(this) {
        @Override
        public Scorer scorer(LeafReaderContext context) throws IOException {
            return new ConstantScoreScorer(this, score(), DocIdSetIterator.all(context.reader().maxDoc()));
        }
    };
}

@Override
public Weight createWeight(IndexSearcher searcher, boolean needsScores) throws IOException {
    if (!needsScores) {
        // If scores are not needed simply return a constant score on all docs
        return new ConstantScoreWeight(this) {
            @Override
            public Scorer scorer(LeafReaderContext context) throws IOException {
                return new ConstantScoreScorer(this, score(), DocIdSetIterator.all(context.reader().maxDoc()));
            }
        };
    }

    return new FVWeight(this);
}

@Override
public Weight createWeight(IndexSearcher searcher, boolean needsScores) throws IOException {
    final Weight childWeight = childFilter.createWeight(searcher, false);
    return new ConstantScoreWeight(this) {
        @Override
        public Scorer scorer(LeafReaderContext context) throws IOException {
            // Nested docs only reside in a single segment, so no need to evaluate all segments
            if (!context.reader().getCoreCacheKey().equals(leafReader.getCoreCacheKey())) {
                return null;
            }

            // If docId == 0 then we a parent doc doesn't have child docs, because child docs are stored
            // before the parent doc and because parent doc is 0 we can safely assume that there are no child docs.
            if (docId == 0) {
                return null;
            }

            final BitSet parents = parentFilter.getBitSet(context);
            final int firstChildDocId = parents.prevSetBit(docId - 1) + 1;
            // A parent doc doesn't have child docs, so we can early exit here:
            if (firstChildDocId == docId) {
                return null;
            }

            final Scorer childrenScorer = childWeight.scorer(context);
            if (childrenScorer == null) {
                return null;
            }
            DocIdSetIterator childrenIterator = childrenScorer.iterator();
            final DocIdSetIterator it = new DocIdSetIterator() {

                int doc = -1;

                @Override
                public int docID() {
                    return doc;
                }

                @Override
                public int nextDoc() throws IOException {
                    return advance(doc + 1);
                }

                @Override
                public int advance(int target) throws IOException {
                    target = Math.max(firstChildDocId, target);
                    if (target >= docId) {
                        // We're outside the child nested scope, so it is done
                        return doc = NO_MORE_DOCS;
                    } else {
                        int advanced = childrenIterator.advance(target);
                        if (advanced >= docId) {
                            // We're outside the child nested scope, so it is done
                            return doc = NO_MORE_DOCS;
                        } else {
                            return doc = advanced;
                        }
                    }
                }

                @Override
                public long cost() {
                    return Math.min(childrenIterator.cost(), docId - firstChildDocId);
                }

            };
            return new ConstantScoreScorer(this, score(), it);
        }
    };
}

@Override
public Weight createWeight(IndexSearcher searcher, boolean needsScores) throws IOException {
    final Weight boundingBoxWeight;
    if (boundingBoxFilter != null) {
        boundingBoxWeight = searcher.createNormalizedWeight(boundingBoxFilter, false);
    } else {
        boundingBoxWeight = null;
    }
    return new ConstantScoreWeight(this) {
        @Override
        public Scorer scorer(LeafReaderContext context) throws IOException {
            final DocIdSetIterator approximation;
            if (boundingBoxWeight != null) {
                Scorer s = boundingBoxWeight.scorer(context);
                if (s == null) {
                    // if the approximation does not match anything, we're done
                    return null;
                }
                approximation = s.iterator();
            } else {
                approximation = DocIdSetIterator.all(context.reader().maxDoc());
            }
            final MultiGeoPointValues values = indexFieldData.load(context).getGeoPointValues();
            final TwoPhaseIterator twoPhaseIterator = new TwoPhaseIterator(approximation) {
                @Override
                public boolean matches() throws IOException {
                    final int doc = approximation.docID();
                    values.setDocument(doc);
                    final int length = values.count();
                    for (int i = 0; i < length; i++) {
                        GeoPoint point = values.valueAt(i);
                        if (distanceBoundingCheck.isWithin(point.lat(), point.lon())) {
                            double d = fixedSourceDistance.calculate(point.lat(), point.lon());
                            if (d >= inclusiveLowerPoint && d <= inclusiveUpperPoint) {
                                return true;
                            }
                        }
                    }
                    return false;
                }

                @Override
                public float matchCost() {
                    if (distanceBoundingCheck == GeoDistance.ALWAYS_INSTANCE) {
                        return 0.0f;
                    } else {
                        // TODO: is this right (up to 4 comparisons from GeoDistance.SimpleDistanceBoundingCheck)?
                        return 4.0f;
                    }
                }
            };
            return new ConstantScoreScorer(this, score(), twoPhaseIterator);
        }
    };
}

@Override
public Weight createWeight(IndexSearcher searcher, boolean needsScores) {
    return new ConstantScoreWeight(this) {
        @Override
        public Scorer scorer(LeafReaderContext context) throws IOException {
            return new ConstantScoreScorer(this, score(), new DocIdSetIterator() {
                private BinaryDocValues keysDocValues = DocValues.getBinary(context.reader(), keyName);
                private int maxDoc = context.reader().maxDoc();
                int docId = -1;

                @Override
                public int docID() {
                    return this.docId;
                }

                @Override
                public int nextDoc() throws IOException {
                    this.docId++;
                    while (this.docId < this.maxDoc) {
                        String keys = this.keysDocValues.get(this.docId).utf8ToString();
                        for (String key: keys.split("\\|")) {
                            if (keySet.get(Integer.parseInt(key))) {
                                return this.docId;
                            }
                        }
                        this.docId++;
                    }
                    this.docId = DocIdSetIterator.NO_MORE_DOCS;
                    return this.docId;
                }

                @Override
                public int advance(int target) throws IOException {
                    this.docId = target - 1;
                    return nextDoc();
                }

                @Override
                public long cost() {
                    return 1L;
                }
           });
       }
   };
}