/// <summary> /// Constructor. </summary> /// <param name="innerSet"> Underlying DocIdSet </param> /// <param name="acceptDocs"> Allowed docs, all docids not in this set will not be returned by this DocIdSet </param> public BitsFilteredDocIdSet(DocIdSet innerSet, Bits acceptDocs) : base(innerSet) { if (acceptDocs == null) { throw new System.NullReferenceException("acceptDocs is null"); } this.AcceptDocs = acceptDocs; }
internal virtual int GetDocIdSetSize(DocIdSet docIdSet) { int size = 0; DocIdSetIterator it = docIdSet.Iterator(); while (it.NextDoc() != DocIdSetIterator.NO_MORE_DOCS) { size++; } return size; }
public GeoHashFilteredDocIdSet(DocIdSet innerSet, string[] geoHashValues, Dictionary<string, double> distanceLookupCache, double lat, double lng, int docBase, double distance, Dictionary<int, double> distances) : base(innerSet) { _geoHashValues = geoHashValues; _distances = distances; _distance = distance; _docBase = docBase; _lng = lng; _lat = lat; _distanceLookupCache = distanceLookupCache; }
private HashSet<int> DocIdSetToHashSet(DocIdSet docs) { var result = new HashSet<int>(); var iterator = docs.Iterator(); int docId; while ((docId = iterator.NextDoc()) != DocIdSetIterator.NO_MORE_DOCS) result.Add(docId); return result; }
public LatLongFilteredDocIdSet(DocIdSet innerSet, double[] latIndex, double[] lngIndex, Dictionary<string, double> distanceLookupCache, double lat, double lng, double distance, int docBase, Dictionary<int, double> distances) : base(innerSet) { _latIndex = latIndex; _distances = distances; _docBase = docBase; _distance = distance; _lng = lng; _lat = lat; _distanceLookupCache = distanceLookupCache; _lngIndex = lngIndex; }
public LatLongFilteredDocIdSet(DocIdSet innerSet, double[] latIndex, double[] lngIndex, Dictionary<string, double> distanceLookupCache, double lat, double lng, double distance, int docBase, Dictionary<int, double> distances) : base(innerSet, (int docid) => /* was: public override Match */ { double x = latIndex[docid]; double y = lngIndex[docid]; string ck = x + "," + y; double cachedDistance = distanceLookupCache.ContainsKey(ck) ? distanceLookupCache[ck] : 0; double d; if (cachedDistance > 0) { d = cachedDistance; } else { d = DistanceUtils.GetInstance().GetDistanceMi(lat, lng, x, y); distanceLookupCache[ck] = d; } if (d < distance) { // Save distances, so they can be pulled for // sorting after filtering is done: distances[docid + docBase] = d; return true; } return false; }) { _latIndex = latIndex; _distances = distances; _docBase = docBase; _distance = distance; _lng = lng; _lat = lat; _distanceLookupCache = distanceLookupCache; _lngIndex = lngIndex; }
public GeoHashFilteredDocIdSet(DocIdSet innerSet, string[] geoHashValues, Dictionary<string, double> distanceLookupCache, double lat, double lng, int docBase, double distance, Dictionary<int, double> distances) : base(innerSet , (docid) => /* was: public override Match */ { String geoHash = geoHashValues[docid]; double[] coords = GeoHashUtils.Decode(geoHash); double x = coords[0]; double y = coords[1]; Double cachedDistance = 0; distanceLookupCache.TryGetValue(geoHash, out cachedDistance); double d; if (cachedDistance > 0) { d = cachedDistance; } else { d = DistanceUtils.GetInstance().GetDistanceMi(lat, lng, x, y); distanceLookupCache[geoHash] = d; } if (d < distance) { distances[docid + docBase] = d; return true; } return false; }) { _geoHashValues = geoHashValues; _distances = distances; _distance = distance; _docBase = docBase; _lng = lng; _lat = lat; _distanceLookupCache = distanceLookupCache; }
protected override DocIdSet DocIdSetToCache(DocIdSet docIdSet, AtomicReader reader) { if (docIdSet == null) { return EMPTY_DOCIDSET; } if (docIdSet is FixedBitSet) { // this is different from CachingWrapperFilter: even when the DocIdSet is // cacheable, we convert it to a FixedBitSet since we require all the // cached filters to be FixedBitSets return docIdSet; } DocIdSetIterator it = docIdSet.GetIterator(); if (it == null) { return EMPTY_DOCIDSET; } FixedBitSet copy = new FixedBitSet(reader.MaxDoc); copy.Or(it); return copy; }
/// <summary> Constructor.</summary> /// <param name="innerSet">Underlying DocIdSet /// </param> public FilteredDocIdSet(DocIdSet innerSet) { _innerSet = innerSet; }
/// <summary> /// Convenience wrapper method: If {@code acceptDocs == null} it returns the original set without wrapping. </summary> /// <param name="set"> Underlying DocIdSet. If {@code null}, this method returns {@code null} </param> /// <param name="acceptDocs"> Allowed docs, all docids not in this set will not be returned by this DocIdSet. /// If {@code null}, this method returns the original set without wrapping. </param> public static DocIdSet Wrap(DocIdSet set, Bits acceptDocs) { return (set == null || acceptDocs == null) ? set : new BitsFilteredDocIdSet(set, acceptDocs); }
/// <summary> /// Sole constructor. /// </summary> public MatchingDocs(AtomicReaderContext context, DocIdSet bits, int totalHits, float[] scores) { this.Context = context; this.Bits = bits; this.Scores = scores; this.TotalHits = totalHits; }
public NotDocIdSet(DocIdSet docSet, int maxVal) { innerSet = docSet; max = maxVal; }
/// <summary> Constructor.</summary> /// <param name="innerSet">Underlying DocIdSet /// </param> public FilteredDocIdSet(DocIdSet innerSet,Func<int,bool> match) { _innerSet = innerSet; this.Match = match; }
public override BulkScorer FilteredBulkScorer(AtomicReaderContext context, Weight weight, bool scoreDocsInOrder, DocIdSet docIdSet) // ignored (we always top-score in order) { Bits filterAcceptDocs = docIdSet.GetBits(); if (filterAcceptDocs == null) { // Filter does not provide random-access Bits; we // must fallback to leapfrog: return LEAP_FROG_QUERY_FIRST_STRATEGY.FilteredBulkScorer(context, weight, scoreDocsInOrder, docIdSet); } Scorer scorer = weight.Scorer(context, null); return scorer == null ? null : new QueryFirstBulkScorer(scorer, filterAcceptDocs); }
private IList<PositionInfo> positions; //Spans spans; /// <summary> </summary> /// <param name="docIdSet">The DocIdSet for the Filter /// </param> /// <param name="positions">A List of <see cref="Lucene.Net.Search.SpanFilterResult.PositionInfo" /> objects /// </param> public SpanFilterResult(DocIdSet docIdSet, IList<PositionInfo> positions) { this.docIdSet = docIdSet; this.positions = positions; }
public ValueSourceFilteredDocIdSet(DocIdSet innerSet, FunctionValues values, ValueSourceFilter caller) : base(innerSet) { this.enclosingFilter = caller; this.values = values; }
public FilteredDocIdSetAnonymousInnerClassHelper2(FilterAnonymousInnerClassHelper2 outerInstance, DocIdSet innerNullIteratorSet) : base(innerNullIteratorSet) { this.OuterInstance = outerInstance; }
public override BulkScorer FilteredBulkScorer(AtomicReaderContext context, Weight weight, bool scoreDocsInOrder, DocIdSet docIdSet) // ignored (we always top-score in order) { IBits filterAcceptDocs = docIdSet.Bits; if (filterAcceptDocs == null) { // Filter does not provide random-access Bits; we // must fallback to leapfrog: return(LEAP_FROG_QUERY_FIRST_STRATEGY.FilteredBulkScorer(context, weight, scoreDocsInOrder, docIdSet)); } Scorer scorer = weight.GetScorer(context, null); return(scorer == null ? null : new QueryFirstBulkScorer(scorer, filterAcceptDocs)); }
public override Scorer FilteredScorer(AtomicReaderContext context, Weight weight, DocIdSet docIdSet) { IBits filterAcceptDocs = docIdSet.Bits; if (filterAcceptDocs == null) { // Filter does not provide random-access Bits; we // must fallback to leapfrog: return(LEAP_FROG_QUERY_FIRST_STRATEGY.FilteredScorer(context, weight, docIdSet)); } Scorer scorer = weight.GetScorer(context, null); return(scorer == null ? null : new QueryFirstScorer(weight, filterAcceptDocs, scorer)); }
/// <summary> /// Constructor. </summary> /// <param name="innerSet"> Underlying <see cref="DocIdSet"/> </param> /// <param name="acceptDocs"> Allowed docs, all docids not in this set will not be returned by this <see cref="DocIdSet"/> </param> public BitsFilteredDocIdSet(DocIdSet innerSet, IBits acceptDocs) : base(innerSet) { this.acceptDocs = acceptDocs ?? throw new ArgumentNullException(nameof(acceptDocs), "acceptDocs can not be null"); // LUCENENET specific - changed from IllegalArgumentException to ArgumentNullException (.NET convention) }
/// <summary> /// Convenience wrapper method: If <c>acceptDocs == null</c> it returns the original set without wrapping. </summary> /// <param name="set"> Underlying DocIdSet. If <c>null</c>, this method returns <c>null</c> </param> /// <param name="acceptDocs"> Allowed docs, all docids not in this set will not be returned by this <see cref="DocIdSet"/>. /// If <c>null</c>, this method returns the original set without wrapping. </param> public static DocIdSet Wrap(DocIdSet set, IBits acceptDocs) { return((set == null || acceptDocs == null) ? set : new BitsFilteredDocIdSet(set, acceptDocs)); }
public AnonymousFilteredDocIdSet(DocIdSet innerSet, IndexReader r) : base(innerSet) { this.r = r; }
public FilteredDocIdSetAnonymousInnerClassHelper(TestDocIdSet outerInstance, DocIdSet innerSet) : base(innerSet) { this.OuterInstance = outerInstance; }
public override Scorer FilteredScorer(AtomicReaderContext context, Weight weight, DocIdSet docIdSet) { Bits filterAcceptDocs = docIdSet.GetBits(); if (filterAcceptDocs == null) { // Filter does not provide random-access Bits; we // must fallback to leapfrog: return LEAP_FROG_QUERY_FIRST_STRATEGY.FilteredScorer(context, weight, docIdSet); } Scorer scorer = weight.Scorer(context, null); return scorer == null ? null : new QueryFirstScorer(weight, filterAcceptDocs, scorer); }
public JustCompileFilteredDocIdSet(DocIdSet innerSet) : base(innerSet) { }
public RandomAccessAndFilterSet(RandomAccessDocIdSet[] randomAccessDocIdSets, DocIdSet andDocIdSet) { this.randomAccessDocIdSets = randomAccessDocIdSets; this.andDocIdSet = andDocIdSet; }
/// <summary> /// Get the id set for the filter. /// </summary> /// <param name="reader">The reader.</param> /// <returns>The filter set to use.</returns> public override DocIdSet GetDocIdSet(IndexReader reader) { OpenBitSetDISI res = null; if (shouldFilters != null) { for (int i = 0; i < shouldFilters.Count; i++) { if (res == null) { res = new OpenBitSetDISI(GetDISI(shouldFilters, i, reader), reader.MaxDoc()); } else { DocIdSet dis = ((Filter)shouldFilters[i]).GetDocIdSet(reader); if (dis is OpenBitSet) { // optimized case for OpenBitSets res.Or((OpenBitSet)dis); } else { res.InPlaceOr(GetDISI(shouldFilters, i, reader)); } } } } if (notFilters != null) { for (int i = 0; i < notFilters.Count; i++) { if (res == null) { res = new OpenBitSetDISI(GetDISI(notFilters, i, reader), reader.MaxDoc()); res.Flip(0, reader.MaxDoc()); // NOTE: may set bits on deleted docs } else { DocIdSet dis = ((Filter)notFilters[i]).GetDocIdSet(reader); if (dis is OpenBitSet) { // optimized case for OpenBitSets res.AndNot((OpenBitSet)dis); } else { res.InPlaceNot(GetDISI(notFilters, i, reader)); } } } } if (mustFilters != null) { for (int i = 0; i < mustFilters.Count; i++) { if (res == null) { res = new OpenBitSetDISI(GetDISI(mustFilters, i, reader), reader.MaxDoc()); } else { DocIdSet dis = ((Filter)mustFilters[i]).GetDocIdSet(reader); if (dis is OpenBitSet) { // optimized case for OpenBitSets res.And((OpenBitSet)dis); } else { res.InPlaceAnd(GetDISI(mustFilters, i, reader)); } } } } if (res != null) { return(FinalResult(res, reader.MaxDoc())); } else { //TODO: 2.- change return DocIdSet.EMPTY_DOCIDSET; return(null); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void doChain(org.apache.lucene.util.FixedBitSet result, int logic, org.apache.lucene.search.DocIdSet dis) throws java.io.IOException private void doChain(FixedBitSet result, int logic, DocIdSet dis) { if (dis is FixedBitSet) { // optimized case for FixedBitSets switch (logic) { case OR: result.Or((FixedBitSet)dis); break; case AND: result.And((FixedBitSet)dis); break; case ANDNOT: result.AndNot((FixedBitSet)dis); break; case XOR: result.Xor((FixedBitSet)dis); break; default: doChain(result, DEFAULT, dis); break; } } else { DocIdSetIterator disi; if (dis == null) { disi = DocIdSetIterator.Empty(); } else { disi = dis.GetIterator() ?? DocIdSetIterator.Empty(); } switch (logic) { case OR: result.Or(disi); break; case AND: result.And(disi); break; case ANDNOT: result.AndNot(disi); break; case XOR: result.Xor(disi); break; default: doChain(result, DEFAULT, dis); break; } } }
/// <summary> /// Returns a filtered <seealso cref="Scorer"/> based on this strategy. /// </summary> /// <param name="context"> /// the <seealso cref="AtomicReaderContext"/> for which to return the <seealso cref="Scorer"/>. </param> /// <param name="weight"> the <seealso cref="FilteredQuery"/> <seealso cref="Weight"/> to create the filtered scorer. </param> /// <param name="docIdSet"> the filter <seealso cref="DocIdSet"/> to apply </param> /// <returns> a filtered scorer /// </returns> /// <exception cref="IOException"> if an <seealso cref="IOException"/> occurs </exception> public abstract Scorer FilteredScorer(AtomicReaderContext context, Weight weight, DocIdSet docIdSet);
public FilteredDocIdSetAnonymousClass2(FilterAnonymousClass2 outerInstance, DocIdSet innerNullIteratorSet) : base(innerNullIteratorSet) { this.outerInstance = outerInstance; }
/// <summary> /// Returns a filtered <seealso cref="BulkScorer"/> based on this /// strategy. this is an optional method: the default /// implementation just calls <seealso cref="#filteredScorer"/> and /// wraps that into a BulkScorer. /// </summary> /// <param name="context"> /// the <seealso cref="AtomicReaderContext"/> for which to return the <seealso cref="Scorer"/>. </param> /// <param name="weight"> the <seealso cref="FilteredQuery"/> <seealso cref="Weight"/> to create the filtered scorer. </param> /// <param name="docIdSet"> the filter <seealso cref="DocIdSet"/> to apply </param> /// <returns> a filtered top scorer </returns> public virtual BulkScorer FilteredBulkScorer(AtomicReaderContext context, Weight weight, bool scoreDocsInOrder, DocIdSet docIdSet) { Scorer scorer = FilteredScorer(context, weight, docIdSet); if (scorer == null) { return(null); } // this impl always scores docs in order, so we can // ignore scoreDocsInOrder: return(new Weight.DefaultBulkScorer(scorer)); }
/// <summary> </summary> /// <param name="docIdSet">The DocIdSet for the Filter /// </param> /// <param name="positions">A List of {@link Lucene.Net.Search.SpanFilterResult.PositionInfo} objects /// </param> public SpanFilterResult(DocIdSet docIdSet, System.Collections.IList positions) { this.docIdSet = docIdSet; this.positions = positions; }
public override Scorer FilteredScorer(AtomicReaderContext context, Weight weight, DocIdSet docIdSet) { DocIdSetIterator filterIter = docIdSet.GetIterator(); if (filterIter == null) { // this means the filter does not accept any documents. return(null); } int firstFilterDoc = filterIter.NextDoc(); if (firstFilterDoc == DocIdSetIterator.NO_MORE_DOCS) { return(null); } IBits filterAcceptDocs = docIdSet.Bits; // force if RA is requested bool useRandomAccess = filterAcceptDocs != null && UseRandomAccess(filterAcceptDocs, firstFilterDoc); if (useRandomAccess) { // if we are using random access, we return the inner scorer, just with other acceptDocs return(weight.GetScorer(context, filterAcceptDocs)); } else { Debug.Assert(firstFilterDoc > -1); // we are gonna advance() this scorer, so we set inorder=true/toplevel=false // we pass null as acceptDocs, as our filter has already respected acceptDocs, no need to do twice Scorer scorer = weight.GetScorer(context, null); // TODO once we have way to figure out if we use RA or LeapFrog we can remove this scorer return((scorer == null) ? null : new PrimaryAdvancedLeapFrogScorer(weight, firstFilterDoc, filterIter, scorer)); } }
public FilteredDocIdSetAnonymousClass(TestDocIdSet outerInstance, DocIdSet innerSet) : base(innerSet) { this.outerInstance = outerInstance; }
public override Scorer FilteredScorer(AtomicReaderContext context, Weight weight, DocIdSet docIdSet) { DocIdSetIterator filterIter = docIdSet.GetIterator(); if (filterIter == null) { // this means the filter does not accept any documents. return(null); } // we pass null as acceptDocs, as our filter has already respected acceptDocs, no need to do twice Scorer scorer = weight.GetScorer(context, null); if (scorer == null) { return(null); } if (scorerFirst) { return(new LeapFrogScorer(weight, scorer, filterIter, scorer)); } else { return(new LeapFrogScorer(weight, filterIter, scorer, scorer)); } }
static DocIdSet() { EMPTY_DOCIDSET = new AnonymousClassDocIdSet(); }
private void doChain(OpenBitSetDISI result, int logic, DocIdSet dis) { if (dis is OpenBitSet) { // optimized case for OpenBitSets switch (logic) { case OR: result.Or((OpenBitSet)dis); break; case AND: result.And((OpenBitSet)dis); break; case ANDNOT: result.AndNot((OpenBitSet)dis); break; case XOR: result.Xor((OpenBitSet)dis); break; default: doChain(result, DEFAULT, dis); break; } } else { DocIdSetIterator disi; if (dis == null) { disi = DocIdSet.EMPTY_DOCIDSET.Iterator(); } else { disi = dis.Iterator(); if (disi == null) { disi = DocIdSet.EMPTY_DOCIDSET.Iterator(); } } switch (logic) { case OR: result.InPlaceOr(disi); break; case AND: result.InPlaceAnd(disi); break; case ANDNOT: result.InPlaceNot(disi); break; case XOR: result.InPlaceXor(disi); break; default: doChain(result, DEFAULT, dis); break; } } }
public virtual DocIdSet Parse(SelectionNode[] selectionNodes, SelectionNode[] notSelectionNodes, int maxDoc) { DocIdSet docSet = null; DocIdSet selSet = null; if (selectionNodes != null && selectionNodes.Length > 0) { List<DocIdSet> selSetList = new List<DocIdSet>(selectionNodes.Length); foreach (SelectionNode selectionNode in selectionNodes) { DocIdSet ds = selectionNode.DocSet; if (ds != null) { selSetList.Add(ds); } } if (selSetList.Count > 0) { if (selSetList.Count == 1) { selSet = selSetList[0]; } else { selSet = new AndDocIdSet(selSetList); } } } DocIdSet notSelSet = null; if (notSelectionNodes != null && notSelectionNodes.Length > 0) { List<DocIdSet> notSelSetList = new List<DocIdSet>(notSelectionNodes.Length); foreach (SelectionNode selectionNode in notSelectionNodes) { DocIdSet ds = selectionNode.DocSet; if (ds != null) { notSelSetList.Add(ds); } if (notSelSetList.Count > 0) { if (notSelSetList.Count == 1) { notSelSet = notSelSetList[0]; } else { notSelSet = new OrDocIdSet(notSelSetList); } } } } if (notSelSet != null) { notSelSet = new NotDocIdSet(notSelSet, maxDoc); } if (selSet != null && notSelSet != null) { DocIdSet[] sets = new DocIdSet[] { selSet, notSelSet }; docSet = new AndDocIdSet(sets.ToList()); } else if (selSet != null) { docSet = selSet; } else if (notSelSet != null) { docSet = notSelSet; } return docSet; }
/// <summary>Provide the DocIdSet to be cached, using the DocIdSet provided /// by the wrapped Filter. /// This implementation returns the given DocIdSet. /// </summary> protected internal virtual DocIdSet DocIdSetToCache(DocIdSet docIdSet, IndexReader reader) { if (docIdSet.IsCacheable()) { return docIdSet; } else { DocIdSetIterator it = docIdSet.Iterator(); // null is allowed to be returned by iterator(), // in this case we wrap with the empty set, // which is cacheable. return (it == null) ? DocIdSet.EMPTY_DOCIDSET : new OpenBitSetDISI(it, reader.MaxDoc()); } }
/// <summary> /// Constructor. </summary> /// <param name="innerSet"> Underlying <see cref="DocIdSet"/> </param> public FilteredDocIdSet(DocIdSet innerSet) { this.innerSet = innerSet; }
public virtual void AssertContainsDocId(System.String msg, DocIdSet docIdSet, int docId) { DocIdSetIterator it = docIdSet.Iterator(); Assert.IsTrue(it.Advance(docId) != DocIdSetIterator.NO_MORE_DOCS, msg); Assert.IsTrue(it.DocID() == docId, msg); }
public override Scorer FilteredScorer(AtomicReaderContext context, Weight weight, DocIdSet docIdSet) { DocIdSetIterator filterIter = docIdSet.GetIterator(); if (filterIter == null) { // this means the filter does not accept any documents. return null; } int firstFilterDoc = filterIter.NextDoc(); if (firstFilterDoc == DocIdSetIterator.NO_MORE_DOCS) { return null; } Bits filterAcceptDocs = docIdSet.GetBits(); // force if RA is requested bool useRandomAccess = filterAcceptDocs != null && UseRandomAccess(filterAcceptDocs, firstFilterDoc); if (useRandomAccess) { // if we are using random access, we return the inner scorer, just with other acceptDocs return weight.Scorer(context, filterAcceptDocs); } else { Debug.Assert(firstFilterDoc > -1); // we are gonna advance() this scorer, so we set inorder=true/toplevel=false // we pass null as acceptDocs, as our filter has already respected acceptDocs, no need to do twice Scorer scorer = weight.Scorer(context, null); // TODO once we have way to figure out if we use RA or LeapFrog we can remove this scorer return (scorer == null) ? null : new PrimaryAdvancedLeapFrogScorer(weight, firstFilterDoc, filterIter, scorer); } }
public override Scorer FilteredScorer(AtomicReaderContext context, Weight weight, DocIdSet docIdSet) { DocIdSetIterator filterIter = docIdSet.GetIterator(); if (filterIter == null) { // this means the filter does not accept any documents. return null; } // we pass null as acceptDocs, as our filter has already respected acceptDocs, no need to do twice Scorer scorer = weight.Scorer(context, null); if (scorer == null) { return null; } if (ScorerFirst) { return new LeapFrogScorer(weight, scorer, filterIter, scorer); } else { return new LeapFrogScorer(weight, filterIter, scorer, scorer); } }
public JustCompileFilteredDocIdSet(DocIdSet innerSet):base(innerSet) { }
/// <summary></summary> /// <param name="docIdSet">The DocIdSet for the Filter</param> /// <param name="positions">A List of {@link Lucene.Net.Search.SpanFilterResult.PositionInfo} objects</param> public SpanFilterResult(DocIdSet docIdSet, System.Collections.IList positions) { this.docIdSet = docIdSet; this.positions = positions; }