Struct memtable_core::FixedColumnTable

pub struct FixedColumnTable<T: Default, const COL: usize> { /* fields omitted */ }

Represents an inmemory table containing rows & columns of some data T with a fixed capacity across columns, but ability to grow dynamically with rows

Implementations

impl<T: Default, const COL: usize> FixedColumnTable<T, COL>

pub fn new() -> Self

Creates a new, empty table

pub fn truncate(&mut self)

Removes all cells contained within the table that are outside the current row capacity

pub fn shrink_to_fit(&mut self)

Shrinks the table’s row capacity to fit where cells exist

pub fn iter(&self) -> ZipPosition<&T, Cells<'_, T, FixedColumnTable<T, COL>>>

Returns an iterator over the cells and their positions within the table

Trait Implementations

impl<T: Clone + Default, const COL: usize> Clone for FixedColumnTable<T, COL>

fn clone(&self) -> FixedColumnTable<T, COL>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Default, const COL: usize> Debug for FixedColumnTable<T, COL>

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

Formats the value using the given formatter.

impl<T: Default, const COL: usize> Default for FixedColumnTable<T, COL>

fn default() -> FixedColumnTable<T, COL>

Returns the “default value” for a type.

impl<'de, T: Default, const COL: usize> Deserialize<'de> for FixedColumnTable<T, COL> where
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T: Default, const COL: usize> From<Vec<[T; COL], Global>> for FixedColumnTable<T, COL>

fn from(cells: Vec<[T; COL]>) -> Self

Performs the conversion.

impl<T: Default, V: Into<T>, const COL: usize> FromIterator<(Position, V)> for FixedColumnTable<T, COL>

fn from_iter<I: IntoIterator<Item = (Position, V)>>(iter: I) -> Self

Produces a table from the provided iterator of (position, value). All values that would go outside of the range of the table will be dropped.

impl<T: Default, V: Into<T>, const COL: usize> FromIterator<(usize, usize, V)> for FixedColumnTable<T, COL>

fn from_iter<I: IntoIterator<Item = (usize, usize, V)>>(iter: I) -> Self

Produces a table from the provided iterator of (row, col, value). All values that would go outside of the range of the table will be dropped.

impl<T: Default, const COL: usize> Index<(usize, usize)> for FixedColumnTable<T, COL>

fn index(&self, (row, col): (usize, usize)) -> &Self::Output

Indexes into a table by a specific row and column, returning a reference to the cell if it exists, otherwise panicking

type Output = T

The returned type after indexing.

impl<T: Default, const COL: usize> IndexMut<(usize, usize)> for FixedColumnTable<T, COL>

fn index_mut(&mut self, (row, col): (usize, usize)) -> &mut Self::Output

Indexes into a table by a specific row and column, returning a mutable reference to the cell if it exists, otherwise panicking

impl<'a, T: Default, const COL: usize> IntoIterator for &'a FixedColumnTable<T, COL>

fn into_iter(self) -> Self::IntoIter

Converts into an iterator over the table’s cells’ positions and values

