Struct Card64

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

A 64-bit representation of a set of playing cards using bitwise operations.

Card64 efficiently stores multiple cards in a single u64 value, where each bit represents a specific card. This allows for fast set operations like union, intersection, and membership testing using bitwise operations.

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 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::default();
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::default());

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 const fn from_ranks(rs: Rank16) -> Self

Creates a Card64 with all four cards of each rank in the given Rank16.

Examples

use open_pql::{Card64, Rank::*, Rank16};

let ranks = Rank16::from([RA, RK].as_ref());
let c64 = Card64::from_ranks(ranks);

assert_eq!(c64.count_by_rank(RA), 4);
assert_eq!(c64.count_by_rank(RK), 4);
assert_eq!(c64.count_by_rank(RQ), 0);

pub const fn ranks(self) -> Rank16

Returns a Rank16 containing all ranks that have at least one card marked.

Examples

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

let c64 = Card64::from([Card::new(RA, S), Card::new(RK, H)].as_ref());
let ranks = c64.ranks();

assert!(ranks.contains_rank(RA));
assert!(ranks.contains_rank(RK));
assert!(!ranks.contains_rank(RQ));

pub const fn iter(self) -> CardIter

Returns an iterator over all cards in this set.

Examples

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

let c64 = Card64::from([Card::new(RA, S), Card::new(RK, H)].as_ref());
let cards: Vec<Card> = c64.iter().collect();

assert_eq!(cards.len(), 2);

pub const fn iter_ranks(self) -> Rank16Iter

Returns an iterator over the ranks in each suit.

The iterator yields tuples of (Rank16, Suit) for each suit in the order S, H, D, C.

Examples

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

let c64 = Card64::from([Card::new(RA, S), Card::new(RK, H)].as_ref());
let ranks: Vec<_> = c64.iter_ranks().collect();

assert_eq!(ranks.len(), 4);
assert!(ranks[0].0.contains_rank(RA)); // Spades
assert!(ranks[1].0.contains_rank(RK)); // Hearts

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