use crate::core::analysis::token_stream::TokenStream;
use crate::core::util::attribute_source::AttributeSource;
use crate::core::util::error::lucene_error::{LuceneError, Result};
use crate::sandbox::search::term_automaton_query::TermAutomatonQuery;
pub struct TokenStreamToTermAutomatonQuery {
preserve_position_increments: bool,
}
impl Default for TokenStreamToTermAutomatonQuery {
fn default() -> Self {
Self::new()
}
}
impl TokenStreamToTermAutomatonQuery {
pub fn new() -> Self {
Self {
preserve_position_increments: true,
}
}
pub fn set_preserve_position_increments(&mut self, enable_position_increments: bool) {
self.preserve_position_increments = enable_position_increments;
}
pub fn to_query<TS, F>(&self, field: F, input: &mut TS) -> Result<TermAutomatonQuery>
where
TS: TokenStream,
F: Into<String>,
{
input.reset()?;
let mut query = TermAutomatonQuery::new(field);
let mut pos = -1;
let mut max_offset = 0;
let mut max_pos = -1;
let mut state = -1;
while input.increment_token()? {
let attributes = input.get_attribute_source_mut();
let mut pos_inc = attributes.get_position_increment()?;
if !self.preserve_position_increments && pos_inc > 1 {
pos_inc = 1;
}
debug_assert!(pos > -1 || pos_inc > 0);
if pos_inc > 1 {
return Err(LuceneError::illegal_argument(
"cannot handle holes; to accept any term, use '*' term",
));
}
if pos_inc > 0 {
pos += pos_inc;
}
let end_pos = pos + attributes.get_position_length()?;
while state < end_pos {
state = query.create_state();
}
let end_offset = attributes.end_offset()?;
let term = attributes
.get_bytes_ref()?
.ok_or_else(|| LuceneError::illegal_state("TermToBytesRefAttribute is missing"))?;
if term.length == 1 && term.bytes[term.offset] == b'*' {
query.add_any_transition(pos, end_pos)?;
} else {
query.add_transition_bytes(pos, end_pos, term)?;
}
max_offset = max_offset.max(end_offset);
max_pos = max_pos.max(end_pos);
}
input.end()?;
let _ = max_offset;
let _ = max_pos;
query.set_accept(state, true);
query.finish()?;
Ok(query)
}
}