use std::sync::Arc;
use crate::internal_protocol::{Opcode, OwnedRequestFrame};
use crate::internal_core::{Operation, Result};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum RequestRetryPolicy {
Always,
Never,
}
impl RequestRetryPolicy {
pub(crate) const fn is_safe(self) -> bool {
matches!(self, Self::Always)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct RequestContext {
pub(crate) opcode: Opcode,
pub(crate) operation: Operation,
pub(crate) mutation: bool,
pub(crate) retry_policy: RequestRetryPolicy,
}
pub(crate) trait RequestBuilder: Sized {
fn context(&self) -> RequestContext;
fn into_frame(self, request_id: u64) -> Result<OwnedRequestFrame>;
}
pub(crate) enum RequestAttempts<R> {
Once(Option<R>),
Replay(Option<Arc<OwnedRequestFrame>>),
}
impl<R: RequestBuilder> RequestAttempts<R> {
pub(crate) fn new(request: R, replayable: bool, request_id: u64) -> Result<Self> {
if replayable {
request
.into_frame(request_id)
.map(|frame| Self::Replay(Some(Arc::new(frame))))
} else {
Ok(Self::Once(Some(request)))
}
}
pub(crate) fn next(&mut self, final_attempt: bool) -> Option<PendingRequest<R>> {
match self {
Self::Once(request) => request.take().map(PendingRequest::Once),
Self::Replay(frame) if final_attempt => frame.take().map(PendingRequest::Replay),
Self::Replay(frame) => frame
.as_ref()
.map(|frame| PendingRequest::Replay(Arc::clone(frame))),
}
}
}
pub(crate) enum PendingRequest<R> {
Once(R),
Replay(Arc<OwnedRequestFrame>),
}
pub(crate) enum RequestAttempt {
Once(OwnedRequestFrame),
Replay(Arc<OwnedRequestFrame>),
}
impl RequestAttempt {
pub(crate) fn len(&self) -> usize {
self.frame().len()
}
fn frame(&self) -> &OwnedRequestFrame {
match self {
Self::Once(frame) => frame,
Self::Replay(frame) => frame,
}
}
pub(crate) fn segments(&self) -> impl Iterator<Item = &[u8]> {
self.frame().segments()
}
}