Struct CompressedVec 

pub struct CompressedVec<I, T> { /* private fields */ }

Implementations

impl<I, T> CompressedVec<I, T>

where I: StoredIndex, T: StoredCompressed,

pub fn forced_import( db: &Database, name: &str, version: Version, ) -> Result<Self>

Same as import but will reset the vec under certain errors, so be careful !

pub fn forced_import_with(options: ImportOptions<'_>) -> Result<Self>

Same as import but will reset the vec under certain errors, so be careful !

pub fn import(db: &Database, name: &str, version: Version) -> Result<Self>

pub fn import_with(options: ImportOptions<'_>) -> Result<Self>

pub fn iter(&self) -> Result<CompressedVecIterator<'_, I, T>>

pub fn clean_iter(&self) -> Result<CleanCompressedVecIterator<'_, I, T>>

pub fn dirty_iter(&self) -> Result<DirtyCompressedVecIterator<'_, I, T>>

pub fn is_dirty(&self) -> bool

Trait Implementations

impl<I: Allocative, T: Allocative> Allocative for CompressedVec<I, T>

fn visit<'allocative_a, 'allocative_b: 'allocative_a>( &self, visitor: &'allocative_a mut Visitor<'allocative_b>, )

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

where I: StoredIndex, T: StoredCompressed,

fn collect_range_json_bytes( &self, from: Option<usize>, to: Option<usize>, ) -> Vec<u8>

fn collect_range_string( &self, from: Option<usize>, to: Option<usize>, ) -> Vec<String>

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> AnyIterableVec<I, T> for CompressedVec<I, T>

where I: StoredIndex, T: StoredCompressed,

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

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

where I: StoredIndex, T: StoredRaw,

impl<I, T> AnyStoredVec for CompressedVec<I, T>

where I: StoredIndex, T: StoredCompressed,

fn db_path(&self) -> PathBuf

fn region(&self) -> &Region

fn header(&self) -> &Header

fn mut_header(&mut self) -> &mut Header

fn saved_stamped_changes(&self) -> u16

fn stored_len(&self) -> usize

fn real_stored_len(&self) -> usize

fn flush(&mut self) -> Result<()>

fn serialize_changes(&self) -> Result<Vec<u8>>

fn safe_flush(&mut self, exit: &Exit) -> Result<()>

fn update_stamp(&mut self, stamp: Stamp)

fn stamp(&self) -> Stamp

fn stamped_flush(&mut self, stamp: Stamp) -> Result<()>

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

where I: StoredIndex, T: StoredCompressed,

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 region_names(&self) -> Vec<String>

fn is_empty(&self) -> bool

fn index_to_name(&self) -> String

fn etag(&self, stamp: Stamp, to: Option<i64>) -> String

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

impl<I, T> Clone for CompressedVec<I, T>

fn clone(&self) -> Self

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 CompressedVec<I, T>

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

Formats the value using the given formatter.

impl<I, T> GenericStoredVec<I, T> for CompressedVec<I, T>

where I: StoredIndex, T: StoredCompressed,

fn read_(&self, index: usize, reader: &Reader<'_>) -> Result<T>

fn pushed(&self) -> &[T]

fn mut_pushed(&mut self) -> &mut Vec<T>

fn prev_pushed(&self) -> &[T]

fn mut_prev_pushed(&mut self) -> &mut Vec<T>

fn holes(&self) -> &BTreeSet<usize>

fn mut_holes(&mut self) -> &mut BTreeSet<usize>

fn prev_holes(&self) -> &BTreeSet<usize>

fn mut_prev_holes(&mut self) -> &mut BTreeSet<usize>

fn updated(&self) -> &BTreeMap<usize, T>

fn mut_updated(&mut self) -> &mut BTreeMap<usize, T>

fn prev_updated(&self) -> &BTreeMap<usize, T>

fn mut_prev_updated(&mut self) -> &mut BTreeMap<usize, T>

fn prev_stored_len(&self) -> usize

fn mut_prev_stored_len(&mut self) -> &mut usize

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

const SIZE_OF_T: usize = _

fn create_reader(&self) -> Reader<'_>

Be careful with deadlocks

fn create_static_reader(&self) -> Reader<'static>

Be careful with deadlocks

fn unwrap_read(&self, index: I, reader: &Reader<'_>) -> T

fn unwrap_read_(&self, index: usize, reader: &Reader<'_>) -> T

fn one_shot_read(&self, index: I) -> Result<T>

fn read(&self, index: I, reader: &Reader<'_>) -> Result<T>

fn one_shot_read_(&self, index: usize) -> Result<T>

fn get_any_or_read(&self, index: I, reader: &Reader<'_>) -> Result<Option<T>>

fn get_any_or_read_( &self, index: usize, reader: &Reader<'_>, ) -> Result<Option<T>>

fn one_shot_get_pushed_or_read(&self, index: I) -> Result<Option<T>>

fn get_pushed_or_read(&self, index: I, reader: &Reader<'_>) -> Result<Option<T>>

fn one_shot_get_pushed_or_read_(&self, index: usize) -> Result<Option<T>>

fn get_pushed_or_read_( &self, index: usize, reader: &Reader<'_>, ) -> Result<Option<T>>

fn get_pushed(&self, index: usize, stored_len: usize) -> Option<&T>

fn len_(&self) -> usize

fn pushed_len(&self) -> usize

fn push(&mut self, value: T)

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

fn forced_push_at(&mut self, index: I, value: T, exit: &Exit) -> Result<()>

fn forced_push_at_(&mut self, index: usize, value: T, exit: &Exit) -> Result<()>

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

fn get_first_empty_index(&self) -> I

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

fn take(&mut self, index: I, reader: &Reader<'_>) -> Result<Option<T>>

fn delete(&mut self, index: I)

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

fn update_(&mut self, index: usize, value: T) -> Result<()>

fn reset_(&mut self) -> Result<()>

fn validate_computed_version_or_reset(&mut self, version: Version) -> Result<()>

fn is_pushed_empty(&self) -> bool

fn has(&self, index: I) -> bool

fn has_(&self, index: usize) -> bool

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

fn truncate_if_needed_(&mut self, index: usize) -> Result<()>

fn truncate_if_needed_with_stamp( &mut self, index: I, stamp: Stamp, ) -> Result<()>

fn deserialize_then_undo_changes(&mut self, bytes: &[u8]) -> Result<()>

fn stamped_flush_maybe_with_changes( &mut self, stamp: Stamp, with_changes: bool, ) -> Result<()>

fn changes_path(&self) -> PathBuf

fn stamped_flush_with_changes(&mut self, stamp: Stamp) -> Result<()>

fn rollback_before(&mut self, stamp: Stamp) -> Result<Stamp>

fn is_dirty(&mut self) -> bool

fn rollback(&mut self) -> Result<()>

fn reset_unsaved(&mut self)

fn collect_holed(&self) -> Result<Vec<Option<T>>>

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

fn vec_region_name(&self) -> String

fn vec_region_name_(name: &str) -> String

fn holes_region_name(&self) -> String

fn holes_region_name_(name: &str) -> String

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

where I: StoredIndex, T: StoredCompressed,

type Item = T

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.