use std::cmp::Ordering;
use crate::error::{BoxError, Error};
pub trait Migrate {
type From;
fn migrate(from: Self::From) -> Self;
}
pub fn from_tail<T, E, F>(decode: F) -> impl FnOnce(&[u8]) -> Result<(T, usize), E>
where
F: FnOnce(&[u8]) -> Result<(T, &[u8]), E>,
{
move |bytes: &[u8]| decode(bytes).map(|(value, tail)| (value, consumed_from_tail(bytes, tail)))
}
fn consumed_from_tail(payload: &[u8], tail: &[u8]) -> usize {
let payload_start = payload.as_ptr() as usize;
let payload_end = payload_start.wrapping_add(payload.len());
let tail_start = tail.as_ptr() as usize;
let tail_end = tail_start.wrapping_add(tail.len());
if tail_start >= payload_start && tail_end == payload_end {
tail_start - payload_start
} else if payload.is_empty() {
1
} else {
0
}
}
enum State<T> {
Pending,
Gap,
Decoded(Result<T, Error>),
}
#[must_use = "a chain does nothing until you call `done`"]
pub struct Chain<'a, T> {
tag: u16,
payload: &'a [u8],
state: State<T>,
known: Vec<u16>,
top: u16,
}
impl<'a, T> Chain<'a, T> {
pub(crate) fn seed<F, E>(tag: u16, payload: &'a [u8], version: u16, decode: F) -> Chain<'a, T>
where
F: FnOnce(&[u8]) -> Result<(T, usize), E>,
E: Into<BoxError>,
{
let state = match tag.cmp(&version) {
Ordering::Equal => State::Decoded(finish_decode(version, payload, decode)),
Ordering::Less => State::Gap,
Ordering::Greater => State::Pending,
};
Chain {
tag,
payload,
state,
known: vec![version],
top: version,
}
}
pub fn then<U, F, E>(self, version: u16, decode: F) -> Chain<'a, U>
where
U: Migrate<From = T>,
F: FnOnce(&[u8]) -> Result<(U, usize), E>,
E: Into<BoxError>,
{
self.then_with(version, decode, U::migrate)
}
pub fn then_with<U, F, E, M>(self, version: u16, decode: F, migrate: M) -> Chain<'a, U>
where
F: FnOnce(&[u8]) -> Result<(U, usize), E>,
E: Into<BoxError>,
M: FnOnce(T) -> U,
{
assert!(
version > self.top,
"verstamp: version {version} registered out of order; each `then` or \
`then_with` must use a version greater than every earlier one \
(highest so far is {})",
self.top
);
let state = match self.state {
State::Decoded(carried) => State::Decoded(carried.map(migrate)),
State::Gap => State::Gap,
State::Pending => match self.tag.cmp(&version) {
Ordering::Equal => State::Decoded(finish_decode(version, self.payload, decode)),
Ordering::Less => State::Gap,
Ordering::Greater => State::Pending,
},
};
let mut known = self.known;
known.push(version);
Chain {
tag: self.tag,
payload: self.payload,
state,
known,
top: self.top.max(version),
}
}
pub fn done(self) -> Result<T, Error> {
match self.state {
State::Decoded(result) => result,
State::Pending => Err(Error::ForwardIncompatible {
found: self.tag,
current: self.top,
}),
State::Gap => Err(Error::UnknownVersion {
found: self.tag,
known: self.known,
}),
}
}
}
fn finish_decode<T, F, E>(version: u16, payload: &[u8], decode: F) -> Result<T, Error>
where
F: FnOnce(&[u8]) -> Result<(T, usize), E>,
E: Into<BoxError>,
{
match decode(payload) {
Ok((value, consumed)) if consumed == payload.len() => Ok(value),
Ok((_, consumed)) => Err(Error::TrailingBytes {
version,
consumed,
total: payload.len(),
}),
Err(e) => Err(Error::Decode {
version,
source: e.into(),
}),
}
}