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: StoredType,

pub fn forced_import( path: &Path, version: Version, compressed: Compressed, ) -> Result<Self>

Examples found in repository

examples/main.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let _ = fs::remove_dir_all("./vec");

    let version = Version::ZERO;
    let compressed = Compressed::YES;

    {
        let mut vec: StoredVec<usize, u32> =
            StoredVec::forced_import(Path::new("./vec"), version, compressed)?;

        (0..21_u32).for_each(|v| {
            vec.push(v);
        });

        let mut iter = vec.into_iter();
        dbg!(iter.get(0));
        dbg!(iter.get(20));
        dbg!(iter.get(21));

        vec.flush()?;
    }

    {
        let mut vec: StoredVec<usize, u32> =
            StoredVec::forced_import(Path::new("./vec"), version, compressed)?;
        let mut iter = vec.into_iter();

        dbg!(iter.get(0));
        dbg!(iter.get(0));
        dbg!(iter.get(1));
        dbg!(iter.get(2));
        dbg!(iter.get(20));
        dbg!(iter.get(20));
        dbg!(iter.get(0));

        vec.push(21);
        vec.push(22);

        let mut iter = vec.into_iter();

        dbg!(iter.get(20));
        dbg!(iter.get(21));
        dbg!(iter.get(22));
        dbg!(iter.get(23));

        vec.flush()?;
    }

    {
        let mut vec: StoredVec<usize, u32> =
            StoredVec::forced_import(Path::new("./vec"), version, compressed)?;
        let mut iter = vec.into_iter();

        dbg!(iter.get(0));
        dbg!(iter.get(20));
        dbg!(iter.get(21));
        dbg!(iter.get(22));

        vec.truncate_if_needed(14)?;

        let mut iter = vec.into_iter();

        iter.get(0);
        iter.get(5);
        dbg!(iter.get(20));

        dbg!(vec.collect_signed_range(Some(-5), None)?);

        vec.push(vec.len() as u32);
        dbg!(VecIterator::last(vec.into_iter()));

        dbg!(vec.into_iter().collect::<Vec<_>>());
    }

    Ok(())
}

Trait Implementations

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

where I: StoredIndex, T: StoredType,

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

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

where I: StoredIndex, T: StoredType,

fn version(&self) -> Version

fn index_type_to_string(&self) -> &str

fn len(&self) -> usize

fn modified_time(&self) -> Result<Duration>

fn name(&self) -> String

fn is_empty(&self) -> bool

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

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

Returns a copy 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: StoredType,

fn read_(&self, index: usize, guard: &Mmap) -> Result<Option<T>>

fn mmap(&self) -> &ArcSwap<Mmap>

fn stored_len(&self) -> usize

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

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

fn path(&self) -> &Path

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

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

const SIZE_OF_T: usize = _

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

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

fn get_or_read_( &self, index: usize, mmap: &Mmap, ) -> Result<Option<Value<'_, T>>>

fn len_(&self) -> usize

fn pushed_len(&self) -> usize

fn push(&mut self, value: T)

fn open_file(&self) -> Result<File>

fn open_file_(path: &Path) -> Result<File>

fn file_set_len(&mut self, len: u64) -> Result<()>

fn file_set_len_(file: &mut File, len: u64) -> Result<()>

fn file_write_all(&mut self, buf: &[u8]) -> Result<()>

fn file_truncate_and_write_all(&mut self, len: u64, buf: &[u8]) -> Result<()>

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

fn new_mmap(file: File) -> Result<Arc<Mmap>>

fn update_mmap(&mut self, file: File) -> Result<()>

fn is_pushed_empty(&self) -> bool

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

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

fn path_vec(&self) -> PathBuf

fn path_vec_(path: &Path) -> PathBuf

fn path_version_(path: &Path) -> PathBuf

fn path_compressed_(path: &Path) -> PathBuf

fn name_(&self) -> String

fn modified_time_(&self) -> Result<Duration>

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

where I: StoredIndex, T: StoredType,

type Item = (I, Value<'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.