Struct Enigma

pub struct Enigma<R, P, O, const ROTOR_NUM: usize = DEFAULT_ROTOR_NUM> { /* private fields */ }

Enigma Finite State Machine

An incomplete instance (e.g. from Enigma::default) can be initialised later semi-dynamically with the compiler checking correct initialisation before use.

Examples

let enigma = Enigma::default()
    .set_rotors(Wheel::new([ROTOR_I, ROTOR_II, ROTOR_III]))
    .set_plugboard(Plugboard::new(&[]));

let mut enigma = enigma.set_reflector(REFLECTOR_A);

enigma.encrypt_letter(Letter::A);

The compiler can detect if one of the required initialisation steps is missing:

let mut enigma = Enigma::default()
    .set_rotors(Wheel::new([ROTOR_I, ROTOR_II, ROTOR_III]))
    .set_plugboard(Plugboard::new(&[]));

enigma.encrypt_letter(Letter::A); // encrypt can't be called until a reflector is set

Implementations

impl Enigma<Unset, Unset, Unset>

pub fn new<const ROTOR_NUM: usize>( config: &EnigmaSettings<ROTOR_NUM>, ) -> Enigma<Wheel<ROTOR_NUM>, Plugboard, Reflector, ROTOR_NUM>

Create a fully setup Enigma FSM from the provided settings

Examples

let mut enigma = Enigma::new(&EnigmaSettings {
    rotors: [ROTOR_II, ROTOR_IV, ROTOR_V],
    plugboard: Plugboard::from_str(
        "AV,BS,CG,DL,FU,HZ,IN,KM,OW,RX",
    ).unwrap(),
    reflector: REFLECTOR_B,
    ringstellung: [2, 21, 12],
    grundstellung: [Letter::B, Letter::L, Letter::A],
});
enigma.encrypt_letter(Letter::A);

Rust will attempt to determine whether to create an M3 or M4 (or another variant) based on the size of the rotor array. However, in some cases, it may be necessary to specify this explicitly:

let settings = EnigmaSettings {
    rotors: [ROTOR_II, ROTOR_IV, ROTOR_V, ROTOR_III],
    plugboard: Plugboard::from_str(
        "AV,BS,CG,DL,FU,HZ,IN,KM,OW,RX",
    ).unwrap(),
    reflector: REFLECTOR_B_THIN,
    ringstellung: [2, 21, 12, 3],
    grundstellung: [Letter::B, Letter::L, Letter::A, Letter::B],
};

let mut enigma = Enigma::new::<M4>(&settings);
enigma.encrypt_letter(Letter::A);

As alluded to above this also lets you create instances of machines that never existed. For example, a 10-rotor enigma machine can be created with Enigma::new<10>(&settings)

impl<AnyRotor, AnyPlugboard, AnyReflector, const ROTOR_NUM: usize> Enigma<AnyRotor, AnyPlugboard, AnyReflector, ROTOR_NUM>

pub fn set_rotors( self, rotors: Wheel, ) -> Enigma<Wheel, AnyPlugboard, AnyReflector, ROTOR_NUM>

Set the Enigma rotors

pub fn set_plugboard( self, plugboard: Plugboard, ) -> Enigma<AnyRotor, Plugboard, AnyReflector, ROTOR_NUM>

Set the Enigma plguboard

pub fn set_reflector( self, reflector: Reflector, ) -> Enigma<AnyRotor, AnyPlugboard, Reflector, ROTOR_NUM>

Set the Enigma reflector

impl<AnyPlugboard, AnyReflector, const ROTOR_NUM: usize> Enigma<Wheel<ROTOR_NUM>, AnyPlugboard, AnyReflector, ROTOR_NUM>

pub fn set_grundstellung( &mut self, positions: [Letter; ROTOR_NUM], ) -> &mut Enigma<Wheel<ROTOR_NUM>, AnyPlugboard, AnyReflector, ROTOR_NUM>

Set the starting position for the rotors

pub fn set_ringstellung( &mut self, positions: [u8; ROTOR_NUM], ) -> &mut Enigma<Wheel<ROTOR_NUM>, AnyPlugboard, AnyReflector, ROTOR_NUM>

Set the ring settings for the rotors

pub fn get_grundstellung(&self) -> [Letter; ROTOR_NUM]

Get Rotor positions

impl<const ROTOR_NUM: usize> Enigma<Wheel<ROTOR_NUM>, Plugboard, Reflector, ROTOR_NUM>

pub fn encrypt_letter(&mut self, letter: Letter) -> Letter

Encrypt/decrypt a Letter and advance the state

pub fn encrypt_char(&mut self, letter: char) -> char

Encrypt/decrypt a char and advance the state

Trait Implementations

impl<R: Clone, P: Clone, O: Clone, const ROTOR_NUM: usize> Clone for Enigma<R, P, O, ROTOR_NUM>

fn clone(&self) -> Enigma<R, P, O, ROTOR_NUM>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: Debug, P: Debug, O: Debug, const ROTOR_NUM: usize> Debug for Enigma<R, P, O, ROTOR_NUM>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Enigma<Unset, Unset, Unset, DEFAULT_ROTOR_NUM>

fn default() -> Self

Creates a default Enigma state machine where all parameters are unset.

This function will always create an M3 variant Enigma.

The configuration can be set later in execution using the various setter functions.

impl<R: Hash, P: Hash, O: Hash, const ROTOR_NUM: usize> Hash for Enigma<R, P, O, ROTOR_NUM>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<R: Ord, P: Ord, O: Ord, const ROTOR_NUM: usize> Ord for Enigma<R, P, O, ROTOR_NUM>

fn cmp(&self, other: &Enigma<R, P, O, ROTOR_NUM>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<R: PartialEq, P: PartialEq, O: PartialEq, const ROTOR_NUM: usize> PartialEq for Enigma<R, P, O, ROTOR_NUM>

fn eq(&self, other: &Enigma<R, P, O, ROTOR_NUM>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R: PartialOrd, P: PartialOrd, O: PartialOrd, const ROTOR_NUM: usize> PartialOrd for Enigma<R, P, O, ROTOR_NUM>

fn partial_cmp(&self, other: &Enigma<R, P, O, ROTOR_NUM>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<R: Copy, P: Copy, O: Copy, const ROTOR_NUM: usize> Copy for Enigma<R, P, O, ROTOR_NUM>

impl<R: Eq, P: Eq, O: Eq, const ROTOR_NUM: usize> Eq for Enigma<R, P, O, ROTOR_NUM>

impl<R, P, O, const ROTOR_NUM: usize> StructuralPartialEq for Enigma<R, P, O, ROTOR_NUM>