use crate::core::store::byte_buffers_index_input::ByteBuffersIndexInputOwned;
use crate::core::store::data_input_ext::DataInputExt;
use crate::core::store::memory_segment_index_input::{
MappedFloatVectors, MemorySegmentIndexInput, MemorySegmentRandomAccessInput,
};
use crate::core::store::nio_fs_directory::NIOFSIndexInput;
use crate::core::store::random_access_input::{
BoxRandomAccessInput, RandomAccessInput, RandomAccessInputEnum2, RandomAccessInputEnum3,
};
use crate::core::store::{BufferedIndexInput, DataInput, ReadAdvice};
use crate::core::util::TryIntoInt;
use crate::core::util::clone::TryClone;
use crate::core::util::close::CloseableRef;
use crate::core::util::error::lucene_error::{LuceneError, Result};
use std::collections::{HashMap, HashSet};
use std::fmt::{Display, Formatter};
use std::sync::Arc;
pub trait IndexInput: DataInput + TryClone + CloseableRef {
type IndexInput: IndexInput;
fn get_file_pointer(&self) -> Result<usize>;
fn seek(&mut self, pos: usize) -> Result<()>;
fn skip_bytes(&mut self, num_bytes: i64) -> Result<()> {
if num_bytes < 0 {
return Err(LuceneError::illegal_argument(format!(
"num_bytes must be >= 0, got {num_bytes}"
)));
}
let num_bytes: usize = num_bytes.try_convert()?;
let skip_to = self.get_file_pointer()? + num_bytes;
self.seek(skip_to)?;
Ok(())
}
fn length(&self) -> Result<usize>;
fn slice(
&self,
_slice_description: &str,
_offset: usize,
_length: usize,
) -> Result<Self::IndexInput> {
Err(LuceneError::unsupported_operation("not support slicing"))
}
fn slice_with_read_advice(
&self,
description: &str,
offset: usize,
length: usize,
_read_advice: &ReadAdvice,
) -> Result<Self::IndexInput> {
self.slice(description, offset, length)
}
type RandomAccessSlice: RandomAccessInput;
fn random_access_slice(&self, offset: usize, length: usize) -> Result<Self::RandomAccessSlice>;
fn prefetch(&self, _pos: usize, _len: usize) -> Result<()> {
Ok(())
}
fn update_read_advice(&self, _read_advice: ReadAdvice) -> Result<()> {
Ok(())
}
fn is_loaded(&self) -> Result<Option<bool>> {
Ok(None)
}
fn mapped_float_vectors(&self, _dimension: usize, _count: usize) -> Option<MappedFloatVectors> {
None
}
}
pub trait ErasedIndexInput:
IndexInput<RandomAccessSlice = BoxRandomAccessInput, IndexInput = IndexInputEnum>
{
fn try_clone_index_input(&self) -> Result<IndexInputEnum>;
}
pub type DynIndexInput = dyn ErasedIndexInput + Send + Sync;
pub type CustomIndexInput = Box<DynIndexInput>;
pub type IndexInputEnumRandomAccessSlice =
RandomAccessInputEnum2<BufferedIndexInput<NIOFSIndexInput>, BoxRandomAccessInput>;
pub enum IndexInputEnum {
Fs(BufferedIndexInput<NIOFSIndexInput>),
Custom(CustomIndexInput),
}
impl IndexInputEnum {
pub fn custom<I>(input: I) -> Self
where
I: ErasedIndexInput + Send + Sync + 'static,
{
Self::Custom(Box::new(input))
}
}
impl CloseableRef for IndexInputEnum {
fn close(&self) -> Result<()> {
match self {
IndexInputEnum::Fs(inner) => inner.close(),
IndexInputEnum::Custom(inner) => inner.close(),
}
}
}
impl DataInput for IndexInputEnum {
fn read_byte(&mut self) -> Result<u8> {
match self {
IndexInputEnum::Fs(inner) => DataInput::read_byte(inner),
IndexInputEnum::Custom(inner) => inner.read_byte(),
}
}
fn get_bytes<'a>(&'a mut self, len: usize) -> Result<std::borrow::Cow<'a, [u8]>> {
match self {
IndexInputEnum::Fs(inner) => DataInput::get_bytes(inner, len),
IndexInputEnum::Custom(inner) => DataInput::get_bytes(inner, len),
}
}
fn read_bytes(&mut self, b: &mut [u8], offset: usize, len: usize) -> Result<()> {
match self {
IndexInputEnum::Fs(inner) => DataInput::read_bytes(inner, b, offset, len),
IndexInputEnum::Custom(inner) => inner.read_bytes(b, offset, len),
}
}
fn read_bytes_with_buffer(
&mut self,
b: &mut [u8],
offset: usize,
len: usize,
_use_buffer: bool,
) -> Result<()> {
match self {
IndexInputEnum::Fs(inner) => inner.read_bytes_with_buffer(b, offset, len, _use_buffer),
IndexInputEnum::Custom(inner) => inner.read_bytes_with_buffer(b, offset, len, _use_buffer),
}
}
fn read_short(&mut self) -> Result<i16> {
match self {
IndexInputEnum::Fs(inner) => DataInput::read_short(inner),
IndexInputEnum::Custom(inner) => inner.read_short(),
}
}
fn read_int(&mut self) -> Result<i32> {
match self {
IndexInputEnum::Fs(inner) => DataInput::read_int(inner),
IndexInputEnum::Custom(inner) => inner.read_int(),
}
}
fn read_group_vint(&mut self, dst: &mut [i32], offset: usize) -> Result<()> {
match self {
IndexInputEnum::Fs(inner) => inner.read_group_vint(dst, offset),
IndexInputEnum::Custom(inner) => inner.read_group_vint(dst, offset),
}
}
fn read_vint(&mut self) -> Result<i32> {
match self {
IndexInputEnum::Fs(inner) => DataInput::read_vint(inner),
IndexInputEnum::Custom(inner) => inner.read_vint(),
}
}
fn read_zint(&mut self) -> Result<i32> {
match self {
IndexInputEnum::Fs(inner) => DataInput::read_zint(inner),
IndexInputEnum::Custom(inner) => inner.read_zint(),
}
}
fn read_long(&mut self) -> Result<i64> {
match self {
IndexInputEnum::Fs(inner) => DataInput::read_long(inner),
IndexInputEnum::Custom(inner) => inner.read_long(),
}
}
fn read_longs(&mut self, dst: &mut [i64], offset: usize, len: usize) -> Result<()> {
match self {
IndexInputEnum::Fs(inner) => inner.read_longs(dst, offset, len),
IndexInputEnum::Custom(inner) => inner.read_longs(dst, offset, len),
}
}
fn read_ints(&mut self, dst: &mut [i32], offset: usize, len: usize) -> Result<()> {
match self {
IndexInputEnum::Fs(inner) => inner.read_ints(dst, offset, len),
IndexInputEnum::Custom(inner) => inner.read_ints(dst, offset, len),
}
}
fn read_floats(&mut self, dst: &mut [f32], offset: usize, len: usize) -> Result<()> {
match self {
IndexInputEnum::Fs(inner) => inner.read_floats(dst, offset, len),
IndexInputEnum::Custom(inner) => inner.read_floats(dst, offset, len),
}
}
fn read_vlong(&mut self) -> Result<i64> {
match self {
IndexInputEnum::Fs(inner) => DataInput::read_vlong(inner),
IndexInputEnum::Custom(inner) => inner.read_vlong(),
}
}
fn read_zlong(&mut self) -> Result<i64> {
match self {
IndexInputEnum::Fs(inner) => DataInput::read_zlong(inner),
IndexInputEnum::Custom(inner) => inner.read_zlong(),
}
}
fn read_string<'a>(&'a mut self) -> Result<std::borrow::Cow<'a, str>> {
match self {
IndexInputEnum::Fs(inner) => DataInput::read_string(inner),
IndexInputEnum::Custom(inner) => inner.read_string(),
}
}
fn read_map_of_strings(&mut self) -> Result<HashMap<String, String>> {
match self {
IndexInputEnum::Fs(inner) => DataInput::read_map_of_strings(inner),
IndexInputEnum::Custom(inner) => inner.read_map_of_strings(),
}
}
fn read_set_of_strings(&mut self) -> Result<HashSet<String>> {
match self {
IndexInputEnum::Fs(inner) => DataInput::read_set_of_strings(inner),
IndexInputEnum::Custom(inner) => inner.read_set_of_strings(),
}
}
fn skip_bytes(&mut self, num_bytes: i64) -> Result<()> {
match self {
IndexInputEnum::Fs(inner) => DataInput::skip_bytes(inner, num_bytes),
IndexInputEnum::Custom(inner) => DataInput::skip_bytes(inner, num_bytes),
}
}
}
impl DataInputExt for IndexInputEnum {
crate::core::store::data_input_ext::impl_index_input_ext!();
}
impl Display for IndexInputEnum {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
IndexInputEnum::Fs(inner) => inner.fmt(f),
IndexInputEnum::Custom(inner) => inner.fmt(f),
}
}
}
impl TryClone for IndexInputEnum {
fn try_clone(&self) -> Result<Self>
where
Self: Sized,
{
match self {
IndexInputEnum::Fs(inner) => Ok(IndexInputEnum::Fs(inner.try_clone()?)),
IndexInputEnum::Custom(inner) => inner.try_clone_index_input(),
}
}
}
impl IndexInput for IndexInputEnum {
type IndexInput = IndexInputEnum;
fn get_file_pointer(&self) -> Result<usize> {
match self {
IndexInputEnum::Fs(inner) => inner.get_file_pointer(),
IndexInputEnum::Custom(inner) => inner.get_file_pointer(),
}
}
fn seek(&mut self, pos: usize) -> Result<()> {
match self {
IndexInputEnum::Fs(inner) => inner.seek(pos),
IndexInputEnum::Custom(inner) => inner.seek(pos),
}
}
fn skip_bytes(&mut self, num_bytes: i64) -> Result<()> {
match self {
IndexInputEnum::Fs(inner) => IndexInput::skip_bytes(inner, num_bytes),
IndexInputEnum::Custom(inner) => inner.skip_bytes(num_bytes),
}
}
fn length(&self) -> Result<usize> {
match self {
IndexInputEnum::Fs(inner) => IndexInput::length(inner),
IndexInputEnum::Custom(inner) => inner.length(),
}
}
fn slice(
&self,
slice_description: &str,
offset: usize,
length: usize,
) -> Result<Self::IndexInput> {
match self {
IndexInputEnum::Fs(inner) => Ok(IndexInputEnum::Fs(inner.slice(
slice_description,
offset,
length,
)?)),
IndexInputEnum::Custom(inner) => inner.slice(slice_description, offset, length),
}
}
fn slice_with_read_advice(
&self,
description: &str,
offset: usize,
length: usize,
_read_advice: &ReadAdvice,
) -> Result<Self::IndexInput> {
match self {
IndexInputEnum::Fs(inner) => Ok(IndexInputEnum::Fs(inner.slice_with_read_advice(
description,
offset,
length,
_read_advice,
)?)),
IndexInputEnum::Custom(inner) => {
inner.slice_with_read_advice(description, offset, length, _read_advice)
},
}
}
type RandomAccessSlice = IndexInputEnumRandomAccessSlice;
fn random_access_slice(&self, offset: usize, length: usize) -> Result<Self::RandomAccessSlice> {
match self {
IndexInputEnum::Fs(inner) => Ok(IndexInputEnumRandomAccessSlice::A(
inner.random_access_slice(offset, length)?,
)),
IndexInputEnum::Custom(inner) => Ok(IndexInputEnumRandomAccessSlice::B(
inner.random_access_slice(offset, length)?,
)),
}
}
fn prefetch(&self, pos: usize, len: usize) -> Result<()> {
match self {
IndexInputEnum::Fs(inner) => IndexInput::prefetch(inner, pos, len),
IndexInputEnum::Custom(inner) => inner.prefetch(pos, len),
}
}
fn update_read_advice(&self, read_advice: ReadAdvice) -> Result<()> {
match self {
IndexInputEnum::Fs(inner) => inner.update_read_advice(read_advice),
IndexInputEnum::Custom(inner) => inner.update_read_advice(read_advice),
}
}
fn is_loaded(&self) -> Result<Option<bool>> {
match self {
IndexInputEnum::Fs(inner) => IndexInput::is_loaded(inner),
IndexInputEnum::Custom(inner) => IndexInput::is_loaded(inner.as_ref()),
}
}
}
pub fn get_full_slice_description(slice_description: &str) -> String {
format!(" [slice={slice_description}] ")
}
macro_rules! either_index_input {
(
$vis:vis $name:ident<$( $G:ident ),+>,
index_input = $index_input:ty,
random_access = $random_access_type:ty,
random_access_enum = $random_access:ident
{ $( $Variant:ident : $T:ty ),+ $(,)? }
) => {
either_index_input!(@impl
$vis $name [<$( $G ),+>],
index_input = $index_input,
random_access = $random_access_type,
random_access_enum = $random_access
{ $( $Variant : $T ),+ }
);
};
(
$vis:vis $name:ident,
index_input = $index_input:ty,
random_access = $random_access_type:ty,
random_access_enum = $random_access:ident
{ $( $Variant:ident : $T:ty ),+ $(,)? }
) => {
either_index_input!(@impl
$vis $name [],
index_input = $index_input,
random_access = $random_access_type,
random_access_enum = $random_access
{ $( $Variant : $T ),+ }
);
};
(@impl
$vis:vis $name:ident [$($generics:tt)*],
index_input = $index_input:ty,
random_access = $random_access_type:ty,
random_access_enum = $random_access:ident
{ $( $Variant:ident : $T:ty ),+ $(,)? }
) => {
$vis enum $name $($generics)* {
$( $Variant($T), )+
}
impl $($generics)* CloseableRef for $name $($generics)*
where
$( $T: CloseableRef ),+
{
fn close(&self) -> Result<()> {
match self {
$( Self::$Variant(inner) => inner.close(), )+
}
}
}
impl $($generics)* DataInput for $name $($generics)*
where
$( $T: DataInput ),+
{
fn read_byte(&mut self) -> Result<u8> {
match self {
$( Self::$Variant(inner) => DataInput::read_byte(inner), )+
}
}
fn get_bytes<'a>(&'a mut self, len: usize) -> Result<std::borrow::Cow<'a, [u8]>> {
match self {
$( Self::$Variant(inner) => DataInput::get_bytes(inner, len), )+
}
}
fn read_bytes(&mut self, b: &mut [u8], offset: usize, len: usize) -> Result<()> {
match self {
$( Self::$Variant(inner) => DataInput::read_bytes(inner, b, offset, len), )+
}
}
fn read_bytes_with_buffer(
&mut self,
b: &mut [u8],
offset: usize,
len: usize,
_use_buffer: bool,
) -> Result<()> {
match self {
$( Self::$Variant(inner) => inner.read_bytes_with_buffer(
b,
offset,
len,
_use_buffer
), )+
}
}
fn read_short(&mut self) -> Result<i16> {
match self {
$( Self::$Variant(inner) => DataInput::read_short(inner), )+
}
}
fn read_int(&mut self) -> Result<i32> {
match self {
$( Self::$Variant(inner) => DataInput::read_int(inner), )+
}
}
fn read_group_vint(&mut self, dst: &mut [i32], offset: usize) -> Result<()> {
match self {
$( Self::$Variant(inner) => inner.read_group_vint(dst, offset), )+
}
}
fn read_vint(&mut self) -> Result<i32> {
match self {
$( Self::$Variant(inner) => inner.read_vint(), )+
}
}
fn read_zint(&mut self) -> Result<i32> {
match self {
$( Self::$Variant(inner) => inner.read_zint(), )+
}
}
fn read_long(&mut self) -> Result<i64> {
match self {
$( Self::$Variant(inner) => DataInput::read_long(inner), )+
}
}
fn read_longs(&mut self, dst: &mut [i64], offset: usize, len: usize) -> Result<()> {
match self {
$( Self::$Variant(inner) => inner.read_longs(dst, offset, len), )+
}
}
fn read_ints(&mut self, dst: &mut [i32], offset: usize, len: usize) -> Result<()> {
match self {
$( Self::$Variant(inner) => inner.read_ints(dst, offset, len), )+
}
}
fn read_floats(&mut self, dst: &mut [f32], offset: usize, len: usize) -> Result<()> {
match self {
$( Self::$Variant(inner) => inner.read_floats(dst, offset, len), )+
}
}
fn read_vlong(&mut self) -> Result<i64> {
match self {
$( Self::$Variant(inner) => inner.read_vlong(), )+
}
}
fn read_zlong(&mut self) -> Result<i64> {
match self {
$( Self::$Variant(inner) => inner.read_zlong(), )+
}
}
fn read_string<'a>(&'a mut self) -> Result<std::borrow::Cow<'a, str>> {
match self {
$( Self::$Variant(inner) => inner.read_string(), )+
}
}
fn read_map_of_strings(&mut self) -> Result<HashMap<String, String>> {
match self {
$( Self::$Variant(inner) => inner.read_map_of_strings(), )+
}
}
fn read_set_of_strings(&mut self) -> Result<HashSet<String>> {
match self {
$( Self::$Variant(inner) => inner.read_set_of_strings(), )+
}
}
fn skip_bytes(&mut self, num_bytes: i64) -> Result<()> {
match self {
$( Self::$Variant(inner) => DataInput::skip_bytes(inner, num_bytes), )+
}
}
}
impl $($generics)* $crate::core::store::data_input_ext::DataInputExt for $name $($generics)*
where
$( $T: DataInput ),+
{
fn is_index_input(&self) -> bool {
match self {
$( Self::$Variant(inner) => inner.is_index_input(), )+
}
}
fn seek_in_data_input(&mut self, _pos: usize) -> Result<()> {
match self {
$( Self::$Variant(inner) => inner.seek_in_data_input(_pos), )+
}
}
fn get_file_pointer_in_data_input(&self) -> Result<usize>{
match self {
$( Self::$Variant(inner) => inner.get_file_pointer_in_data_input(), )+
}
}
}
impl $($generics)* Display for $name $($generics)*
where
$( $T: Display ),+
{
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
$( Self::$Variant(inner) => inner.fmt(f), )+
}
}
}
impl $($generics)* TryClone for $name $($generics)*
where
$( $T: TryClone ),+
{
fn try_clone(&self) -> Result<Self>
where
Self: Sized,
{
match self {
$( Self::$Variant(inner) => Ok(Self::$Variant(inner.try_clone()?)), )+
}
}
}
impl $($generics)* RandomAccessInput for $name $($generics)*
where
$( $T: RandomAccessInput ),+
{
fn length(&self) -> Result<usize> {
match self {
$( Self::$Variant(inner) => RandomAccessInput::length(inner), )+
}
}
fn read_byte(&self, pos: usize) -> Result<u8> {
match self {
$( Self::$Variant(inner) => RandomAccessInput::read_byte(inner, pos), )+
}
}
fn read_bytes(&self, pos: usize, len: usize) -> Result<std::borrow::Cow<'_, [u8]>> {
match self {
$( Self::$Variant(inner) => RandomAccessInput::read_bytes(inner, pos, len), )+
}
}
fn read_short(&self, pos: usize) -> Result<i16> {
match self {
$( Self::$Variant(inner) => RandomAccessInput::read_short(inner, pos), )+
}
}
fn read_int(&self, pos: usize) -> Result<i32> {
match self {
$( Self::$Variant(inner) => RandomAccessInput::read_int(inner, pos), )+
}
}
fn read_long(&self, pos: usize) -> Result<i64> {
match self {
$( Self::$Variant(inner) => RandomAccessInput::read_long(inner, pos), )+
}
}
fn prefetch(&self, pos: usize, len: usize) -> Result<()> {
match self {
$( Self::$Variant(inner) => RandomAccessInput::prefetch(inner, pos, len), )+
}
}
}
impl $($generics)* IndexInput for $name $($generics)*
where
$( $T: IndexInput ),+
{
type IndexInput = $index_input;
fn get_file_pointer(&self) -> Result<usize>{
match self {
$( Self::$Variant(inner) => inner.get_file_pointer(), )+
}
}
fn seek(&mut self, pos: usize) -> Result<()> {
match self {
$( Self::$Variant(inner) => inner.seek(pos), )+
}
}
fn skip_bytes(&mut self, num_bytes: i64) -> Result<()> {
match self {
$( Self::$Variant(inner) => IndexInput::skip_bytes(inner, num_bytes), )+
}
}
fn length(&self) -> Result<usize> {
match self {
$( Self::$Variant(inner) => IndexInput::length(inner), )+
}
}
fn slice(
&self,
slice_description: &str,
offset: usize,
length: usize,
) -> Result<Self::IndexInput> {
match self {
$( Self::$Variant(inner) => Ok($name::$Variant(
inner.slice(slice_description, offset, length)?,
)), )+
}
}
fn slice_with_read_advice(
&self,
description: &str,
offset: usize,
length: usize,
read_advice: &ReadAdvice,
) -> Result<Self::IndexInput> {
match self {
$( Self::$Variant(inner) => Ok($name::$Variant(inner.slice_with_read_advice(
description,
offset,
length,
read_advice,
)?)), )+
}
}
type RandomAccessSlice = $random_access_type;
fn random_access_slice(&self, offset: usize, length: usize) -> Result<Self::RandomAccessSlice> {
match self {
$( Self::$Variant(inner) => Ok($random_access::$Variant(
inner.random_access_slice(offset, length)?,
)), )+
}
}
fn prefetch(&self, pos: usize, len: usize) -> Result<()> {
match self {
$( Self::$Variant(inner) => IndexInput::prefetch(inner, pos, len), )+
}
}
fn update_read_advice(&self, read_advice: ReadAdvice) -> Result<()> {
match self {
$( Self::$Variant(inner) => inner.update_read_advice(read_advice), )+
}
}
fn is_loaded(&self) -> Result<Option<bool>> {
match self {
$( Self::$Variant(inner) => IndexInput::is_loaded(inner), )+
}
}
}
};
}
impl<I> DataInput for Arc<I>
where
I: IndexInput,
{
fn read_byte(&mut self) -> Result<u8> {
Err(LuceneError::unsupported_operation(""))
}
fn get_bytes(&mut self, _len: usize) -> Result<std::borrow::Cow<'_, [u8]>> {
Err(LuceneError::unsupported_operation(""))
}
fn read_bytes(&mut self, _b: &mut [u8], _offset: usize, _len: usize) -> Result<()> {
Err(LuceneError::unsupported_operation(""))
}
fn read_bytes_with_buffer(
&mut self,
_b: &mut [u8],
_offset: usize,
_len: usize,
_use_buffer: bool,
) -> Result<()> {
Err(LuceneError::unsupported_operation(""))
}
fn read_short(&mut self) -> Result<i16> {
Err(LuceneError::unsupported_operation(""))
}
fn read_int(&mut self) -> Result<i32> {
Err(LuceneError::unsupported_operation(""))
}
fn read_group_vint(&mut self, _dst: &mut [i32], _offset: usize) -> Result<()> {
Err(LuceneError::unsupported_operation(""))
}
fn read_vint(&mut self) -> Result<i32> {
Err(LuceneError::unsupported_operation(""))
}
fn read_zint(&mut self) -> Result<i32> {
Err(LuceneError::unsupported_operation(""))
}
fn read_long(&mut self) -> Result<i64> {
Err(LuceneError::unsupported_operation(""))
}
fn read_longs(&mut self, _dst: &mut [i64], _offset: usize, _len: usize) -> Result<()> {
Err(LuceneError::unsupported_operation(""))
}
fn read_ints(&mut self, _dst: &mut [i32], _offset: usize, _len: usize) -> Result<()> {
Err(LuceneError::unsupported_operation(""))
}
fn read_floats(&mut self, _dst: &mut [f32], _offset: usize, _len: usize) -> Result<()> {
Err(LuceneError::unsupported_operation(""))
}
fn read_vlong(&mut self) -> Result<i64> {
Err(LuceneError::unsupported_operation(""))
}
fn read_zlong(&mut self) -> Result<i64> {
Err(LuceneError::unsupported_operation(""))
}
fn read_string<'a>(&'a mut self) -> Result<std::borrow::Cow<'a, str>> {
Err(LuceneError::unsupported_operation(""))
}
fn read_map_of_strings(&mut self) -> Result<HashMap<String, String>> {
Err(LuceneError::unsupported_operation(""))
}
fn read_set_of_strings(&mut self) -> Result<HashSet<String>> {
Err(LuceneError::unsupported_operation(""))
}
fn skip_bytes(&mut self, _num_bytes: i64) -> Result<()> {
Err(LuceneError::unsupported_operation(""))
}
}
impl<I> DataInputExt for Arc<I>
where
I: IndexInput,
{
fn is_index_input(&self) -> bool {
(**self).is_index_input()
}
fn seek_in_data_input(&mut self, _pos: usize) -> Result<()> {
Err(LuceneError::unsupported_operation(""))
}
fn get_file_pointer_in_data_input(&self) -> Result<usize> {
(**self).get_file_pointer_in_data_input()
}
}
impl<I> TryClone for Arc<I>
where
I: IndexInput,
{
fn try_clone(&self) -> Result<Self>
where
Self: Sized,
{
Ok(Arc::clone(self))
}
}
impl<I> IndexInput for Arc<I>
where
I: IndexInput,
{
type IndexInput = I::IndexInput;
fn get_file_pointer(&self) -> Result<usize> {
(**self).get_file_pointer()
}
fn seek(&mut self, _pos: usize) -> Result<()> {
Err(LuceneError::unsupported_operation(""))
}
fn skip_bytes(&mut self, _num_bytes: i64) -> Result<()> {
Err(LuceneError::unsupported_operation(""))
}
fn length(&self) -> Result<usize> {
(**self).length()
}
fn slice(
&self,
_slice_description: &str,
_offset: usize,
_length: usize,
) -> Result<Self::IndexInput> {
(**self).slice(_slice_description, _offset, _length)
}
fn slice_with_read_advice(
&self,
description: &str,
offset: usize,
length: usize,
_read_advice: &ReadAdvice,
) -> Result<Self::IndexInput> {
self
.as_ref()
.slice_with_read_advice(description, offset, length, _read_advice)
}
type RandomAccessSlice = I::RandomAccessSlice;
fn random_access_slice(&self, offset: usize, length: usize) -> Result<Self::RandomAccessSlice> {
(**self).random_access_slice(offset, length)
}
fn prefetch(&self, _pos: usize, _len: usize) -> Result<()> {
Err(LuceneError::unsupported_operation(""))
}
fn update_read_advice(&self, read_advice: ReadAdvice) -> Result<()> {
self.as_ref().update_read_advice(read_advice)
}
fn is_loaded(&self) -> Result<Option<bool>> {
IndexInput::is_loaded(self.as_ref())
}
}
either_index_input!(
pub IndexInputEnum2<A, B>,
index_input = IndexInputEnum2<A::IndexInput, B::IndexInput>,
random_access = RandomAccessInputEnum2<A::RandomAccessSlice, B::RandomAccessSlice>,
random_access_enum = RandomAccessInputEnum2
{ A: A, B: B }
);
either_index_input!(
pub IndexInputEnum3<A, B, C>,
index_input = IndexInputEnum3<A::IndexInput, B::IndexInput, C::IndexInput>,
random_access = RandomAccessInputEnum3<
A::RandomAccessSlice,
B::RandomAccessSlice,
C::RandomAccessSlice,
>,
random_access_enum = RandomAccessInputEnum3
{ A: A, B: B, C: C }
);
either_index_input!(
pub NRTCachingIndexInput<I>,
index_input = NRTCachingIndexInput<I::IndexInput>,
random_access = RandomAccessInputEnum2<
<ByteBuffersIndexInputOwned as IndexInput>::RandomAccessSlice,
I::RandomAccessSlice,
>,
random_access_enum = RandomAccessInputEnum2
{ A: ByteBuffersIndexInputOwned, B: I }
);
either_index_input!(
pub BuiltInFSIndexInput,
index_input = BuiltInFSIndexInput,
random_access = RandomAccessInputEnum2<
MemorySegmentRandomAccessInput,
BufferedIndexInput<NIOFSIndexInput>,
>,
random_access_enum = RandomAccessInputEnum2
{
A: MemorySegmentIndexInput,
B: BufferedIndexInput<NIOFSIndexInput>,
}
);