Struct below_store::cursor::StoreCursor

pub struct StoreCursor { /* private fields */ }

For read-only access to a store. Similar to an iterator, but support moving back and forth.

Implementations

impl StoreCursor

pub fn new(logger: Logger, path: PathBuf) -> Self

Create a new cursor with uninitialized shard.

Trait Implementations

impl Cursor for StoreCursor

fn advance(&mut self, direction: Direction) -> Result<bool>

Move the cursor to a neighbor position. Return if the cursor is updated. Returning false means there is no more valid position in the given direction, although retrying may succeed. Notice that true means the current position is valid, but underlying sample may still be invalid.

fn get(&self) -> Option<(SystemTime, DataFrame)>

Get the sample the cursor is currently pointing at. Notice that a store may contain holes due to data corruption etc, and thus returns None. This does not mean samples are depleted. More could be retrieved by advancing further to skip the holes.

type Offset = StoreOffset

type Item = (SystemTime, DataFrame)

fn get_offset(&self) -> StoreOffset

Get offset of the cursor.

fn set_offset(&mut self, offset: StoreOffset)

Set offset of the cursor.

fn next(&mut self, direction: Direction) -> Result<Option<Self::Item>>

Move the cursor in the given direction until a valid item is obtained. If no more valid item available, return None and offset unchanged.

impl KeyedCursor<u64> for StoreCursor

StoreCursor has each cursor position bound to a SystemTime in monotonic order. This allows moving the cursor relative to SystemTime instances.

fn get_key(&self) -> Option<u64>

Get timestamp of the current pos.

fn jump_near_key(&mut self, key: &u64, _direction: Direction)

Set the cursor offset near the given timestamp by inferring shard and index offset.

fn jump_to_key(&mut self, key: &Key, direction: Direction) -> Result<bool>

Move the cursor to the closest valid pos to the given key in the given direction. Return if the key at the final pos satisfies the ordering requirement. For example, for a list of int keys: [3, 7, 8, 12, 19], jumping to key 9 forward moves cursor to index 3 because 12 is the smallest int greater than 9 in the list. Jumping to key 0 reverse moves cursor to index 0 and returns false because no key is smaller than 3.

fn get_near(
    &mut self,
    key: &Key,
    preferred_direction: Direction
) -> Result<Option<Self::Item>>

Convenient function to jump to a key and get the closest valid item to the key. Preference is given to the specified direction. Returns None only if there are no keys at all.

fn get_next(
    &mut self,
    key: &Key,
    direction: Direction
) -> Result<Option<Self::Item>>

Convenient function to jump to a key and get the closest valid item that is at key or in the given direction of key. Returns None if no such key exists.