use crate::core::index::composite_reader_context::CompositeReaderContext;
use crate::core::index::directory_reader::{self, DirectoryReader};
use crate::core::index::index_reader::{
IndexReader, IndexReaderContextKind, IndexReaderContextType,
};
use crate::core::index::index_writer::IndexWriter;
use crate::core::index::standard_directory_reader::StandardDirectoryReader;
use crate::core::search::index_searcher::IndexSearcher;
use crate::core::search::reference_manager::{
ReferenceManager, ReferenceManagerBase, RefreshListenerArc,
};
use crate::core::search::searcher_factory::SearcherFactory;
use crate::core::store::directory::Directory;
use crate::core::util::close::{Closeable, CloseableRef};
use crate::core::util::error::lucene_error::{LuceneError, Result};
use std::panic::{AssertUnwindSafe, catch_unwind};
use std::sync::Arc;
type ManagedSearcher<DR> = IndexSearcher<CompositeReaderContext<Arc<DR>>>;
struct SearcherManagerBase<DR> {
searcher_factory: SearcherFactory<DR>,
}
pub struct SearcherManager<DR>
where
DR: DirectoryReader<DirectoryReader = DR> + 'static,
DR::ContextKind: IndexReaderContextKind<Arc<DR>, Context = CompositeReaderContext<Arc<DR>>>,
CompositeReaderContext<Arc<DR>>: Sync + 'static,
{
reference_manager: ReferenceManager<ManagedSearcher<DR>, SearcherManagerBase<DR>>,
}
impl<D> SearcherManager<StandardDirectoryReader<D>>
where
D: Directory + 'static,
{
pub fn from_writer(
writer: &Arc<IndexWriter<D>>,
searcher_factory: Option<SearcherFactory<StandardDirectoryReader<D>>>,
) -> Result<Self> {
Self::with_writer_deletes(writer, true, false, searcher_factory)
}
pub fn with_writer_deletes(
writer: &Arc<IndexWriter<D>>,
apply_all_deletes: bool,
write_all_deletes: bool,
searcher_factory: Option<SearcherFactory<StandardDirectoryReader<D>>>,
) -> Result<Self> {
let searcher_factory = searcher_factory.unwrap_or_default();
let current = get_searcher(
&searcher_factory,
Arc::new(directory_reader::open_with_writer_deletes(
writer,
apply_all_deletes,
write_all_deletes,
)?),
None,
)?;
Ok(Self {
reference_manager: ReferenceManager::new(current, SearcherManagerBase { searcher_factory }),
})
}
pub fn from_directory(
directory: Arc<D>,
searcher_factory: Option<SearcherFactory<StandardDirectoryReader<D>>>,
) -> Result<Self> {
let searcher_factory = searcher_factory.unwrap_or_default();
let current = get_searcher(
&searcher_factory,
Arc::new(directory_reader::open_with_sorter(directory, None)?),
None,
)?;
Ok(Self {
reference_manager: ReferenceManager::new(current, SearcherManagerBase { searcher_factory }),
})
}
}
impl<DR> SearcherManager<DR>
where
DR: DirectoryReader<DirectoryReader = DR> + 'static,
DR::ContextKind: IndexReaderContextKind<Arc<DR>, Context = CompositeReaderContext<Arc<DR>>>,
CompositeReaderContext<Arc<DR>>: Sync + 'static,
{
pub fn new(reader: DR, searcher_factory: Option<SearcherFactory<DR>>) -> Result<Self> {
let searcher_factory = searcher_factory.unwrap_or_default();
let current = get_searcher(&searcher_factory, Arc::new(reader), None)?;
Ok(Self {
reference_manager: ReferenceManager::new(current, SearcherManagerBase { searcher_factory }),
})
}
}
impl<DR> ReferenceManagerBase<ManagedSearcher<DR>> for SearcherManagerBase<DR>
where
DR: DirectoryReader<DirectoryReader = DR> + 'static,
DR::ContextKind: IndexReaderContextKind<Arc<DR>, Context = CompositeReaderContext<Arc<DR>>>,
CompositeReaderContext<Arc<DR>>: Sync + 'static,
{
fn dec_ref(&self, reference: &ManagedSearcher<DR>) -> Result<()> {
reference.get_index_reader().dec_ref()
}
fn refresh_if_needed(
&self,
reference_to_refresh: &ManagedSearcher<DR>,
) -> Result<Option<ManagedSearcher<DR>>> {
let reader = reference_to_refresh.get_index_reader();
let Some(new_reader) = directory_reader::open_if_changed(reader.as_ref())? else {
return Ok(None);
};
get_searcher(&self.searcher_factory, Arc::new(new_reader), Some(reader)).map(Some)
}
fn try_inc_ref(&self, reference: &ManagedSearcher<DR>) -> Result<bool> {
Ok(reference.get_index_reader().try_inc_ref())
}
fn get_ref_count(&self, reference: &ManagedSearcher<DR>) -> i32 {
reference.get_index_reader().get_ref_count()
}
}
impl<DR> SearcherManager<DR>
where
DR: DirectoryReader<DirectoryReader = DR> + 'static,
DR::ContextKind: IndexReaderContextKind<Arc<DR>, Context = CompositeReaderContext<Arc<DR>>>,
CompositeReaderContext<Arc<DR>>: Sync + 'static,
{
pub fn is_searcher_current(&self) -> Result<bool> {
let searcher = self.acquire()?;
let current_result = catch_unwind(AssertUnwindSafe(|| {
searcher.get_index_reader().is_current()
}));
self.release(searcher)?;
unwrap_caught_result!(current_result)
}
pub fn acquire(&self) -> Result<Arc<ManagedSearcher<DR>>> {
self.reference_manager.acquire()
}
pub fn close(&self) -> Result<()> {
self.reference_manager.close()
}
pub fn maybe_refresh(&self) -> Result<bool> {
self.reference_manager.maybe_refresh()
}
pub fn maybe_refresh_blocking(&self) -> Result<()> {
self.reference_manager.maybe_refresh_blocking()
}
pub fn release(&self, reference: Arc<ManagedSearcher<DR>>) -> Result<()> {
self.reference_manager.release(reference)
}
pub fn add_listener(&self, listener: RefreshListenerArc) {
self.reference_manager.add_listener(listener);
}
pub fn remove_listener(&self, listener: &RefreshListenerArc) {
self.reference_manager.remove_listener(listener);
}
}
pub fn get_searcher<IR>(
searcher_factory: &SearcherFactory<IR>,
reader: Arc<IR>,
previous_reader: Option<&Arc<IR>>,
) -> Result<IndexSearcher<IndexReaderContextType<Arc<IR>>>>
where
IR: IndexReader + 'static,
IR::ContextKind: IndexReaderContextKind<Arc<IR>>,
IndexReaderContextType<Arc<IR>>: Sync + 'static,
{
let reader_to_check = reader.clone();
let mut success = false;
let searcher_result = catch_unwind(AssertUnwindSafe(|| -> Result<_> {
let searcher = searcher_factory.new_searcher(reader, previous_reader)?;
if !Arc::ptr_eq(searcher.get_index_reader(), &reader_to_check) {
return Err(LuceneError::illegal_state(format!(
"SearcherFactory must wrap exactly the provided reader (got {} but expected {})",
searcher.get_index_reader(),
reader_to_check
)));
}
success = true;
Ok(searcher)
}));
if !success {
reader_to_check.dec_ref()?;
}
unwrap_caught_result!(searcher_result)
}
impl<DR> Closeable for SearcherManager<DR>
where
DR: DirectoryReader<DirectoryReader = DR> + 'static,
DR::ContextKind: IndexReaderContextKind<Arc<DR>, Context = CompositeReaderContext<Arc<DR>>>,
CompositeReaderContext<Arc<DR>>: Sync + 'static,
{
fn close(&mut self) -> Result<()> {
SearcherManager::close(self)
}
}
impl<DR> CloseableRef for SearcherManager<DR>
where
DR: DirectoryReader<DirectoryReader = DR> + 'static,
DR::ContextKind: IndexReaderContextKind<Arc<DR>, Context = CompositeReaderContext<Arc<DR>>>,
CompositeReaderContext<Arc<DR>>: Sync + 'static,
{
fn close(&self) -> Result<()> {
SearcherManager::close(self)
}
}