use crate::core::index::field_invert_state::FieldInvertState;
use crate::core::index::index_options::IndexOptions;
use crate::core::search::collection_statistics::CollectionStatistics;
use crate::core::search::explanation::Explanation;
use crate::core::search::term_statistics::TermStatistics;
use crate::core::util::error::lucene_error::{LuceneError, Result};
use crate::core::util::small_float::SmallFloat;
use std::fmt::Display;
use std::sync::Arc;
pub trait Similarity: Display + Send + Sync + 'static {
fn get_discount_overlaps(&self) -> bool {
true
}
fn compute_norm(&self, state: &FieldInvertState) -> Result<i64> {
let num_terms = if state.get_index_options() == IndexOptions::Docs {
state.get_unique_term_count()
} else if self.get_discount_overlaps() {
state.get_length() - state.num_overlap()
} else {
state.get_length()
};
Ok(SmallFloat::int_to_byte4(num_terms)? as i8 as i64)
}
type SimScorer: SimScorer + Send + Sync + 'static;
fn scorer(
&self,
boost: f32,
collection_stats: &CollectionStatistics,
term_stats: &[TermStatistics],
) -> Result<Self::SimScorer>;
}
pub type DynSimScorer = dyn SimScorer + Send + Sync;
pub type BoxSimScorer = Box<DynSimScorer>;
pub type SimilaritySimScorer<
SIM = crate::core::search::similarities_impl::bm25_similarity::BM25Similarity,
> = <SIM as Similarity>::SimScorer;
impl<T: ?Sized + Similarity> Similarity for Box<T> {
fn get_discount_overlaps(&self) -> bool {
(**self).get_discount_overlaps()
}
fn compute_norm(&self, state: &FieldInvertState) -> Result<i64> {
(**self).compute_norm(state)
}
type SimScorer = T::SimScorer;
fn scorer(
&self,
boost: f32,
collection_stats: &CollectionStatistics,
term_stats: &[TermStatistics],
) -> Result<Self::SimScorer> {
(**self).scorer(boost, collection_stats, term_stats)
}
}
pub trait SimScorer {
fn score(&self, freq: f32, norm: i64) -> f32;
fn explain(&self, freq: Explanation, norm: i64) -> Result<Explanation> {
let freq_value = freq.get_value().to_f32().ok_or_else(|| {
LuceneError::illegal_argument(format!("cannot convert to f32: {}", freq.get_value()))
})?;
let value = self.score(freq_value, norm);
let description = format!("score(freq={}), with freq of:", freq.get_value());
Ok(Explanation::match_no_details(value, description))
}
}
impl<T> SimScorer for Arc<T>
where
T: SimScorer,
{
fn score(&self, freq: f32, norm: i64) -> f32 {
(**self).score(freq, norm)
}
fn explain(&self, freq: Explanation, norm: i64) -> Result<Explanation> {
(**self).explain(freq, norm)
}
}
impl<T> SimScorer for &T
where
T: SimScorer,
{
fn score(&self, freq: f32, norm: i64) -> f32 {
(**self).score(freq, norm)
}
fn explain(&self, freq: Explanation, norm: i64) -> Result<Explanation> {
(**self).explain(freq, norm)
}
}
macro_rules! either_sim_scorer {
($vis:vis $name:ident { $( $Variant:ident : $T:ident ),+ $(,)? }) => {
$vis enum $name<$( $T ),+> {
$( $Variant($T), )+
}
impl<$( $T ),+> SimScorer for $name<$( $T ),+>
where
$( $T: SimScorer ),+
{
fn score(&self, freq: f32, norm: i64) -> f32 {
match self {
$( Self::$Variant(inner) => inner.score(freq, norm), )+
}
}
fn explain(&self, freq: Explanation, norm: i64) -> Result<Explanation> {
match self {
$( Self::$Variant(inner) => inner.explain(freq, norm), )+
}
}
}
};
}
either_sim_scorer!(pub SimScorerEnum2 { A: A, B: B});
impl<T> Similarity for Arc<T>
where
T: Similarity,
{
fn get_discount_overlaps(&self) -> bool {
(**self).get_discount_overlaps()
}
fn compute_norm(&self, state: &FieldInvertState) -> Result<i64> {
(**self).compute_norm(state)
}
type SimScorer = T::SimScorer;
fn scorer(
&self,
boost: f32,
collection_stats: &CollectionStatistics,
term_stats: &[TermStatistics],
) -> Result<Self::SimScorer> {
(**self).scorer(boost, collection_stats, term_stats)
}
}
impl<T> Similarity for &'static T
where
T: Similarity,
{
fn get_discount_overlaps(&self) -> bool {
(**self).get_discount_overlaps()
}
fn compute_norm(&self, state: &FieldInvertState) -> Result<i64> {
(**self).compute_norm(state)
}
type SimScorer = T::SimScorer;
fn scorer(
&self,
boost: f32,
collection_stats: &CollectionStatistics,
term_stats: &[TermStatistics],
) -> Result<Self::SimScorer> {
(**self).scorer(boost, collection_stats, term_stats)
}
}
impl<T: ?Sized + SimScorer> SimScorer for Box<T> {
fn score(&self, freq: f32, norm: i64) -> f32 {
(**self).score(freq, norm)
}
fn explain(&self, freq: Explanation, norm: i64) -> Result<Explanation> {
(**self).explain(freq, norm)
}
}