Struct tc_tensor::SparseTable

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

Expand description

Implementations

Create a new SparseTable with the given Schema.

Trait Implementations

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Copy a new instance of Self from an existing instance.

Formats the value using the given formatter. Read more

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

Parse this value using the given Decoder.

Return the schema of this persistent state.

Load a saved state from persistent storage.

Restore this persistent state from a backup.

The type of a slice of this accessor

Return this accessor as a SparseAccessor.

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

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

Return the number of nonzero values in this SparseTensor.

Return true if this SparseTensor contains no elements.

Return a slice of this accessor with the given Bounds.

Return this accessor as transposed according to the given permutation. Read more

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

The datatype of this Tensor

The number of dimensions of this Tensor

The shape of this Tensor

The number of elements in this Tensor

Commit this transaction.

Delete any version data specific to this transaction.

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Cast an instance of T into an instance of Self.

Cast an instance of Self into an instance of T.

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Returns true if self can be cast into the target type T.

Should always be Self

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

Uses borrowed data to replace owned data, usually by cloning. Read more

Converts the given value to a String. Read more

Test if value can be cast into Self.

Returns Some(Self) if the source value can be cast into Self, otherwise None.

Returns Ok(Self) if the source value can be cast into Self, otherwise calls on_err.

Test if self can be cast into T.

Returns Some(T) if self can be cast into T, otherwise None.

Returns Ok(T) if self can be cast into T, otherwise calls on_err.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

Struct tc_tensor::SparseTable

Implementations

impl<FD, FS, D, T> SparseTable<FD, FS, D, T>where FD: File<Array>, FS: File<Node>, D: Dir, T: Transaction<D>, <D::Read as DirRead>::FileEntry: AsType<FD> + AsType<FS>, <D::Write as DirWrite>::FileClass: From<BTreeType>,

pub async fn create(context: &D, schema: Schema, txn_id: TxnId) -> TCResult<Self>

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>

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

