Struct rql::TableGuardMut

pub struct TableGuardMut<'a, T> where
    T: Serialize,  { /* fields omitted */ }

A mutable guard to a Table

Methods

impl<'a, T> TableGuardMut<'a, T> where
    T: Serialize, 

pub fn path(&self) -> PathBuf

Get the path of the table file

Methods from Deref<Target = Table<T>>

pub fn len(&self) -> usize

Get the number of rows in the Table

pub fn is_empty(&self) -> bool

Check if the Table` is empty

pub fn insert(&mut self, row: T) -> Id<T>

Insert a row into the Table

pub fn get(&self, id: Id<T>) -> Option<&T>

Try to get a reference to the row with the given Id

pub fn get_mut(&mut self, id: Id<T>) -> Option<&mut T>

Try to get a mutable reference to the row with the given Id

pub fn remove(&mut self, id: Id<T>) -> Option<T>

Remove the row with the given Id

Important traits for RowIter<'a, T>

impl<'a, T> Iterator for RowIter<'a, T> type Item = Row<'a, T>;

pub fn rows(&self) -> RowIter<T>

Iterate over all rows in the Table

Important traits for RowIterMut<'a, T>

impl<'a, T> Iterator for RowIterMut<'a, T> type Item = RowMut<'a, T>;

pub fn rows_mut(&mut self) -> RowIterMut<T>

Iterate mutably over all rows in the Table

pub fn delete_one(&mut self, id: Id<T>) -> Option<T>

Delete a single row based on its Id and return the value

pub fn delete_where<F>(&mut self, f: F) -> usize where
    F: Fn(&T) -> bool, 

Delete rows that satisfy the clause

Returns how many rows where deleted

pub fn delete_iter<'a, F, I, R>(&'a mut self, f: F) where
    F: Fn(&'a Self) -> I,
    I: IntoIterator<Item = R>,
    R: Idd<RowType = T>, 

Delete rows with ids returned by an iterator

pub fn save<P>(&self, path: P, repr: Representation) -> Result<()> where
    P: AsRef<Path>, 

Save the database to a file

pub fn save_to_bytes(&self, repr: Representation) -> Result<Vec<u8>>

Save the database to a byte vector

Trait Implementations

impl<'a, T> Drop for TableGuardMut<'a, T> where
    T: Serialize, 

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T> DerefMut for TableGuardMut<'a, T> where
    T: Serialize, 

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, T: Debug> Debug for TableGuardMut<'a, T> where
    T: Serialize, 

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

Formats the value using the given formatter.

impl<'a, T> Deref for TableGuardMut<'a, T> where
    T: Serialize, 

type Target = Table<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.