Struct MapxRaw

Source

pub struct MapxRaw { /* private fields */ }

Expand description

A raw, disk-based, key-value map.

MapxRaw provides a Map-like interface for storing and retrieving raw byte slices. It is unversioned and does not perform any encoding on keys or values.

Implementations§

Source §

impl MapxRaw

Source

pub unsafe fn shadow(&self) -> MapxRaw

Creates a “shadow” copy of the MapxRaw instance.

This method creates a new MapxRaw that shares the same underlying data source. It is a lightweight operation that can be used to create multiple references to the same map without the overhead of cloning the entire structure.

§Safety

This API breaks the semantic safety guarantees of Rust’s ownership and borrowing rules. It is safe to use in a race-free environment where you can guarantee that no two threads will access the same data concurrently.

Source

pub fn new() -> MapxRaw

Creates a new, empty MapxRaw.

§Returns

A new MapxRaw instance.

Source

pub fn get(&self, key: impl AsRef<[u8]>) -> Option<Vec<u8>>

Retrieves a value from the map corresponding to the given key.

§Arguments

key - The key to look up.

§Returns

An Option<RawValue> containing the value if the key exists, or None otherwise.

Source

pub fn get_mut(&mut self, key: impl AsRef<[u8]>) -> Option<ValueMut<'_>>

Retrieves a mutable reference to a value in the map.

§Arguments

key - The key to look up.

§Returns

An Option<ValueMut<'_>> containing a mutable reference to the value if the key exists, or None otherwise.

Source

pub fn mock_value_mut(&mut self, key: Vec<u8>, value: Vec<u8>) -> ValueMut<'_>

Mocks a mutable value, typically for use in scenarios where you need to create a ValueMut without actually inserting the value into the map yet.

§Arguments

key - The key associated with the value.
value - The value to be mocked.

§Returns

A ValueMut instance.

Source

pub fn contains_key(&self, key: impl AsRef<[u8]>) -> bool

Checks if the map contains a value for the specified key.

§Arguments

key - The key to check.

§Returns

true if the map contains the key, false otherwise.

Source

pub fn get_le(&self, key: impl AsRef<[u8]>) -> Option<(Vec<u8>, Vec<u8>)>

Retrieves the last entry with a key less than or equal to the given key.

§Arguments

key - The key to search for.

§Returns

An Option<(RawKey, RawValue)> containing the key-value pair if found, or None otherwise.

Source

pub fn get_ge(&self, key: impl AsRef<[u8]>) -> Option<(Vec<u8>, Vec<u8>)>

Retrieves the first entry with a key greater than or equal to the given key.

§Arguments

key - The key to search for.

§Returns

An Option<(RawKey, RawValue)> containing the key-value pair if found, or None otherwise.

Source

pub fn entry<'a>(&'a mut self, key: &'a [u8]) -> Entry<'a>

Gets an entry for the given key, allowing for in-place modification.

§Arguments

key - The key of the entry.

§Returns

An Entry that allows for operations on the value.

Source

pub fn iter(&self) -> MapxIter<'_>

Returns an iterator over the map’s entries.

§Returns

A MapxRawIter that iterates over the key-value pairs.

Source

pub fn range<'a, R>(&'a self, bounds: R) -> MapxIter<'a>
where R: RangeBounds<Cow<'a, [u8]>>,

Returns an iterator over a range of entries in the map.

§Arguments

bounds - The range of keys to iterate over.

§Returns

A MapxRawIter that iterates over the key-value pairs in the specified range.

Source

pub fn range_detached<'a, R>(&self, bounds: R) -> MapxIter<'a>
where R: RangeBounds<Cow<'a, [u8]>>,

Returns a detached iterator over a range of entries in the map.

This iterator is not tied to the lifetime of &self, allowing for concurrent modification of the map during iteration (though the iterator will see a snapshot).

§Arguments

bounds - The range of keys to iterate over.

§Returns

A MapxRawIter that iterates over the key-value pairs in the specified range.

Source

pub fn iter_mut(&mut self) -> MapxIterMut<'_>

Returns a mutable iterator over the map’s entries.

§Returns

A MapxRawIterMut that allows for mutable iteration over the key-value pairs.

Source

pub fn range_mut<'a, R>(&'a mut self, bounds: R) -> MapxIterMut<'a>
where R: RangeBounds<Cow<'a, [u8]>>,

Returns a mutable iterator over a range of entries in the map.

§Arguments

bounds - The range of keys to iterate over.

§Returns

A MapxRawIterMut that allows for mutable iteration over the key-value pairs in the specified range.

Source

pub fn last(&self) -> Option<(Vec<u8>, Vec<u8>)>

Retrieves the last entry in the map.

§Returns

An Option<(RawKey, RawValue)> containing the last key-value pair, or None if the map is empty.

Source

pub fn insert(&mut self, key: impl AsRef<[u8]>, value: impl AsRef<[u8]>)

Inserts a key-value pair into the map.

Does not return the old value for performance reasons.

§Arguments

key - The key to insert.
value - The value to associate with the key.

Source

pub fn remove(&mut self, key: impl AsRef<[u8]>)

Removes a key from the map.

Does not return the old value for performance reasons.

§Arguments

key - The key to remove.

Source

pub fn batch_entry(&mut self) -> Box<dyn BatchTrait + '_>

Start a batch operation.

This method allows you to perform multiple insert/remove operations and commit them atomically.

§Examples

use vsdb_core::basic::mapx_raw::MapxRaw;
use vsdb_core::vsdb_set_base_dir;

vsdb_set_base_dir("/tmp/vsdb_core_mapx_raw_batch_entry").unwrap();
let mut map = MapxRaw::new();

{
    let mut batch = map.batch_entry();
    batch.insert(&[1], &[10]);
    batch.insert(&[2], &[20]);
    batch.commit().unwrap();
}

assert_eq!(map.get(&[1]), Some(vec![10]));
assert_eq!(map.get(&[2]), Some(vec![20]));

Source

pub fn clear(&mut self)

Clears the map, removing all key-value pairs.

Source

pub unsafe fn from_bytes(s: impl AsRef<[u8]>) -> MapxRaw

Creates a MapxRaw from a byte slice.

§Safety

This function is unsafe because it assumes the byte slice is a valid representation of a MapxRaw. This function is unsafe because it assumes the byte slice is a valid representation of a MapxRaw. Do not use this API unless you know the internal details of the data structure extremely well.

Source

pub unsafe fn from_prefix_slice(s: impl AsRef<[u8]>) -> MapxRaw

Creates a MapxRaw from a prefix slice.

§Safety

This function is unsafe because it assumes the prefix slice is a valid representation of a MapxRaw. This function is unsafe because it assumes the byte slice is a valid representation of a MapxRaw. Do not use this API unless you know the internal details of the data structure extremely well.

Source