Struct tc_tensor::SparseTable

pub struct SparseTable<FD, FS, D, T> { /* private fields */ }

The base accessor type of SparseTensor, implementing SparseAccess for a TableIndex.

Trait Implementations

impl<FD: Clone, FS: Clone, D: Clone, T: Clone> Clone for SparseTable<FD, FS, D, T>

fn clone(&self) -> SparseTable<FD, FS, D, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<FD, FS, D, T, A> CopyFrom<D, SparseTensor<FD, FS, D, T, A>> for SparseTable<FD, FS, D, T>where
    FD: File<Key = u64, Block = Array, Inner = D::Inner>,
    FS: File<Key = NodeId, Block = Node, Inner = D::Inner> + TryFrom<D::Store, Error = TCError>,
    D: Dir + TryFrom<D::Store, Error = TCError>,
    T: Transaction<D>,
    A: SparseAccess<FD, FS, D, T>,
    D::Read: DirReadFile<FS>,
    D::Write: DirCreateFile<FS>,
    D::Store: From<FS>,

fn copy_from<'life0, 'async_trait>(
    txn: &'life0 T,
    store: D::Store,
    instance: SparseTensor<FD, FS, D, T, A>
) -> 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<FD, FS, D, T> Display for SparseTable<FD, FS, D, T>

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

Formats the value using the given formatter.

impl<FD, FS, D, T> FromStream for SparseTable<FD, FS, D, T>where
    FD: File<Key = u64, Block = Array>,
    FS: File<Key = NodeId, Block = Node, Inner = D::Inner> + TryFrom<D::Store, Error = TCError>,
    D: Dir,
    T: Transaction<D>,
    D::Read: DirReadFile<FS>,
    D::Write: DirCreateFile<FS>,
    D::Store: From<FS>,

type Context = (SparseTable<FD, FS, D, T>, TxnId)

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>(
    context: (Self, TxnId),
    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<FD, FS, D, T> Persist<D> for SparseTable<FD, FS, D, T>where
    FD: File<Key = u64, Block = Array>,
    FS: File<Key = NodeId, Block = Node, Inner = D::Inner> + TryFrom<D::Store, Error = TCError>,
    D: Dir + TryFrom<D::Store, Error = TCError>,
    T: Transaction<D>,
    D::Read: DirReadFile<FS>,
    D::Write: DirCreateFile<FS>,
    D::Store: From<FS>,

type Txn = T

type Schema = Schema

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) -> D::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<FD, FS, D, T> Restore<D> for SparseTable<FD, FS, D, T>where
    FD: File<Key = u64, Block = Array>,
    FS: File<Key = NodeId, Block = Node, Inner = D::Inner> + TryFrom<D::Store, Error = TCError>,
    D: Dir + TryFrom<D::Store, Error = TCError>,
    T: Transaction<D>,
    D::Read: DirReadFile<FS>,
    D::Write: DirCreateFile<FS>,
    D::Store: From<FS>,

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<FD, FS, D, T> SparseAccess<FD, FS, D, T> for SparseTable<FD, FS, D, T>where
    FD: File<Key = u64, Block = Array, Inner = D::Inner>,
    FS: File<Key = NodeId, Block = Node>,
    D: Dir,
    T: Transaction<D>,
    D::Write: DirCreateFile<FD>,

type Slice = SparseAccessor<FD, FS, D, T>

The type of a slice of this accessor

fn accessor(self) -> SparseAccessor<FD, FS, D, T>

Return this accessor as a SparseAccessor.

fn filled<'a, 'async_trait>(
    self,
    txn: T
) -> Pin<Box<dyn Future<Output = TCResult<Pin<Box<dyn Stream<Item = TCResult<(Coord, Number)>> + Send + Unpin + 'a>>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,

Return this SparseTensor’s contents as an ordered stream of (Coord, [Number]) pairs.

fn filled_at<'a, 'async_trait>(
    self,
    txn: T,
    axes: Vec<usize>
) -> Pin<Box<dyn Future<Output = TCResult<TCBoxTryStream<'a, Coords>>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'a: 'async_trait,

Return an ordered stream of unique Coords on the given axes with nonzero values.

fn filled_count<'async_trait>(
    self,
    txn: T
) -> Pin<Box<dyn Future<Output = TCResult<u64>> + Send + 'async_trait>>where
    Self: 'async_trait,

Return the number of nonzero values in this SparseTensor.

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

Return true if this SparseTensor contains no elements.

fn slice(self, bounds: Bounds) -> TCResult<Self::Slice>

Return a slice of this accessor with the given Bounds.

fn transpose(
    self,
    permutation: Option<Vec<usize>>
) -> TCResult<SparseAccessor<FD, FS, D, T>>

Return this accessor as transposed according to the given permutation.

impl<FD, FS, D, T> SparseWrite for SparseTable<FD, FS, D, T>where
    D: Dir,
    T: Transaction<D>,
    TableIndex<FS, D, T>: TableWrite,
    Self: TensorAccess + Send + Sync,

fn write_value<'life0, 'async_trait>(
    &'life0 self,
    txn_id: TxnId,
    coord: Coord,
    value: Number
) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Write the given value at the given coord of this SparseTensor.

impl<FD, FS, D, T> TensorAccess for SparseTable<FD, FS, D, T>

fn dtype(&self) -> NumberType

The datatype of this Tensor

fn ndim(&self) -> usize

The number of dimensions of this Tensor

fn shape(&self) -> &Shape

The shape of this Tensor

fn size(&self) -> u64

The number of elements in this Tensor

impl<FD, FS, D, T> Transact for SparseTable<FD, FS, D, T>where
    FD: File<Key = u64, Block = Array>,
    FS: File<Key = NodeId, Block = Node>,
    D: Dir,
    T: Transaction<D>,
    TableIndex<FS, D, T>: Transact,

type Commit = <TableIndex<FS, D, T> as Transact>::Commit

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.