use crate::core::codecs::term_vectors_reader::DefaultTermVectorsReader;
use crate::core::index::dummy::dummy_fields::DummyFields;
use crate::core::index::fields::{Fields, FieldsEnum2};
use crate::core::index::terms::{Terms, TermsEnum2};
use crate::core::store::dummy::dummy_index_input::DummyIndexInput;
use crate::core::store::index_input::IndexInput;
use crate::core::util::error::lucene_error::{LuceneError, Result};
pub trait RawTermVectors {
type IndexInput: IndexInput;
fn raw_term_vectors_mut(&mut self) -> Result<&mut DefaultTermVectorsReader<Self::IndexInput>>;
fn raw_term_vectors(&self) -> Result<&DefaultTermVectorsReader<Self::IndexInput>>;
}
pub trait TermVectors: RawTermVectors {
fn prefetch(&mut self, _doc_id: i32) -> Result<()> {
Ok(())
}
type Fields: Fields;
fn get(&mut self, doc: i32) -> Result<Option<Self::Fields>>;
type Terms: Terms;
fn get_field_terms(
&mut self,
doc: i32,
field: &str,
) -> Result<Option<<Self::Fields as Fields>::Terms>>;
fn default_get_field_terms(
&mut self,
doc: i32,
field: &str,
) -> Result<Option<<Self::Fields as Fields>::Terms>> {
match self.get(doc)? {
Some(fields) => fields.terms(field),
None => Ok(None),
}
}
}
#[derive(Default)]
pub struct EmptyTermVectors;
impl RawTermVectors for EmptyTermVectors {
type IndexInput = DummyIndexInput;
fn raw_term_vectors_mut(&mut self) -> Result<&mut DefaultTermVectorsReader<Self::IndexInput>> {
Err(LuceneError::illegal_state(
"raw term vectors reader is not available".to_string(),
))
}
fn raw_term_vectors(&self) -> Result<&DefaultTermVectorsReader<Self::IndexInput>> {
Err(LuceneError::illegal_state(
"raw term vectors reader is not available".to_string(),
))
}
}
impl TermVectors for EmptyTermVectors {
type Fields = DummyFields;
fn get(&mut self, _doc: i32) -> Result<Option<Self::Fields>> {
Ok(None)
}
type Terms = <Self::Fields as Fields>::Terms;
fn get_field_terms(
&mut self,
doc: i32,
field: &str,
) -> Result<Option<<Self::Fields as Fields>::Terms>> {
self.default_get_field_terms(doc, field)
}
}
pub enum OptionalTermVectors<T> {
Empty,
Reader(T),
}
impl<T> RawTermVectors for OptionalTermVectors<T> {
type IndexInput = DummyIndexInput;
fn raw_term_vectors_mut(&mut self) -> Result<&mut DefaultTermVectorsReader<Self::IndexInput>> {
Err(LuceneError::illegal_state(
"raw term vectors reader is not available".to_string(),
))
}
fn raw_term_vectors(&self) -> Result<&DefaultTermVectorsReader<Self::IndexInput>> {
Err(LuceneError::illegal_state(
"raw term vectors reader is not available".to_string(),
))
}
}
impl<T> TermVectors for OptionalTermVectors<T>
where
T: TermVectors,
{
type Fields = T::Fields;
type Terms = <T::Fields as Fields>::Terms;
fn prefetch(&mut self, doc_id: i32) -> Result<()> {
match self {
Self::Empty => Ok(()),
Self::Reader(reader) => reader.prefetch(doc_id),
}
}
fn get(&mut self, doc: i32) -> Result<Option<Self::Fields>> {
match self {
Self::Empty => Ok(None),
Self::Reader(reader) => reader.get(doc),
}
}
fn get_field_terms(
&mut self,
doc: i32,
field: &str,
) -> Result<Option<<Self::Fields as Fields>::Terms>> {
match self {
Self::Empty => Ok(None),
Self::Reader(reader) => reader.get_field_terms(doc, field),
}
}
}
macro_rules! either_term_vectors {
($vis:vis $name:ident => { fe: $fe:ident, te: $te:ident } { $( $Variant:ident : $T:ident ),+ $(,)? }) => {
$vis enum $name<$( $T ),+> {
$( $Variant($T), )+
}
impl<$( $T ),+> TermVectors for $name<$( $T ),+>
where
$( $T: TermVectors ),+
{
type Fields = $fe<$( <$T as TermVectors>::Fields ),+>;
type Terms = $te<$( <<$T as TermVectors>::Fields as Fields>::Terms ),+>;
fn prefetch(&mut self, doc_id: i32) -> Result<()> {
match self {
$( Self::$Variant(inner) => inner.prefetch(doc_id), )+
}
}
fn get(&mut self, doc: i32) -> Result<Option<Self::Fields>> {
match self {
$(
Self::$Variant(inner) => {
let fields = inner.get(doc)?;
Ok(fields.map($fe::$Variant))
}
),+
}
}
fn get_field_terms(
&mut self,
doc: i32,
field: &str,
) -> Result<Option<<Self::Fields as Fields>::Terms>> {
match self {
$(
Self::$Variant(inner) => {
let terms = inner.get_field_terms(doc, field)?;
Ok(terms.map($te::$Variant))
}
),+
}
}
}
};
}
either_term_vectors!(
pub TermVectorsEnum2 => { fe: FieldsEnum2, te: TermsEnum2 } { A: A, B: B }
);
impl<A, B> RawTermVectors for TermVectorsEnum2<A, B> {
type IndexInput = DummyIndexInput;
fn raw_term_vectors_mut(&mut self) -> Result<&mut DefaultTermVectorsReader<Self::IndexInput>> {
Err(LuceneError::illegal_state(
"raw term vectors reader is not available".to_string(),
))
}
fn raw_term_vectors(&self) -> Result<&DefaultTermVectorsReader<Self::IndexInput>> {
Err(LuceneError::illegal_state(
"raw term vectors reader is not available".to_string(),
))
}
}