Struct freecell::Card

pub struct Card {
    pub suit: Suit,
    pub rank: Rank,
}

Represents one card in the game.

Cards can be converted from Strings or &strs. The formats for this are the same formats used by Display and Debug. See the descriptions for TryFrom<String> and TryFrom<&str> below for details.

Examples

Parsing cards from strings:

use std::convert::TryFrom;
use freecell::{ACE, JACK, KING, QUEEN};
use freecell::Suit::{Club, Diamond, Heart, Spade};

// Short representation used by Debug
assert_eq!(Ok(Card { suit: Diamond, rank: ACE }), Card::try_from("AD"));
assert_eq!(Ok(Card { suit: Club, rank: 4 }), Card::try_from("4C"));
assert_eq!(Ok(Card { suit: Diamond, rank: 10 }), Card::try_from("TD"));
assert_eq!(Ok(Card { suit: Club, rank: JACK }), Card::try_from("jc"));
assert_eq!(Ok(Card { suit: Spade, rank: QUEEN }), Card::try_from("qS"));
assert_eq!(Ok(Card { suit: Heart, rank: KING }), Card::try_from("Kh"));

// Long representation used by Display
assert_eq!(Ok(Card { suit: Diamond, rank: JACK }), Card::try_from("Jack of Diamonds"));
assert_eq!(Ok(Card { suit: Club, rank: 10 }), Card::try_from("10 oF cLuBs"));

A formatted card can be converted back to the original card:

let ace_of_spades = Card { suit: Spade, rank: ACE };
// Formatted using Display
assert_eq!(Ok(ace_of_spades), Card::try_from(ace_of_spades.to_string()));
// Formatted using Debug
assert_eq!(Ok(ace_of_spades), Card::try_from(format!("{:?}", ace_of_spades)));

Fields

suit: Suit

rank: Rank

Trait Implementations

impl Clone for Card

fn clone(&self) -> Card

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Card

impl Eq for Card

impl PartialEq<Card> for Card

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

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

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

This method tests for !=.

impl Display for Card

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

Formats the value using the given formatter.

impl Debug for Card

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

Formats the value using the given formatter.

impl TryFrom<String> for Card

type Error = String

The type returned in the event of a conversion error.

fn try_from(string: String) -> Result<Card, Self::Error>

Converts a String to a Card.

The String must follow one of two formats. Both formats are case-insensitive.

The short format used by Debug

The card is represented by a string of two characters. The first character denotes the card's rank:

• 'A' or '1' - Ace
• '2' - 2
• ...
• '9' - 9
• 'T' - 10
• 'J' - Jack
• 'Q' - Queen
• 'K' - King

The second character denotes the suit:

• 'C' - Club
• 'S' - Spade
• 'H' - Heart
• 'D' - Diamond

Examples

use freecell::{ACE, JACK, KING, QUEEN};
use freecell::Suit::{Club, Diamond, Heart, Spade};

assert_eq!(Ok(Card { suit: Diamond, rank: ACE }), Card::try_from("AD"));
assert_eq!(Ok(Card { suit: Club, rank: 4 }), Card::try_from("4C"));
assert_eq!(Ok(Card { suit: Diamond, rank: 10 }), Card::try_from("TD"));
assert_eq!(Ok(Card { suit: Club, rank: JACK }), Card::try_from("jc"));
assert_eq!(Ok(Card { suit: Spade, rank: QUEEN }), Card::try_from("qS"));
assert_eq!(Ok(Card { suit: Heart, rank: KING }), Card::try_from("Kh"));

The long format used by Display

The card is represented by a string of the form "<rank> of <suit>s", where <rank> can be the rank's number or its name.

Examples

use freecell::{JACK, QUEEN};
use freecell::Suit::{Club, Diamond, Spade};

assert_eq!(Ok(Card { suit: Diamond, rank: JACK }), Card::try_from("Jack of Diamonds"));
assert_eq!(Ok(Card { suit: Club, rank: 3 }), Card::try_from("3 of clubs"));
assert_eq!(Ok(Card { suit: Spade, rank: QUEEN }), Card::try_from("12 oF sPaDeS"));

impl<'_> TryFrom<&'_ str> for Card

type Error = String

The type returned in the event of a conversion error.

fn try_from(string: &str) -> Result<Card, Self::Error>

Converts a &str to a Card.

See the description of TryFrom<String> for details.

impl Hash for Card

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, 

Feeds a slice of this type into the given [Hasher].

impl StructuralPartialEq for Card

impl StructuralEq for Card