Struct HashTable

pub struct HashTable<K, V> { /* private fields */ }

This data structure represents a 2-dimensional grid of values. Each element is indexed by a hashable key and a row index. It’s also possible to access a whole row or column of the table.

Example

let timestamps = HashTable::from_column_keys_and_rows(
    ["hour", "minute", "second"],
    [
        [7, 15, 13],
        [8, 30, 32],
        [9, 45, 16]
    ]
);

for row in timestamps {
    let hour = *row.get("hour").unwrap();
    let minute = *row.get("minute").unwrap();
    let second = *row.get("second").unwrap();
    assert!(
        (hour == 7 && minute == 15 && second == 13) ||
        (hour == 8 && minute == 30 && second == 32) ||
        (hour == 9 && minute == 45 && second == 16)
    );
}

Implementations

impl<K, V> HashTable<K, V>

pub fn iter(&self) -> HashTableBorrowedIter<'_, K, V>

Row-wise iterator that borrows the table

pub fn into_iter_columns(self) -> HashTableOwnedIntoIterColumn<K, V>

Column-wise iterator that takes ownership of the keys and values

pub fn iter_columns(&self) -> HashTableBorrowedIterColumn<'_, K, V>

Column-wise iterator that borrows the values from the table

impl<K, V> HashTable<K, V>

pub fn columns_len(&self) -> usize

Returns the number of columns in this table.

pub fn rows_len(&self) -> usize

Returns the number of rows in this table.

pub fn with_capacity(columns: usize, rows: usize) -> Self

Create new HashTable with specified amoutn of reserved capacity.

pub fn get_row(&self, row: usize) -> Option<HashTableRowBorrowed<'_, K, V>>

Get a row of the table.

Returns None if row is bigger than or equal to the number of rows.

pub fn get_row_mut( &mut self, row: usize, ) -> Option<HashTableMutableBorrowedRow<'_, K, V>>

Get row with mutable access.

Returns None if row is bigger than or equal to the number of row.

pub fn remove_row( &mut self, row: usize, ) -> Option<HashTableRowValueOwned<'_, K, V>>

Remove a row and take ownership of its values.

This still borrows the hashtable immutably to allow getting the values by a key. Keys can be converted to an owned variant, usually by cloning them.

pub fn column_keys(&self) -> Keys<'_, K, usize>

Get the column keys of this table

impl<K, V> HashTable<K, V>

where K: Hash + Eq,

pub fn with_columns(columns: impl IntoIterator<Item = K>) -> Self

Create a HashTable from iterator of column keys.

pub fn with_columns_and_capacity( columns: impl IntoIterator<Item = K>, rows: usize, ) -> Self

Create a HashTable from iterator of column keys and with allocated capacity for at least the specified amount of rows.

pub fn remove_row_hashmap(&mut self, row: usize) -> Option<HashMap<&K, V>>

Remove row from the hashtable, taking ownership of teh values. Returns a HashMap

The difference from Self::remove_row is that this only allocates a hashmap that references the keys instead of allocating values and taking a reference to a hashmap of indices used internally.

pub fn get<Q>(&self, column: &Q, row: usize) -> Option<&V>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Get an element from the table.

Will return None if the column does not exist in the table or row is out of range.

pub fn get_mut<Q>(&mut self, column: &Q, row: usize) -> Option<&mut V>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Get an element from the table with mutable access.

Will return None if the column does not exist in the table or row is out of range.

pub fn get_column<'t, 'k, Q>( &'t self, column: &'k Q, ) -> Option<HashTableColumnBorrowed<'t, 'k, Q, V>>

where K: Borrow<Q>, Q: Hash + Eq,

Get a table column.

Will return None if the column does not exist in the table.

pub fn push_row<I>(&mut self, row: I)

where I: IntoIterator<Item = (K, V)>,

Add a row to the table from an iterator of key-value pairs.

pub fn push_row_with<F>(&mut self, row_generator: F)

