Enum poker::ParseCardError

pub enum ParseCardError {
    InvalidLength {
        original_input: String,
    },
    InvalidRank {
        original_input: String,
        incorrect_char: char,
    },
    InvalidSuit {
        original_input: String,
        incorrect_char: char,
    },
}

An error than can be thrown when parsing Card types from strings.

Examples

An input with invalid length yields ParseCardError::InvalidLength.

use poker::{Card, ParseCardError};
let ten_of_clubs = "10c"; // not two characters; use 'T' instead of '10'!
let result = ten_of_clubs.parse::<Card>();
assert_eq!(
    result,
    Err(ParseCardError::InvalidLength {
        original_input: "10c".into()
    })
);

If an input is two characters, ParseCardError::InvalidRank will be thrown if the first character, representing the card’s rank, is not one of ‘23456789TJQKA’.

use poker::{Card, ParseCardError};
let jack_of_clubs = "jc";
let result = jack_of_clubs.parse::<Card>();
assert_eq!(
    result,
    Err(ParseCardError::InvalidRank {
        original_input: "jc".into(),
        incorrect_char: 'j'
    })
);

Similarly, a two-character input, with a second character representing the suit, does not contain one of “chsd”, ParseCardError::InvalidSuit will be thrown.

use poker::{Card, ParseCardError};
let two_of_diamonds = "2D";
let result = two_of_diamonds.parse::<Card>();
assert_eq!(
    result,
    Err(ParseCardError::InvalidSuit {
        original_input: "2D".into(),
        incorrect_char: 'D'
    })
);

Variants

InvalidLength

A string to be interpreted as a Card must be exactly two characters long. This variant is used if the input does not have meet this criterion.

Fields of InvalidLength

original_input: String

The input that incited this error, converted to a String if needed. The original input is also used for calculating and reporting the incorrect number of characters received.

InvalidRank

A string to be interpreted as a Card must have its first character be one of “23456789TJQKA”, otherwise, this error will be thrown and indicate the incorrect character.

Fields of InvalidRank

original_input: String

The input that incited this error, converted to a String if needed.

incorrect_char: char

The actual character within the input that was unexpected and could not be interpreted as a card rank.

InvalidSuit

A string to be interpreted as a Card must have its first character be one of “23456789TJQKA”, otherwise, this error will be thrown and indicate the incorrect character.

Fields of InvalidSuit

original_input: String

The input that incited this error, converted to a String if needed.

incorrect_char: char

The actual character within the input that was unexpected and could not be interpreted as a card suit.

Trait Implementations

impl Clone for ParseCardError

fn clone(&self) -> ParseCardError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ParseCardError

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

Formats the value using the given formatter.

impl Display for ParseCardError

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

Formats the value using the given formatter.

impl Eq for ParseCardError

impl Error for ParseCardError

pub fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

pub fn backtrace(&self) -> Option<&Backtrace>

🔬 This is a nightly-only experimental API. (backtrace)

Returns a stack backtrace, if available, of where this error occurred.

pub fn description(&self) -> &str

👎 Deprecated since 1.42.0:

use the Display impl or to_string()

pub fn cause(&self) -> Option<&dyn Error>

👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

impl PartialEq<ParseCardError> for ParseCardError

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralEq for ParseCardError

impl StructuralPartialEq for ParseCardError