#![allow(clippy::missing_errors_doc)]
mod admin_policy;
mod batch_policy;
mod client_policy;
mod commit_level;
mod concurrency;
mod consistency_level;
mod expiration;
mod generation_policy;
mod priority;
mod query_policy;
mod read_policy;
mod record_exists_action;
mod scan_policy;
mod write_policy;
pub use self::admin_policy::AdminPolicy;
pub use self::batch_policy::BatchPolicy;
pub use self::client_policy::ClientPolicy;
pub use self::commit_level::CommitLevel;
pub use self::concurrency::Concurrency;
pub use self::consistency_level::ConsistencyLevel;
pub use self::expiration::Expiration;
pub use self::generation_policy::GenerationPolicy;
pub use self::priority::Priority;
pub use self::query_policy::QueryPolicy;
pub use self::read_policy::ReadPolicy;
pub use self::record_exists_action::RecordExistsAction;
pub use self::scan_policy::ScanPolicy;
pub use self::write_policy::WritePolicy;
use crate::expressions::FilterExpression;
use std::option::Option;
use std::time::{Duration, Instant};
pub trait Policy {
fn priority(&self) -> &Priority;
#[doc(hidden)]
fn deadline(&self) -> Option<Instant>;
fn timeout(&self) -> Option<Duration>;
fn max_retries(&self) -> Option<usize>;
fn sleep_between_retries(&self) -> Option<Duration>;
fn consistency_level(&self) -> &ConsistencyLevel;
}
#[doc(hidden)]
pub trait PolicyLike {
fn base(&self) -> &BasePolicy;
}
impl<T> Policy for T
where
T: PolicyLike,
{
fn priority(&self) -> &Priority {
self.base().priority()
}
fn consistency_level(&self) -> &ConsistencyLevel {
self.base().consistency_level()
}
fn deadline(&self) -> Option<Instant> {
self.base().deadline()
}
fn timeout(&self) -> Option<Duration> {
self.base().timeout()
}
fn max_retries(&self) -> Option<usize> {
self.base().max_retries()
}
fn sleep_between_retries(&self) -> Option<Duration> {
self.base().sleep_between_retries()
}
}
#[derive(Debug, Clone)]
pub struct BasePolicy {
pub priority: Priority,
pub consistency_level: ConsistencyLevel,
pub timeout: Option<Duration>,
pub max_retries: Option<usize>,
pub sleep_between_retries: Option<Duration>,
pub filter_expression: Option<FilterExpression>,
}
impl Policy for BasePolicy {
fn priority(&self) -> &Priority {
&self.priority
}
fn deadline(&self) -> Option<Instant> {
match self.timeout {
Some(timeout) => Some(Instant::now() + timeout),
None => None,
}
}
fn timeout(&self) -> Option<Duration> {
self.timeout
}
fn max_retries(&self) -> Option<usize> {
self.max_retries
}
fn sleep_between_retries(&self) -> Option<Duration> {
self.sleep_between_retries
}
fn consistency_level(&self) -> &ConsistencyLevel {
&self.consistency_level
}
}