use crate::core::document::lat_lon_point_distance_comparator::LatLonPointDistanceLeafComparator;
use crate::core::document::xy_point_distance_comparator::XYPointDistanceLeafComparator;
use crate::core::index::doc_values::{Binary, SortedNumeric};
use crate::core::index::leaf_reader::LeafReader;
use crate::core::search::comparators::doc_comparator::{DocComparatorIterator, DocLeafComparator};
use crate::core::search::comparators::double_comparator::DoubleLeafComparator;
use crate::core::search::comparators::float_comparator::FloatLeafComparator;
use crate::core::search::comparators::int_comparator::IntLeafComparator;
use crate::core::search::comparators::long_comparator::LongLeafComparator;
use crate::core::search::comparators::numeric_comparator::NumericCompetitiveIterator;
use crate::core::search::comparators::term_ord_val_comparator::{
TermOrdValCompetitiveIterator, TermOrdValLeafComparator,
};
use crate::core::search::doc_id_set_iterator::{DocIdSetIterator, DocIdSetIteratorEnum3};
use crate::core::search::field_comparator::{
FieldComparator, FieldComparatorEnum, RelevanceLeafComparator, TermValLeafComparator,
};
use crate::core::search::scorable::Scorable;
use crate::core::util::error::lucene_error::{LuceneError, Result};
pub trait LeafFieldComparator {
type FieldComparator: FieldComparator;
fn set_bottom(&mut self, slot: usize, comparator: &mut Self::FieldComparator) -> Result<()>;
fn compare_bottom<S>(
&mut self,
doc: i32,
scorer: &mut S,
comparator: &mut Self::FieldComparator,
) -> Result<i32>
where
S: Scorable + ?Sized;
fn compare_top<S>(
&mut self,
doc: i32,
scorer: &mut S,
comparator: &mut Self::FieldComparator,
) -> Result<i32>
where
S: Scorable + ?Sized;
fn copy<S>(
&mut self,
slot: usize,
doc: i32,
scorer: &mut S,
comparator: &mut Self::FieldComparator,
) -> Result<()>
where
S: Scorable + ?Sized;
fn set_scorer<S>(&mut self, scorer: &mut S, comparator: &mut Self::FieldComparator) -> Result<()>
where
S: Scorable + ?Sized;
type DocIdSetIteratorRef<'a>: DocIdSetIterator
where
Self: 'a;
fn competitive_iterator(
&mut self,
_comparator: &mut Self::FieldComparator,
) -> Result<Option<Self::DocIdSetIteratorRef<'_>>> {
Ok(None)
}
fn set_hits_threshold_reached(&mut self, _comparator: &mut Self::FieldComparator) -> Result<()> {
Ok(())
}
}
pub type LeafFieldComparatorDocIdSetIterator<LR> = DocIdSetIteratorEnum3<
DocComparatorIterator,
NumericCompetitiveIterator<LR>,
TermOrdValCompetitiveIterator<LR>,
>;
pub type LeafFieldComparatorDocIdSetIteratorRef<'a, LR> = DocIdSetIteratorEnum3<
<DocLeafComparator as LeafFieldComparator>::DocIdSetIteratorRef<'a>,
<DoubleLeafComparator<LR> as LeafFieldComparator>::DocIdSetIteratorRef<'a>,
<TermOrdValLeafComparator<LR> as LeafFieldComparator>::DocIdSetIteratorRef<'a>,
>;
pub enum LeafFieldComparatorEnum<LR>
where
LR: LeafReader,
{
Relevance(RelevanceLeafComparator),
Doc(DocLeafComparator),
Double(DoubleLeafComparator<LR>),
Float(FloatLeafComparator<LR>),
Int(IntLeafComparator<LR>),
LatLonPointDistance(LatLonPointDistanceLeafComparator<SortedNumeric<LR>>),
Long(LongLeafComparator<LR>),
TermVal(TermValLeafComparator<Binary<LR>>),
TermOrdVal(TermOrdValLeafComparator<LR>),
XYPointDistance(XYPointDistanceLeafComparator<SortedNumeric<LR>>),
}
impl<LR> LeafFieldComparator for LeafFieldComparatorEnum<LR>
where
LR: LeafReader,
{
type FieldComparator = FieldComparatorEnum;
fn set_bottom(&mut self, slot: usize, comparator: &mut Self::FieldComparator) -> Result<()> {
match (self, comparator) {
(Self::Relevance(comparator), FieldComparatorEnum::Relevance(c)) => {
comparator.set_bottom(slot, c)
},
(Self::Doc(comparator), FieldComparatorEnum::Doc(c)) => comparator.set_bottom(slot, c),
(Self::Double(comparator), FieldComparatorEnum::Double(c)) => comparator.set_bottom(slot, c),
(Self::Double(comparator), FieldComparatorEnum::SortedNumericDouble(c)) => {
comparator.set_bottom(slot, &mut c.base)
},
(Self::Float(comparator), FieldComparatorEnum::Float(c)) => comparator.set_bottom(slot, c),
(Self::Float(comparator), FieldComparatorEnum::SortedNumericFloat(c)) => {
comparator.set_bottom(slot, &mut c.base)
},
(Self::Int(comparator), FieldComparatorEnum::Int(c)) => comparator.set_bottom(slot, c),
(Self::Int(comparator), FieldComparatorEnum::SortedNumericInt(c)) => {
comparator.set_bottom(slot, &mut c.base)
},
(Self::Long(comparator), FieldComparatorEnum::Long(c)) => comparator.set_bottom(slot, c),
(Self::Long(comparator), FieldComparatorEnum::SortedNumericLong(c)) => {
comparator.set_bottom(slot, &mut c.base)
},
(Self::TermVal(comparator), FieldComparatorEnum::TermVal(c)) => {
comparator.set_bottom(slot, c)
},
(Self::TermOrdVal(comparator), FieldComparatorEnum::TermOrdValue(c)) => {
comparator.set_bottom(slot, c)
},
(Self::TermOrdVal(comparator), FieldComparatorEnum::SortedDocValuesTermOrdVal(c)) => {
comparator.set_bottom(slot, &mut c.base)
},
(Self::LatLonPointDistance(comparator), FieldComparatorEnum::LatLonPointDistance(c)) => {
comparator.set_bottom(slot, c)
},
(Self::XYPointDistance(comparator), FieldComparatorEnum::XYPointDistance(c)) => {
comparator.set_bottom(slot, c)
},
_ => Err(LuceneError::illegal_state("Mismatched comparator types")),
}
}
fn compare_bottom<S>(
&mut self,
doc: i32,
scorer: &mut S,
comparator: &mut Self::FieldComparator,
) -> Result<i32>
where
S: Scorable + ?Sized,
{
match (self, comparator) {
(Self::Relevance(comparator), FieldComparatorEnum::Relevance(c)) => {
comparator.compare_bottom(doc, scorer, c)
},
(Self::Doc(comparator), FieldComparatorEnum::Doc(c)) => {
comparator.compare_bottom(doc, scorer, c)
},
(Self::Double(comparator), FieldComparatorEnum::Double(c)) => {
comparator.compare_bottom(doc, scorer, c)
},
(Self::Double(comparator), FieldComparatorEnum::SortedNumericDouble(c)) => {
comparator.compare_bottom(doc, scorer, &mut c.base)
},
(Self::Float(comparator), FieldComparatorEnum::Float(c)) => {
comparator.compare_bottom(doc, scorer, c)
},
(Self::Float(comparator), FieldComparatorEnum::SortedNumericFloat(c)) => {
comparator.compare_bottom(doc, scorer, &mut c.base)
},
(Self::Int(comparator), FieldComparatorEnum::Int(c)) => {
comparator.compare_bottom(doc, scorer, c)
},
(Self::Int(comparator), FieldComparatorEnum::SortedNumericInt(c)) => {
comparator.compare_bottom(doc, scorer, &mut c.base)
},
(Self::Long(comparator), FieldComparatorEnum::Long(c)) => {
comparator.compare_bottom(doc, scorer, c)
},
(Self::Long(comparator), FieldComparatorEnum::SortedNumericLong(c)) => {
comparator.compare_bottom(doc, scorer, &mut c.base)
},
(Self::TermVal(comparator), FieldComparatorEnum::TermVal(c)) => {
comparator.compare_bottom(doc, scorer, c)
},
(Self::TermOrdVal(comparator), FieldComparatorEnum::TermOrdValue(c)) => {
comparator.compare_bottom(doc, scorer, c)
},
(Self::TermOrdVal(comparator), FieldComparatorEnum::SortedDocValuesTermOrdVal(c)) => {
comparator.compare_bottom(doc, scorer, &mut c.base)
},
(Self::LatLonPointDistance(comparator), FieldComparatorEnum::LatLonPointDistance(c)) => {
comparator.compare_bottom(doc, scorer, c)
},
(Self::XYPointDistance(comparator), FieldComparatorEnum::XYPointDistance(c)) => {
comparator.compare_bottom(doc, scorer, c)
},
_ => Err(LuceneError::illegal_state("Mismatched comparator types")),
}
}
fn compare_top<S>(
&mut self,
doc: i32,
scorer: &mut S,
comparator: &mut Self::FieldComparator,
) -> Result<i32>
where
S: Scorable + ?Sized,
{
match (self, comparator) {
(Self::Relevance(comparator), FieldComparatorEnum::Relevance(c)) => {
comparator.compare_top(doc, scorer, c)
},
(Self::Doc(comparator), FieldComparatorEnum::Doc(c)) => {
comparator.compare_top(doc, scorer, c)
},
(Self::Double(comparator), FieldComparatorEnum::Double(c)) => {
comparator.compare_top(doc, scorer, c)
},
(Self::Double(comparator), FieldComparatorEnum::SortedNumericDouble(c)) => {
comparator.compare_top(doc, scorer, &mut c.base)
},
(Self::Float(comparator), FieldComparatorEnum::Float(c)) => {
comparator.compare_top(doc, scorer, c)
},
(Self::Float(comparator), FieldComparatorEnum::SortedNumericFloat(c)) => {
comparator.compare_top(doc, scorer, &mut c.base)
},
(Self::Int(comparator), FieldComparatorEnum::Int(c)) => {
comparator.compare_top(doc, scorer, c)
},
(Self::Int(comparator), FieldComparatorEnum::SortedNumericInt(c)) => {
comparator.compare_top(doc, scorer, &mut c.base)
},
(Self::Long(comparator), FieldComparatorEnum::Long(c)) => {
comparator.compare_top(doc, scorer, c)
},
(Self::Long(comparator), FieldComparatorEnum::SortedNumericLong(c)) => {
comparator.compare_top(doc, scorer, &mut c.base)
},
(Self::TermVal(comparator), FieldComparatorEnum::TermVal(c)) => {
comparator.compare_top(doc, scorer, c)
},
(Self::TermOrdVal(comparator), FieldComparatorEnum::TermOrdValue(c)) => {
comparator.compare_top(doc, scorer, c)
},
(Self::TermOrdVal(comparator), FieldComparatorEnum::SortedDocValuesTermOrdVal(c)) => {
comparator.compare_top(doc, scorer, &mut c.base)
},
(Self::LatLonPointDistance(comparator), FieldComparatorEnum::LatLonPointDistance(c)) => {
comparator.compare_top(doc, scorer, c)
},
(Self::XYPointDistance(comparator), FieldComparatorEnum::XYPointDistance(c)) => {
comparator.compare_top(doc, scorer, c)
},
_ => Err(LuceneError::illegal_state("Mismatched comparator types")),
}
}
fn copy<S>(
&mut self,
slot: usize,
doc: i32,
scorer: &mut S,
comparator: &mut Self::FieldComparator,
) -> Result<()>
where
S: Scorable + ?Sized,
{
match (self, comparator) {
(Self::Relevance(comparator), FieldComparatorEnum::Relevance(c)) => {
comparator.copy(slot, doc, scorer, c)
},
(Self::Doc(comparator), FieldComparatorEnum::Doc(c)) => comparator.copy(slot, doc, scorer, c),
(Self::Double(comparator), FieldComparatorEnum::Double(c)) => {
comparator.copy(slot, doc, scorer, c)
},
(Self::Double(comparator), FieldComparatorEnum::SortedNumericDouble(c)) => {
comparator.copy(slot, doc, scorer, &mut c.base)
},
(Self::Float(comparator), FieldComparatorEnum::Float(c)) => {
comparator.copy(slot, doc, scorer, c)
},
(Self::Float(comparator), FieldComparatorEnum::SortedNumericFloat(c)) => {
comparator.copy(slot, doc, scorer, &mut c.base)
},
(Self::Int(comparator), FieldComparatorEnum::Int(c)) => comparator.copy(slot, doc, scorer, c),
(Self::Int(comparator), FieldComparatorEnum::SortedNumericInt(c)) => {
comparator.copy(slot, doc, scorer, &mut c.base)
},
(Self::Long(comparator), FieldComparatorEnum::Long(c)) => {
comparator.copy(slot, doc, scorer, c)
},
(Self::Long(comparator), FieldComparatorEnum::SortedNumericLong(c)) => {
comparator.copy(slot, doc, scorer, &mut c.base)
},
(Self::TermVal(comparator), FieldComparatorEnum::TermVal(c)) => {
comparator.copy(slot, doc, scorer, c)
},
(Self::TermOrdVal(comparator), FieldComparatorEnum::TermOrdValue(c)) => {
comparator.copy(slot, doc, scorer, c)
},
(Self::TermOrdVal(comparator), FieldComparatorEnum::SortedDocValuesTermOrdVal(c)) => {
comparator.copy(slot, doc, scorer, &mut c.base)
},
(Self::LatLonPointDistance(comparator), FieldComparatorEnum::LatLonPointDistance(c)) => {
comparator.copy(slot, doc, scorer, c)
},
(Self::XYPointDistance(comparator), FieldComparatorEnum::XYPointDistance(c)) => {
comparator.copy(slot, doc, scorer, c)
},
_ => Err(LuceneError::illegal_state("Mismatched comparator types")),
}
}
fn set_scorer<S>(&mut self, scorer: &mut S, comparator: &mut Self::FieldComparator) -> Result<()>
where
S: Scorable + ?Sized,
{
match (self, comparator) {
(Self::Relevance(comparator), FieldComparatorEnum::Relevance(c)) => {
comparator.set_scorer(scorer, c)
},
(Self::Doc(comparator), FieldComparatorEnum::Doc(c)) => comparator.set_scorer(scorer, c),
(Self::Double(comparator), FieldComparatorEnum::Double(c)) => {
comparator.set_scorer(scorer, c)
},
(Self::Double(comparator), FieldComparatorEnum::SortedNumericDouble(c)) => {
comparator.set_scorer(scorer, &mut c.base)
},
(Self::Float(comparator), FieldComparatorEnum::Float(c)) => comparator.set_scorer(scorer, c),
(Self::Float(comparator), FieldComparatorEnum::SortedNumericFloat(c)) => {
comparator.set_scorer(scorer, &mut c.base)
},
(Self::Int(comparator), FieldComparatorEnum::Int(c)) => comparator.set_scorer(scorer, c),
(Self::Int(comparator), FieldComparatorEnum::SortedNumericInt(c)) => {
comparator.set_scorer(scorer, &mut c.base)
},
(Self::Long(comparator), FieldComparatorEnum::Long(c)) => comparator.set_scorer(scorer, c),
(Self::Long(comparator), FieldComparatorEnum::SortedNumericLong(c)) => {
comparator.set_scorer(scorer, &mut c.base)
},
(Self::TermVal(comparator), FieldComparatorEnum::TermVal(c)) => {
comparator.set_scorer(scorer, c)
},
(Self::TermOrdVal(comparator), FieldComparatorEnum::TermOrdValue(c)) => {
comparator.set_scorer(scorer, c)
},
(Self::TermOrdVal(comparator), FieldComparatorEnum::SortedDocValuesTermOrdVal(c)) => {
comparator.set_scorer(scorer, &mut c.base)
},
(Self::LatLonPointDistance(comparator), FieldComparatorEnum::LatLonPointDistance(c)) => {
comparator.set_scorer(scorer, c)
},
(Self::XYPointDistance(comparator), FieldComparatorEnum::XYPointDistance(c)) => {
comparator.set_scorer(scorer, c)
},
_ => Err(LuceneError::illegal_state("Mismatched comparator types")),
}
}
type DocIdSetIteratorRef<'a>
= LeafFieldComparatorDocIdSetIteratorRef<'a, LR>
where
LR: 'a;
fn competitive_iterator(
&mut self,
comparator: &mut Self::FieldComparator,
) -> Result<Option<Self::DocIdSetIteratorRef<'_>>> {
match (self, comparator) {
(Self::Relevance(_comparator), FieldComparatorEnum::Relevance(_c)) => Ok(None),
(Self::Doc(comparator), FieldComparatorEnum::Doc(c)) => comparator
.competitive_iterator(c)
.map(|opt| opt.map(DocIdSetIteratorEnum3::A)),
(Self::Double(comparator), FieldComparatorEnum::Double(c)) => comparator
.competitive_iterator(c)
.map(|opt| opt.map(DocIdSetIteratorEnum3::B)),
(Self::Double(comparator), FieldComparatorEnum::SortedNumericDouble(c)) => comparator
.competitive_iterator(&mut c.base)
.map(|opt| opt.map(DocIdSetIteratorEnum3::B)),
(Self::Float(comparator), FieldComparatorEnum::Float(c)) => comparator
.competitive_iterator(c)
.map(|opt| opt.map(DocIdSetIteratorEnum3::B)),
(Self::Float(comparator), FieldComparatorEnum::SortedNumericFloat(c)) => comparator
.competitive_iterator(&mut c.base)
.map(|opt| opt.map(DocIdSetIteratorEnum3::B)),
(Self::Int(comparator), FieldComparatorEnum::Int(c)) => comparator
.competitive_iterator(c)
.map(|opt| opt.map(DocIdSetIteratorEnum3::B)),
(Self::Int(comparator), FieldComparatorEnum::SortedNumericInt(c)) => comparator
.competitive_iterator(&mut c.base)
.map(|opt| opt.map(DocIdSetIteratorEnum3::B)),
(Self::Long(comparator), FieldComparatorEnum::Long(c)) => comparator
.competitive_iterator(c)
.map(|opt| opt.map(DocIdSetIteratorEnum3::B)),
(Self::Long(comparator), FieldComparatorEnum::SortedNumericLong(c)) => comparator
.competitive_iterator(&mut c.base)
.map(|opt| opt.map(DocIdSetIteratorEnum3::B)),
(Self::TermVal(_comparator), FieldComparatorEnum::TermVal(_c)) => Ok(None),
(Self::TermOrdVal(comparator), FieldComparatorEnum::TermOrdValue(c)) => comparator
.competitive_iterator(c)
.map(|opt| opt.map(DocIdSetIteratorEnum3::C)),
(Self::TermOrdVal(comparator), FieldComparatorEnum::SortedDocValuesTermOrdVal(c)) => {
comparator
.competitive_iterator(&mut c.base)
.map(|opt| opt.map(DocIdSetIteratorEnum3::C))
},
(Self::LatLonPointDistance(_comparator), FieldComparatorEnum::LatLonPointDistance(_c)) => {
Ok(None)
},
(Self::XYPointDistance(_comparator), FieldComparatorEnum::XYPointDistance(_c)) => Ok(None),
_ => Ok(None),
}
}
fn set_hits_threshold_reached(&mut self, comparator: &mut Self::FieldComparator) -> Result<()> {
match (self, comparator) {
(Self::Relevance(comparator), FieldComparatorEnum::Relevance(c)) => {
comparator.set_hits_threshold_reached(c)
},
(Self::Doc(comparator), FieldComparatorEnum::Doc(c)) => {
comparator.set_hits_threshold_reached(c)
},
(Self::Double(comparator), FieldComparatorEnum::Double(c)) => {
comparator.set_hits_threshold_reached(c)
},
(Self::Double(comparator), FieldComparatorEnum::SortedNumericDouble(c)) => {
comparator.set_hits_threshold_reached(&mut c.base)
},
(Self::Float(comparator), FieldComparatorEnum::Float(c)) => {
comparator.set_hits_threshold_reached(c)
},
(Self::Float(comparator), FieldComparatorEnum::SortedNumericFloat(c)) => {
comparator.set_hits_threshold_reached(&mut c.base)
},
(Self::Int(comparator), FieldComparatorEnum::Int(c)) => {
comparator.set_hits_threshold_reached(c)
},
(Self::Int(comparator), FieldComparatorEnum::SortedNumericInt(c)) => {
comparator.set_hits_threshold_reached(&mut c.base)
},
(Self::Long(comparator), FieldComparatorEnum::Long(c)) => {
comparator.set_hits_threshold_reached(c)
},
(Self::Long(comparator), FieldComparatorEnum::SortedNumericLong(c)) => {
comparator.set_hits_threshold_reached(&mut c.base)
},
(Self::TermVal(comparator), FieldComparatorEnum::TermVal(c)) => {
comparator.set_hits_threshold_reached(c)
},
(Self::TermOrdVal(comparator), FieldComparatorEnum::TermOrdValue(c)) => {
comparator.set_hits_threshold_reached(c)
},
(Self::TermOrdVal(comparator), FieldComparatorEnum::SortedDocValuesTermOrdVal(c)) => {
comparator.set_hits_threshold_reached(&mut c.base)
},
(Self::LatLonPointDistance(comparator), FieldComparatorEnum::LatLonPointDistance(c)) => {
comparator.set_hits_threshold_reached(c)
},
(Self::XYPointDistance(comparator), FieldComparatorEnum::XYPointDistance(c)) => {
comparator.set_hits_threshold_reached(c)
},
_ => Err(LuceneError::illegal_state("Mismatched comparator types")),
}
}
}