use crate::analysis::common::analysis_impl::core::whitespace_analyzer::WhitespaceAnalyzerTS;
use crate::core::analysis::dummy::dummy_token_stream::DummyTokenStream;
use crate::core::analysis::lower_case_filter::LowerCaseFilter;
use crate::core::analysis::reader::ReaderEnum;
use crate::core::analysis::standard::standard_analyzer::StandardAnalyzerTS;
use crate::core::analysis::token_attributes::packed_token_attribute_impl::PackedTokenAttributeImpl;
use crate::core::util::attribute_source::{AttributeSource, Attributes};
use crate::core::util::close::Closeable;
use crate::core::util::error::lucene_error::{LuceneError, Result};
use crate::impl_from_for_enum;
use std::cell::RefMut;
pub trait TokenStream: Closeable {
fn increment_token(&mut self) -> Result<bool> {
Err(LuceneError::unsupported_operation(
"must be implemented by sub",
))
}
fn end(&mut self) -> Result<()>;
fn default_end(&mut self) -> Result<()> {
self.get_attribute_source_mut().end_attributes();
Ok(())
}
fn reset(&mut self) -> Result<()> {
Ok(())
}
fn default_reset(&mut self) -> Result<()> {
Ok(())
}
fn get_attribute_source(&self) -> &Attributes;
fn get_attribute_source_mut(&mut self) -> &mut Attributes;
fn set_reader(&mut self, _input: ReaderEnum) -> Result<()> {
Ok(())
}
fn set_reader_test_point(&mut self) -> Result<()> {
Ok(())
}
}
pub struct TokenStreamBase {
pub(crate) att: Attributes,
}
impl TokenStreamBase {
pub fn new(att: Attributes) -> Self {
Self { att }
}
}
pub fn default_attribute() -> Result<Attributes> {
PackedTokenAttributeImpl::new().map(Into::into)
}
#[macro_export]
macro_rules! either_token_stream {
($vis:vis $name:ident { $( $Variant:ident : $T:ident ),+ $(,)? }) => {
$vis enum $name<$( $T ),+> {
$( $Variant($T), )+
}
impl<$( $T ),+> Closeable for $name<$( $T ),+>
where
$( $T: Closeable ),+
{
#[inline]
fn close(&mut self) -> Result<()> {
match self { $( Self::$Variant(inner) => inner.close(), )+ }
}
}
impl<$( $T ),+> TokenStream for $name<$( $T ),+>
where
$( $T: TokenStream ),+
{
#[inline]
fn increment_token(&mut self) -> Result<bool> {
match self { $( Self::$Variant(inner) => inner.increment_token(), )+ }
}
#[inline]
fn end(&mut self) -> Result<()> {
match self { $( Self::$Variant(inner) => inner.end(), )+ }
}
#[inline]
fn default_end(&mut self) -> Result<()> {
match self { $( Self::$Variant(inner) => TokenStream::default_end(inner), )+ }
}
#[inline]
fn reset(&mut self) -> Result<()> {
match self { $( Self::$Variant(inner) => inner.reset(), )+ }
}
#[inline]
fn default_reset(&mut self) -> Result<()> {
match self { $( Self::$Variant(inner) => TokenStream::default_reset(inner), )+ }
}
#[inline]
fn get_attribute_source(&self) -> &Attributes {
match self { $( Self::$Variant(inner) => inner.get_attribute_source(), )+ }
}
#[inline]
fn get_attribute_source_mut(&mut self) -> &mut Attributes {
match self { $( Self::$Variant(inner) => inner.get_attribute_source_mut(), )+ }
}
#[inline]
fn set_reader(&mut self, input: ReaderEnum) -> Result<()> {
match self { $( Self::$Variant(inner) => inner.set_reader(input), )+ }
}
#[inline]
fn set_reader_test_point(&mut self) -> Result<()> {
match self { $( Self::$Variant(inner) => inner.set_reader_test_point(), )+ }
}
}
};
}
either_token_stream!(pub TokenStreamEnum { Whitespace: A, Dummy: B });
either_token_stream!(pub TokenStreamEnum2 { A: A, B: B });
either_token_stream!(pub TokenStreamEnum3 { String: A, LowerCase: B, Custom: C });
either_token_stream!(pub TokenStreamEnum4 { Whitespace: A, Standard: B, Dummy: C, Custom: D });
type CustomAnalyzerTokenStream = Box<dyn TokenStream + Send + Sync>;
pub type AnalyzerTokenStreams = TokenStreamEnum4<
WhitespaceAnalyzerTS,
StandardAnalyzerTS,
DummyTokenStream,
CustomAnalyzerTokenStream,
>;
type NormalizeTokenStreamEnum = TokenStreamEnum3<
crate::core::analysis::analyzer::StringTokenStream,
LowerCaseFilter<Box<NormalizeTokenStream>>,
CustomAnalyzerTokenStream,
>;
pub struct NormalizeTokenStream(NormalizeTokenStreamEnum);
impl_from_for_enum!(
AnalyzerTokenStreams,
WhitespaceAnalyzerTS=> Whitespace,
StandardAnalyzerTS => Standard,
DummyTokenStream => Dummy,
Box<dyn TokenStream + Send + Sync> => Custom,
);
impl From<crate::core::analysis::analyzer::StringTokenStream> for NormalizeTokenStream {
fn from(v: crate::core::analysis::analyzer::StringTokenStream) -> Self {
Self(NormalizeTokenStreamEnum::String(v))
}
}
impl From<LowerCaseFilter<Box<NormalizeTokenStream>>> for NormalizeTokenStream {
fn from(v: LowerCaseFilter<Box<NormalizeTokenStream>>) -> Self {
Self(NormalizeTokenStreamEnum::LowerCase(v))
}
}
impl From<Box<dyn TokenStream + Send + Sync>> for NormalizeTokenStream {
fn from(v: Box<dyn TokenStream + Send + Sync>) -> Self {
Self(NormalizeTokenStreamEnum::Custom(v))
}
}
impl<T> TokenStream for Box<T>
where
T: TokenStream + ?Sized,
{
fn increment_token(&mut self) -> Result<bool> {
(**self).increment_token()
}
fn end(&mut self) -> Result<()> {
(**self).end()
}
fn default_end(&mut self) -> Result<()> {
(**self).default_end()
}
fn reset(&mut self) -> Result<()> {
(**self).reset()
}
fn default_reset(&mut self) -> Result<()> {
(**self).default_reset()
}
fn get_attribute_source(&self) -> &Attributes {
(**self).get_attribute_source()
}
fn get_attribute_source_mut(&mut self) -> &mut Attributes {
(**self).get_attribute_source_mut()
}
fn set_reader(&mut self, input: ReaderEnum) -> Result<()> {
(**self).set_reader(input)
}
fn set_reader_test_point(&mut self) -> Result<()> {
(**self).set_reader_test_point()
}
}
impl Closeable for NormalizeTokenStream {
fn close(&mut self) -> Result<()> {
self.0.close()
}
}
impl TokenStream for NormalizeTokenStream {
fn increment_token(&mut self) -> Result<bool> {
self.0.increment_token()
}
fn end(&mut self) -> Result<()> {
self.0.end()
}
fn default_end(&mut self) -> Result<()> {
self.0.default_end()
}
fn reset(&mut self) -> Result<()> {
self.0.reset()
}
fn default_reset(&mut self) -> Result<()> {
self.0.default_reset()
}
fn get_attribute_source(&self) -> &Attributes {
self.0.get_attribute_source()
}
fn get_attribute_source_mut(&mut self) -> &mut Attributes {
self.0.get_attribute_source_mut()
}
fn set_reader(&mut self, input: ReaderEnum) -> Result<()> {
self.0.set_reader(input)
}
fn set_reader_test_point(&mut self) -> Result<()> {
self.0.set_reader_test_point()
}
}
impl<T> TokenStream for &mut T
where
T: TokenStream,
{
fn increment_token(&mut self) -> Result<bool> {
(**self).increment_token()
}
fn end(&mut self) -> Result<()> {
(**self).end()
}
fn default_end(&mut self) -> Result<()> {
(**self).default_end()
}
fn reset(&mut self) -> Result<()> {
(**self).reset()
}
fn default_reset(&mut self) -> Result<()> {
(**self).default_reset()
}
fn get_attribute_source(&self) -> &Attributes {
(**self).get_attribute_source()
}
fn get_attribute_source_mut(&mut self) -> &mut Attributes {
(**self).get_attribute_source_mut()
}
fn set_reader(&mut self, input: ReaderEnum) -> Result<()> {
(**self).set_reader(input)
}
fn set_reader_test_point(&mut self) -> Result<()> {
(**self).set_reader_test_point()
}
}
impl<T> Closeable for RefMut<'_, T>
where
T: TokenStream,
{
fn close(&mut self) -> Result<()> {
(**self).close()
}
}
impl<T> TokenStream for RefMut<'_, T>
where
T: TokenStream,
{
fn increment_token(&mut self) -> Result<bool> {
(**self).increment_token()
}
fn end(&mut self) -> Result<()> {
(**self).end()
}
fn default_end(&mut self) -> Result<()> {
(**self).default_end()
}
fn reset(&mut self) -> Result<()> {
(**self).reset()
}
fn default_reset(&mut self) -> Result<()> {
(**self).default_reset()
}
fn get_attribute_source(&self) -> &Attributes {
(**self).get_attribute_source()
}
fn get_attribute_source_mut(&mut self) -> &mut Attributes {
(**self).get_attribute_source_mut()
}
fn set_reader(&mut self, input: ReaderEnum) -> Result<()> {
(**self).set_reader(input)
}
fn set_reader_test_point(&mut self) -> Result<()> {
(**self).set_reader_test_point()
}
}