where F: FnMut(&K) -> V,

Add a row to the table using a generator function that returns the value from the column key.

pub fn insert_column<I>(&mut self, column: K, values: I)

where I: IntoIterator<Item = V>,

Add a column with values provided through an iterator.

The iterator must have the same amount of elements as there are currently rows in the table.

This function has O(n^2) complexity, where n is the number of rows. It is recommended to insert the needed columns beforehand.

pub fn insert_column_with<F>(&mut self, column: K, values: F)

where F: FnMut(HashTableRowBorrowed<'_, K, V>) -> V,

Add a column using a generator function that returns a value based on the values of the row.

This function has O(n^2) complexity, where n is the number of rows. It is recommended to insert the needed columns beforehand.

pub fn remove_column<Q>( &mut self, column: &Q, ) -> Option<HashTableColumnOwned<K, V>>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Remove a column from the table and take ownership of the key and values.

Will return None if the column does not exist in the table.

pub fn from_column_iter<I, C>(iter: I) -> Self

where I: IntoIterator<Item = C>, C: Into<HashTableColumnOwned<K, V>>,

Construct HashTable from an iterator of columns

pub fn from_column_keys_and_rows<CKI, RI, R>(columns: CKI, rows: RI) -> Self

where CKI: IntoIterator<Item = K>, RI: IntoIterator<Item = R>, R: IntoIterator<Item = V>,

Construct a HashTable from an iterator of column keys and an iterator of rows of values

The only check of row lengths performed is whether there is a remainder from division of the total amount of values (sum of row lengths) by the amount of columns. If there is a nonzero remainder, these values get dropped.

This means that with 2 columns teh row iterator can have two rows with lengths 1 and 3 and the first element of the second row will be moved to teh end of the first row.

Trait Implementations

impl<K: Clone, V: Clone> Clone for HashTable<K, V>

fn clone(&self) -> HashTable<K, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug> Debug for HashTable<K, V>

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

Formats the value using the given formatter.

impl<K, V> Default for HashTable<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V> Deserialize<'de> for HashTable<K, V>

where K: Hash + Eq + Deserialize<'de>, V: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserializes a HashTable from sequence of key-value maps

Will fall back to deserialize_hashtable_from_map if deserializer decides to provide a map

impl<K, V> From<HashTableFromColumns<K, V>> for HashTable<K, V>

fn from(value: HashTableFromColumns<K, V>) -> Self

Converts to this type from the input type.

impl<K, V, R> FromIterator<R> for HashTable<K, V>

where K: Hash + Eq, R: IntoIterator<Item = (K, V)>,

fn from_iter<T: IntoIterator<Item = R>>(iter: T) -> Self

Creates a value from an iterator.

impl<K, V, Q> Index<(&Q, usize)> for HashTable<K, V>

where K: Hash + Eq + Borrow<Q>, Q: Hash + Eq,

type Output = V

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<K, V, Q> IndexMut<(&Q, usize)> for HashTable<K, V>

where K: Hash + Eq + Borrow<Q>, Q: Hash + Eq,

fn index_mut(&mut self, index: (&Q, usize)) -> &mut Self::Output

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

impl<'t, K, V> IntoIterator for &'t HashTable<K, V>

type Item = HashTableRowBorrowed<'t, K, V>

The type of the elements being iterated over.

type IntoIter = HashTableBorrowedIter<'t, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V> IntoIterator for HashTable<K, V>

where K: Clone + Hash + Eq,

fn into_iter(self) -> Self::IntoIter

Row-wise iterator that takes ownership of both keys and values, cloning the keys each time and allocating a new hashmap.

type Item = HashMap<K, V>

The type of the elements being iterated over.

type IntoIter = HashTableIntoIter<K, V>

Which kind of iterator are we turning this into?

impl<K, V> Serialize for HashTable<K, V>

where K: Serialize, V: Serialize,

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

where S: Serializer,

Serialize this value into the given Serde serializer.