type Item = (Position, &'a T)

The type of the elements being iterated over.

type IntoIter = ZipPosition<&'a T, Cells<'a, T, FixedColumnTable<T, COL>>>

Which kind of iterator are we turning this into?

impl<T: Default, const COL: usize> IntoIterator for FixedColumnTable<T, COL>

fn into_iter(self) -> Self::IntoIter

Converts into an iterator over the table’s cells’ positions and values

type Item = (Position, T)

The type of the elements being iterated over.

type IntoIter = ZipPosition<T, IntoCells<T, FixedColumnTable<T, COL>>>

Which kind of iterator are we turning this into?

impl<T: PartialEq + Default, const COL: usize> PartialEq<FixedColumnTable<T, COL>> for FixedColumnTable<T, COL>

fn eq(&self, other: &FixedColumnTable<T, COL>) -> bool

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

fn ne(&self, other: &FixedColumnTable<T, COL>) -> bool

This method tests for !=.

impl<T: Default, const COL: usize> Serialize for FixedColumnTable<T, COL> where
    T: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<T: Default, const COL: usize> Table for FixedColumnTable<T, COL>

fn set_row_capacity(&mut self, capacity: usize)

Will adjust the internal row count tracker to the specified capacity

Note that this does not remove any cells from the table in their old positions. To do that, call Self::truncate.

type Data = T

The type of data stored in individual cells within the table

fn row_cnt(&self) -> usize

Returns the total rows contained in the table

fn col_cnt(&self) -> usize

Returns the total columns contained in the table

fn get_cell(&self, row: usize, col: usize) -> Option<&Self::Data>

Returns reference to the cell found at the specified row and column

fn get_mut_cell(&mut self, row: usize, col: usize) -> Option<&mut Self::Data>

Returns mut reference to the cell found at the specified row and column

fn insert_cell(
    &mut self,
    row: usize,
    col: usize,
    value: Self::Data
) -> Option<Self::Data>

Replaces the given value into the cell of the table at the specified row and column, returning the previous value contained in the cell

fn remove_cell(&mut self, row: usize, col: usize) -> Option<T>

Removes the given value from the cell at the specified position, but does not shift any other cell to fill in the gap

fn set_column_capacity(&mut self, capacity: usize)

Sets the preferred capacity of the table when it comes to total columns

fn len(&self) -> usize

Returns the total cells (rows * columns) contained in the table

fn is_empty(&self) -> bool

Returns true if the total cells (rows * columns) contained in the table is zero

fn rows(&self) -> Rows<'_, Self::Data, Self>

Returns an iterator of refs through all rows in the table

fn row(&self, idx: usize) -> Row<'_, Self::Data, Self>

Returns an iterator of refs through a specific row in the table

fn into_row(self, idx: usize) -> IntoRow<Self::Data, Self>

Consumes the table and returns an iterator through a specific row in the table

fn columns(&self) -> Columns<'_, Self::Data, Self>

Returns an iterator of refs through all columns in the table

fn column(&self, idx: usize) -> Column<'_, Self::Data, Self>

Returns an iterator of refs through a specific column in the table

fn into_column(self, idx: usize) -> IntoColumn<Self::Data, Self>

Consumes the table and returns an iterator through a specific column in the table

fn cells(&self) -> Cells<'_, Self::Data, Self>

Returns an iterator of refs through all cells in the table, starting from the first row, iterating through all cells from beginning to end, and then moving on to the next row

fn into_cells(self) -> IntoCells<Self::Data, Self>

Consumes the table and returns an iterator through all cells in the table, starting from the first row, iterating through all cells from beginning to end, and then moving on to the next row

fn has_cell(&self, row: usize, col: usize) -> bool

Returns whether or not a cell exists at the specified row & column. Note that this is not the same as whether or not the table’s current row & column range would include a cell at that position! Rather, this is reporting if a cell actually exists

fn insert_row<I: IntoIterator<Item = Self::Data>>(
    &mut self,
    row: usize,
    cells: I
)

Inserts a new row into the table at the given position, shifting down all rows after it

fn push_row<I: IntoIterator<Item = Self::Data>>(&mut self, cells: I)

Pushes a row to the end of the table

fn remove_row(&mut self, row: usize) -> IntoRow<Self::Data, Self>

Removes the row at the specified position, shifting up all rows after it

fn pop_row(&mut self) -> IntoRow<Self::Data, Self>

Pops a row off the end of the table

fn insert_column<I: IntoIterator<Item = Self::Data>>(
    &mut self,
    col: usize,
    cells: I
)

Inserts a new column into the table at the given position, shifting right all columns after it

fn push_column<I: IntoIterator<Item = Self::Data>>(&mut self, cells: I)

Pushes a column to the end of the table

fn remove_column(&mut self, col: usize) -> IntoColumn<Self::Data, Self>

Removes the column at the specified position, shifting left all columns after it

fn pop_column(&mut self) -> IntoColumn<Self::Data, Self>

Pops a column off the end of the table

impl<T: Eq + Default, const COL: usize> Eq for FixedColumnTable<T, COL>

impl<T: Default, const COL: usize> StructuralEq for FixedColumnTable<T, COL>

impl<T: Default, const COL: usize> StructuralPartialEq for FixedColumnTable<T, COL>