Enum Format 

#[non_exhaustive]
pub enum Format {
    Text,
    Digits,
    Alphanumeric,
    Hex,
    Base64,
    Paper32,
    Bip39,
}

What kind of value a person types.

Each format has one canonical representation, which is what an entry step keeps: the text as typed for a text format, the decoded bytes for an encoding. An encoding is forgiving of the grouping a person types it in, so whitespace is dropped before decoding, except between the words of a bip39 phrase, where it separates them.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Text

Anything the person can type.

Digits

0 to 9.

Alphanumeric

ASCII letters and digits.

Hex

Bytes as hexadecimal, in either case, two digits per byte.

Base64

Bytes as standard base64 with padding, as openssl base64 writes it.

Paper32

Bytes as paper32 rows, as reveal shows them and a sheet holds them; typed a row at a time, a wrong character in a row corrected. See crate::paper32.

Bip39

A BIP-39 recovery phrase in the English list, typed a word at a time; the value is the entropy it encodes, and a length counts words. See crate::bip39.

Implementations

impl Format

pub fn is_encoding(self) -> bool

Whether the value stands for bytes, which is what the step then keeps.

pub fn rows(self) -> Option<RevealFormat>

The encoding a value in this format is typed in a row at a time, from a sheet or a device’s screen; None for a value typed on one line. Such a value is a secret, and only enter_secret takes it.

pub fn length_of(self, bytes: usize) -> usize

A decoded value of bytes bytes in the format’s unit: the words of a phrase for bip39, the bytes for another encoding.

pub fn decode(self, value: &str) -> Result<Vec<u8>, String>

Decode a typed value of an encoding.

Errors

Returns why the value is not this encoding, or that the format is not one, worded for the person who typed it and naming nothing of what they typed.

pub fn describe(self) -> &'static str

The unit a length counts, as a person reads it in a hint.

pub fn placeholder(self, length: usize) -> Option<String>

A stand-in of length units that satisfies the format, for a run with no one at the keyboard. Never a real value.

None above PLACEHOLDER_LIMIT: a length a ceremony declares is not bounded, and a stand-in that size would be allocated for nothing. The caller then declines to answer rather than answering with something the rule refuses, which would be asked again without end.

Trait Implementations

impl Clone for Format

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Format

impl Debug for Format

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Format

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Format

impl FromStr for Format

type Err = String

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for Format

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Format

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Format