use crate::core::index::dummy::dummy_doc_index_iterator::DummyDocIndexIterator;
use crate::core::index::knn_vector_values::{BitsImpl, KnnVectorValues};
use crate::core::index::leaf_reader::LeafReader;
use crate::core::index::vector_encoding::VectorEncoding;
use crate::core::search::dummy::dummy_vector_scorer::DummyVectorScorer;
use crate::core::search::vector_scorer::VectorScorer;
use crate::core::util::bits::Bits;
use crate::core::util::clone::TryClone;
use crate::core::util::error::lucene_error::{LuceneError, Result};
use std::borrow::Cow;
#[derive(Debug)]
pub struct ByteVectorValue<'a>(pub(crate) ByteVectorValueStorage<'a>);
#[derive(Debug)]
pub(crate) enum ByteVectorValueStorage<'a> {
Borrowed(&'a [u8]),
Owned(Vec<u8>),
Buffer(parking_lot::MappedMutexGuard<'a, [u8]>),
}
impl std::ops::Deref for ByteVectorValue<'_> {
type Target = [u8];
fn deref(&self) -> &Self::Target {
match &self.0 {
ByteVectorValueStorage::Borrowed(value) => value,
ByteVectorValueStorage::Owned(value) => value.as_slice(),
ByteVectorValueStorage::Buffer(value) => value,
}
}
}
impl AsRef<[u8]> for ByteVectorValue<'_> {
fn as_ref(&self) -> &[u8] {
self
}
}
impl<'a> From<&'a [u8]> for ByteVectorValue<'a> {
fn from(value: &'a [u8]) -> Self {
Self(ByteVectorValueStorage::Borrowed(value))
}
}
impl From<Vec<u8>> for ByteVectorValue<'_> {
fn from(value: Vec<u8>) -> Self {
Self(ByteVectorValueStorage::Owned(value))
}
}
impl<'a> From<parking_lot::MappedMutexGuard<'a, [u8]>> for ByteVectorValue<'a> {
fn from(value: parking_lot::MappedMutexGuard<'a, [u8]>) -> Self {
Self(ByteVectorValueStorage::Buffer(value))
}
}
impl<'a> From<Cow<'a, [u8]>> for ByteVectorValue<'a> {
fn from(value: Cow<'a, [u8]>) -> Self {
Self(match value {
Cow::Borrowed(value) => ByteVectorValueStorage::Borrowed(value),
Cow::Owned(value) => ByteVectorValueStorage::Owned(value),
})
}
}
impl<'a> TryFrom<Cow<'a, VectorValueEnum>> for ByteVectorValue<'a> {
type Error = LuceneError;
fn try_from(value: Cow<'a, VectorValueEnum>) -> Result<Self> {
match value {
Cow::Borrowed(VectorValueEnum::Byte(value)) => {
Ok(Self(ByteVectorValueStorage::Borrowed(value.as_slice())))
},
Cow::<VectorValueEnum>::Owned(VectorValueEnum::Byte(value)) => {
Ok(Self(ByteVectorValueStorage::Owned(value)))
},
_ => Err(LuceneError::unsupported_operation("")),
}
}
}
impl<'a> From<ByteVectorValue<'a>> for Cow<'a, [u8]> {
fn from(value: ByteVectorValue<'a>) -> Self {
match value.0 {
ByteVectorValueStorage::Borrowed(value) => Cow::Borrowed(value),
ByteVectorValueStorage::Owned(value) => Cow::Owned(value),
ByteVectorValueStorage::Buffer(value) => Cow::Owned(value.to_vec()),
}
}
}
impl ByteVectorValue<'_> {
pub fn into_owned(self) -> Vec<u8> {
match self.0 {
ByteVectorValueStorage::Borrowed(value) => value.to_vec(),
ByteVectorValueStorage::Owned(value) => value,
ByteVectorValueStorage::Buffer(value) => value.to_vec(),
}
}
}
impl From<ByteVectorValue<'_>> for VectorValueEnum {
fn from(value: ByteVectorValue<'_>) -> Self {
Self::Byte(value.into_owned())
}
}
pub trait ByteVectorValues: KnnVectorValues {
type VectorValue<'v>: std::ops::Deref<Target = [u8]> + Into<ByteVectorValue<'v>>
where
Self: 'v;
fn vector_value(&self, ord: usize) -> Result<Self::VectorValue<'_>>;
type ByteVectorValues: ByteVectorValues;
fn byte_copy(&self) -> Result<Option<Self::ByteVectorValues>> {
Err(LuceneError::unsupported_operation(""))
}
type VectorScorer: VectorScorer;
fn scorer<TV>(&self, _query: TV) -> Result<Option<Self::VectorScorer>>
where
TV: Into<Vec<u8>>,
{
Err(LuceneError::unsupported_operation(""))
}
fn get_encoding(&self) -> VectorEncoding {
VectorEncoding::BYTE(1)
}
fn get_vectors_mut(&mut self) -> Result<&mut Vec<Box<[u8]>>> {
Err(LuceneError::unsupported_operation(""))
}
fn get_vectors(&self) -> Result<&[Box<[u8]>]> {
Err(LuceneError::unsupported_operation(""))
}
fn get_vectors_capacity(&self) -> Result<usize> {
Ok(self.get_vectors()?.len())
}
}
impl<T> ByteVectorValues for &T
where
T: ByteVectorValues,
{
type VectorValue<'v>
= T::VectorValue<'v>
where
Self: 'v;
fn vector_value(&self, ord: usize) -> Result<Self::VectorValue<'_>> {
(**self).vector_value(ord)
}
type ByteVectorValues = T::ByteVectorValues;
fn byte_copy(&self) -> Result<Option<Self::ByteVectorValues>> {
(**self).byte_copy()
}
type VectorScorer = T::VectorScorer;
fn scorer<TV>(&self, query: TV) -> Result<Option<Self::VectorScorer>>
where
TV: Into<Vec<u8>>,
{
let query = query.into();
(**self).scorer(query)
}
fn get_encoding(&self) -> VectorEncoding {
<T as ByteVectorValues>::get_encoding(*self)
}
fn get_vectors_mut(&mut self) -> Result<&mut Vec<Box<[u8]>>> {
Err(LuceneError::unsupported_operation(""))
}
fn get_vectors(&self) -> Result<&[Box<[u8]>]> {
(**self).get_vectors()
}
fn get_vectors_capacity(&self) -> Result<usize> {
(**self).get_vectors_capacity()
}
}
pub fn check_field<LR>(reader: &LR, field: &str) -> Result<()>
where
LR: LeafReader,
{
if let Some(fi) = reader.get_field_infos()?.field_info_by_name(field)?
&& fi.has_vector_values()
&& *fi.get_vector_encoding() != VectorEncoding::BYTE(1)
{
return Err(LuceneError::illegal_state(format!(
"Unexpected vector encoding ({:?}) for field {}(expected={:?})",
fi.get_vector_encoding(),
field,
VectorEncoding::BYTE(1)
)));
}
Ok(())
}
pub fn from_bytes(dim: usize) -> ByteVectorValuesImpl {
ByteVectorValuesImpl::new(dim)
}
pub struct ByteVectorValuesImpl {
vectors: Vec<Box<[u8]>>,
dim: usize,
}
impl TryClone for ByteVectorValuesImpl {
fn try_clone(&self) -> Result<Self>
where
Self: Sized,
{
Ok(Self {
vectors: self.vectors.clone(),
dim: self.dim,
})
}
}
impl ByteVectorValuesImpl {
pub(crate) fn new(dim: usize) -> Self {
Self {
vectors: Vec::new(),
dim,
}
}
}
impl KnnVectorValues for ByteVectorValuesImpl {
fn dimension(&self) -> usize {
self.dim
}
fn size(&self) -> usize {
self.vectors.len()
}
type KnnVectorValues = ByteVectorValuesImpl;
fn get_encoding(&self) -> VectorEncoding {
ByteVectorValues::get_encoding(self)
}
type Bits<'a, B>
= BitsImpl<B, &'a Self>
where
B: Bits,
Self: 'a;
fn get_accept_ords<'a, B>(&'a self, accept_docs: Option<B>) -> Option<Self::Bits<'a, B>>
where
B: Bits,
{
self.default_get_accept_ords(accept_docs)
}
type DocIndexIterator = DummyDocIndexIterator;
}
impl ByteVectorValues for ByteVectorValuesImpl {
type VectorValue<'v>
= &'v [u8]
where
Self: 'v;
#[inline]
fn vector_value(&self, target_ord: usize) -> Result<Self::VectorValue<'_>> {
Ok(self.vectors[target_ord].as_ref())
}
type ByteVectorValues = crate::core::index::knn_vector_values::NoVectorValuesCopy;
fn byte_copy(&self) -> Result<Option<Self::ByteVectorValues>> {
Ok(None)
}
type VectorScorer = DummyVectorScorer;
fn get_vectors_mut(&mut self) -> Result<&mut Vec<Box<[u8]>>> {
Ok(&mut self.vectors)
}
fn get_vectors(&self) -> Result<&[Box<[u8]>]> {
Ok(&self.vectors)
}
fn get_vectors_capacity(&self) -> Result<usize> {
Ok(self.vectors.capacity())
}
}
use crate::core::codecs::knn_field_vectors_writer::VectorValueEnum;