use crate::core::analysis::analyzer::Analyzer;
use crate::core::analysis::reader::ReaderEnum;
use crate::core::document::field::FieldDataEnum::Dummy;
use crate::core::document::field::{Field, FieldBase, FieldDataEnum};
use crate::core::document::field_type::FieldType;
use crate::core::document::invertable_field::InvertableType;
use crate::core::document::range_field_query::{QueryType, RangeFieldQuery, RangeFieldQueryBase};
use crate::core::index::BinaryValueEnum;
use crate::core::index::BytesRef;
use crate::core::index::indexable_field::{
IndexableField, IndexingTokenStream, ReusedIndexingTokenStream,
};
use crate::core::index::indexable_field_type::IndexableFieldType;
use crate::core::util::CoreHelper;
use crate::core::util::error::lucene_error::LuceneError;
use crate::core::util::error::lucene_error::Result;
use crate::core::util::number::Number;
use crate::core::util::numeric_utils::NumericUtils;
use std::borrow::Cow;
use std::fmt;
pub struct LongRange {
parent_field: Field,
}
pub const BYTES: usize = std::mem::size_of::<i64>();
impl LongRange {
pub fn new<T, L, U>(name: T, min: L, max: U) -> Result<Self>
where
T: Into<Cow<'static, str>>,
L: AsRef<[i64]>,
U: AsRef<[i64]>,
{
let min = min.as_ref();
let field_type = Self::get_type(min.len())?;
let mut parent_field = Field::new(name, Dummy(()), field_type);
Self::set_range_values_internal(&mut parent_field, min, max.as_ref())?;
Ok(LongRange { parent_field })
}
fn get_type(dimensions: usize) -> Result<FieldType> {
if dimensions > 4 {
return Err(LuceneError::illegal_argument(
"LongRange does not support greater than 4 dimensions",
));
}
let mut ft = FieldType::new();
ft.set_dimensions(dimensions * 2, BYTES)?;
ft.freeze();
Ok(ft)
}
pub fn set_range_values<L, U>(&mut self, min: L, max: U) -> Result<()>
where
L: AsRef<[i64]>,
U: AsRef<[i64]>,
{
Self::set_range_values_internal(&mut self.parent_field, min.as_ref(), max.as_ref())
}
fn set_range_values_internal(parent_field: &mut Field, min: &[i64], max: &[i64]) -> Result<()> {
check_args(min, max)?;
let dims = parent_field.field_type().point_dimension_count();
if min.len() * 2 != dims || max.len() * 2 != dims {
return Err(LuceneError::illegal_argument(format!(
"field (name={}) uses {} dimensions; cannot change to (incoming) {} dimensions",
parent_field.name(),
dims / 2,
min.len()
)));
}
let bytes = match &mut parent_field.fields_data {
FieldDataEnum::Binary(b) => &mut b.bytes,
FieldDataEnum::Dummy(_) => {
let new_bytes = vec![0u8; BYTES * 2 * min.len()];
parent_field.fields_data = BytesRef::from_bytes(new_bytes).into();
match &mut parent_field.fields_data {
FieldDataEnum::Binary(b) => &mut b.bytes,
_ => return Err(LuceneError::illegal_state("should not be here")),
}
},
_ => Err(LuceneError::illegal_state(
"Unsupported FieldDataEnum variant",
))?,
};
verify_and_encode(min, max, bytes)
}
pub fn get_min(&self, dimension: usize) -> Result<i64> {
CoreHelper::check_index(
dimension,
self.parent_field.field_type().point_dimension_count() / 2,
)?;
match &self.parent_field.fields_data {
FieldDataEnum::Binary(b) => Ok(decode_min(&b.bytes, dimension)),
_ => Err(LuceneError::illegal_argument(
"Unsupported FieldDataEnum variant",
)),
}
}
pub fn get_max(&self, dimension: usize) -> Result<i64> {
CoreHelper::check_index(
dimension,
self.parent_field.field_type().point_dimension_count() / 2,
)?;
match &self.parent_field.fields_data {
FieldDataEnum::Binary(b) => Ok(decode_max(&b.bytes, dimension)),
_ => Err(LuceneError::illegal_argument(
"Unsupported FieldDataEnum variant",
)),
}
}
pub fn new_intersects_query<T, L, U>(field: T, min: L, max: U) -> Result<RangeFieldQuery>
where
T: Into<String>,
L: AsRef<[i64]>,
U: AsRef<[i64]>,
{
Self::new_relation_query(field, min, max, QueryType::Intersects)
}
pub fn new_contains_query<T, L, U>(field: T, min: L, max: U) -> Result<RangeFieldQuery>
where
T: Into<String>,
L: AsRef<[i64]>,
U: AsRef<[i64]>,
{
Self::new_relation_query(field, min, max, QueryType::Contains)
}
pub fn new_within_query<T, L, U>(field: T, min: L, max: U) -> Result<RangeFieldQuery>
where
T: Into<String>,
L: AsRef<[i64]>,
U: AsRef<[i64]>,
{
Self::new_relation_query(field, min, max, QueryType::Within)
}
pub fn new_crosses_query<T, L, U>(field: T, min: L, max: U) -> Result<RangeFieldQuery>
where
T: Into<String>,
L: AsRef<[i64]>,
U: AsRef<[i64]>,
{
Self::new_relation_query(field, min, max, QueryType::Crosses)
}
fn new_relation_query<T, L, U>(
field: T,
min: L,
max: U,
relation: QueryType,
) -> Result<RangeFieldQuery>
where
T: Into<String>,
L: AsRef<[i64]>,
U: AsRef<[i64]>,
{
let min = min.as_ref();
let max = max.as_ref();
check_args(min, max)?;
RangeFieldQuery::new(
field.into(),
encode_range(min, max)?,
min.len(),
relation,
LongRangeFieldQuery,
)
}
}
impl FieldBase for LongRange {}
impl IndexableField for LongRange {
fn name(&self) -> &str {
self.parent_field.name()
}
type FieldType<'a>
= &'a FieldType
where
Self: 'a;
fn field_type(&self) -> Self::FieldType<'_> {
self.parent_field.field_type()
}
fn token_stream<'a, A>(
&'a mut self,
analyzer: &'a A,
reuse_token_stream: &'a mut Option<ReusedIndexingTokenStream>,
) -> Result<IndexingTokenStream<'a>>
where
A: Analyzer,
{
self.parent_field.token_stream(analyzer, reuse_token_stream)
}
fn binary_value(&self) -> Result<Option<BinaryValueEnum<'_>>> {
self.parent_field.binary_value()
}
fn take_binary_value(&mut self) -> Result<Option<BytesRef<Vec<u8>>>> {
self.parent_field.take_binary_value()
}
fn string_value(&self) -> Result<Option<Cow<'_, str>>> {
self.parent_field.string_value()
}
fn take_string_value(&mut self) -> Result<Option<String>> {
self.parent_field.take_string_value()
}
fn take_reader_value(&mut self) -> Result<Option<ReaderEnum>> {
todo!()
}
fn numeric_value(&self) -> Result<Option<Number>> {
Err(LuceneError::illegal_argument(
"cannot convert LongRange to a single numeric value",
))
}
type StoredValue<'a>
= &'a FieldDataEnum
where
Self: 'a;
fn stored_value(&self) -> Result<Option<Self::StoredValue<'_>>> {
self.parent_field.stored_value()
}
fn invertable_type(&self) -> &InvertableType {
self.parent_field.invertable_type()
}
}
impl fmt::Display for LongRange {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "LongRange <{}: ", self.parent_field.name())?;
let dims = self.parent_field.field_type().point_dimension_count() / 2;
match &self.parent_field.fields_data {
FieldDataEnum::Binary(bytes) => {
for dim in 0..dims {
if dim > 0 {
write!(f, " ")?;
}
let min = decode_min(&bytes.bytes, dim);
let max = decode_max(&bytes.bytes, dim);
write!(f, "[{} : {}]", min, max)?;
}
},
_ => {
write!(f, "Unsupported FieldDataEnum variant")?;
},
}
write!(f, ">")
}
}
fn check_args(min: &[i64], max: &[i64]) -> Result<()> {
if min.is_empty() || max.is_empty() {
return Err(LuceneError::illegal_argument(
"min/max range values cannot be null or empty",
));
}
if min.len() != max.len() {
return Err(LuceneError::illegal_argument("min/max ranges must agree"));
}
if min.len() > 4 {
return Err(LuceneError::illegal_argument(
"LongRange does not support greater than 4 dimensions",
));
}
Ok(())
}
pub(crate) fn encode_range(min: &[i64], max: &[i64]) -> Result<Vec<u8>> {
check_args(min, max)?;
let mut bytes = vec![0u8; BYTES * 2 * min.len()];
verify_and_encode(min, max, &mut bytes)?;
Ok(bytes)
}
pub fn verify_and_encode(min: &[i64], max: &[i64], bytes: &mut [u8]) -> Result<()> {
for d in 0..min.len() {
let i = d * BYTES;
let j = min.len() * BYTES + d * BYTES;
if min[d] > max[d] {
return Err(LuceneError::illegal_argument(format!(
"min value ({}) is greater than max value ({})",
min[d], max[d]
)));
}
encode(min[d], bytes, i);
encode(max[d], bytes, j);
}
Ok(())
}
fn encode(val: i64, bytes: &mut [u8], offset: usize) {
NumericUtils::long_to_sortable_bytes(val, bytes, offset);
}
fn decode_min(bytes: &[u8], dimension: usize) -> i64 {
let offset = dimension * BYTES;
NumericUtils::sortable_bytes_to_long(bytes, offset)
}
fn decode_max(bytes: &[u8], dimension: usize) -> i64 {
let offset = bytes.len() / 2 + dimension * BYTES;
NumericUtils::sortable_bytes_to_long(bytes, offset)
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LongRangeFieldQuery;
impl RangeFieldQueryBase for LongRangeFieldQuery {
fn to_string(&self, value: &[u8], dimension: usize) -> Result<String> {
Ok(to_string(value, dimension))
}
}
fn to_string(ranges: &[u8], dimension: usize) -> String {
format!(
"[{} : {}]",
decode_min(ranges, dimension),
decode_max(ranges, dimension)
)
}