Struct Table 

pub struct Table<X, T, const N: usize> {
    pub all: [T; N],
    /* private fields */
}

“Full” table, containing an element of T for every value of X.

Fields

all: [T; N]

Implementations

impl<T: Copy> Table<Player, T, { _ }>

pub const fn get(&self, key: Player) -> T

pub const fn set(&mut self, key: Player, value: T)

impl<T> Table<Player, T, { _ }>

pub const fn get_ref(&self, key: Player) -> &T

pub const fn get_mut(&mut self, key: Player) -> &mut T

impl<T: Copy> Table<Role, T, { _ }>

pub const fn get(&self, key: Role) -> T

pub const fn set(&mut self, key: Role, value: T)

impl<T> Table<Role, T, { _ }>

pub const fn get_ref(&self, key: Role) -> &T

pub const fn get_mut(&mut self, key: Role) -> &mut T

impl<X, T, const N: usize> Table<X, T, N>

pub const fn new(all: [T; N]) -> Self

impl<X, T: Copy, const N: usize> Table<X, T, N>

pub const fn filled(value: T) -> Self

impl<X, T: Empty, const N: usize> Table<X, T, N>

pub const fn empty() -> Self

impl<T: Copy> Table<Kind, T, { _ }>

pub const fn get(&self, key: Kind) -> T

pub const fn set(&mut self, key: Kind, value: T)

impl<T> Table<Kind, T, { _ }>

pub const fn get_ref(&self, key: Kind) -> &T

pub const fn get_mut(&mut self, key: Kind) -> &mut T

impl Table<Player, Table<Role, [Option<Square>; 10], { $crate::finite_set!(@count $($variant),+) }>, { $crate::finite_set!(@count $($variant),+) }>

pub fn standard() -> Self

impl<T: Copy> Table<EnPassant, T, { _ }>

pub const fn get(&self, key: EnPassant) -> T

pub const fn set(&mut self, key: EnPassant, value: T)

impl<T> Table<EnPassant, T, { _ }>

pub const fn get_ref(&self, key: EnPassant) -> &T

pub const fn get_mut(&mut self, key: EnPassant) -> &mut T

impl<T: Copy> Table<Side, T, { _ }>

pub const fn get(&self, key: Side) -> T

pub const fn set(&mut self, key: Side, value: T)

impl<T> Table<Side, T, { _ }>

pub const fn get_ref(&self, key: Side) -> &T

pub const fn get_mut(&mut self, key: Side) -> &mut T

impl<T: Copy> Table<File, T, { _ }>

pub const fn get(&self, key: File) -> T

pub const fn set(&mut self, key: File, value: T)

impl<T> Table<File, T, { _ }>

pub const fn get_ref(&self, key: File) -> &T

pub const fn get_mut(&mut self, key: File) -> &mut T

impl<T: Copy> Table<Rank, T, { _ }>

pub const fn get(&self, key: Rank) -> T

pub const fn set(&mut self, key: Rank, value: T)

impl<T> Table<Rank, T, { _ }>

pub const fn get_ref(&self, key: Rank) -> &T

pub const fn get_mut(&mut self, key: Rank) -> &mut T

impl<T: Copy> Table<Square, T, { _ }>

pub const fn get(&self, key: Square) -> T

pub const fn set(&mut self, key: Square, value: T)

impl<T> Table<Square, T, { _ }>

pub const fn get_ref(&self, key: Square) -> &T

pub const fn get_mut(&mut self, key: Square) -> &mut T

Trait Implementations

impl<X: Clone, T: Clone, const N: usize> Clone for Table<X, T, N>

fn clone(&self) -> Table<X, T, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<X: Copy, T: Copy, const N: usize> Copy for Table<X, T, N>

impl<X: Debug, T: Debug, const N: usize> Debug for Table<X, T, N>

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

Formats the value using the given formatter.

impl<X, T: Default, const N: usize> Default for Table<X, T, N>

where [T; N]: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<X, T: Empty, const N: usize> Empty for Table<X, T, N>

const EMPTY: Self

fn is_empty(&self) -> bool

impl<X: Eq, T: Eq, const N: usize> Eq for Table<X, T, N>

impl<X, T, const N: usize> From<Table<X, T, N>> for BTreeMap<X, T>

where T: Copy, X: FiniteSet<N> + Ord,

fn from(table: Table<X, T, N>) -> Self

Converts to this type from the input type.

impl<T> Index<EnPassant> for Table<EnPassant, T, { _ }>

type Output = T

The returned type after indexing.

fn index(&self, key: EnPassant) -> &T

Performs the indexing (container[index]) operation.

impl<T> Index<File> for Table<File, T, { _ }>

type Output = T

The returned type after indexing.

fn index(&self, key: File) -> &T

Performs the indexing (container[index]) operation.

impl<T> Index<Kind> for Table<Kind, T, { _ }>

type Output = T

The returned type after indexing.

fn index(&self, key: Kind) -> &T

Performs the indexing (container[index]) operation.

impl<T> Index<Player> for Table<Player, T, { _ }>

type Output = T

The returned type after indexing.

fn index(&self, key: Player) -> &T

Performs the indexing (container[index]) operation.

impl<T> Index<Rank> for Table<Rank, T, { _ }>

type Output = T

The returned type after indexing.

fn index(&self, key: Rank) -> &T

Performs the indexing (container[index]) operation.

impl<T> Index<Role> for Table<Role, T, { _ }>

type Output = T

The returned type after indexing.

fn index(&self, key: Role) -> &T

Performs the indexing (container[index]) operation.

impl<T> Index<Side> for Table<Side, T, { _ }>

type Output = T

The returned type after indexing.

fn index(&self, key: Side) -> &T

Performs the indexing (container[index]) operation.

impl<T> Index<Square> for Table<Square, T, { _ }>

type Output = T

The returned type after indexing.

fn index(&self, key: Square) -> &T

Performs the indexing (container[index]) operation.

impl<T> IndexMut<EnPassant> for Table<EnPassant, T, { _ }>

fn index_mut(&mut self, key: EnPassant) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T> IndexMut<File> for Table<File, T, { _ }>

fn index_mut(&mut self, key: File) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T> IndexMut<Kind> for Table<Kind, T, { _ }>

fn index_mut(&mut self, key: Kind) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T> IndexMut<Player> for Table<Player, T, { _ }>

fn index_mut(&mut self, key: Player) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T> IndexMut<Rank> for Table<Rank, T, { _ }>

fn index_mut(&mut self, key: Rank) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T> IndexMut<Role> for Table<Role, T, { _ }>

fn index_mut(&mut self, key: Role) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T> IndexMut<Side> for Table<Side, T, { _ }>

fn index_mut(&mut self, key: Side) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T> IndexMut<Square> for Table<Square, T, { _ }>

fn index_mut(&mut self, key: Square) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<X: PartialEq, T: PartialEq, const N: usize> PartialEq for Table<X, T, N>

fn eq(&self, other: &Table<X, T, N>) -> 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<X, T, const N: usize> Serialize for Table<X, T, N>

where T: Copy + Serialize, X: FiniteSet<N> + Ord + Serialize,

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<X: PartialEq, T: PartialEq, const N: usize> StructuralPartialEq for Table<X, T, N>