Struct exonum_merkledb::indexes::MapIndex

pub struct MapIndex<T: RawAccess, K: ?Sized, V> { /* fields omitted */ }

A map of keys and values. Access to the elements of this map is obtained using the keys.

MapIndex requires that keys implement the BinaryKey trait and values implement the BinaryValue trait.

Methods

impl<T, K: ?Sized, V> MapIndex<T, K, V> where
    T: RawAccess,
    K: BinaryKey,
    V: BinaryValue, 

pub fn get(&self, key: &K) -> Option<V>

Returns a value corresponding to the key.

Examples

use exonum_merkledb::{access::CopyAccessExt, TemporaryDB, Database, MapIndex};

let db = TemporaryDB::default();
let fork = db.fork();
let mut index = fork.get_map("name");
assert!(index.get(&1).is_none());

index.put(&1, 2);
assert_eq!(Some(2), index.get(&1));

pub fn contains(&self, key: &K) -> bool

Returns true if the map contains a value corresponding to the specified key.

Examples

use exonum_merkledb::{access::CopyAccessExt, TemporaryDB, Database, MapIndex};

let db = TemporaryDB::default();
let fork = db.fork();
let mut index = fork.get_map("name");
assert!(!index.contains(&1));

index.put(&1, 2);
assert!(index.contains(&1));

pub fn iter(&self) -> Entries<K, V>

Returns an iterator over the entries of the map in ascending order.

Examples

use exonum_merkledb::{access::CopyAccessExt, TemporaryDB, Database, MapIndex};

let db = TemporaryDB::default();
let fork = db.fork();
let index: MapIndex<_, u8, u8> = fork.get_map("name");

for v in index.iter() {
    println!("{:?}", v);
}

pub fn keys(&self) -> Keys<K>

Returns an iterator over the keys of a map in ascending order.

Examples

use exonum_merkledb::{access::CopyAccessExt, TemporaryDB, Database, MapIndex};

let db = TemporaryDB::default();
let fork = db.fork();
let index: MapIndex<_, u8, u8> = fork.get_map("name");

for key in index.keys() {
    println!("{}", key);
}

pub fn values(&self) -> Values<V>

Returns an iterator over the values of a map in ascending order of keys.

Examples

use exonum_merkledb::{access::CopyAccessExt, TemporaryDB, Database, MapIndex};

let db = TemporaryDB::default();
let fork = db.fork();
let index: MapIndex<_, u8, u8> = fork.get_map("name");

for val in index.values() {
    println!("{}", val);
}

pub fn iter_from(&self, from: &K) -> Entries<K, V>

Returns an iterator over the entries of a map in ascending order starting from the specified key.

Examples

use exonum_merkledb::{access::CopyAccessExt, TemporaryDB, Database, MapIndex};

let db = TemporaryDB::default();
let fork = db.fork();
let index: MapIndex<_, u8, u8> = fork.get_map("name");

for v in index.iter_from(&2) {
    println!("{:?}", v);
}

pub fn keys_from(&self, from: &K) -> Keys<K>

Returns an iterator over the keys of a map in ascending order starting from the specified key.

Examples

use exonum_merkledb::{access::CopyAccessExt, TemporaryDB, Database, MapIndex};

let db = TemporaryDB::default();
let fork = db.fork();
let index: MapIndex<_, u8, u8> = fork.get_map("name");

for key in index.keys_from(&2) {
    println!("{}", key);
}

pub fn values_from(&self, from: &K) -> Values<V>

Returns an iterator over the values of a map in ascending order of keys starting from the specified key.

Examples

use exonum_merkledb::{access::CopyAccessExt, TemporaryDB, Database, MapIndex};

let db = TemporaryDB::default();
let fork = db.fork();
let index: MapIndex<_, u8, u8> = fork.get_map("name");
for val in index.values_from(&2) {
    println!("{}", val);
}

impl<T, K: ?Sized, V> MapIndex<T, K, V> where
    T: RawAccessMut,
    K: BinaryKey,
    V: BinaryValue, 

pub fn put(&mut self, key: &K, value: V)

Inserts a key-value pair into a map.

Examples

use exonum_merkledb::{access::CopyAccessExt, TemporaryDB, Database, MapIndex};

let db = TemporaryDB::default();
let fork = db.fork();
let mut index = fork.get_map("name");

index.put(&1, 2);
assert!(index.contains(&1));

pub fn remove<Q: ?Sized>(&mut self, key: &Q) where
    K: Borrow<Q>,
    Q: BinaryKey, 

Removes a key from a map.

Examples

use exonum_merkledb::{access::CopyAccessExt, TemporaryDB, Database, MapIndex};

let db = TemporaryDB::default();
let fork = db.fork();
let mut index = fork.get_map("name");

index.put(&1, 2);
assert!(index.contains(&1));

index.remove(&1);
assert!(!index.contains(&1));

pub fn clear(&mut self)

Clears a map, removing all entries.

Notes

Currently, this method is not optimized to delete a large set of data. During the execution of this method, the amount of allocated memory is linearly dependent on the number of elements in the index.

Examples

use exonum_merkledb::{access::CopyAccessExt, TemporaryDB, Database, MapIndex};

let db = TemporaryDB::default();
let fork = db.fork();
let mut index = fork.get_map("name");

index.put(&1, 2);
assert!(index.contains(&1));

index.clear();
assert!(!index.contains(&1));

Trait Implementations

impl<T: Debug + RawAccess, K: Debug + ?Sized, V: Debug> Debug for MapIndex<T, K, V>

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

Formats the value using the given formatter.

impl<T, K: ?Sized, V> FromAccess<T> for MapIndex<T::Base, K, V> where
    T: Access,
    K: BinaryKey,
    V: BinaryValue, 

fn from_access(access: T, addr: IndexAddress) -> Result<Self, AccessError>

Constructs the object at the given address.

fn from_root(access: T) -> Result<Self, AccessError>

Constructs the object from the root of the access.

impl<T, K: ?Sized, V> IndexIterator for MapIndex<T, K, V> where
    T: RawAccess,
    K: BinaryKey,
    V: BinaryValue, 

type Key = K

Type encompassing index keys.

type Value = V

Type encompassing index values.

fn index_iter(&self, from: Option<&K>) -> Entries<K, V>

Continues iteration from the specified position. If from is None, starts the iteration from scratch.

impl<'a, T, K: ?Sized, V> IntoIterator for &'a MapIndex<T, K, V> where
    T: RawAccess,
    K: BinaryKey,
    V: BinaryValue, 

type Item = (K::Owned, V)

The type of the elements being iterated over.

type IntoIter = Entries<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.