use core::{error, fmt, marker};
#[cfg(feature = "alloc")]
extern crate alloc;
use crate::accumulator::{self, AccumulateResult, Accumulator};
use crate::charset::{self, Decoder, Encoder};
#[derive(Debug, Default)]
pub struct System<const N_CC: usize, Acc, Enc, Dec> {
_acc: marker::PhantomData<Acc>,
encoder: Enc,
decoder: Dec,
}
impl<const N_CC: usize, Acc, Enc, Dec> System<N_CC, Acc, Enc, Dec>
where
Acc: Accumulator<Computed = [u32; N_CC]> + Default,
Enc: Encoder,
Dec: Decoder,
{
#[cfg(feature = "alloc")]
#[track_caller]
pub fn protect(&self, s: &mut alloc::string::String) -> Result<(), ComputeError<char>> {
self.compute(s).map(|cc| s.extend(cc))
}
#[cfg(feature = "alloc")]
#[track_caller]
pub fn protect_lax(&self, s: &mut alloc::string::String) {
s.extend(self.compute_lax(s));
}
#[track_caller]
pub fn compute(&self, s: &str) -> Result<[char; N_CC], ComputeError<char>> {
self.compute_from_chars(s.chars())
}
#[track_caller]
pub fn compute_lax(&self, s: &str) -> [char; N_CC] {
self.compute_from_chars_lax(s.chars())
}
#[track_caller]
pub fn compute_from_chars(
&self,
chars: impl IntoIterator<Item = char>,
) -> Result<[char; N_CC], ComputeError<char>> {
let vs = self.compute_from_iter(chars)?;
Ok(self.encode_computed(vs))
}
#[track_caller]
pub fn compute_from_chars_lax(&self, chars: impl IntoIterator<Item = char>) -> [char; N_CC] {
let vs = self.lax_from_iter(chars).compute();
self.encode_computed(vs)
}
#[track_caller]
fn encode_computed(&self, values: [u32; N_CC]) -> [char; N_CC] {
const ERR: &str = "invalid charset implementation";
let mut chars = [char::default(); N_CC];
for (p, v) in chars.iter_mut().zip(values) {
*p = self.encoder.encode(v).expect(ERR);
}
chars
}
}
impl<const N_CC: usize, Acc, Enc, Dec> System<N_CC, Acc, Enc, Dec>
where
Acc: Accumulator + Default,
Dec: Decoder,
{
pub fn verify(&self, s: &str) -> Result<bool, VerifyError<char>> {
self.verify_from_chars(s.chars())
}
pub fn verify_lax(&self, s: &str) -> bool {
self.verify_from_chars_lax(s.chars())
}
pub fn verify_from_chars(
&self,
chars: impl IntoIterator<Item = char>,
) -> Result<bool, VerifyError<char>> {
self.verify_from_iter(chars)
}
pub fn verify_from_chars_lax(&self, chars: impl IntoIterator<Item = char>) -> bool {
self.lax_from_iter(chars).verify()
}
}
impl<const N_CC: usize, Acc, Enc, Dec> System<N_CC, Acc, Enc, Dec>
where
Acc: Accumulator + Default,
{
pub fn compute_from_values(
&self,
values: impl IntoIterator<Item = u32>,
) -> Result<Acc::Computed, ComputeError<u32>> {
self.compute_from_iter(values)
}
pub fn compute_from_values_lax(&self, values: impl IntoIterator<Item = u32>) -> Acc::Computed {
self.lax_from_iter(values).compute()
}
pub fn verify_from_values(
&self,
values: impl IntoIterator<Item = u32>,
) -> Result<bool, VerifyError<u32>> {
self.verify_from_iter(values)
}
pub fn verify_from_values_lax(&self, values: impl IntoIterator<Item = u32>) -> bool {
self.lax_from_iter(values).verify()
}
fn compute_from_iter<T: Accumulatable<Dec> + Copy>(
&self,
iter: impl IntoIterator<Item = T>,
) -> Result<Acc::Computed, ComputeError<T>> {
let mut acc = Acc::default();
for (pos, val) in iter.into_iter().enumerate() {
let AccumulateResult::Processed = val.accumulate_to(&mut acc, &self.decoder) else {
return Err(ComputeError { val, pos });
};
}
Ok(acc.compute())
}
fn verify_from_iter<T: Accumulatable<Dec> + Copy>(
&self,
iter: impl IntoIterator<Item = T>,
) -> Result<bool, VerifyError<T>> {
let mut acc = Acc::default();
let mut it = iter.into_iter().enumerate();
while let Some((pos, val)) = it.next() {
match val.accumulate_to(&mut acc, &self.decoder) {
AccumulateResult::Processed => (),
AccumulateResult::SupplFound => match it.next() {
None => break,
Some(_) => {
let kind = VerifyErrorKind::UnexpectedSuppl;
return Err(VerifyError { val, pos, kind });
}
},
AccumulateResult::NotInCharset => {
let kind = VerifyErrorKind::NotInCharset;
return Err(VerifyError { val, pos, kind });
}
}
}
Ok(acc.verify())
}
fn lax_from_iter<T: Accumulatable<Dec>>(&self, iter: impl IntoIterator<Item = T>) -> Acc {
let mut acc = Acc::default();
for val in iter {
let _ = val.accumulate_to(&mut acc, &self.decoder);
}
acc
}
pub const fn with_charset(encoder: Enc, decoder: Dec) -> Self {
Self {
_acc: marker::PhantomData,
encoder,
decoder,
}
}
}
trait Accumulatable<Dec> {
fn accumulate_to(self, acc: &mut impl Accumulator, decoder: &Dec) -> AccumulateResult;
}
impl<Dec> Accumulatable<Dec> for u32 {
#[inline]
fn accumulate_to(self, acc: &mut impl Accumulator, _decoder: &Dec) -> AccumulateResult {
acc.accumulate(self)
}
}
impl<Dec: Decoder> Accumulatable<Dec> for char {
#[inline]
fn accumulate_to(self, acc: &mut impl Accumulator, decoder: &Dec) -> AccumulateResult {
match decoder.decode(self) {
Some(value) => acc.accumulate(value),
None => AccumulateResult::NotInCharset,
}
}
}
pub type Mod11_2 = System<1, accumulator::Mod11_2, charset::NumericX, charset::NumericX>;
pub type Mod37_2 =
System<1, accumulator::Mod37_2, charset::AlphanumericAst, charset::AlphanumericAst>;
pub type Mod97_10 = System<2, accumulator::Mod97_10, charset::Numeric, charset::Numeric>;
pub type Mod661_26 = System<2, accumulator::Mod661_26, charset::Alphabetic, charset::Alphabetic>;
pub type Mod1271_36 =
System<2, accumulator::Mod1271_36, charset::Alphanumeric, charset::Alphanumeric>;
pub type Mod11_10 = System<1, accumulator::Mod11_10, charset::Numeric, charset::Numeric>;
pub type Mod27_26 = System<1, accumulator::Mod27_26, charset::Alphabetic, charset::Alphabetic>;
pub type Mod37_36 = System<1, accumulator::Mod37_36, charset::Alphanumeric, charset::Alphanumeric>;
#[derive(Debug)]
pub struct ComputeError<T> {
val: T,
pos: usize,
}
impl<T: fmt::Debug> fmt::Display for ComputeError<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let kind = VerifyErrorKind::NotInCharset;
write!(f, "{}: {:?} at {}", kind, self.val, self.pos)
}
}
impl<T: fmt::Debug> error::Error for ComputeError<T> {}
#[derive(Debug)]
pub struct VerifyError<T> {
val: T,
pos: usize,
kind: VerifyErrorKind,
}
impl<T: fmt::Debug> fmt::Display for VerifyError<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}: {:?} at {}", self.kind, self.val, self.pos)
}
}
impl<T: fmt::Debug> error::Error for VerifyError<T> {}
#[derive(Debug)]
enum VerifyErrorKind {
NotInCharset,
UnexpectedSuppl,
}
impl fmt::Display for VerifyErrorKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::NotInCharset => f.write_str("char not in charset"),
Self::UnexpectedSuppl => f.write_str("suppl check char not at end"),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(feature = "alloc")]
#[test]
fn do_not_mutate_on_error() {
let mod1271_36 = Mod1271_36::default();
let mut buf = alloc::string::String::from("0 1 2 3");
assert!(mod1271_36.protect(&mut buf).is_err());
assert_eq!(buf, "0 1 2 3");
}
#[test]
fn reject_unexpected_suppl() {
let mod11_2 = Mod11_2::default();
assert!(mod11_2.compute("012X34").is_err());
assert!(mod11_2.compute("01234X").is_err());
assert!(mod11_2.verify("012X34").is_err());
assert!(mod11_2.verify("01234X").is_ok());
}
#[test]
fn ignore_unexpected_suppl() {
let mod11_2 = Mod11_2::default();
assert_eq!(mod11_2.compute_lax("32X37"), ['X']);
assert_eq!(mod11_2.compute_lax("3237X"), ['X']);
assert!(mod11_2.verify_lax("32X37X"));
assert!(mod11_2.verify_lax("3237XX"));
assert!(mod11_2.verify_lax("3237X"));
}
}