use crate::core::analysis::analyzer::{Analyzer, AnalyzerText};
use crate::core::analysis::reader::ReaderEnum;
use crate::core::analysis::token_attributes::packed_token_and_binary::BinaryTokenStreamAttributeImpl;
use crate::core::analysis::token_stream::{TokenStream, TokenStreamBase};
use crate::core::codecs::knn_field_vectors_writer::VectorValueEnum;
use crate::core::document::field_type::FieldType;
use crate::core::document::fields::FieldTokenStreamEnum;
use crate::core::document::invertable_field::InvertableType;
use crate::core::index::BinaryValueEnum;
use crate::core::index::BytesRef;
use crate::core::index::doc_values_type::DocValuesType;
use crate::core::index::index_options::IndexOptions;
use crate::core::index::indexable_field::{
IndexableField, IndexingTokenStream, ReusedIndexingTokenStream,
};
use crate::core::index::indexable_field_type::IndexableFieldType;
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::core::util::number::Number;
use crate::{either_token_stream, impl_from_for_enum};
use std::borrow::{Borrow, Cow};
use std::fmt;
use std::fmt::{Debug, Display};
use std::sync::Arc;
pub struct Field<FT = FieldType> {
indexable_field_type: FT,
pub(crate) name: Cow<'static, str>,
pub(crate) fields_data: FieldDataEnum,
}
impl<FT: Borrow<FieldType>> Field<FT> {
pub fn new<T, FD>(name: T, fields_data: FD, indexable_field_type: FT) -> Self
where
T: Into<Cow<'static, str>>,
FD: Into<FieldDataEnum>,
{
Self {
name: match name.into() {
Cow::Owned(name) => Cow::Owned(name.into_boxed_str().into_string()),
name => name,
},
fields_data: match fields_data.into() {
FieldDataEnum::String(text)
if indexable_field_type.borrow().tokenized()
&& *indexable_field_type.borrow().index_options() != IndexOptions::None =>
{
FieldDataEnum::SharedString(Arc::new(text))
},
value => value,
},
indexable_field_type,
}
}
pub fn from_reader<T, R>(name: T, reader: R, indexable_field_type: FT) -> Result<Self>
where
T: Into<Cow<'static, str>>,
R: Into<ReaderEnum>,
{
if indexable_field_type.borrow().stored() {
return Err(LuceneError::illegal_argument(
"fields with a Reader value cannot be stored",
));
}
if !indexable_field_type.borrow().tokenized() {
return Err(LuceneError::illegal_argument(
"non-tokenized fields must use String values",
));
}
Ok(Field {
indexable_field_type,
name: match name.into() {
Cow::Owned(name) => Cow::Owned(name.into_boxed_str().into_string()),
name => name,
},
fields_data: reader.into().into(),
})
}
pub fn from_token_stream<T, V>(name: T, token_stream: V, indexable_field_type: FT) -> Result<Self>
where
T: Into<Cow<'static, str>>,
V: Into<FieldTokenStreamEnum>,
{
if !indexable_field_type.borrow().tokenized()
|| indexable_field_type.borrow().index_options() == &IndexOptions::None
{
return Err(LuceneError::illegal_argument(
"TokenStream fields must be indexed and tokenized",
));
}
if indexable_field_type.borrow().stored() {
return Err(LuceneError::illegal_argument(
"TokenStream fields cannot be stored",
));
}
let ts = token_stream.into();
Ok(Field {
indexable_field_type,
name: match name.into() {
Cow::Owned(name) => Cow::Owned(name.into_boxed_str().into_string()),
name => name,
},
fields_data: ts.into(),
})
}
pub fn from_binary<T, V>(name: T, value: V, indexable_field_type: FT) -> Result<Self>
where
T: Into<Cow<'static, str>>,
V: Into<Vec<u8>>,
{
let value = value.into();
let len = value.len();
Self::from_binary_range(name, value, 0, len, indexable_field_type)
}
pub fn from_binary_range<T, V>(
name: T,
value: V,
offset: usize,
length: usize,
indexable_field_type: FT,
) -> Result<Self>
where
T: Into<Cow<'static, str>>,
V: Into<Vec<u8>>,
{
let value = value.into();
let value = BytesRef::from_slice(value, offset, length);
Self::from_bytes_ref(name, value, indexable_field_type)
}
pub fn from_bytes_ref<T, B>(name: T, bytes: B, indexable_field_type: FT) -> Result<Self>
where
T: Into<Cow<'static, str>>,
B: Into<BytesRef<Vec<u8>>>,
{
if indexable_field_type
.borrow()
.index_options()
.cmp(&IndexOptions::DocsAndFreqsAndPositionsAndOffsets)
!= std::cmp::Ordering::Less
|| indexable_field_type.borrow().store_term_vector_offsets()
{
return Err(LuceneError::illegal_argument(
"It doesn't make sense to index offsets on binary fields",
));
}
if indexable_field_type.borrow().index_options() != &IndexOptions::None
&& indexable_field_type.borrow().tokenized()
{
return Err(LuceneError::illegal_argument(
"cannot set a BytesRef value on a tokenized field",
));
}
if indexable_field_type.borrow().index_options() == &IndexOptions::None
&& indexable_field_type.borrow().point_dimension_count() == 0
&& indexable_field_type.borrow().doc_values_type() == &DocValuesType::None
&& !indexable_field_type.borrow().stored()
{
return Err(LuceneError::illegal_argument(
"it doesn't make sense to have a field that is neither indexed, nor doc-valued, nor stored",
));
}
Ok(Field {
indexable_field_type,
name: match name.into() {
Cow::Owned(name) => Cow::Owned(name.into_boxed_str().into_string()),
name => name,
},
fields_data: FieldDataEnum::Binary(bytes.into()),
})
}
pub fn from_string<'a, T1, T2>(name: T1, value: T2, indexable_field_type: FT) -> Result<Self>
where
T1: Into<Cow<'static, str>>,
T2: Into<Cow<'a, str>>,
{
if !indexable_field_type.borrow().stored()
&& *indexable_field_type.borrow().index_options() == IndexOptions::None
{
return Err(LuceneError::illegal_argument(
"it doesn't make sense to have a field that is neither indexed nor stored",
));
}
let shared_text = indexable_field_type.borrow().tokenized()
&& *indexable_field_type.borrow().index_options() != IndexOptions::None;
Ok(Field {
indexable_field_type,
name: match name.into() {
Cow::Owned(name) => Cow::Owned(name.into_boxed_str().into_string()),
name => name,
},
fields_data: if shared_text {
match value.into() {
Cow::Borrowed(text) => FieldDataEnum::SharedText(Arc::from(text)),
Cow::Owned(text) => FieldDataEnum::SharedString(Arc::new(text)),
}
} else {
FieldDataEnum::String(value.into().into_owned())
},
})
}
pub fn token_stream_value(&mut self) -> Result<Option<&mut FieldTokenStreamEnum>> {
match self.fields_data {
FieldDataEnum::TokenStream(ref mut token_stream) => Ok(Some(token_stream)),
_ => Ok(None),
}
}
pub fn set_string_value<'a, T>(&mut self, value: T) -> Result<()>
where
T: Into<Cow<'a, str>>,
{
match &mut self.fields_data {
FieldDataEnum::String(current) => match value.into() {
Cow::Borrowed(value) => value.clone_into(current),
Cow::Owned(value) => *current = value,
},
FieldDataEnum::SharedText(_) => {
let value = value.into();
self.fields_data = FieldDataEnum::SharedString(Arc::new(value.into_owned()));
},
FieldDataEnum::SharedString(current) => {
let value = value.into();
if let Some(current) = Arc::get_mut(current) {
match value {
Cow::Borrowed(value) => value.clone_into(current),
Cow::Owned(value) => *current = value,
}
} else {
*current = Arc::new(value.into_owned());
}
},
_ => {
return Err(LuceneError::illegal_argument(format!(
"cannot change value type from {:?} to String",
self.fields_data
)));
},
}
Ok(())
}
pub fn set_reader_value<R>(&mut self, value: R) -> Result<()>
where
R: Into<ReaderEnum>,
{
match &self.fields_data {
FieldDataEnum::Reader(_) => {},
_ => {
return Err(LuceneError::illegal_argument(format!(
"cannot change value type from {:?} to Reader",
self.fields_data
)));
},
}
self.fields_data = FieldDataEnum::Reader(value.into());
Ok(())
}
pub fn set_vec_value<V>(&mut self, value: V) -> Result<()>
where
V: Into<Vec<u8>>,
{
self.set_bytes_value(BytesRef::from_bytes(value.into()))
}
pub fn set_bytes_value<'a, B>(&mut self, value: B) -> Result<()>
where
B: Into<BinaryValueEnum<'a>>,
{
match &mut self.fields_data {
FieldDataEnum::Binary(current) => match value.into() {
BinaryValueEnum::Owned(value) => *current = value,
BinaryValueEnum::Borrowed(value) => {
current.copy_from_slice(&value.bytes);
current.offset = value.offset;
current.length = value.length;
},
BinaryValueEnum::Slice(value) => {
current.copy_from_slice(value.bytes);
current.offset = value.offset;
current.length = value.length;
},
BinaryValueEnum::Inline { bytes, length } => {
current.copy_from_slice(&bytes[..length]);
},
},
_ => {
return Err(LuceneError::illegal_argument(format!(
"cannot change value type from {:?} to BytesRef",
self.fields_data
)));
},
}
Ok(())
}
pub fn set_byte_value(&mut self, value: u8) -> Result<()> {
match &self.fields_data {
FieldDataEnum::Number(Number::U8(_)) => {},
_ => {
return Err(LuceneError::illegal_argument(format!(
"cannot change value type from {:?} to Byte",
self.fields_data
)));
},
}
self.fields_data = value.into();
Ok(())
}
pub fn set_short_value(&mut self, value: i16) -> Result<()> {
match &self.fields_data {
FieldDataEnum::Number(Number::I16(_)) => {},
_ => {
return Err(LuceneError::illegal_argument(format!(
"cannot change value type from {:?} to Short",
self.fields_data
)));
},
}
self.fields_data = FieldDataEnum::Number(Number::I16(value));
Ok(())
}
pub fn set_int_value(&mut self, value: i32) -> Result<()> {
match &self.fields_data {
FieldDataEnum::Number(Number::I32(_)) => {},
_ => {
return Err(LuceneError::illegal_argument(format!(
"cannot change value type from {:?} to Integer",
self.fields_data
)));
},
}
self.fields_data = FieldDataEnum::Number(Number::I32(value));
Ok(())
}
pub fn set_long_value(&mut self, value: i64) -> Result<()> {
match &mut self.fields_data {
FieldDataEnum::Number(Number::I64(current)) => *current = value,
_ => {
return Err(LuceneError::illegal_argument(format!(
"cannot change value type from {:?} to Long",
self.fields_data
)));
},
}
Ok(())
}
pub fn set_float_value(&mut self, value: f32) -> Result<()> {
match &self.fields_data {
FieldDataEnum::Number(Number::F32(_)) => {},
_ => {
return Err(LuceneError::illegal_argument(format!(
"cannot change value type from {:?} to Float",
self.fields_data
)));
},
}
self.fields_data = FieldDataEnum::Number(Number::F32(value));
Ok(())
}
pub fn set_double_value(&mut self, value: f64) -> Result<()> {
match &self.fields_data {
FieldDataEnum::Number(Number::F64(_)) => {},
_ => {
return Err(LuceneError::illegal_argument(format!(
"cannot change value type from {:?} to Double",
self.fields_data
)));
},
}
self.fields_data = FieldDataEnum::Number(Number::F64(value));
Ok(())
}
pub fn set_token_stream<S>(&mut self, token_stream: S) -> Result<()>
where
S: Into<FieldTokenStreamEnum>,
{
match &self.fields_data {
FieldDataEnum::TokenStream(_) => {},
_ => {
return Err(LuceneError::illegal_argument(format!(
"cannot change value type from {:?} to TokenStream",
self.fields_data
)));
},
}
self.fields_data = FieldDataEnum::TokenStream(token_stream.into());
Ok(())
}
}
impl<FT: Borrow<FieldType>> IndexableField for Field<FT> {
fn name(&self) -> &str {
&self.name
}
type FieldType<'a>
= &'a FieldType
where
Self: 'a;
fn field_type(&self) -> Self::FieldType<'_> {
self.indexable_field_type.borrow()
}
fn token_stream<'a, A>(
&'a mut self,
analyzer: &'a A,
reuse_token_stream: &'a mut Option<ReusedIndexingTokenStream>,
) -> Result<IndexingTokenStream<'a>>
where
A: Analyzer,
{
if *self.field_type().index_options() == IndexOptions::None {
return Ok(None);
}
if !self.field_type().tokenized() {
if let Some(string_value) = self.string_value()? {
if !matches!(
reuse_token_stream.as_ref(),
Some(ReusedIndexingTokenStream::B(_))
) {
*reuse_token_stream = Some(ReusedIndexingTokenStream::B(StringTokenStream::new()));
}
let stream = reuse_token_stream
.as_mut()
.ok_or_else(|| LuceneError::illegal_state("should StringTokenStream here"))?;
match stream {
ReusedIndexingTokenStream::B(s) => s.set_value(string_value.as_ref())?,
ReusedIndexingTokenStream::A(_) => {
return Err(LuceneError::illegal_state("should StringTokenStream here"));
},
}
return Ok(Some(IndexingTokenStreamEnum3::Reused(stream)));
}
if let Some(binary_value) = self.binary_value()?.map(|v| v.into_owned()) {
if !matches!(
reuse_token_stream.as_ref(),
Some(ReusedIndexingTokenStream::A(_))
) {
*reuse_token_stream = Some(ReusedIndexingTokenStream::A(BinaryTokenStream::new()?));
}
let stream = reuse_token_stream
.as_mut()
.ok_or_else(|| LuceneError::illegal_state("should BinaryTokenStream here"))?;
match stream {
ReusedIndexingTokenStream::A(s) => s.set_value(binary_value),
ReusedIndexingTokenStream::B(_) => {
return Err(LuceneError::illegal_state("should BinaryTokenStream here"));
},
}
return Ok(Some(IndexingTokenStreamEnum3::Reused(stream)));
}
debug_assert!(reuse_token_stream.is_none());
}
debug_assert!(reuse_token_stream.is_none());
if let FieldDataEnum::TokenStream(ref mut token_stream) = self.fields_data {
return Ok(Some(IndexingTokenStreamEnum3::FieldTokenStream(
token_stream,
)));
}
if let Some(reader) = self.take_reader_value()? {
Ok(Some(IndexingTokenStreamEnum3::AnalyzerTokenStream(
analyzer.token_stream(self.name(), reader)?,
)))
} else if let FieldDataEnum::SharedText(text) = &self.fields_data {
Ok(Some(IndexingTokenStreamEnum3::AnalyzerTokenStream(
analyzer.token_stream_from_text(self.name(), AnalyzerText::SharedText(Arc::clone(text)))?,
)))
} else if let FieldDataEnum::SharedString(text) = &self.fields_data {
Ok(Some(IndexingTokenStreamEnum3::AnalyzerTokenStream(
analyzer.token_stream_from_text(self.name(), Arc::clone(text).into())?,
)))
} else if let Some(v) = self.string_value()? {
let token_stream = match v {
Cow::Borrowed(text) => analyzer.token_stream_from_text(self.name(), text.into())?,
Cow::Owned(text) => analyzer.token_stream(self.name(), ReaderEnum::from(text))?,
};
Ok(Some(IndexingTokenStreamEnum3::AnalyzerTokenStream(
token_stream,
)))
} else {
Err(LuceneError::illegal_state(format!(
"Field must have either TokenStream, String, Reader or Number value; got {}",
self
)))
}
}
fn binary_value(&self) -> Result<Option<BinaryValueEnum<'_>>> {
if let FieldDataEnum::Binary(bytes) = &self.fields_data {
Ok(Some(BinaryValueEnum::Borrowed(bytes)))
} else {
Ok(None)
}
}
fn take_binary_value(&mut self) -> Result<Option<BytesRef<Vec<u8>>>> {
if !matches!(self.fields_data, FieldDataEnum::Binary(_)) {
return Ok(None);
}
if let FieldDataEnum::Binary(binary) =
std::mem::replace(&mut self.fields_data, FieldDataEnum::Dummy(()))
{
Ok(Some(binary))
} else {
Ok(None)
}
}
fn string_value(&self) -> Result<Option<Cow<'_, str>>> {
match &self.fields_data {
FieldDataEnum::String(s) => Ok(Some(Cow::Borrowed(s))),
FieldDataEnum::SharedString(s) => Ok(Some(Cow::Borrowed(s.as_str()))),
FieldDataEnum::SharedText(s) => Ok(Some(Cow::Borrowed(s))),
FieldDataEnum::Number(n) => Ok(Some(Cow::Owned(n.to_string()))),
_ => Ok(None),
}
}
fn take_string_value(&mut self) -> Result<Option<String>> {
if !matches!(
self.fields_data,
FieldDataEnum::String(_) | FieldDataEnum::SharedString(_) | FieldDataEnum::SharedText(_)
) && !matches!(self.fields_data, FieldDataEnum::Number(_))
{
return Ok(None);
}
match std::mem::replace(&mut self.fields_data, FieldDataEnum::Dummy(())) {
FieldDataEnum::String(s) => Ok(Some(s)),
FieldDataEnum::SharedString(s) => Ok(Some(
Arc::try_unwrap(s).unwrap_or_else(|s| s.as_ref().clone()),
)),
FieldDataEnum::SharedText(s) => Ok(Some(s.to_string())),
FieldDataEnum::Number(n) => Ok(Some(n.to_string())),
_ => Ok(None),
}
}
fn get_char_sequence_value(&self) -> Result<Option<Cow<'_, str>>> {
if let FieldDataEnum::String(s) = &self.fields_data {
Ok(Some(Cow::Borrowed(s)))
} else {
self.string_value()
}
}
fn take_reader_value(&mut self) -> Result<Option<ReaderEnum>> {
if !matches!(self.fields_data, FieldDataEnum::Reader(_)) {
return Ok(None);
}
if let FieldDataEnum::Reader(reader) =
std::mem::replace(&mut self.fields_data, FieldDataEnum::Dummy(()))
{
Ok(Some(reader))
} else {
Ok(None)
}
}
fn numeric_value(&self) -> Result<Option<Number>> {
if let FieldDataEnum::Number(n) = &self.fields_data {
Ok(Some(n.clone()))
} else {
Ok(None)
}
}
type StoredValue<'a>
= &'a FieldDataEnum
where
Self: 'a;
fn stored_value(&self) -> Result<Option<Self::StoredValue<'_>>> {
if !self.indexable_field_type.borrow().stored() {
return Ok(None);
}
match &self.fields_data {
FieldDataEnum::Number(_)
| FieldDataEnum::Binary(_)
| FieldDataEnum::String(_)
| FieldDataEnum::SharedString(_)
| FieldDataEnum::SharedText(_) => Ok(Some(&self.fields_data)),
_ => Err(LuceneError::illegal_state(
"stored field data must be numeric, binary, or a string",
)),
}
}
fn invertable_type(&self) -> &InvertableType {
&InvertableType::TokenStream
}
fn float_vector_value(&self) -> Result<&[f32]> {
if let FieldDataEnum::VectorValue(v) = &self.fields_data {
v.as_floats()
} else {
Err(LuceneError::unsupported_operation(""))
}
}
fn byte_vector_value(&self) -> Result<&[u8]> {
if let FieldDataEnum::VectorValue(v) = &self.fields_data {
v.as_bytes()
} else {
Err(LuceneError::unsupported_operation(""))
}
}
}
impl<FT: Borrow<FieldType>> FieldBase for Field<FT> {}
impl<FT: Borrow<FieldType>> Display for Field<FT> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}<{}:", self.indexable_field_type.borrow(), self.name)?;
write!(f, "{}", self.fields_data)?;
write!(f, ">")
}
}
pub trait FieldBase {
fn set_bytes_value<'a, B>(&mut self, _value: B) -> Result<()>
where
B: Into<BinaryValueEnum<'a>>,
{
Err(LuceneError::not_implemented(
"set_bytes_value not implement",
))
}
fn set_byte_value(&mut self, _value: u8) -> Result<()> {
Err(LuceneError::not_implemented("set_byte_value not implement"))
}
fn set_short_value(&mut self, _value: i16) -> Result<()> {
Err(LuceneError::not_implemented(
"set_short_value not implement",
))
}
fn set_int_value(&mut self, _value: i32) -> Result<()> {
Err(LuceneError::not_implemented("set_int_value not implement"))
}
fn set_long_value(&mut self, _value: i64) -> Result<()> {
Err(LuceneError::not_implemented("set_long_value not implement"))
}
fn set_float_value(&mut self, _value: f32) -> Result<()> {
Err(LuceneError::not_implemented(
"set_float_value not implement",
))
}
fn set_double_value(&mut self, _value: f64) -> Result<()> {
Err(LuceneError::not_implemented(
"set_double_value not implement",
))
}
fn set_token_stream<S>(&mut self, _token_stream: S) -> Result<()>
where
S: Into<FieldTokenStreamEnum>,
{
Err(LuceneError::not_implemented(
"set_token_stream not implement",
))
}
fn set_string_value<'a, T>(&mut self, _value: T) -> Result<()>
where
T: Into<Cow<'a, str>>,
{
Err(LuceneError::not_implemented(
"set_string_value not implement",
))
}
fn set_reader_value<R>(&mut self, _value: R) -> Result<()>
where
R: Into<ReaderEnum>,
{
Err(LuceneError::not_implemented(
"set_reader_value not implement",
))
}
}
pub enum Store {
Yes,
No,
}
impl From<Store> for bool {
fn from(store: Store) -> bool {
matches!(store, Store::Yes)
}
}
pub enum FieldDataEnum {
Number(Number),
Binary(BytesRef<Vec<u8>>),
String(String),
SharedString(Arc<String>),
SharedText(Arc<str>),
Reader(ReaderEnum),
TokenStream(FieldTokenStreamEnum),
Dummy(()),
VectorValue(VectorValueEnum),
}
impl Debug for FieldDataEnum {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Number(v) => f.debug_tuple("Number").field(v).finish(),
Self::Binary(v) => f.debug_tuple("Binary").field(v).finish(),
Self::String(v) => f.debug_tuple("String").field(v).finish(),
Self::SharedString(v) => f.debug_tuple("String").field(v.as_ref()).finish(),
Self::SharedText(v) => f.debug_tuple("String").field(v).finish(),
Self::Reader(v) => f.debug_tuple("Reader").field(v).finish(),
Self::TokenStream(v) => f.debug_tuple("TokenStream").field(v).finish(),
Self::Dummy(v) => f.debug_tuple("Dummy").field(v).finish(),
Self::VectorValue(v) => f.debug_tuple("VectorValue").field(v).finish(),
}
}
}
impl FieldDataEnum {
pub fn try_clone(&self) -> Result<Self> {
match self {
Self::Number(n) => Ok(Self::Number(n.clone())),
Self::Binary(b) => Ok(Self::Binary(b.clone())),
Self::String(s) => Ok(Self::String(s.clone())),
Self::SharedString(s) => Ok(Self::SharedString(Arc::new(s.as_ref().clone()))),
Self::SharedText(s) => Ok(Self::SharedText(Arc::from(s.as_ref()))),
Self::Reader(r) => Ok(Self::Reader(r.clone())),
Self::TokenStream(_) => Err(LuceneError::illegal_state("token stream cannot be cloned")),
Self::Dummy(d) => {
let _: () = *d;
Ok(Self::Dummy(()))
},
Self::VectorValue(v) => Ok(Self::VectorValue(v.clone())),
}
}
}
impl From<i32> for FieldDataEnum {
fn from(v: i32) -> Self {
FieldDataEnum::Number(Number::I32(v))
}
}
impl From<i64> for FieldDataEnum {
fn from(v: i64) -> Self {
FieldDataEnum::Number(Number::I64(v))
}
}
impl From<u8> for FieldDataEnum {
fn from(v: u8) -> Self {
FieldDataEnum::Number(Number::U8(v))
}
}
impl From<i16> for FieldDataEnum {
fn from(v: i16) -> Self {
FieldDataEnum::Number(Number::I16(v))
}
}
impl From<f32> for FieldDataEnum {
fn from(v: f32) -> Self {
FieldDataEnum::Number(Number::F32(v))
}
}
impl From<f64> for FieldDataEnum {
fn from(v: f64) -> Self {
FieldDataEnum::Number(Number::F64(v))
}
}
impl_from_for_enum!(
FieldDataEnum,
BytesRef<Vec<u8>> => Binary,
String => String,
ReaderEnum => Reader,
FieldTokenStreamEnum => TokenStream,
VectorValueEnum => VectorValue,
);
impl From<&str> for FieldDataEnum {
fn from(s: &str) -> Self {
FieldDataEnum::String(s.to_string())
}
}
impl Display for FieldDataEnum {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
FieldDataEnum::Number(n) => write!(f, "{}", n),
FieldDataEnum::Binary(b) => write!(f, "{}", b),
FieldDataEnum::String(s) => write!(f, "{}", s),
FieldDataEnum::SharedString(s) => write!(f, "{}", s),
FieldDataEnum::SharedText(s) => write!(f, "{}", s),
FieldDataEnum::Reader(r) => write!(f, "{:?}", r),
FieldDataEnum::TokenStream(t) => write!(f, "{:?}", t),
FieldDataEnum::Dummy(s) => write!(f, "{:?}", s),
FieldDataEnum::VectorValue(v) => write!(f, "{:?}", v),
}
}
}
pub struct BinaryTokenStream {
used: bool,
value: Option<BytesRef<Vec<u8>>>,
token_stream_base: TokenStreamBase,
}
impl BinaryTokenStream {
pub(crate) fn new() -> Result<Self> {
Ok(Self {
used: false,
value: None,
token_stream_base: TokenStreamBase::new(BinaryTokenStreamAttributeImpl::new()?.into()),
})
}
pub(crate) fn set_value(&mut self, value: BytesRef<Vec<u8>>) {
self.value = Some(value);
}
}
impl Drop for BinaryTokenStream {
fn drop(&mut self) {
let _ = self.close();
}
}
impl Closeable for BinaryTokenStream {
fn close(&mut self) -> Result<()> {
let _ = self.value.take();
Ok(())
}
}
impl TokenStream for BinaryTokenStream {
fn increment_token(&mut self) -> Result<bool> {
if self.used {
return Ok(false);
}
self.token_stream_base.att.clear_attributes()?;
let value = self.value.take();
self.token_stream_base.att.set_bytes_ref(value)?;
self.used = true;
Ok(true)
}
fn end(&mut self) -> Result<()> {
self.default_end()
}
fn reset(&mut self) -> Result<()> {
self.used = false;
Ok(())
}
fn get_attribute_source(&self) -> &Attributes {
&self.token_stream_base.att
}
fn get_attribute_source_mut(&mut self) -> &mut Attributes {
&mut self.token_stream_base.att
}
}
pub struct StringTokenStream {
used: bool,
value: String,
has_value: bool,
end_offset: i32,
token_stream_base: TokenStreamBase,
}
impl StringTokenStream {
pub(crate) fn new() -> Self {
Self {
used: false,
value: String::new(),
has_value: false,
end_offset: 0,
token_stream_base: TokenStreamBase::new(Attributes::default()),
}
}
pub(crate) fn set_value(&mut self, value: &str) -> Result<()> {
let utf16_length = if value.is_ascii() {
value.len()
} else if value.len() <= char::MAX.len_utf8() {
value.chars().map(char::len_utf16).sum()
} else {
value.chars().count() + value.bytes().filter(|byte| *byte >= 0xF0).count()
};
self.end_offset = i32::try_from(utf16_length)
.map_err(|_| LuceneError::illegal_argument("string UTF-16 length exceeds i32::MAX"))?;
self.value.clear();
self.value.push_str(value);
self.has_value = true;
Ok(())
}
}
impl Drop for StringTokenStream {
fn drop(&mut self) {
let _ = self.close();
}
}
impl Closeable for StringTokenStream {
fn close(&mut self) -> Result<()> {
self.has_value = false;
Ok(())
}
}
impl TokenStream for StringTokenStream {
fn increment_token(&mut self) -> Result<bool> {
if self.used {
return Ok(false);
}
self.token_stream_base.att.clear_attributes()?;
if !self.has_value {
return Err(LuceneError::illegal_argument("set_value() not call?"));
}
self.token_stream_base.att.append_str(Some(&self.value))?;
self.token_stream_base.att.set_offset(0, self.end_offset)?;
self.used = true;
Ok(true)
}
fn end(&mut self) -> Result<()> {
self.default_end()?;
if !self.has_value {
return Err(LuceneError::illegal_state(
"StringTokenStream value is not set",
));
}
let final_offset = self.end_offset;
self
.token_stream_base
.att
.set_offset(final_offset, final_offset)
}
fn reset(&mut self) -> Result<()> {
self.used = false;
Ok(())
}
fn get_attribute_source(&self) -> &Attributes {
&self.token_stream_base.att
}
fn get_attribute_source_mut(&mut self) -> &mut Attributes {
&mut self.token_stream_base.att
}
}
either_token_stream!(pub IndexingTokenStreamEnum3 { AnalyzerTokenStream: A, Reused: B,FieldTokenStream:C });