Struct memtable::exts::prelude::SledTable

pub struct SledTable<D, R, C, T> where
    C: List<Item = D>,
    T: Table<Data = D, Row = R, Column = C>,
    R: List<Item = D>,
    D: Serialize + for<'de> Deserialize<'de>,  { /* fields omitted */ }

Represents a table that is replicated using a [sled::Tree]

Implementations

impl<D, R, C, T> SledTable<D, R, C, T> where
    C: List<Item = D>,
    T: Table<Data = D, Row = R, Column = C>,
    R: List<Item = D>,
    D: for<'de> Deserialize<'de> + Serialize, 

pub fn new(
    tree: Tree,
    new_table: impl FnOnce(usize, usize) -> T
) -> Result<SledTable<D, R, C, T>, Error>

Creates a new sled table using the provided tree and factory function to create the inmemory table that takes in the current row and column capacities

pub fn reload(&mut self, refresh_capacities: bool) -> Result<(), Error>

Reloads the data in the table from sled, optionally refreshing the row and column capacities first

pub fn has_errors(&self) -> bool

Returns true if this table has uncleared errors

pub fn clear_errors(&mut self)

Removes errors in table without returning them

pub fn take_errors(&mut self) -> Vec<Error, Global>

Removes errors in table and returns them

pub fn flush(&mut self, rewrite: bool) -> Result<usize, Error>

Flushes any changes to sled, optionally rewriting the entire table prior to flushing

Trait Implementations

impl<D, R, C, T> Debug for SledTable<D, R, C, T> where
    C: Debug + List<Item = D>,
    T: Debug + Table<Data = D, Row = R, Column = C>,
    R: List<Item = D> + Debug,
    D: Serialize + for<'de> Deserialize<'de> + Debug, 

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

Formats the value using the given formatter.

impl<D, R, C, T> Table for SledTable<D, R, C, T> where
    C: List<Item = D>,
    T: Table<Data = D, Row = R, Column = C>,
    R: List<Item = D>,
    D: for<'de> Deserialize<'de> + Serialize, 

pub fn insert_cell(
    &mut self,
    row: usize,
    col: usize,
    value: <SledTable<D, R, C, T> as Table>::Data
) -> Option<<SledTable<D, R, C, T> as Table>::Data>

Will insert the data into the cell, replicate it using the [sled::Tree], and update the metadata within the [sled::Tree] based on if the maximum row or column count has changed

pub fn remove_cell(
    &mut self,
    row: usize,
    col: usize
) -> Option<<SledTable<D, R, C, T> as Table>::Data>

Will remove the data from the cell, remove it from the [sled::Tree], and update the metadata within the [sled::Tree] based on if the maximum row or column count has changed

pub fn set_preferred_row_cnt(&mut self, capacity: usize)

Will set the row capacity of the inner table and replicate the metadata in the [sled::Tree]

pub fn set_preferred_col_cnt(&mut self, capacity: usize)

Will set the column capacity of the inner table and replicate the metadata in the [sled::Tree]

type Data = D

The type of data stored in individual cells within the table

type Row = R

The type of structure to hold a row of data

type Column = C

The type of structure to hold a column of data

pub fn max_row_capacity(&self) -> Capacity

Returns the maximum row capacity of the table

pub fn max_column_capacity(&self) -> Capacity

Returns the maximum column capacity of the table

pub fn row_cnt(&self) -> usize

Returns the total rows contained in the table

pub fn col_cnt(&self) -> usize

Returns the total columns contained in the table

pub fn cell(
    &self,
    row: usize,
    col: usize
) -> Option<&<SledTable<D, R, C, T> as Table>::Data>

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

pub fn mut_cell(
    &mut self,
    row: usize,
    col: usize
) -> Option<&mut <SledTable<D, R, C, T> as Table>::Data>

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

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>(&mut self, row: usize, cells: I) where
    I: IntoIterator<Item = Self::Data>, 

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

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

Pushes a row to the end of the table

fn remove_row(&mut self, row: usize) -> Option<Self::Row>

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

fn pop_row(&mut self) -> Option<Self::Row>

Pops a row off the end of the table

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

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

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

Pushes a column to the end of the table

fn remove_column(&mut self, col: usize) -> Option<Self::Column>

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

fn pop_column(&mut self) -> Option<Self::Column>

Pops a column off the end of the table

impl<D, R, C, T> TryFrom<Tree> for SledTable<D, R, C, T> where
    C: List<Item = D>,
    T: Table<Data = D, Row = R, Column = C> + Default,
    R: List<Item = D>,
    D: for<'de> Deserialize<'de> + Serialize, 

pub fn try_from(
    tree: Tree
) -> Result<SledTable<D, R, C, T>, <SledTable<D, R, C, T> as TryFrom<Tree>>::Error>

Tries to create a database wrapper using sled by mapping a tree’s data to that of a table; will create a new instance of the inmemory table using its Default implementation

type Error = Error

The type returned in the event of a conversion error.