fn copy_from<'life0, 'async_trait>( instance: SparseTensor<FD, FS, D, T, A>, store: D, txn: &'life0 T) -> Pin<Box<dyn Future<Output = TCResult<Self>> + Send + 'async_trait>>where 'life0: 'async_trait, Self: 'async_trait,

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

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

impl<FD, FS, D, T> FromStream for SparseTable<FD, FS, D, T>where D: Dir, T: Transaction<D>, FD: File<Array>, FS: File<Node>, <D::Read as DirRead>::FileEntry: AsType<FD> + AsType<FS>, <D::Write as DirWrite>::FileClass: From<BTreeType> + From<TensorType>,

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

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, 'life0: 'async_trait, Self: 'async_trait,

impl<FD, FS, D, T> Persist<D> for SparseTable<FD, FS, D, T>where D: Dir, T: Transaction<D>, FD: File<Array>, FS: File<Node>, <D::Read as DirRead>::FileEntry: AsType<FD> + AsType<FS>, <D::Write as DirWrite>::FileClass: From<BTreeType> + From<TensorType>,

type Schema = Schema

type Store = D

type Txn = T

fn schema(&self) -> &Self::Schema

fn load<'life0, 'async_trait>( txn: &'life0 Self::Txn, schema: Self::Schema, store: Self::Store) -> Pin<Box<dyn Future<Output = TCResult<Self>> + Send + 'async_trait>>where 'life0: 'async_trait, Self: 'async_trait,

impl<FD, FS, D, T> Restore<D> for SparseTable<FD, FS, D, T>where D: Dir, T: Transaction<D>, FD: File<Array>, FS: File<Node>, <D::Read as DirRead>::FileEntry: AsType<FD> + AsType<FS>, <D::Write as DirWrite>::FileClass: From<BTreeType> + From<TensorType>,

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

impl<FD, FS, D, T> SparseAccess<FD, FS, D, T> for SparseTable<FD, FS, D, T>where D: Dir, T: Transaction<D>, FD: File<Array>, FS: File<Node>, <D::Read as DirRead>::FileEntry: AsType<FD> + AsType<FS>, <D::Write as DirWrite>::FileClass: From<BTreeType> + From<TensorType>,

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

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

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 'a: 'async_trait, Self: 'async_trait,

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 'a: 'async_trait, Self: 'async_trait,

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

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

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

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

impl<FD, FS, D, T> SparseWrite<FD, FS, D, T> for SparseTable<FD, FS, D, T>where FD: File<Array>, FS: File<Node>, D: Dir, T: Transaction<D>, <D::Write as DirWrite>::FileClass: From<BTreeType>, <D::Read as DirRead>::FileEntry: AsType<FS>, Self: SparseAccess<FD, FS, D, T>,

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 'life0: 'async_trait, Self: 'async_trait,

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

fn dtype(&self) -> NumberType

fn ndim(&self) -> usize

fn shape(&self) -> &Shape

fn size(&self) -> u64

impl<FD, FS, D, T> Transact for SparseTable<FD, FS, D, T>where FD: File<Array>, FS: File<Node>, D: Dir, T: Transaction<D>, TableIndex<FS, D, T>: Transact,

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

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

Auto Trait Implementations

impl<FD, FS, D, T> !RefUnwindSafe for SparseTable<FD, FS, D, T>

impl<FD, FS, D, T> Send for SparseTable<FD, FS, D, T>where D: Send + Sync, FD: Send, FS: Send + Sync, T: Send + Sync,

impl<FD, FS, D, T> Sync for SparseTable<FD, FS, D, T>where D: Send + Sync, FD: Sync, FS: Send + Sync, T: Send + Sync,

impl<FD, FS, D, T> Unpin for SparseTable<FD, FS, D, T>where FD: Unpin,

impl<FD, FS, D, T> !UnwindSafe for SparseTable<FD, FS, D, T>

Blanket Implementations

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<F, T> CastFrom<F> for Twhere T: From<F>,

fn cast_from(f: F) -> T

impl<T, F> CastInto<F> for Twhere F: CastFrom<T>,

fn cast_into(self) -> F

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<F> Match for F

fn matches<T>(&self) -> boolwhere T: TryCastFrom<Self>,

impl<T> Same<T> for T

type Output = T

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T> ToString for Twhere T: Display + ?Sized,

default fn to_string(&self) -> String

impl<F, T> TryCastFrom<F> for Twhere T: CastFrom<F>,

fn can_cast_from(&F) -> bool

fn opt_cast_from(f: F) -> Option<T>

fn try_cast_from<Err, OnErr>(value: T, on_err: OnErr) -> Result<Self, Err>where OnErr: FnOnce(&T) -> Err,

impl<F, T> TryCastInto<T> for Fwhere T: TryCastFrom<F>,

fn can_cast_into(&self) -> bool

fn opt_cast_into(self) -> Option<T>

fn try_cast_into<Err, OnErr>(self, on_err: OnErr) -> Result<T, Err>where OnErr: FnOnce(&Self) -> Err,

impl<FD, FS, D, T> SparseTable<FD, FS, D, T>where
FD: File<Array>,
FS: File<Node>,
D: Dir,
T: Transaction<D>,
<D::Read as DirRead>::FileEntry: AsType<FD> + AsType<FS>,
<D::Write as DirWrite>::FileClass: From<BTreeType>,

fn copy_from<'life0, 'async_trait>(
instance: SparseTensor<FD, FS, D, T, A>,
store: D,
txn: &'life0 T
) -> Pin<Box<dyn Future<Output = TCResult<Self>> + Send + 'async_trait>>where
'life0: 'async_trait,
Self: 'async_trait,

impl<FD, FS, D, T> FromStream for SparseTable<FD, FS, D, T>where
D: Dir,
T: Transaction<D>,
FD: File<Array>,
FS: File<Node>,
<D::Read as DirRead>::FileEntry: AsType<FD> + AsType<FS>,
<D::Write as DirWrite>::FileClass: From<BTreeType> + From<TensorType>,

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,
'life0: 'async_trait,
Self: 'async_trait,

impl<FD, FS, D, T> Persist<D> for SparseTable<FD, FS, D, T>where
D: Dir,
T: Transaction<D>,
FD: File<Array>,
FS: File<Node>,
<D::Read as DirRead>::FileEntry: AsType<FD> + AsType<FS>,
<D::Write as DirWrite>::FileClass: From<BTreeType> + From<TensorType>,

fn load<'life0, 'async_trait>(
txn: &'life0 Self::Txn,
schema: Self::Schema,
store: Self::Store
) -> Pin<Box<dyn Future<Output = TCResult<Self>> + Send + 'async_trait>>where
'life0: 'async_trait,
Self: 'async_trait,

impl<FD, FS, D, T> Restore<D> for SparseTable<FD, FS, D, T>where
D: Dir,
T: Transaction<D>,
FD: File<Array>,
FS: File<Node>,
<D::Read as DirRead>::FileEntry: AsType<FD> + AsType<FS>,
<D::Write as DirWrite>::FileClass: From<BTreeType> + From<TensorType>,

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

impl<FD, FS, D, T> SparseAccess<FD, FS, D, T> for SparseTable<FD, FS, D, T>where
D: Dir,
T: Transaction<D>,
FD: File<Array>,
FS: File<Node>,
<D::Read as DirRead>::FileEntry: AsType<FD> + AsType<FS>,
<D::Write as DirWrite>::FileClass: From<BTreeType> + From<TensorType>,

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
'a: 'async_trait,
Self: 'async_trait,

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
'a: 'async_trait,
Self: 'async_trait,

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

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

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

impl<FD, FS, D, T> SparseWrite<FD, FS, D, T> for SparseTable<FD, FS, D, T>where
FD: File<Array>,
FS: File<Node>,
D: Dir,
T: Transaction<D>,
<D::Write as DirWrite>::FileClass: From<BTreeType>,
<D::Read as DirRead>::FileEntry: AsType<FS>,
Self: SparseAccess<FD, FS, D, T>,

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
'life0: 'async_trait,
Self: 'async_trait,

impl<FD, FS, D, T> Transact for SparseTable<FD, FS, D, T>where
FD: File<Array>,
FS: File<Node>,
D: Dir,
T: Transaction<D>,
TableIndex<FS, D, T>: Transact,

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

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

impl<FD, FS, D, T> Send for SparseTable<FD, FS, D, T>where
D: Send + Sync,
FD: Send,
FS: Send + Sync,
T: Send + Sync,

impl<FD, FS, D, T> Sync for SparseTable<FD, FS, D, T>where
D: Send + Sync,
FD: Sync,
FS: Send + Sync,
T: Send + Sync,

impl<FD, FS, D, T> Unpin for SparseTable<FD, FS, D, T>where
FD: Unpin,

impl<T> Any for Twhere
T: 'static + ?Sized,

impl<T> Borrow<T> for Twhere
T: ?Sized,

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

impl<F, T> CastFrom<F> for Twhere
T: From<F>,

impl<T, F> CastInto<F> for Twhere
F: CastFrom<T>,

impl<T, U> Into<U> for Twhere
U: From<T>,

fn matches<T>(&self) -> boolwhere
T: TryCastFrom<Self>,

impl<T> ToOwned for Twhere
T: Clone,

impl<T> ToString for Twhere
T: Display + ?Sized,

impl<F, T> TryCastFrom<F> for Twhere
T: CastFrom<F>,

fn try_cast_from<Err, OnErr>(value: T, on_err: OnErr) -> Result<Self, Err>where
OnErr: FnOnce(&T) -> Err,

impl<F, T> TryCastInto<T> for Fwhere
T: TryCastFrom<F>,

fn try_cast_into<Err, OnErr>(self, on_err: OnErr) -> Result<T, Err>where
OnErr: FnOnce(&Self) -> Err,

impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,

impl<V, T> VZip<V> for Twhere
V: MultiLane<T>,