Struct IndexedVec 

pub struct IndexedVec<I, T>(/* private fields */);

Implementations

impl<I, T> IndexedVec<I, T>

where I: StoredIndex, T: StoredType,

pub fn forced_import( path: &Path, name: &str, version: Version, format: Format, ) -> Result<Self>

pub fn unwrap_read(&self, index: I, mmap: &Mmap) -> T

pub fn get_or_read(&self, index: I, mmap: &Mmap) -> Result<Option<Cow<'_, T>>>

pub fn update_or_push(&mut self, index: I, value: T) -> Result<()>

pub fn checked_push(&mut self, index: I, value: T) -> Result<()>

pub fn push_if_needed(&mut self, index: I, value: T) -> Result<()>

pub fn fill_first_hole_or_push(&mut self, value: T) -> Result<I>

pub fn update(&mut self, index: I, value: T) -> Result<()>

pub fn take(&mut self, index: I, mmap: &Mmap) -> Result<Option<T>>

pub fn delete(&mut self, index: I)

pub fn reset(&mut self) -> Result<()>

pub fn truncate_if_needed(&mut self, index: I, height: Height) -> Result<()>

pub fn flush(&mut self, height: Height) -> Result<()>

pub fn header(&self) -> &Header

pub fn create_mmap(&self) -> Result<Mmap>

pub fn hasnt(&self, index: I) -> Result<bool>

Trait Implementations

impl<I, T> AnyCollectableVec for IndexedVec<I, T>

where I: StoredIndex, T: StoredType,

fn collect_range_serde_json( &self, from: Option<usize>, to: Option<usize>, ) -> Result<Vec<Value>>

fn range_count(&self, from: Option<i64>, to: Option<i64>) -> usize

fn range_weight(&self, from: Option<i64>, to: Option<i64>) -> usize

impl<I, T> AnyIndexedVec for IndexedVec<I, T>

where I: StoredIndex, T: StoredType,

fn height(&self) -> Height

fn flush(&mut self, height: Height) -> Result<()>

impl<I, T> AnyIterableVec<I, T> for IndexedVec<I, T>

where I: StoredIndex, T: StoredType,

fn boxed_iter<'a>(&'a self) -> BoxedVecIterator<'a, I, T>

where T: 'a,

fn iter<'a>(&'a self) -> BoxedVecIterator<'a, I, T>

where I: StoredIndex, T: StoredType + 'a,

fn iter_at<'a>(&'a self, i: I) -> BoxedVecIterator<'a, I, T>

where I: StoredIndex, T: StoredType + 'a,

fn iter_at_<'a>(&'a self, i: usize) -> BoxedVecIterator<'a, I, T>

where I: StoredIndex, T: StoredType + 'a,

impl<I, T> AnyVec for IndexedVec<I, T>

where I: StoredIndex, T: StoredType,

fn version(&self) -> Version

fn name(&self) -> &str

fn len(&self) -> usize

fn index_type_to_string(&self) -> &'static str

fn value_type_to_size_of(&self) -> usize

fn is_empty(&self) -> bool

fn etag(&self, height: Height, to: Option<i64>) -> String

fn i64_to_usize(&self, i: i64) -> usize

impl<I: Clone, T: Clone> Clone for IndexedVec<I, T>

fn clone(&self) -> IndexedVec<I, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug, T: Debug> Debug for IndexedVec<I, T>

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

Formats the value using the given formatter.

impl<'a, I, T> IntoIterator for &'a IndexedVec<I, T>

where I: StoredIndex, T: StoredType,

type Item = (I, Cow<'a, T>)

The type of the elements being iterated over.

type IntoIter = StoredVecIterator<'a, I, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.