Struct Card64

pub struct Card64(/* private fields */);

Card Set

Memory Layout:

[63, 48]:  xxxAKQJT 98765432  // Club
[47, 32]:  xxxAKQJT 98765432  // Diamond
[31, 16]:  xxxAKQJT 98765432  // Heart
[15, 0]:   xxxAKQJT 98765432  // Spade, x: unused

Implementations

impl Card64

pub const fn from_u64(v: u64) -> Self

Constructs Card64 from u64

Examples

use open_pql::{Card, Card64, Rank::*, Suit::*};

let i: u64 = 0b11;
let c64: Card64 = Card64::from_u64(i);

assert_eq!(
    c64,
    Card64::from([Card::new(R2, S), Card::new(R3, S)].as_ref())
);

pub const fn to_u64(self) -> u64

Returns the inner u64

Examples

use open_pql::{Card, Card64, Rank::*, Suit::*};

let i: u64 = 0b11;
let c64: Card64 = Card64::from_u64(i);

assert_eq!(i, c64.to_u64());

pub const fn empty() -> Self

Constructs an empty Card64

Examples

use open_pql::{Card, Card64, Rank::*, Suit::*};

let c64: Card64 = Card64::empty();

assert_eq!(c64, Card64::from([].as_ref()));

pub const fn is_empty(self) -> bool

Checks whether all rank masks are unset

Examples

use open_pql::{Card, Card64, Rank::*, Suit::*};

let c64: Card64 = Card64::from(Card::new(R2, S));

assert!(!c64.is_empty());

pub const fn all() -> Self

Constructs Card64 as the set of all 52 cards

Examples

use open_pql::{Card, Card64, Rank::*, Suit::*};

let c64: Card64 = Card64::all();

assert_eq!(c64.count(), 52);

pub fn contains(self, other: Self) -> bool

checks whether another Card64 is a subset

Examples

use open_pql::{Card, Card64, Rank::*, Suit::*};

let c64_2s: Card64 = Card64::from(Card::new(R2, S));
let c64_2h: Card64 = Card64::from(Card::new(R2, H));
let c64_2s_2h: Card64 = c64_2s | c64_2h;

assert!(c64_2s_2h.contains(c64_2h));
assert!(!c64_2s.contains(c64_2h));

pub const fn contains_card(self, c: Card) -> bool

checks whether a Card is in the set

Examples

use open_pql::{Card, Card64, Rank::*, Suit::*};

let c64: Card64 = Card64::from(Card::new(R2, S));

assert!(c64.contains_card(Card::new(R2, S)));
assert!(!c64.contains_card(Card::new(R2, H)));

pub const fn set(&mut self, c: Card)

Marks a Card

Examples

use open_pql::{Card, Card64, Rank::*, Suit::*};

let mut c64: Card64 = Card64::empty();
c64.set(Card::new(R2, S));

assert_eq!(c64, Card64::from(Card::new(R2, S)));

pub const fn unset(&mut self, c: Card)

Unmarks a Card

Examples

use open_pql::{Card, Card64, Rank::*, Suit::*};

let mut c64: Card64 = Card64::from(Card::new(R2, S));
c64.unset(Card::new(R2, S));

assert_eq!(c64, Card64::empty());

pub const fn count(&self) -> PQLCardCount

Returns the number of marked cards

Examples

use open_pql::{Card, Card64, Rank::*, Suit::*};

let c64: Card64 = Card64::from(Card::new(R2, S));

assert_eq!(c64.count(), 1);

pub const fn count_by_rank(self, r: Rank) -> PQLCardCount

Returns the number of marked cards of rank r

Examples

use open_pql::{Card, Card64, Rank::*, Suit::*};

let c64: Card64 = Card64::all();

assert_eq!(c64.count_by_rank(RA), 4);

pub const fn count_by_suit(self, s: Suit) -> PQLCardCount

Returns the number of marked cards of suit s

Examples

use open_pql::{Card, Card64, Rank::*, Suit::*};

let c64: Card64 = Card64::all();

assert_eq!(c64.count_by_suit(D), 13);

pub fn set_available_card_by_rank(&mut self, r: Rank)

Attempts to mark a card of rank r in the order S, H, D, C

Examples

use open_pql::{Card, Card64, Rank::*, Suit::*};

let mut c64: Card64 = Card64::from(Card::new(R2, S));

c64.set_available_card_by_rank(R2);

assert!(c64.contains_card(Card::new(R2, H)));

pub const fn normalize(&mut self)

Normalize u64 so that each u16 indicates rank count

Examples

use open_pql::{Card, Card64, Rank::*, Suit::*};

let mut c64: Card64 =
    Card64::from([Card::new(R2, D), Card::new(R2, C)].as_ref());

c64.normalize();

assert_eq!(
    Card64::from([Card::new(R2, S), Card::new(R2, H)].as_ref()),
    c64
);

pub const fn ranks_by_suit(self, s: Suit) -> Rank16

pub const fn from_ranks(rs: Rank16) -> Self

pub const fn ranks(self) -> Rank16

pub const fn iter(self) -> CardIter

pub const fn iter_ranks(self) -> RanksIter

Trait Implementations

impl AsMut<Card64> for DeadCards

fn as_mut(&mut self) -> &mut Card64

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<Card64> for DeadCards

fn as_ref(&self) -> &Card64

Converts this type into a shared reference of the (usually inferred) input type.

impl BitAnd for Card64

type Output = Card64

The resulting type after applying the & operator.

fn bitand(self, rhs: Card64) -> Card64

Performs the & operation.

impl BitAndAssign for Card64

fn bitand_assign(&mut self, rhs: Card64)

Performs the &= operation.

impl BitOr for Card64

type Output = Card64

The resulting type after applying the | operator.

fn bitor(self, rhs: Card64) -> Card64

Performs the | operation.

impl BitOrAssign for Card64

fn bitor_assign(&mut self, rhs: Card64)

Performs the |= operation.

impl Clone for Card64

fn clone(&self) -> Card64

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Card64

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

Formats the value using the given formatter.

impl Default for Card64

fn default() -> Card64

Returns the “default value” for a type.

impl From<&[Card]> for Card64

fn from(cs: &[Card]) -> Self

Converts to this type from the input type.

impl From<(Board, PQLStreet)> for Card64

fn from((board, street): (Board, PQLStreet)) -> Self

Converts to this type from the input type.

impl From<Board> for Card64

fn from(board: Board) -> Self

Converts to this type from the input type.

impl From<Card> for Card64

fn from(c: Card) -> Self

Converts to this type from the input type.

impl From<Card64> for DeadCards

fn from(value: Card64) -> Self

Converts to this type from the input type.

impl From<Card64> for Rank16

fn from(c: Card64) -> Self

Converts to this type from the input type.

impl From<Card64> for Suit4

fn from(c: Card64) -> Self

Converts to this type from the input type.

impl From<DeadCards> for Card64

fn from(value: DeadCards) -> Self

Converts to this type from the input type.

impl<const N: usize> From<HandN<N>> for Card64

fn from(hand: HandN<N>) -> Self

Converts to this type from the input type.

impl Hash for Card64

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 Not for Card64

type Output = Card64

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for Card64

fn eq(&self, other: &Card64) -> 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 Copy for Card64

impl Eq for Card64

impl StructuralPartialEq for Card64