Enum StoredVec

pub enum StoredVec<I, T> {
    Raw(RawVec<I, T>),
    Compressed(CompressedVec<I, T>),
}

Variants

Raw(RawVec<I, T>)

Compressed(CompressedVec<I, T>)

Implementations

impl<I, T> StoredVec<I, T>

where I: StoredIndex, T: StoredCompressed,

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

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

Trait Implementations

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

where I: StoredIndex, T: StoredCompressed,

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

where I: StoredIndex, T: StoredCompressed,

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: StoredRaw + 'a,

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

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

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

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

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

where I: StoredIndex, T: StoredCompressed,

fn db(&self) -> &Database

fn region_index(&self) -> usize

fn region(&self) -> &RwLock<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 changes_path(&self) -> PathBuf

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

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

where I: StoredIndex, T: StoredCompressed,

fn version(&self) -> Version

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

fn len(&self) -> usize

fn name(&self) -> &str

fn value_type_to_size_of(&self) -> usize

fn is_empty(&self) -> bool

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

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

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

fn clone(&self) -> StoredVec<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 StoredVec<I, T>

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

Formats the value using the given formatter.

impl<I, T> GenericStoredVec<I, T> for StoredVec<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 holes(&self) -> &BTreeSet<usize>

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

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

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

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

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 read(&self, index: I, reader: &Reader<'_>) -> Result<T>

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

fn get_or_read_( &self, index: usize, reader: &Reader<'_>, ) -> Result<Option<Cow<'_, 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 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 is_pushed_empty(&self) -> bool

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

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

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 rollback_stamp(&mut self, stamp: Stamp) -> Result<()>

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

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

fn index_to_name(&self) -> String

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

where I: StoredIndex, T: StoredCompressed,

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.