mini-enigma 0.3.0

#[no-std] (and no alloc) zero dependency implementation of the M3 Enigma
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use super::{ConversionError, ROTOR_SIZE_U8};

const ASCII_OFFSET: u8 = 65;

#[repr(u8)]
#[allow(missing_docs)]
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Default)]
/// Represent a letter in the enigma machine. Essentially a u8 mod 26.
pub enum Letter {
    #[default]
    A = 0,
    B = 1,
    C = 2,
    D = 3,
    E = 4,
    F = 5,
    G = 6,
    H = 7,
    I = 8,
    J = 9,
    K = 10,
    L = 11,
    M = 12,
    N = 13,
    O = 14,
    P = 15,
    Q = 16,
    R = 17,
    S = 18,
    T = 19,
    U = 20,
    V = 21,
    W = 22,
    X = 23,
    Y = 24,
    Z = 25,
}

impl core::ops::Add for Letter {
    type Output = Letter;
    fn add(self, rhs: Self) -> Self::Output {
        unsafe { core::mem::transmute::<u8, Letter>((self as u8 + rhs as u8) % ROTOR_SIZE_U8) }
    }
}
impl core::ops::Add<u8> for Letter {
    type Output = Letter;

    fn add(self, rhs: u8) -> Self::Output {
        unsafe { core::mem::transmute::<u8, Letter>((self as u8 + rhs) % ROTOR_SIZE_U8) }
    }
}
impl core::ops::Sub for Letter {
    type Output = Letter;

    fn sub(self, rhs: Self) -> Self::Output {
        unsafe {
            core::mem::transmute::<u8, Letter>(
                (self as u8 + (ROTOR_SIZE_U8 - rhs as u8 % ROTOR_SIZE_U8)) % ROTOR_SIZE_U8,
            )
        }
    }
}
impl core::ops::Sub<u8> for Letter {
    type Output = Letter;

    fn sub(self, rhs: u8) -> Self::Output {
        unsafe {
            core::mem::transmute::<u8, Letter>(
                (self as u8 + (ROTOR_SIZE_U8 - rhs % ROTOR_SIZE_U8)) % ROTOR_SIZE_U8,
            )
        }
    }
}
impl core::ops::AddAssign<u8> for Letter {
    fn add_assign(&mut self, rhs: u8) {
        *self = *self + rhs;
    }
}

impl From<Letter> for char {
    fn from(value: Letter) -> Self {
        (value as u8 + ASCII_OFFSET) as char
    }
}

impl TryFrom<char> for Letter {
    type Error = ConversionError;

    fn try_from(value: char) -> Result<Self, Self::Error> {
        if value > 64 as char && value <= 90 as char {
            Ok(unsafe { core::mem::transmute::<u8, Letter>(value as u8 - ASCII_OFFSET) })
        } else {
            Err(ConversionError)
        }
    }
}

impl From<u8> for Letter {
    fn from(value: u8) -> Self {
        unsafe { core::mem::transmute::<u8, Letter>(value % ROTOR_SIZE_U8) }
    }
}

impl Letter {
    /// Create a `Letter` from a `char`
    ///
    /// # Panics
    ///
    /// Unable to convert char
    #[must_use]
    pub const fn const_from_char(value: char) -> Letter {
        unsafe { core::mem::transmute::<u8, Letter>((value as u8 - ASCII_OFFSET) % ROTOR_SIZE_U8) }
    }

    /// Create a `Letter` from a `u8`
    #[must_use]
    pub const fn const_from_u8(value: u8) -> Letter {
        unsafe { core::mem::transmute::<u8, Letter>(value % ROTOR_SIZE_U8) }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(Letter::A + Letter::B, Letter::B);
        assert_eq!(Letter::Z + Letter::B, Letter::A);
        assert_eq!(Letter::Y + Letter::B, Letter::Z);
        assert_eq!(Letter::Y + Letter::E, Letter::C);
    }

    #[test]
    fn test_sub() {
        assert_eq!(Letter::B - Letter::B, Letter::A);
        assert_eq!(Letter::B - Letter::D, Letter::Y);
    }

    #[test]
    fn test_idx() {
        let arr = [Letter::C, Letter::B, Letter::A];
        assert_eq!(arr[Letter::B], Letter::B);
        assert_eq!(arr[Letter::A], Letter::C);
    }
}