Enum lace::TableIndex

pub enum TableIndex<R: RowIndex, C: ColumnIndex> {
    Row(R),
    Column(C),
    Cell(R, C),
}

Variants

Row(R)

Represents an entire row

Column(C)

Represents an entire column

Cell(R, C)

Represents a single cell

Implementations

impl<R: RowIndex, C: ColumnIndex> TableIndex<R, C>

pub fn is_row(&self) -> bool

pub fn is_column(&self) -> bool

pub fn is_cell(&self) -> bool

pub fn in_codebook(&self, codebook: &Codebook) -> bool

Returns true if this index is in the codebook

pub fn into_usize_index( self, codebook: &Codebook ) -> Result<TableIndex<usize, usize>, IndexError>

Convert an index to an integer type index.

Trait Implementations

impl<R: Clone + RowIndex, C: Clone + ColumnIndex> Clone for TableIndex<R, C>

fn clone(&self) -> TableIndex<R, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug + RowIndex, C: Debug + ColumnIndex> Debug for TableIndex<R, C>

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

Formats the value using the given formatter.

impl<'de, R, C> Deserialize<'de> for TableIndex<R, C>

where R: Deserialize<'de> + RowIndex, C: Deserialize<'de> + ColumnIndex,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R: RowIndex, C: ColumnIndex> From<(R, C)> for TableIndex<R, C>

fn from(value: (R, C)) -> Self

Converts to this type from the input type.

impl<R: Hash + RowIndex, C: Hash + ColumnIndex> Hash for TableIndex<R, C>

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<R: PartialEq + RowIndex, C: PartialEq + ColumnIndex> PartialEq for TableIndex<R, C>

fn eq(&self, other: &TableIndex<R, C>) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R, C> Serialize for TableIndex<R, C>

where R: Serialize + RowIndex, C: Serialize + ColumnIndex,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<R: Eq + RowIndex, C: Eq + ColumnIndex> Eq for TableIndex<R, C>

impl<R: RowIndex, C: ColumnIndex> StructuralPartialEq for TableIndex<R, C>