use super::{Contract, Direction, Error};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Connection {
pub id: u64,
pub generation: u64,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Outcome {
Admitted,
Completed,
Rejected(Error),
Cancelled,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Record {
pub connection: Connection,
pub contract: Contract,
pub direction: Direction,
pub sequence: Option<u64>,
pub outcome: Outcome,
}
pub struct Records<T: Copy, const CAP: usize> {
entries: [Option<T>; CAP],
head: usize,
len: usize,
lost: u64,
}
impl<T: Copy, const CAP: usize> Default for Records<T, CAP> {
fn default() -> Self {
Self::new()
}
}
impl<T: Copy, const CAP: usize> Records<T, CAP> {
#[must_use]
pub const fn new() -> Self {
Self {
entries: [None; CAP],
head: 0,
len: 0,
lost: 0,
}
}
pub fn push(&mut self, record: T) {
if CAP == 0 {
self.add_lost(1);
return;
}
if self.len == CAP {
self.entries[self.head] = Some(record);
self.head = (self.head + 1) % CAP;
self.add_lost(1);
} else {
self.entries[(self.head + self.len) % CAP] = Some(record);
self.len += 1;
}
}
pub fn pop(&mut self) -> Option<T> {
if self.len == 0 {
return None;
}
let record = self.entries[self.head].take();
self.head = (self.head + 1) % CAP;
self.len -= 1;
record
}
#[must_use]
pub const fn lost(&self) -> u64 {
self.lost
}
pub(crate) fn add_lost(&mut self, count: u64) {
self.lost = self.lost.saturating_add(count);
}
}
#[derive(Clone, Copy)]
struct FrameRecord {
sequence: Option<u64>,
outcome: Outcome,
}
pub struct Accountability {
connection: Connection,
contract: Contract,
direction: Direction,
sequence: Option<u64>,
terminal: bool,
records: Records<FrameRecord, 8>,
}
impl Accountability {
#[must_use]
pub const fn new(connection: Connection, contract: Contract, direction: Direction) -> Self {
Self {
connection,
contract,
direction,
sequence: None,
terminal: false,
records: Records::new(),
}
}
pub fn pop(&mut self) -> Option<Record> {
self.records.pop().map(|record| Record {
connection: self.connection,
contract: self.contract,
direction: self.direction,
sequence: record.sequence,
outcome: record.outcome,
})
}
#[must_use]
pub const fn lost(&self) -> u64 {
self.records.lost()
}
pub(crate) fn observe(&mut self, sequence: u64) {
self.sequence = Some(sequence);
}
pub(crate) fn record(&mut self, sequence: Option<u64>, outcome: Outcome) {
if !self.terminal {
self.records.push(FrameRecord { sequence, outcome });
}
}
pub(crate) fn admitted(&mut self) {
self.record(self.sequence, Outcome::Admitted);
}
pub(crate) fn completed(&mut self, sequence: u64) {
self.record(Some(sequence), Outcome::Completed);
}
pub(crate) fn finish(&mut self, error: Error) {
self.record(self.sequence, Outcome::Rejected(error));
self.terminal = true;
}
pub(crate) fn cancel(&mut self) {
self.record(self.sequence, Outcome::Cancelled);
self.terminal = true;
}
}