use crate::core::index::index_reader::Identity;
#[cfg(test)]
use crate::core::store::ByteBuffersDirectory;
use crate::core::store::IO_CONTEXT_DEFAULT;
#[cfg(test)]
use crate::core::store::ReadAdvice;
use crate::core::store::buffered_checksum_index_input::BufferedChecksumIndexInput;
#[cfg(test)]
use crate::core::store::byte_buffers_directory::DirectoryByteBuffersIndexOutput;
#[cfg(test)]
use crate::core::store::byte_buffers_index_input::ByteBuffersIndexInputOwned;
#[cfg(test)]
use crate::core::store::data_input::DataInput;
#[cfg(test)]
use crate::core::store::data_input_ext::DataInputExt;
use crate::core::store::data_output::DataOutput;
#[cfg(test)]
use crate::core::store::file_switch_directory::FileSwitchDirectory;
use crate::core::store::index_input::IndexInput;
use crate::core::store::lock::{Lock, LockEnum, LockEnum2, LockEnum3};
#[cfg(test)]
use crate::core::store::lock_factory::LockFactoryEnum;
#[cfg(test)]
use crate::core::store::mmap_directory::MMapDirectory;
use crate::core::store::nio_fs_directory::NIOFSDirectory;
#[cfg(test)]
use crate::core::store::nrt_caching_directory::NRTCachingDirectory;
#[cfg(test)]
use crate::core::store::random_access_input::{RandomAccessInput, RandomAccessInputEnum2};
use crate::core::store::{
FSDirectory, IOContext, IndexInputEnum, IndexInputEnum2, IndexInputEnum3, IndexOutput,
IndexOutputEnum, IndexOutputEnum2, IndexOutputEnum3, NativeFSLockFactory,
};
use crate::core::util::HasIdentity;
#[cfg(test)]
use crate::core::util::clone::TryClone;
use crate::core::util::close::{Closeable, CloseableRef};
use crate::core::util::error::lucene_error::{LuceneError, Result};
use crate::core::util::io_utils::IOUtils;
#[cfg(test)]
use crate::test_framework::core::store::mock_directory_wrapper::MockDirectoryWrapper;
#[cfg(test)]
use crate::test_framework::core::store::raw_directory_wrapper::RawDirectoryWrapper;
use num_bigint::BigInt;
#[cfg(test)]
use std::collections::HashMap;
use std::collections::HashSet;
use std::fmt::{Display, Formatter};
#[cfg(test)]
use std::ops::{Deref, DerefMut};
use std::sync::Arc;
pub trait Directory: Display + CloseableRef + HasIdentity + Send + Sync {
fn list_all(&self) -> Result<Vec<String>>;
fn delete_file(&self, name: &str) -> Result<()>;
fn file_length(&self, name: &str) -> Result<usize>;
fn create_output(&self, name: &str, context: &IOContext) -> Result<Self::IndexOutput>;
type IndexOutput: IndexOutput;
fn create_temp_output(
&self,
prefix: &str,
suffix: &str,
context: &IOContext,
) -> Result<Self::IndexOutput>;
fn sync(&self, names: &[String]) -> Result<()>;
fn sync_metadata(&self) -> Result<()>;
fn rename(&self, source: &str, dest: &str) -> Result<()>;
type IndexInput: IndexInput<IndexInput = Self::IndexInput, RandomAccessSlice: Send + Sync>
+ Send
+ Sync;
fn open_input(&self, name: &str, context: &IOContext) -> Result<Self::IndexInput>;
fn open_checksum_input(
&self,
name: &str,
) -> Result<BufferedChecksumIndexInput<Self::IndexInput>> {
Ok(BufferedChecksumIndexInput::new(
self.open_input(name, &IOContext::read_once_io_context()?)?,
))
}
type Lock: Lock;
fn obtain_lock(&self, name: &str) -> Result<Self::Lock>;
fn copy_from<D>(&self, from: &D, src: &str, dest: &str, context: &IOContext) -> Result<()>
where
Self: Sized,
D: Directory + ?Sized,
{
let mut success = false;
let mut input = None;
let mut output = None;
let body_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| -> Result<()> {
input = Some(from.open_input(src, &IOContext::read_once_io_context()?)?);
output = Some(self.create_output(dest, context)?);
let input = input
.as_mut()
.ok_or_else(|| LuceneError::illegal_state("copy source input is missing"))?;
let output = output
.as_mut()
.ok_or_else(|| LuceneError::illegal_state("copy destination output is missing"))?;
let length = IndexInput::length(input)?;
output.copy_bytes(input, length)?;
success = true;
Ok(())
}));
let close_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
IOUtils::close_with(0..2, |operation| match operation {
0 => match output.as_mut() {
Some(output) => output.close(),
None => Ok(()),
},
_ => match input.as_mut() {
Some(input) => input.close(),
None => Ok(()),
},
})
}));
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
IOUtils::use_or_suppress_caught_result(body_result, close_result)
}));
if !success {
IOUtils::delete_files_ignoring_exceptions(self, [dest]);
}
unwrap_caught_result!(result)
}
fn as_erased_directory(&self) -> Option<&dyn ErasedDirectory> {
None
}
fn get_pending_deletions(&self) -> Result<HashSet<String>>;
#[cfg(test)]
fn is_fs_directory(&self) -> bool {
false
}
fn ensure_open(&self) -> Result<()> {
Ok(())
}
}
pub fn get_temp_file_name(prefix: &str, suffix: &str, counter: u64) -> String {
let counter_str = BigInt::from(counter).to_str_radix(36);
format!("{prefix}_{suffix}_{counter_str}.tmp")
}
pub trait ErasedDirectory:
Directory<IndexOutput = IndexOutputEnum, IndexInput = IndexInputEnum, Lock = LockEnum> + Send + Sync
{
fn copy_from_erased(
&self,
from: &dyn ErasedDirectory,
src: &str,
dest: &str,
context: &IOContext,
) -> Result<()>;
}
impl<T> ErasedDirectory for T
where
T: Directory<IndexOutput = IndexOutputEnum, IndexInput = IndexInputEnum, Lock = LockEnum>
+ Send
+ Sync,
{
fn copy_from_erased(
&self,
from: &dyn ErasedDirectory,
src: &str,
dest: &str,
context: &IOContext,
) -> Result<()> {
self.copy_from(from, src, dest, context)
}
}
pub type DynDirectory = dyn ErasedDirectory;
pub type CustomDirectory = Box<DynDirectory>;
pub enum DirectoryEnum {
Fs(FSDirectory<NativeFSLockFactory, NIOFSDirectory>),
Custom(CustomDirectory),
}
impl DirectoryEnum {
pub fn custom<D>(directory: D) -> Self
where
D: ErasedDirectory + 'static,
{
Self::Custom(Box::new(directory))
}
}
impl From<FSDirectory<NativeFSLockFactory, NIOFSDirectory>> for DirectoryEnum {
fn from(directory: FSDirectory<NativeFSLockFactory, NIOFSDirectory>) -> Self {
Self::Fs(directory)
}
}
impl Display for DirectoryEnum {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
Self::Fs(inner) => inner.fmt(f),
Self::Custom(inner) => inner.fmt(f),
}
}
}
impl HasIdentity for DirectoryEnum {
fn identity(&self) -> &Identity {
match self {
Self::Fs(inner) => inner.identity(),
Self::Custom(inner) => inner.identity(),
}
}
}
impl Directory for DirectoryEnum {
fn list_all(&self) -> Result<Vec<String>> {
match self {
Self::Fs(inner) => inner.list_all(),
Self::Custom(inner) => inner.list_all(),
}
}
fn delete_file(&self, name: &str) -> Result<()> {
match self {
Self::Fs(inner) => inner.delete_file(name),
Self::Custom(inner) => inner.delete_file(name),
}
}
fn file_length(&self, name: &str) -> Result<usize> {
match self {
Self::Fs(inner) => inner.file_length(name),
Self::Custom(inner) => inner.file_length(name),
}
}
type IndexOutput = IndexOutputEnum;
fn create_output(&self, name: &str, context: &IOContext) -> Result<Self::IndexOutput> {
match self {
Self::Fs(inner) => Ok(IndexOutputEnum::Fs(inner.create_output(name, context)?)),
Self::Custom(inner) => inner.create_output(name, context),
}
}
fn create_temp_output(
&self,
prefix: &str,
suffix: &str,
context: &IOContext,
) -> Result<Self::IndexOutput> {
match self {
Self::Fs(inner) => Ok(IndexOutputEnum::Fs(
inner.create_temp_output(prefix, suffix, context)?,
)),
Self::Custom(inner) => inner.create_temp_output(prefix, suffix, context),
}
}
fn sync(&self, names: &[String]) -> Result<()> {
match self {
Self::Fs(inner) => inner.sync(names),
Self::Custom(inner) => inner.sync(names),
}
}
fn sync_metadata(&self) -> Result<()> {
match self {
Self::Fs(inner) => inner.sync_metadata(),
Self::Custom(inner) => inner.sync_metadata(),
}
}
fn rename(&self, source: &str, dest: &str) -> Result<()> {
match self {
Self::Fs(inner) => inner.rename(source, dest),
Self::Custom(inner) => inner.rename(source, dest),
}
}
type IndexInput = IndexInputEnum;
fn open_input(&self, name: &str, context: &IOContext) -> Result<Self::IndexInput> {
match self {
Self::Fs(inner) => Ok(IndexInputEnum::Fs(inner.open_input(name, context)?)),
Self::Custom(inner) => inner.open_input(name, context),
}
}
type Lock = LockEnum;
fn obtain_lock(&self, name: &str) -> Result<Self::Lock> {
match self {
Self::Fs(inner) => Ok(LockEnum::Native(inner.obtain_lock(name)?)),
Self::Custom(inner) => inner.obtain_lock(name),
}
}
fn copy_from<D>(&self, from: &D, src: &str, dest: &str, context: &IOContext) -> Result<()>
where
D: Directory + ?Sized,
{
match self {
Self::Fs(inner) => inner.copy_from(from, src, dest, context),
Self::Custom(inner) => {
if let Some(from) = from.as_erased_directory() {
inner.copy_from_erased(from, src, dest, context)
} else {
Err(LuceneError::unsupported_operation(
"custom Directory copy_from requires an erased source Directory",
))
}
},
}
}
fn as_erased_directory(&self) -> Option<&dyn ErasedDirectory> {
Some(self)
}
fn get_pending_deletions(&self) -> Result<HashSet<String>> {
match self {
Self::Fs(inner) => inner.get_pending_deletions(),
Self::Custom(inner) => inner.get_pending_deletions(),
}
}
#[cfg(test)]
fn is_fs_directory(&self) -> bool {
match self {
Self::Fs(inner) => inner.is_fs_directory(),
Self::Custom(inner) => inner.is_fs_directory(),
}
}
fn ensure_open(&self) -> Result<()> {
match self {
Self::Fs(inner) => inner.ensure_open(),
Self::Custom(inner) => inner.ensure_open(),
}
}
}
impl CloseableRef for DirectoryEnum {
fn close(&self) -> Result<()> {
match self {
Self::Fs(inner) => inner.close(),
Self::Custom(inner) => inner.close(),
}
}
}
macro_rules! either_directory {
($vis:vis $name:ident, $index_output:ident, $index_input:ident, $lock:ident { $( $Variant:ident : $T:ident ),+ $(,)? }) => {
$vis enum $name<$( $T ),+> {
$( $Variant($T), )+
}
impl<$( $T ),+> Display for $name<$( $T ),+>
where
$( $T: Display ),+
{
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
$( Self::$Variant(inner) => inner.fmt(f), )+
}
}
}
impl<$( $T ),+> HasIdentity for $name<$( $T ),+>
where
$( $T: HasIdentity ),+
{
fn identity(&self) -> &Identity {
match self {
$( Self::$Variant(inner) => inner.identity(), )+
}
}
}
impl<$( $T ),+> Directory for $name<$( $T ),+>
where
$( $T: Directory ),+
{
fn list_all(&self) -> Result<Vec<String>> {
match self {
$( Self::$Variant(inner) => inner.list_all(), )+
}
}
fn delete_file(&self, name: &str) -> Result<()> {
match self {
$( Self::$Variant(inner) => inner.delete_file(name), )+
}
}
fn file_length(&self, name: &str) -> Result<usize> {
match self {
$( Self::$Variant(inner) => inner.file_length(name), )+
}
}
fn create_output(&self, name: &str, context: &IOContext) -> Result<Self::IndexOutput> {
match self {
$( Self::$Variant(inner) => Ok($index_output::$Variant(
inner.create_output(name, context)?,
)), )+
}
}
type IndexOutput = $index_output<$( $T::IndexOutput ),+>;
fn create_temp_output(
&self,
prefix: &str,
suffix: &str,
context: &IOContext,
) -> Result<Self::IndexOutput> {
match self {
$( Self::$Variant(inner) => Ok($index_output::$Variant(
inner.create_temp_output(prefix, suffix, context)?,
)), )+
}
}
fn sync(&self, names: &[String]) -> Result<()> {
match self {
$( Self::$Variant(inner) => inner.sync(names), )+
}
}
fn sync_metadata(&self) -> Result<()> {
match self {
$( Self::$Variant(inner) => inner.sync_metadata(), )+
}
}
fn rename(&self, source: &str, dest: &str) -> Result<()> {
match self {
$( Self::$Variant(inner) => inner.rename(source, dest), )+
}
}
type IndexInput = $index_input<$( $T::IndexInput ),+>;
fn open_input(&self, name: &str, context: &IOContext) -> Result<Self::IndexInput> {
match self {
$( Self::$Variant(inner) => Ok($index_input::$Variant(
inner.open_input(name, context)?,
)), )+
}
}
fn open_checksum_input(
&self,
name: &str,
) -> Result<BufferedChecksumIndexInput<Self::IndexInput>> {
let input = self.open_input(name, IO_CONTEXT_DEFAULT.as_ref().map_err(Clone::clone)?)?;
Ok(BufferedChecksumIndexInput::new(input))
}
type Lock = $lock<$( $T::Lock ),+>;
fn obtain_lock(&self, name: &str) -> Result<Self::Lock> {
match self {
$( Self::$Variant(inner) => Ok($lock::$Variant(inner.obtain_lock(name)?)), )+
}
}
fn copy_from<D>(
&self,
from: &D,
src: &str,
dest: &str,
context: &IOContext,
) -> Result<()>
where
D: Directory + ?Sized,
{
match self {
$( Self::$Variant(inner) => inner.copy_from(from, src, dest, context), )+
}
}
fn get_pending_deletions(&self) -> Result<HashSet<String>> {
match self {
$( Self::$Variant(inner) => inner.get_pending_deletions(), )+
}
}
#[cfg(test)]
fn is_fs_directory(&self) -> bool {
match self {
$( Self::$Variant(inner) => inner.is_fs_directory(), )+
}
}
fn ensure_open(&self) -> Result<()> {
match self {
$( Self::$Variant(inner) => inner.ensure_open(), )+
}
}
}
impl<$( $T ),+> CloseableRef for $name<$( $T ),+>
where
$( $T: CloseableRef ),+
{
fn close(&self) -> Result<()> {
match self {
$( Self::$Variant(inner) => inner.close(), )+
}
}
}
};
}
either_directory!(
pub DirectoryEnum2,
IndexOutputEnum2,
IndexInputEnum2,
LockEnum2 { A: A, B: B }
);
either_directory!(
pub DirectoryEnum3,
IndexOutputEnum3,
IndexInputEnum3,
LockEnum3 { A: A, B: B, C: C }
);
impl<D: Directory> Directory for &D {
fn list_all(&self) -> Result<Vec<String>> {
(**self).list_all()
}
fn delete_file(&self, name: &str) -> Result<()> {
(**self).delete_file(name)
}
fn file_length(&self, name: &str) -> Result<usize> {
(**self).file_length(name)
}
fn create_output(&self, name: &str, ctx: &IOContext) -> Result<Self::IndexOutput> {
(**self).create_output(name, ctx)
}
type IndexOutput = D::IndexOutput;
fn create_temp_output(&self, p: &str, s: &str, ctx: &IOContext) -> Result<Self::IndexOutput> {
(**self).create_temp_output(p, s, ctx)
}
fn sync(&self, names: &[String]) -> Result<()> {
(**self).sync(names)
}
fn sync_metadata(&self) -> Result<()> {
(**self).sync_metadata()
}
fn rename(&self, src: &str, dst: &str) -> Result<()> {
(**self).rename(src, dst)
}
type IndexInput = D::IndexInput;
fn open_input(&self, name: &str, ctx: &IOContext) -> Result<Self::IndexInput> {
(**self).open_input(name, ctx)
}
type Lock = D::Lock;
fn obtain_lock(&self, name: &str) -> Result<Self::Lock> {
(**self).obtain_lock(name)
}
fn copy_from<F>(&self, from: &F, src: &str, dst: &str, ctx: &IOContext) -> Result<()>
where
F: Directory + ?Sized,
{
(**self).copy_from(from, src, dst, ctx)
}
fn as_erased_directory(&self) -> Option<&dyn ErasedDirectory> {
(**self).as_erased_directory()
}
fn get_pending_deletions(&self) -> Result<HashSet<String>> {
(**self).get_pending_deletions()
}
#[cfg(test)]
fn is_fs_directory(&self) -> bool {
(**self).is_fs_directory()
}
fn ensure_open(&self) -> Result<()> {
(**self).ensure_open()
}
}
impl<D: Directory> Directory for Arc<D> {
fn list_all(&self) -> Result<Vec<String>> {
(**self).list_all()
}
fn delete_file(&self, name: &str) -> Result<()> {
(**self).delete_file(name)
}
fn file_length(&self, name: &str) -> Result<usize> {
(**self).file_length(name)
}
fn create_output(&self, name: &str, ctx: &IOContext) -> Result<Self::IndexOutput> {
(**self).create_output(name, ctx)
}
type IndexOutput = D::IndexOutput;
fn create_temp_output(&self, p: &str, s: &str, ctx: &IOContext) -> Result<Self::IndexOutput> {
(**self).create_temp_output(p, s, ctx)
}
fn sync(&self, names: &[String]) -> Result<()> {
(**self).sync(names)
}
fn sync_metadata(&self) -> Result<()> {
(**self).sync_metadata()
}
fn rename(&self, src: &str, dst: &str) -> Result<()> {
(**self).rename(src, dst)
}
type IndexInput = D::IndexInput;
fn open_input(&self, name: &str, ctx: &IOContext) -> Result<Self::IndexInput> {
(**self).open_input(name, ctx)
}
type Lock = D::Lock;
fn obtain_lock(&self, name: &str) -> Result<Self::Lock> {
(**self).obtain_lock(name)
}
fn copy_from<F>(&self, from: &F, src: &str, dst: &str, ctx: &IOContext) -> Result<()>
where
F: Directory + ?Sized,
{
(**self).copy_from(from, src, dst, ctx)
}
fn as_erased_directory(&self) -> Option<&dyn ErasedDirectory> {
(**self).as_erased_directory()
}
fn get_pending_deletions(&self) -> Result<HashSet<String>> {
(**self).get_pending_deletions()
}
#[cfg(test)]
fn is_fs_directory(&self) -> bool {
(**self).is_fs_directory()
}
fn ensure_open(&self) -> Result<()> {
(**self).ensure_open()
}
}
#[cfg(test)]
pub(crate) type SharedLockFactory = Arc<LockFactoryEnum>;
#[cfg(test)]
pub(crate) type NioDir = FSDirectory<SharedLockFactory, NIOFSDirectory>;
#[cfg(test)]
pub(crate) type MMapDir = FSDirectory<SharedLockFactory, MMapDirectory>;
#[cfg(test)]
pub(crate) type ByteBuffersDir = ByteBuffersDirectory<SharedLockFactory>;
#[cfg(test)]
type CoreDirIndexOutput =
IndexOutputEnum2<<NioDir as Directory>::IndexOutput, <ByteBuffersDir as Directory>::IndexOutput>;
#[cfg(test)]
type CoreDirIndexInput = IndexInputEnum3<
<NioDir as Directory>::IndexInput,
<MMapDir as Directory>::IndexInput,
<ByteBuffersDir as Directory>::IndexInput,
>;
#[cfg(test)]
type CoreDirLock = <NioDir as Directory>::Lock;
#[cfg(test)]
pub(crate) enum CoreDirEnum {
A(NioDir),
B(MMapDir),
C(ByteBuffersDir),
}
#[cfg(test)]
impl Display for CoreDirEnum {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
Self::A(inner) => inner.fmt(f),
Self::B(inner) => inner.fmt(f),
Self::C(inner) => inner.fmt(f),
}
}
}
#[cfg(test)]
impl HasIdentity for CoreDirEnum {
fn identity(&self) -> &Identity {
match self {
Self::A(inner) => inner.identity(),
Self::B(inner) => inner.identity(),
Self::C(inner) => inner.identity(),
}
}
}
#[cfg(test)]
impl CloseableRef for CoreDirEnum {
fn close(&self) -> Result<()> {
match self {
Self::A(inner) => inner.close(),
Self::B(inner) => inner.close(),
Self::C(inner) => inner.close(),
}
}
}
#[cfg(test)]
impl Directory for CoreDirEnum {
fn list_all(&self) -> Result<Vec<String>> {
match self {
Self::A(inner) => inner.list_all(),
Self::B(inner) => inner.list_all(),
Self::C(inner) => inner.list_all(),
}
}
fn delete_file(&self, name: &str) -> Result<()> {
match self {
Self::A(inner) => inner.delete_file(name),
Self::B(inner) => inner.delete_file(name),
Self::C(inner) => inner.delete_file(name),
}
}
fn file_length(&self, name: &str) -> Result<usize> {
match self {
Self::A(inner) => inner.file_length(name),
Self::B(inner) => inner.file_length(name),
Self::C(inner) => inner.file_length(name),
}
}
type IndexOutput = CoreDirIndexOutput;
fn create_output(&self, name: &str, context: &IOContext) -> Result<Self::IndexOutput> {
match self {
Self::A(inner) => inner.create_output(name, context).map(IndexOutputEnum2::A),
Self::B(inner) => inner.create_output(name, context).map(IndexOutputEnum2::A),
Self::C(inner) => inner.create_output(name, context).map(IndexOutputEnum2::B),
}
}
fn create_temp_output(
&self,
prefix: &str,
suffix: &str,
context: &IOContext,
) -> Result<Self::IndexOutput> {
match self {
Self::A(inner) => inner
.create_temp_output(prefix, suffix, context)
.map(IndexOutputEnum2::A),
Self::B(inner) => inner
.create_temp_output(prefix, suffix, context)
.map(IndexOutputEnum2::A),
Self::C(inner) => inner
.create_temp_output(prefix, suffix, context)
.map(IndexOutputEnum2::B),
}
}
fn sync(&self, names: &[String]) -> Result<()> {
match self {
Self::A(inner) => inner.sync(names),
Self::B(inner) => inner.sync(names),
Self::C(inner) => inner.sync(names),
}
}
fn sync_metadata(&self) -> Result<()> {
match self {
Self::A(inner) => inner.sync_metadata(),
Self::B(inner) => inner.sync_metadata(),
Self::C(inner) => inner.sync_metadata(),
}
}
fn rename(&self, source: &str, dest: &str) -> Result<()> {
match self {
Self::A(inner) => inner.rename(source, dest),
Self::B(inner) => inner.rename(source, dest),
Self::C(inner) => inner.rename(source, dest),
}
}
type IndexInput = CoreDirIndexInput;
fn open_input(&self, name: &str, context: &IOContext) -> Result<Self::IndexInput> {
match self {
Self::A(inner) => inner.open_input(name, context).map(IndexInputEnum3::A),
Self::B(inner) => inner.open_input(name, context).map(IndexInputEnum3::B),
Self::C(inner) => inner.open_input(name, context).map(IndexInputEnum3::C),
}
}
type Lock = CoreDirLock;
fn obtain_lock(&self, name: &str) -> Result<Self::Lock> {
match self {
Self::A(inner) => inner.obtain_lock(name),
Self::B(inner) => inner.obtain_lock(name),
Self::C(inner) => inner.obtain_lock(name),
}
}
fn copy_from<D>(&self, from: &D, src: &str, dest: &str, context: &IOContext) -> Result<()>
where
D: Directory + ?Sized,
{
match self {
Self::A(inner) => inner.copy_from(from, src, dest, context),
Self::B(inner) => inner.copy_from(from, src, dest, context),
Self::C(inner) => inner.copy_from(from, src, dest, context),
}
}
fn get_pending_deletions(&self) -> Result<HashSet<String>> {
match self {
Self::A(inner) => inner.get_pending_deletions(),
Self::B(inner) => inner.get_pending_deletions(),
Self::C(inner) => inner.get_pending_deletions(),
}
}
fn is_fs_directory(&self) -> bool {
match self {
Self::A(inner) => inner.is_fs_directory(),
Self::B(inner) => inner.is_fs_directory(),
Self::C(inner) => inner.is_fs_directory(),
}
}
fn ensure_open(&self) -> Result<()> {
match self {
Self::A(inner) => inner.ensure_open(),
Self::B(inner) => inner.ensure_open(),
Self::C(inner) => inner.ensure_open(),
}
}
}
#[cfg(test)]
pub(crate) type FileSwitchDir = FileSwitchDirectory<CoreDirEnum>;
#[cfg(test)]
type MaybeNrtIndexInput =
IndexInputEnum2<<RawDirEnum as Directory>::IndexInput, ByteBuffersIndexInputOwned>;
#[cfg(test)]
type MaybeNrtIndexOutput =
IndexOutputEnum2<<RawDirEnum as Directory>::IndexOutput, DirectoryByteBuffersIndexOutput>;
#[cfg(test)]
pub(crate) enum MaybeNrtDirEnum {
Raw(RawDirEnum),
Nrt(NRTCachingDirectory<RawDirEnum>),
}
#[cfg(test)]
impl Display for MaybeNrtDirEnum {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
Self::Raw(directory) => directory.fmt(f),
Self::Nrt(directory) => directory.fmt(f),
}
}
}
#[cfg(test)]
impl HasIdentity for MaybeNrtDirEnum {
fn identity(&self) -> &Identity {
match self {
Self::Raw(directory) => directory.identity(),
Self::Nrt(directory) => directory.identity(),
}
}
}
#[cfg(test)]
impl CloseableRef for MaybeNrtDirEnum {
fn close(&self) -> Result<()> {
match self {
Self::Raw(directory) => directory.close(),
Self::Nrt(directory) => directory.close(),
}
}
}
#[cfg(test)]
impl Directory for MaybeNrtDirEnum {
fn list_all(&self) -> Result<Vec<String>> {
match self {
Self::Raw(directory) => directory.list_all(),
Self::Nrt(directory) => directory.list_all(),
}
}
fn delete_file(&self, name: &str) -> Result<()> {
match self {
Self::Raw(directory) => directory.delete_file(name),
Self::Nrt(directory) => directory.delete_file(name),
}
}
fn file_length(&self, name: &str) -> Result<usize> {
match self {
Self::Raw(directory) => directory.file_length(name),
Self::Nrt(directory) => directory.file_length(name),
}
}
type IndexOutput = MaybeNrtIndexOutput;
fn create_output(&self, name: &str, context: &IOContext) -> Result<Self::IndexOutput> {
match self {
Self::Raw(directory) => Ok(IndexOutputEnum2::A(directory.create_output(name, context)?)),
Self::Nrt(directory) => match directory.create_output(name, context)? {
IndexOutputEnum2::A(output) => Ok(IndexOutputEnum2::B(output)),
IndexOutputEnum2::B(output) => Ok(IndexOutputEnum2::A(output)),
},
}
}
fn create_temp_output(
&self,
prefix: &str,
suffix: &str,
context: &IOContext,
) -> Result<Self::IndexOutput> {
match self {
Self::Raw(directory) => Ok(IndexOutputEnum2::A(
directory.create_temp_output(prefix, suffix, context)?,
)),
Self::Nrt(directory) => match directory.create_temp_output(prefix, suffix, context)? {
IndexOutputEnum2::A(output) => Ok(IndexOutputEnum2::B(output)),
IndexOutputEnum2::B(output) => Ok(IndexOutputEnum2::A(output)),
},
}
}
fn sync(&self, names: &[String]) -> Result<()> {
match self {
Self::Raw(directory) => directory.sync(names),
Self::Nrt(directory) => directory.sync(names),
}
}
fn sync_metadata(&self) -> Result<()> {
match self {
Self::Raw(directory) => directory.sync_metadata(),
Self::Nrt(directory) => directory.sync_metadata(),
}
}
fn rename(&self, source: &str, dest: &str) -> Result<()> {
match self {
Self::Raw(directory) => directory.rename(source, dest),
Self::Nrt(directory) => directory.rename(source, dest),
}
}
type IndexInput = MaybeNrtIndexInput;
fn open_input(&self, name: &str, context: &IOContext) -> Result<Self::IndexInput> {
match self {
Self::Raw(directory) => Ok(IndexInputEnum2::A(directory.open_input(name, context)?)),
Self::Nrt(directory) => match directory.open_input(name, context)? {
crate::core::store::NRTCachingIndexInput::A(input) => Ok(IndexInputEnum2::B(input)),
crate::core::store::NRTCachingIndexInput::B(input) => Ok(IndexInputEnum2::A(input)),
},
}
}
type Lock = <RawDirEnum as Directory>::Lock;
fn obtain_lock(&self, name: &str) -> Result<Self::Lock> {
match self {
Self::Raw(directory) => directory.obtain_lock(name),
Self::Nrt(directory) => directory.obtain_lock(name),
}
}
fn copy_from<D>(&self, from: &D, src: &str, dest: &str, context: &IOContext) -> Result<()>
where
D: Directory + ?Sized,
{
match self {
Self::Raw(directory) => directory.copy_from(from, src, dest, context),
Self::Nrt(directory) => directory.copy_from(from, src, dest, context),
}
}
fn get_pending_deletions(&self) -> Result<HashSet<String>> {
match self {
Self::Raw(directory) => directory.get_pending_deletions(),
Self::Nrt(directory) => directory.get_pending_deletions(),
}
}
#[cfg(test)]
fn is_fs_directory(&self) -> bool {
match self {
Self::Raw(directory) => directory.is_fs_directory(),
Self::Nrt(directory) => directory.is_fs_directory(),
}
}
fn ensure_open(&self) -> Result<()> {
match self {
Self::Raw(directory) => directory.ensure_open(),
Self::Nrt(directory) => directory.ensure_open(),
}
}
}
#[cfg(test)]
pub(crate) type RawDirWrapper = RawDirectoryWrapper<MaybeNrtDirEnum>;
#[cfg(test)]
type MockDirWrapperInner = MockDirectoryWrapper<MaybeNrtDirEnum>;
#[cfg(test)]
#[derive(Clone)]
pub(crate) struct MockDirWrapper(MockDirWrapperInner);
#[cfg(test)]
impl MockDirWrapper {
pub(crate) fn from_inner(directory: MockDirWrapperInner) -> Self {
Self(directory)
}
}
#[cfg(test)]
impl Deref for MockDirWrapper {
type Target = MockDirWrapperInner;
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[cfg(test)]
impl DerefMut for MockDirWrapper {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
#[cfg(test)]
impl Display for MockDirWrapper {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
self.0.fmt(f)
}
}
#[cfg(test)]
impl HasIdentity for MockDirWrapper {
fn identity(&self) -> &Identity {
self.0.identity()
}
}
#[cfg(test)]
impl Directory for MockDirWrapper {
fn list_all(&self) -> Result<Vec<String>> {
self.0.list_all()
}
fn delete_file(&self, name: &str) -> Result<()> {
self.0.delete_file(name)
}
fn file_length(&self, name: &str) -> Result<usize> {
self.0.file_length(name)
}
type IndexOutput = DirIndexOutput;
fn create_output(&self, name: &str, context: &IOContext) -> Result<Self::IndexOutput> {
Ok(DirIndexOutput(IndexOutputEnum2::B(
self.0.create_output(name, context)?,
)))
}
fn create_temp_output(
&self,
prefix: &str,
suffix: &str,
context: &IOContext,
) -> Result<Self::IndexOutput> {
Ok(DirIndexOutput(IndexOutputEnum2::B(
self.0.create_temp_output(prefix, suffix, context)?,
)))
}
fn sync(&self, names: &[String]) -> Result<()> {
self.0.sync(names)
}
fn sync_metadata(&self) -> Result<()> {
self.0.sync_metadata()
}
fn rename(&self, source: &str, dest: &str) -> Result<()> {
self.0.rename(source, dest)
}
type IndexInput = DirIndexInput;
fn open_input(&self, name: &str, context: &IOContext) -> Result<Self::IndexInput> {
Ok(DirIndexInput(IndexInputEnum2::B(
self.0.open_input(name, context)?,
)))
}
fn open_checksum_input(
&self,
name: &str,
) -> Result<BufferedChecksumIndexInput<Self::IndexInput>> {
Ok(BufferedChecksumIndexInput::new(
self.open_input(name, &IOContext::read_once_io_context()?)?,
))
}
type Lock = <MockDirWrapperInner as Directory>::Lock;
fn obtain_lock(&self, name: &str) -> Result<Self::Lock> {
self.0.obtain_lock(name)
}
fn copy_from<D>(&self, from: &D, src: &str, dest: &str, context: &IOContext) -> Result<()>
where
D: Directory + ?Sized,
{
self.0.copy_from(from, src, dest, context)
}
fn get_pending_deletions(&self) -> Result<HashSet<String>> {
self.0.get_pending_deletions()
}
#[cfg(test)]
fn is_fs_directory(&self) -> bool {
self.0.is_fs_directory()
}
fn ensure_open(&self) -> Result<()> {
self.0.ensure_open()
}
}
#[cfg(test)]
impl CloseableRef for MockDirWrapper {
fn close(&self) -> Result<()> {
self.0.close()
}
}
#[cfg(test)]
type DirIndexOutputInner = IndexOutputEnum2<
<RawDirWrapper as Directory>::IndexOutput,
<MockDirWrapperInner as Directory>::IndexOutput,
>;
#[cfg(test)]
pub(crate) struct DirIndexOutput(DirIndexOutputInner);
#[cfg(test)]
impl DataOutput for DirIndexOutput {
fn write_byte(&mut self, b: u8) -> Result<()> {
self.0.write_byte(b)
}
fn write_bytes_with_len(&mut self, b: &[u8], len: usize) -> Result<()> {
self.0.write_bytes_with_len(b, len)
}
fn write_bytes_range(&mut self, b: &[u8], offset: usize, length: usize) -> Result<()> {
self.0.write_bytes_range(b, offset, length)
}
fn write_int(&mut self, i: i32) -> Result<()> {
self.0.write_int(i)
}
fn write_short(&mut self, i: i16) -> Result<()> {
self.0.write_short(i)
}
fn write_vint(&mut self, i: i32) -> Result<()> {
self.0.write_vint(i)
}
fn write_zint(&mut self, i: i32) -> Result<()> {
self.0.write_zint(i)
}
fn write_long(&mut self, i: i64) -> Result<()> {
self.0.write_long(i)
}
fn write_vlong(&mut self, i: i64) -> Result<()> {
self.0.write_vlong(i)
}
fn write_signed_vlong(&mut self, i: i64) -> Result<()> {
self.0.write_signed_vlong(i)
}
fn write_zlong(&mut self, i: i64) -> Result<()> {
self.0.write_zlong(i)
}
fn write_string(&mut self, s: &str) -> Result<()> {
self.0.write_string(s)
}
fn copy_bytes<I>(&mut self, input: &mut I, num_bytes: usize) -> Result<()>
where
I: DataInput + ?Sized,
{
self.0.copy_bytes(input, num_bytes)
}
fn write_map_of_strings(&mut self, map: &HashMap<String, String>) -> Result<()> {
self.0.write_map_of_strings(map)
}
fn write_set_of_strings(&mut self, set: &HashSet<String>) -> Result<()> {
self.0.write_set_of_strings(set)
}
}
#[cfg(test)]
impl Display for DirIndexOutput {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
self.0.fmt(f)
}
}
#[cfg(test)]
impl Closeable for DirIndexOutput {
fn close(&mut self) -> Result<()> {
self.0.close()
}
}
#[cfg(test)]
impl IndexOutput for DirIndexOutput {
fn get_file_pointer(&self) -> Result<usize> {
self.0.get_file_pointer()
}
fn get_checksum(&mut self) -> Result<u64> {
self.0.get_checksum()
}
fn get_name(&self) -> &str {
self.0.get_name()
}
fn align_file_pointer(&mut self, alignment_bytes: usize) -> Result<usize> {
self.0.align_file_pointer(alignment_bytes)
}
}
#[cfg(test)]
type DirIndexInputInner = IndexInputEnum2<
<RawDirWrapper as Directory>::IndexInput,
<MockDirWrapperInner as Directory>::IndexInput,
>;
#[cfg(test)]
type DirRandomAccessInputInner = RandomAccessInputEnum2<
<<RawDirWrapper as Directory>::IndexInput as IndexInput>::RandomAccessSlice,
<<MockDirWrapperInner as Directory>::IndexInput as IndexInput>::RandomAccessSlice,
>;
#[cfg(test)]
pub(crate) struct DirIndexInput(DirIndexInputInner);
#[cfg(test)]
impl Display for DirIndexInput {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
self.0.fmt(f)
}
}
#[cfg(test)]
impl CloseableRef for DirIndexInput {
fn close(&self) -> Result<()> {
self.0.close()
}
}
#[cfg(test)]
impl TryClone for DirIndexInput {
fn try_clone(&self) -> Result<Self> {
Ok(Self(self.0.try_clone()?))
}
}
#[cfg(test)]
impl DataInput for DirIndexInput {
fn read_byte(&mut self) -> Result<u8> {
DataInput::read_byte(&mut self.0)
}
fn get_bytes<'a>(&'a mut self, len: usize) -> Result<std::borrow::Cow<'a, [u8]>> {
DataInput::get_bytes(&mut self.0, len)
}
fn read_bytes(&mut self, b: &mut [u8], offset: usize, len: usize) -> Result<()> {
DataInput::read_bytes(&mut self.0, b, offset, len)
}
fn read_bytes_with_buffer(
&mut self,
b: &mut [u8],
offset: usize,
len: usize,
use_buffer: bool,
) -> Result<()> {
self.0.read_bytes_with_buffer(b, offset, len, use_buffer)
}
fn read_short(&mut self) -> Result<i16> {
DataInput::read_short(&mut self.0)
}
fn read_int(&mut self) -> Result<i32> {
DataInput::read_int(&mut self.0)
}
fn read_group_vint(&mut self, dst: &mut [i32], offset: usize) -> Result<()> {
self.0.read_group_vint(dst, offset)
}
fn read_vint(&mut self) -> Result<i32> {
self.0.read_vint()
}
fn read_zint(&mut self) -> Result<i32> {
self.0.read_zint()
}
fn read_long(&mut self) -> Result<i64> {
DataInput::read_long(&mut self.0)
}
fn read_longs(&mut self, dst: &mut [i64], offset: usize, len: usize) -> Result<()> {
self.0.read_longs(dst, offset, len)
}
fn read_ints(&mut self, dst: &mut [i32], offset: usize, len: usize) -> Result<()> {
self.0.read_ints(dst, offset, len)
}
fn read_floats(&mut self, dst: &mut [f32], offset: usize, len: usize) -> Result<()> {
self.0.read_floats(dst, offset, len)
}
fn read_vlong(&mut self) -> Result<i64> {
self.0.read_vlong()
}
fn read_zlong(&mut self) -> Result<i64> {
self.0.read_zlong()
}
fn read_string<'a>(&'a mut self) -> Result<std::borrow::Cow<'a, str>> {
self.0.read_string()
}
fn read_map_of_strings(&mut self) -> Result<HashMap<String, String>> {
self.0.read_map_of_strings()
}
fn read_set_of_strings(&mut self) -> Result<HashSet<String>> {
self.0.read_set_of_strings()
}
fn skip_bytes(&mut self, num_bytes: i64) -> Result<()> {
DataInput::skip_bytes(&mut self.0, num_bytes)
}
}
#[cfg(test)]
impl DataInputExt for DirIndexInput {
crate::core::store::data_input_ext::impl_index_input_ext!();
}
#[cfg(test)]
pub(crate) struct DirRandomAccessInput(DirRandomAccessInputInner);
#[cfg(test)]
impl RandomAccessInput for DirRandomAccessInput {
fn length(&self) -> Result<usize> {
self.0.length()
}
fn read_byte(&self, pos: usize) -> Result<u8> {
self.0.read_byte(pos)
}
fn read_bytes(&self, pos: usize, len: usize) -> Result<std::borrow::Cow<'_, [u8]>> {
self.0.read_bytes(pos, len)
}
fn read_short(&self, pos: usize) -> Result<i16> {
self.0.read_short(pos)
}
fn read_int(&self, pos: usize) -> Result<i32> {
self.0.read_int(pos)
}
fn read_long(&self, pos: usize) -> Result<i64> {
self.0.read_long(pos)
}
fn prefetch(&self, pos: usize, len: usize) -> Result<()> {
RandomAccessInput::prefetch(&self.0, pos, len)
}
fn is_loaded(&self) -> Result<Option<bool>> {
self.0.is_loaded()
}
}
#[cfg(test)]
impl IndexInput for DirIndexInput {
type IndexInput = Self;
fn get_file_pointer(&self) -> Result<usize> {
self.0.get_file_pointer()
}
fn seek(&mut self, pos: usize) -> Result<()> {
self.0.seek(pos)
}
fn skip_bytes(&mut self, num_bytes: i64) -> Result<()> {
IndexInput::skip_bytes(&mut self.0, num_bytes)
}
fn length(&self) -> Result<usize> {
IndexInput::length(&self.0)
}
fn slice(
&self,
slice_description: &str,
offset: usize,
length: usize,
) -> Result<Self::IndexInput> {
Ok(Self(self.0.slice(slice_description, offset, length)?))
}
fn slice_with_read_advice(
&self,
description: &str,
offset: usize,
length: usize,
read_advice: &ReadAdvice,
) -> Result<Self::IndexInput> {
Ok(Self(self.0.slice_with_read_advice(
description,
offset,
length,
read_advice,
)?))
}
type RandomAccessSlice = DirRandomAccessInput;
fn random_access_slice(&self, offset: usize, length: usize) -> Result<Self::RandomAccessSlice> {
Ok(DirRandomAccessInput(
self.0.random_access_slice(offset, length)?,
))
}
fn prefetch(&self, pos: usize, len: usize) -> Result<()> {
IndexInput::prefetch(&self.0, pos, len)
}
fn update_read_advice(&self, read_advice: ReadAdvice) -> Result<()> {
self.0.update_read_advice(read_advice)
}
fn is_loaded(&self) -> Result<Option<bool>> {
IndexInput::is_loaded(&self.0)
}
}
#[cfg(test)]
pub(crate) enum DirEnum {
A(Box<RawDirWrapper>),
B(MockDirWrapper),
}
#[cfg(test)]
impl Display for DirEnum {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
Self::A(directory) => directory.fmt(f),
Self::B(directory) => directory.fmt(f),
}
}
}
#[cfg(test)]
impl HasIdentity for DirEnum {
fn identity(&self) -> &Identity {
match self {
Self::A(directory) => directory.identity(),
Self::B(directory) => directory.identity(),
}
}
}
#[cfg(test)]
impl Directory for DirEnum {
fn list_all(&self) -> Result<Vec<String>> {
match self {
Self::A(directory) => directory.list_all(),
Self::B(directory) => directory.list_all(),
}
}
fn delete_file(&self, name: &str) -> Result<()> {
match self {
Self::A(directory) => directory.delete_file(name),
Self::B(directory) => directory.delete_file(name),
}
}
fn file_length(&self, name: &str) -> Result<usize> {
match self {
Self::A(directory) => directory.file_length(name),
Self::B(directory) => directory.file_length(name),
}
}
type IndexOutput = DirIndexOutput;
fn create_output(&self, name: &str, context: &IOContext) -> Result<Self::IndexOutput> {
match self {
Self::A(directory) => Ok(DirIndexOutput(IndexOutputEnum2::A(
directory.create_output(name, context)?,
))),
Self::B(directory) => directory.create_output(name, context),
}
}
fn create_temp_output(
&self,
prefix: &str,
suffix: &str,
context: &IOContext,
) -> Result<Self::IndexOutput> {
match self {
Self::A(directory) => Ok(DirIndexOutput(IndexOutputEnum2::A(
directory.create_temp_output(prefix, suffix, context)?,
))),
Self::B(directory) => directory.create_temp_output(prefix, suffix, context),
}
}
fn sync(&self, names: &[String]) -> Result<()> {
match self {
Self::A(directory) => directory.sync(names),
Self::B(directory) => directory.sync(names),
}
}
fn sync_metadata(&self) -> Result<()> {
match self {
Self::A(directory) => directory.sync_metadata(),
Self::B(directory) => directory.sync_metadata(),
}
}
fn rename(&self, source: &str, dest: &str) -> Result<()> {
match self {
Self::A(directory) => directory.rename(source, dest),
Self::B(directory) => directory.rename(source, dest),
}
}
type IndexInput = DirIndexInput;
fn open_input(&self, name: &str, context: &IOContext) -> Result<Self::IndexInput> {
match self {
Self::A(directory) => Ok(DirIndexInput(IndexInputEnum2::A(
directory.open_input(name, context)?,
))),
Self::B(directory) => directory.open_input(name, context),
}
}
fn open_checksum_input(
&self,
name: &str,
) -> Result<BufferedChecksumIndexInput<Self::IndexInput>> {
let input = self.open_input(name, IO_CONTEXT_DEFAULT.as_ref().map_err(Clone::clone)?)?;
Ok(BufferedChecksumIndexInput::new(input))
}
type Lock = <RawDirWrapper as Directory>::Lock;
fn obtain_lock(&self, name: &str) -> Result<Self::Lock> {
match self {
Self::A(directory) => directory.obtain_lock(name),
Self::B(directory) => directory.obtain_lock(name),
}
}
fn copy_from<D>(&self, from: &D, src: &str, dest: &str, context: &IOContext) -> Result<()>
where
D: Directory + ?Sized,
{
match self {
Self::A(directory) => directory.copy_from(from, src, dest, context),
Self::B(directory) => directory.copy_from(from, src, dest, context),
}
}
fn get_pending_deletions(&self) -> Result<HashSet<String>> {
match self {
Self::A(directory) => directory.get_pending_deletions(),
Self::B(directory) => directory.get_pending_deletions(),
}
}
#[cfg(test)]
fn is_fs_directory(&self) -> bool {
match self {
Self::A(directory) => directory.is_fs_directory(),
Self::B(directory) => directory.is_fs_directory(),
}
}
fn ensure_open(&self) -> Result<()> {
match self {
Self::A(directory) => directory.ensure_open(),
Self::B(directory) => directory.ensure_open(),
}
}
}
#[cfg(test)]
impl CloseableRef for DirEnum {
fn close(&self) -> Result<()> {
match self {
Self::A(directory) => directory.close(),
Self::B(directory) => directory.close(),
}
}
}
#[cfg(test)]
impl DirEnum {
pub(crate) fn set_check_index_on_close(&self, value: bool) {
match self {
Self::A(directory) => directory.set_check_index_on_close(value),
Self::B(directory) => directory.set_check_index_on_close(value),
}
}
}
#[cfg(test)]
#[allow(
clippy::large_enum_variant,
reason = "Keep concrete test directories inline without adding a FileSwitchDir heap allocation"
)]
pub(crate) enum RawDirEnum {
Nio(NioDir),
MMap(MMapDir),
ByteBuffers(ByteBuffersDir),
FileSwitch(FileSwitchDir),
}
#[cfg(test)]
impl From<NioDir> for RawDirEnum {
fn from(directory: NioDir) -> Self {
Self::Nio(directory)
}
}
#[cfg(test)]
impl From<MMapDir> for RawDirEnum {
fn from(directory: MMapDir) -> Self {
Self::MMap(directory)
}
}
#[cfg(test)]
impl From<ByteBuffersDir> for RawDirEnum {
fn from(directory: ByteBuffersDir) -> Self {
Self::ByteBuffers(directory)
}
}
#[cfg(test)]
impl From<FileSwitchDir> for RawDirEnum {
fn from(directory: FileSwitchDir) -> Self {
Self::FileSwitch(directory)
}
}
#[cfg(test)]
impl Display for RawDirEnum {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
Self::Nio(inner) => inner.fmt(f),
Self::MMap(inner) => inner.fmt(f),
Self::ByteBuffers(inner) => inner.fmt(f),
Self::FileSwitch(inner) => inner.fmt(f),
}
}
}
#[cfg(test)]
impl HasIdentity for RawDirEnum {
fn identity(&self) -> &Identity {
match self {
Self::Nio(inner) => inner.identity(),
Self::MMap(inner) => inner.identity(),
Self::ByteBuffers(inner) => inner.identity(),
Self::FileSwitch(inner) => inner.identity(),
}
}
}
#[cfg(test)]
impl CloseableRef for RawDirEnum {
fn close(&self) -> Result<()> {
match self {
Self::Nio(inner) => inner.close(),
Self::MMap(inner) => inner.close(),
Self::ByteBuffers(inner) => inner.close(),
Self::FileSwitch(inner) => inner.close(),
}
}
}
#[cfg(test)]
impl Directory for RawDirEnum {
fn list_all(&self) -> Result<Vec<String>> {
match self {
Self::Nio(inner) => inner.list_all(),
Self::MMap(inner) => inner.list_all(),
Self::ByteBuffers(inner) => inner.list_all(),
Self::FileSwitch(inner) => inner.list_all(),
}
}
fn delete_file(&self, name: &str) -> Result<()> {
match self {
Self::Nio(inner) => inner.delete_file(name),
Self::MMap(inner) => inner.delete_file(name),
Self::ByteBuffers(inner) => inner.delete_file(name),
Self::FileSwitch(inner) => inner.delete_file(name),
}
}
fn file_length(&self, name: &str) -> Result<usize> {
match self {
Self::Nio(inner) => inner.file_length(name),
Self::MMap(inner) => inner.file_length(name),
Self::ByteBuffers(inner) => inner.file_length(name),
Self::FileSwitch(inner) => inner.file_length(name),
}
}
type IndexOutput = <CoreDirEnum as Directory>::IndexOutput;
fn create_output(&self, name: &str, context: &IOContext) -> Result<Self::IndexOutput> {
match self {
Self::Nio(inner) => Ok(IndexOutputEnum2::A(inner.create_output(name, context)?)),
Self::MMap(inner) => Ok(IndexOutputEnum2::A(inner.create_output(name, context)?)),
Self::ByteBuffers(inner) => Ok(IndexOutputEnum2::B(inner.create_output(name, context)?)),
Self::FileSwitch(inner) => inner.create_output(name, context),
}
}
fn create_temp_output(
&self,
prefix: &str,
suffix: &str,
context: &IOContext,
) -> Result<Self::IndexOutput> {
match self {
Self::Nio(inner) => Ok(IndexOutputEnum2::A(
inner.create_temp_output(prefix, suffix, context)?,
)),
Self::MMap(inner) => Ok(IndexOutputEnum2::A(
inner.create_temp_output(prefix, suffix, context)?,
)),
Self::ByteBuffers(inner) => Ok(IndexOutputEnum2::B(
inner.create_temp_output(prefix, suffix, context)?,
)),
Self::FileSwitch(inner) => inner.create_temp_output(prefix, suffix, context),
}
}
fn sync(&self, names: &[String]) -> Result<()> {
match self {
Self::Nio(inner) => inner.sync(names),
Self::MMap(inner) => inner.sync(names),
Self::ByteBuffers(inner) => inner.sync(names),
Self::FileSwitch(inner) => inner.sync(names),
}
}
fn sync_metadata(&self) -> Result<()> {
match self {
Self::Nio(inner) => inner.sync_metadata(),
Self::MMap(inner) => inner.sync_metadata(),
Self::ByteBuffers(inner) => inner.sync_metadata(),
Self::FileSwitch(inner) => inner.sync_metadata(),
}
}
fn rename(&self, source: &str, dest: &str) -> Result<()> {
match self {
Self::Nio(inner) => inner.rename(source, dest),
Self::MMap(inner) => inner.rename(source, dest),
Self::ByteBuffers(inner) => inner.rename(source, dest),
Self::FileSwitch(inner) => inner.rename(source, dest),
}
}
type IndexInput = <CoreDirEnum as Directory>::IndexInput;
fn open_input(&self, name: &str, context: &IOContext) -> Result<Self::IndexInput> {
match self {
Self::Nio(inner) => Ok(IndexInputEnum3::A(inner.open_input(name, context)?)),
Self::MMap(inner) => Ok(IndexInputEnum3::B(inner.open_input(name, context)?)),
Self::ByteBuffers(inner) => Ok(IndexInputEnum3::C(inner.open_input(name, context)?)),
Self::FileSwitch(inner) => inner.open_input(name, context),
}
}
type Lock = <CoreDirEnum as Directory>::Lock;
fn obtain_lock(&self, name: &str) -> Result<Self::Lock> {
match self {
Self::Nio(inner) => inner.obtain_lock(name),
Self::MMap(inner) => inner.obtain_lock(name),
Self::ByteBuffers(inner) => inner.obtain_lock(name),
Self::FileSwitch(inner) => inner.obtain_lock(name),
}
}
fn get_pending_deletions(&self) -> Result<HashSet<String>> {
match self {
Self::Nio(inner) => inner.get_pending_deletions(),
Self::MMap(inner) => inner.get_pending_deletions(),
Self::ByteBuffers(inner) => inner.get_pending_deletions(),
Self::FileSwitch(inner) => inner.get_pending_deletions(),
}
}
#[cfg(test)]
fn is_fs_directory(&self) -> bool {
match self {
Self::Nio(inner) => inner.is_fs_directory(),
Self::MMap(inner) => inner.is_fs_directory(),
Self::ByteBuffers(inner) => inner.is_fs_directory(),
Self::FileSwitch(inner) => inner.is_fs_directory(),
}
}
fn ensure_open(&self) -> Result<()> {
match self {
Self::Nio(inner) => inner.ensure_open(),
Self::MMap(inner) => inner.ensure_open(),
Self::ByteBuffers(inner) => inner.ensure_open(),
Self::FileSwitch(inner) => inner.ensure_open(),
}
}
}