use std::fmt::Display;
use std::path::Path;
use std::sync::Arc;
use crate::impl_from_for_enum;
use std::fmt::Formatter;
use crate::core::store::lock::{Lock, LockEnum};
use crate::core::store::native_fs_lock_factory::NativeFSLockFactory;
use crate::core::store::no_lock_factory::NoLockFactory;
use crate::core::store::simple_fs_lock_factory::SimpleFSLockFactory;
use crate::core::store::single_instance_lock_factory::SingleInstanceLockFactory;
use crate::core::util::error::lucene_error::Result;
pub trait LockFactory: Display + Send + Sync {
type Lock: Lock;
fn obtain_lock(&self, dir: &Path, lock_name: &str) -> Result<Self::Lock>;
}
impl<LF> LockFactory for Arc<LF>
where
LF: LockFactory + ?Sized,
{
type Lock = LF::Lock;
fn obtain_lock(&self, dir: &Path, lock_name: &str) -> Result<Self::Lock> {
(**self).obtain_lock(dir, lock_name)
}
}
pub type DynLockFactory = dyn LockFactory<Lock = LockEnum> + Send + Sync;
pub type CustomLockFactory = Box<DynLockFactory>;
pub enum LockFactoryEnum {
Single(SingleInstanceLockFactory),
Simple(SimpleFSLockFactory),
Native(NativeFSLockFactory),
Custom(CustomLockFactory),
NoLock(NoLockFactory),
}
impl LockFactoryEnum {
pub fn custom<F>(lock_factory: F) -> Self
where
F: LockFactory<Lock = LockEnum> + Send + Sync + 'static,
{
Self::Custom(Box::new(lock_factory))
}
}
impl Display for LockFactoryEnum {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
Self::Single(inner) => inner.fmt(f),
Self::Simple(inner) => inner.fmt(f),
Self::Native(inner) => inner.fmt(f),
Self::Custom(inner) => inner.fmt(f),
Self::NoLock(inner) => inner.fmt(f),
}
}
}
impl LockFactory for LockFactoryEnum {
type Lock = LockEnum;
fn obtain_lock(&self, dir: &Path, lock_name: &str) -> Result<Self::Lock> {
match self {
Self::Single(inner) => inner.obtain_lock(dir, lock_name).map(LockEnum::Single),
Self::Simple(inner) => inner.obtain_lock(dir, lock_name).map(LockEnum::Simple),
Self::Native(inner) => inner.obtain_lock(dir, lock_name).map(LockEnum::Native),
Self::Custom(inner) => inner.obtain_lock(dir, lock_name),
Self::NoLock(inner) => inner.obtain_lock(dir, lock_name).map(LockEnum::NoLock),
}
}
}
impl_from_for_enum!(
LockFactoryEnum,
SingleInstanceLockFactory => Single,
SimpleFSLockFactory => Simple,
NativeFSLockFactory => Native,
NoLockFactory => NoLock,
);