use crate::core::index::term::Term;
use crate::core::search::boolean_clause::Occur;
use crate::core::search::query::QueryRef;
use crate::core::util::automation::byte_run_automaton::ByteRunAutomaton;
use crate::core::util::error::lucene_error::Result;
use std::borrow::Borrow;
use std::collections::HashSet;
pub trait QueryVisitor {
type SubVisitor<'a>: QueryVisitor
where
Self: 'a;
fn consume_terms<T: Borrow<Term>>(&mut self, _query: QueryRef<'_>, _terms: &[T]) -> Result<()> {
Ok(())
}
fn consume_terms_matching<A>(
&mut self,
query: QueryRef<'_>,
_field: &str,
_automaton: A,
) -> Result<()>
where
A: Fn() -> Result<Option<ByteRunAutomaton>>,
{
self.visit_leaf(query) }
fn visit_leaf(&mut self, _query: QueryRef<'_>) -> Result<()> {
Ok(())
}
fn accept_field(&self, _field: &str) -> bool {
true
}
fn get_sub_visitor<'a>(&'a mut self, occur: Occur, parent: QueryRef<'_>) -> Self::SubVisitor<'a>;
fn default_get_sub_visitor<'a>(
&'a mut self,
occur: Occur,
_parent: QueryRef<'_>,
) -> DefaultQueryVisitor<'a, Self> {
if occur == Occur::MustNot {
DefaultQueryVisitor::Empty
} else {
DefaultQueryVisitor::Visitor(self)
}
}
}
pub enum DefaultQueryVisitor<'a, V>
where
V: ?Sized,
{
Visitor(&'a mut V),
Empty,
}
impl<V> QueryVisitor for DefaultQueryVisitor<'_, V>
where
V: QueryVisitor + ?Sized,
{
type SubVisitor<'a>
= DefaultQueryVisitor<'a, V>
where
Self: 'a;
fn consume_terms<T: Borrow<Term>>(&mut self, query: QueryRef<'_>, terms: &[T]) -> Result<()> {
match self {
Self::Visitor(visitor) => visitor.consume_terms(query, terms),
Self::Empty => Ok(()),
}
}
fn consume_terms_matching<S>(
&mut self,
query: QueryRef<'_>,
field: &str,
automaton: S,
) -> Result<()>
where
S: Fn() -> Result<Option<ByteRunAutomaton>>,
{
match self {
Self::Visitor(visitor) => visitor.consume_terms_matching(query, field, automaton),
Self::Empty => Ok(()),
}
}
fn visit_leaf(&mut self, query: QueryRef<'_>) -> Result<()> {
match self {
Self::Visitor(visitor) => visitor.visit_leaf(query),
Self::Empty => Ok(()),
}
}
fn accept_field(&self, field: &str) -> bool {
match self {
Self::Visitor(visitor) => visitor.accept_field(field),
Self::Empty => true,
}
}
fn get_sub_visitor<'a>(
&'a mut self,
occur: Occur,
_parent: QueryRef<'_>,
) -> Self::SubVisitor<'a> {
match self {
Self::Visitor(visitor) if occur != Occur::MustNot => {
DefaultQueryVisitor::Visitor(&mut **visitor)
},
Self::Visitor(_) | Self::Empty => DefaultQueryVisitor::Empty,
}
}
}
impl<V> QueryVisitor for &mut V
where
V: QueryVisitor + ?Sized,
{
type SubVisitor<'a>
= V::SubVisitor<'a>
where
Self: 'a;
fn consume_terms<T: Borrow<Term>>(&mut self, query: QueryRef<'_>, terms: &[T]) -> Result<()> {
(**self).consume_terms(query, terms)
}
fn consume_terms_matching<A>(
&mut self,
query: QueryRef<'_>,
field: &str,
automaton: A,
) -> Result<()>
where
A: Fn() -> Result<Option<ByteRunAutomaton>>,
{
(**self).consume_terms_matching(query, field, automaton)
}
fn visit_leaf(&mut self, query: QueryRef<'_>) -> Result<()> {
(**self).visit_leaf(query)
}
fn accept_field(&self, field: &str) -> bool {
(**self).accept_field(field)
}
fn get_sub_visitor<'a>(&'a mut self, occur: Occur, parent: QueryRef<'_>) -> Self::SubVisitor<'a> {
(**self).get_sub_visitor(occur, parent)
}
}
pub fn term_collector(term_set: &mut HashSet<Term>) -> impl QueryVisitor + use<'_> {
TermCollector::Collector(term_set)
}
enum TermCollector<'a> {
Collector(&'a mut HashSet<Term>),
Empty(EmptyQueryVisitor),
}
impl QueryVisitor for TermCollector<'_> {
type SubVisitor<'a>
= TermCollector<'a>
where
Self: 'a;
fn consume_terms<T: Borrow<Term>>(&mut self, _query: QueryRef<'_>, terms: &[T]) -> Result<()> {
match self {
Self::Collector(term_set) => {
for term in terms {
let term = Borrow::<Term>::borrow(term);
if !term_set.contains(term) {
term_set.insert(term.clone());
}
}
},
Self::Empty(_) => {},
}
Ok(())
}
fn get_sub_visitor<'a>(
&'a mut self,
occur: Occur,
_parent: QueryRef<'_>,
) -> Self::SubVisitor<'a> {
match self {
Self::Collector(term_set) if occur != Occur::MustNot => TermCollector::Collector(term_set),
Self::Collector(_) | Self::Empty(_) => TermCollector::Empty(EMPTY_VISITOR),
}
}
}
#[derive(Clone, Copy, Debug, Default)]
pub struct EmptyQueryVisitor;
impl QueryVisitor for EmptyQueryVisitor {
type SubVisitor<'a>
= EmptyQueryVisitor
where
Self: 'a;
fn get_sub_visitor<'a>(
&'a mut self,
_occur: Occur,
_parent: QueryRef<'_>,
) -> Self::SubVisitor<'a> {
EMPTY_VISITOR
}
}
pub const EMPTY_VISITOR: EmptyQueryVisitor = EmptyQueryVisitor;