Struct tc_btree::BTreeFile

pub struct BTreeFile<F, D, T> { /* private fields */ }

The base type of a BTree

Trait Implementations

impl<F, D, T> BTreeInstance for BTreeFile<F, D, T>where
    F: File<Key = NodeId, Block = Node>,
    D: Dir,
    T: Transaction<D>,
    BTreeSlice<F, D, T>: 'static,
    Self: Clone,

type Slice = BTreeSlice<F, D, T>

fn collator(&self) -> &ValueCollator

Borrow this BTree’s collator.

fn schema(&self) -> &RowSchema

Borrow to this BTree’s schema.

fn slice(self, range: Range, reverse: bool) -> TCResult<Self::Slice>

Return a slice of this BTree with the given range.

fn is_empty<'life0, 'async_trait>(
    &'life0 self,
    txn_id: TxnId
) -> Pin<Box<dyn Future<Output = TCResult<bool>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Return true if this BTree has no Keys.

fn keys<'a, 'async_trait>(
    self,
    txn_id: TxnId
) -> Pin<Box<dyn Future<Output = TCResult<TCBoxTryStream<'a, Key>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,

Return a Stream of this BTree’s Keys.

fn validate_key(&self, key: Key) -> TCResult<Key>

Return an error if the given key does not match this BTree’s schema

fn count<'life0, 'async_trait>(
    &'life0 self,
    txn_id: TxnId
) -> Pin<Box<dyn Future<Output = TCResult<u64>> + Send + 'async_trait>>where
    Self: Sync + 'async_trait,
    'life0: 'async_trait,

Return the number of Keys in this BTree.

impl<F, D, T> BTreeWrite for BTreeFile<F, D, T>where
    F: File<Key = NodeId, Block = Node>,
    D: Dir,
    T: Transaction<D>,
    BTreeSlice<F, D, T>: 'static,
    Self: Clone,

fn delete<'life0, 'async_trait>(
    &'life0 self,
    txn_id: TxnId,
    range: Range
) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Delete all the Keys in this BTree.

fn insert<'life0, 'async_trait>(
    &'life0 self,
    txn_id: TxnId,
    key: Key
) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Insert the given Key into this BTree.

fn try_insert_from<'life0, 'async_trait, S>(
    &'life0 self,
    txn_id: TxnId,
    keys: S
) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>>where
    S: 'async_trait + Stream<Item = TCResult<Key>> + Send + Unpin,
    Self: Sync + 'async_trait,
    'life0: 'async_trait,

Insert all the keys from the given Stream into this BTree.

impl<F: Clone, D: Clone, T: Clone> Clone for BTreeFile<F, D, T>

fn clone(&self) -> BTreeFile<F, D, T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F, D, T, I> CopyFrom<D, I> for BTreeFile<F, D, T>where
    F: File<Key = NodeId, Block = Node, Inner = D::Inner> + TryFrom<D::Store, Error = TCError>,
    D: Dir,
    T: Transaction<D>,
    I: BTreeInstance + 'static,
    D::Store: From<F>,

fn copy_from<'life0, 'async_trait>(
    txn: &'life0 T,
    store: D::Store,
    source: I
) -> Pin<Box<dyn Future<Output = TCResult<Self>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Copy a new instance of Self from an existing instance.

impl<F, D, T> Display for BTreeFile<F, D, T>

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

Formats the value using the given formatter.

impl<F, D, T> From<BTreeFile<F, D, T>> for BTree<F, D, T>

fn from(btree: BTreeFile<F, D, T>) -> Self

Converts to this type from the input type.

impl<F, D, T> FromStream for BTreeFile<F, D, T>where
    F: File<Key = NodeId, Block = Node, Inner = D::Inner> + TryFrom<D::Store, Error = TCError>,
    D: Dir,
    T: Transaction<D>,
    D::Store: From<F>,
    Self: Send + Sync + 'static,

type Context = (T, F)

The decoding context of this type, useful in situations where the stream to be decoded may be too large to hold in main memory.

fn from_stream<'life0, 'async_trait, De>(
    cxt: (T, F),
    decoder: &'life0 mut De
) -> Pin<Box<dyn Future<Output = Result<Self, De::Error>> + Send + 'async_trait>>where
    De: 'async_trait + Decoder,
    Self: 'async_trait,
    'life0: 'async_trait,

Parse this value using the given Decoder.

impl<F, D, T> Instance for BTreeFile<F, D, T>where
    Self: Send + Sync,

type Class = BTreeType

The Class type of this instance

fn class(&self) -> Self::Class

Returns the [Class] of this instance.

impl<F, D, T> Persist<D> for BTreeFile<F, D, T>where
    F: File<Key = NodeId, Block = Node, Inner = D::Inner> + TryFrom<D::Store, Error = TCError>,
    D: Dir,
    T: Transaction<D>,
    D::Store: From<F>,

type Txn = T

type Schema = Vec<Column, Global>

fn create(txn_id: TxnId, schema: Self::Schema, store: D::Store) -> TCResult<Self>

Create a new instance of Self from an empty Store.

fn load(txn_id: TxnId, schema: Self::Schema, store: D::Store) -> TCResult<Self>

Load a saved instance of Self from persistent storage. Should only be invoked at startup time.

fn dir(&self) -> F::Inner

Access the filesystem directory in which stores this persistent state.

fn load_or_create(
    txn_id: TxnId,
    schema: Self::Schema,
    store: <D as Dir>::Store
) -> Result<Self, TCError>

Load a saved instance of Self from persistent storage if present, or create a new one.

impl<F, D, T> Restore<D> for BTreeFile<F, D, T>where
    F: File<Key = NodeId, Block = Node, Inner = D::Inner> + TryFrom<D::Store, Error = TCError>,
    D: Dir,
    T: Transaction<D>,
    D::Store: From<F>,

fn restore<'life0, 'life1, 'async_trait>(
    &'life0 self,
    txn_id: TxnId,
    backup: &'life1 Self
) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Restore this persistent state from a backup.

impl<F, D, T> Transact for BTreeFile<F, D, T>where
    F: File<Key = NodeId, Block = Node> + Transact,
    D: Dir,
    T: Transaction<D>,

type Commit = Option<TxnLockCommit<TxnId, Uuid>>

A guard which blocks concurrent commits

fn commit<'life0, 'async_trait>(
    &'life0 self,
    txn_id: TxnId
) -> Pin<Box<dyn Future<Output = Self::Commit> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Commit this transaction.

fn rollback<'life0, 'life1, 'async_trait>(
    &'life0 self,
    txn_id: &'life1 TxnId
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Roll back this transaction.

fn finalize<'life0, 'life1, 'async_trait>(
    &'life0 self,
    txn_id: &'life1 TxnId
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Delete any version data specific to this transaction.