[−][src]Struct exonum_merkledb::sparse_list_index::SparseListIndex
A list of items similar to the ListIndex
, however, it may contain "spaces". For instance,
a list might contain six elements with indices: "1, 2, 3, 5, 7, 8" (missing 4 and 6). And if you
try to get the element for index 4 or 6, you'll get None
.
Later, elements can be added to the spaces, if required. Elements in this list are added to the end of the list and are removed either from the end of the list or from certain indices.
SparseListIndex
has length and capacity. Length is the number of non-empty
elements in the list. Capacity is the number of all elements in the list, both
empty and non-empty.
SparseListIndex
implements an array list, storing an element as a value and using u64
as an index.
SparseListIndex
requires that elements should implement the BinaryValue
trait.
Methods
impl<T, V> SparseListIndex<T, V> where
T: IndexAccess,
V: BinaryValue,
[src]
T: IndexAccess,
V: BinaryValue,
pub fn new<S: Into<String>>(index_name: S, view: T) -> Self
[src]
Creates a new index representation based on the name and storage view.
Storage view can be specified as &Snapshot
or &mut Fork
. In the first case, only
immutable methods are available. In the second case, both immutable and mutable methods are
available.
Examples
use exonum_merkledb::{TemporaryDB, Database, SparseListIndex}; let db = TemporaryDB::new(); let snapshot = db.snapshot(); let name = "name"; let index: SparseListIndex<_, u8> = SparseListIndex::new(name, &snapshot);
pub fn new_in_family<S, I>(family_name: S, index_id: &I, view: T) -> Self where
I: BinaryKey,
I: ?Sized,
S: Into<String>,
[src]
I: BinaryKey,
I: ?Sized,
S: Into<String>,
Creates a new index representation based on the name, index ID in family and storage view.
Storage view can be specified as &Snapshot
or &mut Fork
. In the first case, only
immutable methods are available. In the second case, both immutable and mutable methods are
available.
Examples
use exonum_merkledb::{TemporaryDB, Database, SparseListIndex}; let db = TemporaryDB::new(); let snapshot = db.snapshot(); let name = "name"; let index_id = vec![123]; let index: SparseListIndex<_, u8> = SparseListIndex::new_in_family( name, &index_id, &snapshot, );
pub fn get(&self, index: u64) -> Option<V>
[src]
Returns an element at the indicated position or None
if the indicated
position is out of bounds or if it does not exist.
Examples
use exonum_merkledb::{TemporaryDB, Database, SparseListIndex}; let db = TemporaryDB::new(); let fork = db.fork(); let mut index = SparseListIndex::new("name", &fork); assert_eq!(None, index.get(0)); index.push(42); assert_eq!(Some(42), index.get(0)); index.push(1); index.remove(0); assert_eq!(None, index.get(0)); assert_eq!(Some(1), index.get(1));
pub fn is_empty(&self) -> bool
[src]
Returns true
if the list contains no elements.
Examples
use exonum_merkledb::{TemporaryDB, Database, SparseListIndex}; let db = TemporaryDB::new(); let fork = db.fork(); let mut index = SparseListIndex::new("name", &fork); assert!(index.is_empty()); index.push(42); assert!(!index.is_empty());
pub fn capacity(&self) -> u64
[src]
Returns the total amount of elements, including empty elements, in the list. The value of capacity is determined by the maximum index of an element ever inserted into the given index.
Examples
use exonum_merkledb::{TemporaryDB, Database, SparseListIndex}; let db = TemporaryDB::new(); let fork = db.fork(); let mut index = SparseListIndex::new("name", &fork); assert_eq!(0, index.capacity()); index.push(10); index.push(12); assert_eq!(2, index.capacity()); index.remove(0); index.push(100); assert_eq!(3, index.capacity());
pub fn len(&self) -> u64
[src]
Returns the total amount of non-empty elements in the list.
Examples
use exonum_merkledb::{TemporaryDB, Database, SparseListIndex}; let db = TemporaryDB::new(); let fork = db.fork(); let mut index = SparseListIndex::new("name", &fork); assert_eq!(0, index.len()); index.push(10); assert_eq!(1, index.len()); index.remove(0); index.push(100); assert_eq!(1, index.len());
ⓘImportant traits for SparseListIndexIter<'a, V>pub fn iter(&self) -> SparseListIndexIter<V>
[src]
Returns an iterator over the list. The iterator element type is (u64, V).
Examples
use exonum_merkledb::{TemporaryDB, Database, SparseListIndex}; let db = TemporaryDB::new(); let fork = db.fork(); let mut index = SparseListIndex::new("name", &fork); index.extend([1, 2, 3, 4, 5].iter().cloned()); for val in index.iter() { println!("{:?}", val); }
ⓘImportant traits for SparseListIndexKeys<'a>pub fn indices(&self) -> SparseListIndexKeys
[src]
Returns an iterator over the indices of the 'SparseListIndex'.
Examples
use exonum_merkledb::{TemporaryDB, Database, SparseListIndex}; let db = TemporaryDB::new(); let mut fork = db.fork(); let mut index = SparseListIndex::new("name", &fork); index.extend([1, 2, 3, 4, 5].iter().cloned()); for val in index.indices() { println!("{}", val); }
ⓘImportant traits for SparseListIndexValues<'a, V>pub fn values(&self) -> SparseListIndexValues<V>
[src]
Returns an iterator over the values of the 'SparseListIndex'. The iterator element type is V.
Examples
use exonum_merkledb::{TemporaryDB, Database, SparseListIndex}; let db = TemporaryDB::new(); let mut fork = db.fork(); let mut index = SparseListIndex::new("name", &fork); index.extend([1, 2, 3, 4, 5].iter().cloned()); for val in index.values() { println!("{}", val); }
ⓘImportant traits for SparseListIndexIter<'a, V>pub fn iter_from(&self, from: u64) -> SparseListIndexIter<V>
[src]
Returns an iterator over the list starting from the specified position. The iterator element type is (u64, V).
Examples
use exonum_merkledb::{TemporaryDB, Database, SparseListIndex}; let db = TemporaryDB::new(); let mut fork = db.fork(); let mut index = SparseListIndex::new("name", &fork); index.extend([1, 2, 3, 4, 5].iter().cloned()); index.remove(3); for val in index.iter_from(3) { println!("{:?}", val); }
pub fn push(&mut self, value: V)
[src]
Appends an element to the back of the 'SparseListIndex'.
Examples
use exonum_merkledb::{TemporaryDB, Database, SparseListIndex}; let db = TemporaryDB::new(); let mut fork = db.fork(); let mut index = SparseListIndex::new("name", &fork); index.push(1); assert!(!index.is_empty());
pub fn remove(&mut self, index: u64) -> Option<V>
[src]
Removes the element with the given index from the list and returns it,
or returns None
if it is empty.
Examples
use exonum_merkledb::{TemporaryDB, Database, SparseListIndex}; let db = TemporaryDB::new(); let mut fork = db.fork(); let mut index = SparseListIndex::new("name", &fork); assert_eq!(0, index.capacity()); index.push(10); index.push(12); assert_eq!(Some(10), index.remove(0)); assert_eq!(None, index.remove(0)); assert_eq!(2, index.capacity()); assert_eq!(1, index.len()); assert_eq!(Some(12), index.remove(1)); assert_eq!(2, index.capacity());
pub fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = V>,
[src]
I: IntoIterator<Item = V>,
Extends the list with the contents of an iterator.
Examples
use exonum_merkledb::{TemporaryDB, Database, SparseListIndex}; let db = TemporaryDB::new(); let mut fork = db.fork(); let mut index = SparseListIndex::new("name", &fork); assert!(index.is_empty()); index.extend([1, 2, 3].iter().cloned()); assert_eq!(3, index.capacity());
pub fn set(&mut self, index: u64, value: V) -> Option<V>
[src]
Changes a value at a specified position. If the position contains an empty value, it also increments the elements count. If the index value of the new element is greater than the current capacity, the capacity of the list is considered index + 1 and all further elements without specific index values will be appended after this index.
Returns the value of a previous element at the indicated position or None
if it is empty.
Examples
use exonum_merkledb::{TemporaryDB, Database, SparseListIndex}; let db = TemporaryDB::new(); let mut fork = db.fork(); let mut index = SparseListIndex::new("name", &fork); index.push(1); assert_eq!(Some(1), index.get(0)); index.set(0, 10); assert_eq!(Some(10), index.get(0));
pub fn clear(&mut self)
[src]
Clears the list, removing all values.
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::{TemporaryDB, Database, SparseListIndex}; let db = TemporaryDB::new(); let mut fork = db.fork(); let mut index = SparseListIndex::new("name", &fork); index.push(1); assert!(!index.is_empty()); index.clear(); assert!(index.is_empty());
pub fn pop(&mut self) -> Option<V>
[src]
Removes the first element from the 'SparseListIndex' and returns it, or
returns None
if it is empty.
Examples
use exonum_merkledb::{TemporaryDB, Database, SparseListIndex}; let db = TemporaryDB::new(); let mut fork = db.fork(); let mut index = SparseListIndex::new("name", &fork); assert_eq!(None, index.pop()); index.push(1); assert_eq!(Some(1), index.pop());
Trait Implementations
impl<'a, T, V> IntoIterator for &'a SparseListIndex<T, V> where
T: IndexAccess,
V: BinaryValue,
[src]
T: IndexAccess,
V: BinaryValue,
type Item = (u64, V)
The type of the elements being iterated over.
type IntoIter = SparseListIndexIter<'a, V>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
impl<T: Debug + IndexAccess, V: Debug> Debug for SparseListIndex<T, V>
[src]
Auto Trait Implementations
impl<T, V> !Sync for SparseListIndex<T, V>
impl<T, V> Send for SparseListIndex<T, V> where
T: Send,
V: Send,
<T as IndexAccess>::Changes: Send,
T: Send,
V: Send,
<T as IndexAccess>::Changes: Send,
impl<T, V> Unpin for SparseListIndex<T, V> where
T: Unpin,
V: Unpin,
<T as IndexAccess>::Changes: Unpin,
T: Unpin,
V: Unpin,
<T as IndexAccess>::Changes: Unpin,
impl<T, V> !RefUnwindSafe for SparseListIndex<T, V>
impl<T, V> UnwindSafe for SparseListIndex<T, V> where
T: UnwindSafe,
V: UnwindSafe,
<T as IndexAccess>::Changes: UnwindSafe,
T: UnwindSafe,
V: UnwindSafe,
<T as IndexAccess>::Changes: UnwindSafe,
Blanket Implementations
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,