use crate::core::index::index_commit::IndexCommit;
use crate::core::index::index_file_deleter::CommitPoint;
use crate::core::index::keep_only_last_commit_deletion_policy::KeepOnlyLastCommitDeletionPolicy;
use crate::core::index::no_deletion_policy::NoDeletionPolicy;
use crate::core::index::persistent_snapshot_deletion_policy::PersistentSnapshotDeletionPolicy;
use crate::core::index::snapshot_deletion_policy::{SnapshotCommitPoint, SnapshotDeletionPolicy};
use crate::core::store::directory::Directory;
use crate::core::util::error::lucene_error::{LuceneError, Result};
#[cfg(test)]
use crate::test_framework::core::index::deletion_policy::{
DeleteLastCommitPolicy, KeepAllTransactionDeletionPolicy, RollbackDeletionPolicy,
};
#[cfg(test)]
use crate::test_framework::core::index::deletion_policy::{
ExpirationTimeDeletionPolicy, KeepAllDeletionPolicy, KeepLastNDeletionPolicy,
KeepNoneOnInitDeletionPolicy,
};
#[cfg(test)]
use crate::test_framework::core::index::test_check_index::DeleteNothingIndexDeletionPolicy;
use std::fmt::{Display, Formatter};
use std::sync::Arc;
pub trait IndexDeletionPolicy<IC>: Display
where
IC: IndexCommit + Clone,
{
fn on_init(&self, commits: &[IC]) -> Result<()>;
fn on_commit(&self, commits: &[IC]) -> Result<()>;
}
pub enum IndexDeletionPolicyEnum<D> {
KeepOnlyLastCommit(KeepOnlyLastCommitDeletionPolicy),
No(NoDeletionPolicy),
Snapshot(Box<SnapshotDeletionPolicy<D>>),
PersistentSnapshot(Box<PersistentSnapshotDeletionPolicy<D>>),
#[cfg(test)]
KeepAll(KeepAllDeletionPolicy),
#[cfg(test)]
KeepNoneOnInit(KeepNoneOnInitDeletionPolicy),
#[cfg(test)]
KeepLastN(KeepLastNDeletionPolicy),
#[cfg(test)]
ExpirationTime(ExpirationTimeDeletionPolicy),
#[cfg(test)]
KeepAllTransaction(KeepAllTransactionDeletionPolicy),
#[cfg(test)]
Rollback(RollbackDeletionPolicy),
#[cfg(test)]
DeleteLastCommit(DeleteLastCommitPolicy),
#[cfg(test)]
DeleteNothing(DeleteNothingIndexDeletionPolicy),
}
impl<D> From<KeepOnlyLastCommitDeletionPolicy> for IndexDeletionPolicyEnum<D> {
fn from(policy: KeepOnlyLastCommitDeletionPolicy) -> Self {
Self::KeepOnlyLastCommit(policy)
}
}
impl<D> From<NoDeletionPolicy> for IndexDeletionPolicyEnum<D> {
fn from(policy: NoDeletionPolicy) -> Self {
Self::No(policy)
}
}
impl<D> From<SnapshotDeletionPolicy<D>> for IndexDeletionPolicyEnum<D> {
fn from(policy: SnapshotDeletionPolicy<D>) -> Self {
Self::Snapshot(Box::new(policy))
}
}
impl<D> From<PersistentSnapshotDeletionPolicy<D>> for IndexDeletionPolicyEnum<D> {
fn from(policy: PersistentSnapshotDeletionPolicy<D>) -> Self {
Self::PersistentSnapshot(Box::new(policy))
}
}
#[cfg(test)]
impl<D> From<KeepAllDeletionPolicy> for IndexDeletionPolicyEnum<D> {
fn from(policy: KeepAllDeletionPolicy) -> Self {
Self::KeepAll(policy)
}
}
#[cfg(test)]
impl<D> From<KeepNoneOnInitDeletionPolicy> for IndexDeletionPolicyEnum<D> {
fn from(policy: KeepNoneOnInitDeletionPolicy) -> Self {
Self::KeepNoneOnInit(policy)
}
}
#[cfg(test)]
impl<D> From<KeepLastNDeletionPolicy> for IndexDeletionPolicyEnum<D> {
fn from(policy: KeepLastNDeletionPolicy) -> Self {
Self::KeepLastN(policy)
}
}
#[cfg(test)]
impl<D> From<ExpirationTimeDeletionPolicy> for IndexDeletionPolicyEnum<D> {
fn from(policy: ExpirationTimeDeletionPolicy) -> Self {
Self::ExpirationTime(policy)
}
}
#[cfg(test)]
impl<D> From<KeepAllTransactionDeletionPolicy> for IndexDeletionPolicyEnum<D> {
fn from(policy: KeepAllTransactionDeletionPolicy) -> Self {
Self::KeepAllTransaction(policy)
}
}
#[cfg(test)]
impl<D> From<RollbackDeletionPolicy> for IndexDeletionPolicyEnum<D> {
fn from(policy: RollbackDeletionPolicy) -> Self {
Self::Rollback(policy)
}
}
#[cfg(test)]
impl<D> From<DeleteLastCommitPolicy> for IndexDeletionPolicyEnum<D> {
fn from(policy: DeleteLastCommitPolicy) -> Self {
Self::DeleteLastCommit(policy)
}
}
#[cfg(test)]
impl<D> From<DeleteNothingIndexDeletionPolicy> for IndexDeletionPolicyEnum<D> {
fn from(policy: DeleteNothingIndexDeletionPolicy) -> Self {
Self::DeleteNothing(policy)
}
}
impl<D> Display for IndexDeletionPolicyEnum<D> {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
Self::KeepOnlyLastCommit(policy) => write!(f, "{policy}"),
Self::No(policy) => write!(f, "{policy}"),
Self::Snapshot(policy) => write!(f, "{policy}"),
Self::PersistentSnapshot(policy) => write!(f, "{policy}"),
#[cfg(test)]
Self::KeepAll(policy) => write!(f, "{policy}"),
#[cfg(test)]
Self::KeepNoneOnInit(policy) => write!(f, "{policy}"),
#[cfg(test)]
Self::KeepLastN(policy) => write!(f, "{policy}"),
#[cfg(test)]
Self::ExpirationTime(policy) => write!(f, "{policy}"),
#[cfg(test)]
Self::KeepAllTransaction(policy) => write!(f, "{policy}"),
#[cfg(test)]
Self::Rollback(policy) => write!(f, "{policy}"),
#[cfg(test)]
Self::DeleteLastCommit(policy) => write!(f, "{policy}"),
#[cfg(test)]
Self::DeleteNothing(policy) => write!(f, "{policy}"),
}
}
}
impl<D> IndexDeletionPolicy<Arc<CommitPoint<D>>> for IndexDeletionPolicyEnum<D>
where
D: Directory,
{
fn on_init(&self, commits: &[Arc<CommitPoint<D>>]) -> Result<()> {
match self {
Self::KeepOnlyLastCommit(policy) => policy.on_init(commits),
Self::No(policy) => policy.on_init(commits),
Self::Snapshot(policy) => policy.on_init(commits),
Self::PersistentSnapshot(policy) => policy.on_init(commits),
#[cfg(test)]
Self::KeepAll(policy) => policy.on_init(commits),
#[cfg(test)]
Self::KeepNoneOnInit(policy) => policy.on_init(commits),
#[cfg(test)]
Self::KeepLastN(policy) => policy.on_init(commits),
#[cfg(test)]
Self::ExpirationTime(policy) => policy.on_init(commits),
#[cfg(test)]
Self::KeepAllTransaction(policy) => policy.on_init(commits),
#[cfg(test)]
Self::Rollback(policy) => policy.on_init(commits),
#[cfg(test)]
Self::DeleteLastCommit(policy) => policy.on_init(commits),
#[cfg(test)]
Self::DeleteNothing(policy) => policy.on_init(commits),
}
}
fn on_commit(&self, commits: &[Arc<CommitPoint<D>>]) -> Result<()> {
match self {
Self::KeepOnlyLastCommit(policy) => policy.on_commit(commits),
Self::No(policy) => policy.on_commit(commits),
Self::Snapshot(policy) => policy.on_commit(commits),
Self::PersistentSnapshot(policy) => policy.on_commit(commits),
#[cfg(test)]
Self::KeepAll(policy) => policy.on_commit(commits),
#[cfg(test)]
Self::KeepNoneOnInit(policy) => policy.on_commit(commits),
#[cfg(test)]
Self::KeepLastN(policy) => policy.on_commit(commits),
#[cfg(test)]
Self::ExpirationTime(policy) => policy.on_commit(commits),
#[cfg(test)]
Self::KeepAllTransaction(policy) => policy.on_commit(commits),
#[cfg(test)]
Self::Rollback(policy) => policy.on_commit(commits),
#[cfg(test)]
Self::DeleteLastCommit(policy) => policy.on_commit(commits),
#[cfg(test)]
Self::DeleteNothing(policy) => policy.on_commit(commits),
}
}
}
impl<'a, D> IndexDeletionPolicy<SnapshotCommitPoint<'a, D>> for IndexDeletionPolicyEnum<D>
where
D: Directory,
{
fn on_init(&self, commits: &[SnapshotCommitPoint<'a, D>]) -> Result<()> {
match self {
Self::KeepOnlyLastCommit(policy) => policy.on_init(commits),
Self::No(policy) => policy.on_init(commits),
Self::Snapshot(_) => Err(LuceneError::illegal_argument(
"SnapshotDeletionPolicy cannot wrap another SnapshotDeletionPolicy",
)),
Self::PersistentSnapshot(_) => Err(LuceneError::illegal_argument(
"SnapshotDeletionPolicy cannot wrap another SnapshotDeletionPolicy",
)),
#[cfg(test)]
Self::KeepAll(policy) => policy.on_init(commits),
#[cfg(test)]
Self::KeepNoneOnInit(policy) => policy.on_init(commits),
#[cfg(test)]
Self::KeepLastN(policy) => policy.on_init(commits),
#[cfg(test)]
Self::ExpirationTime(policy) => policy.on_init(commits),
#[cfg(test)]
Self::KeepAllTransaction(policy) => policy.on_init(commits),
#[cfg(test)]
Self::Rollback(policy) => policy.on_init(commits),
#[cfg(test)]
Self::DeleteLastCommit(policy) => policy.on_init(commits),
#[cfg(test)]
Self::DeleteNothing(policy) => policy.on_init(commits),
}
}
fn on_commit(&self, commits: &[SnapshotCommitPoint<'a, D>]) -> Result<()> {
match self {
Self::KeepOnlyLastCommit(policy) => policy.on_commit(commits),
Self::No(policy) => policy.on_commit(commits),
Self::Snapshot(_) => Err(LuceneError::illegal_argument(
"SnapshotDeletionPolicy cannot wrap another SnapshotDeletionPolicy",
)),
Self::PersistentSnapshot(_) => Err(LuceneError::illegal_argument(
"SnapshotDeletionPolicy cannot wrap another SnapshotDeletionPolicy",
)),
#[cfg(test)]
Self::KeepAll(policy) => policy.on_commit(commits),
#[cfg(test)]
Self::KeepNoneOnInit(policy) => policy.on_commit(commits),
#[cfg(test)]
Self::KeepLastN(policy) => policy.on_commit(commits),
#[cfg(test)]
Self::ExpirationTime(policy) => policy.on_commit(commits),
#[cfg(test)]
Self::KeepAllTransaction(policy) => policy.on_commit(commits),
#[cfg(test)]
Self::Rollback(policy) => policy.on_commit(commits),
#[cfg(test)]
Self::DeleteLastCommit(policy) => policy.on_commit(commits),
#[cfg(test)]
Self::DeleteNothing(policy) => policy.on_commit(commits),
}
}
}