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

🔬 This is a nightly-only experimental API. (toowned_clone_into)

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 D: Dir, T: Transaction<D>, FD: File<Array>, FS: File<Node>, D::File: AsType<FD> + AsType<FS>, D::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)

impl<FD, FS, D, T, A> CopyFrom<D, SparseTensor<FD, FS, D, T, A>> for SparseTable<FD, FS, D, T> where D: Dir, T: Transaction<D>, FD: File<Array>, FS: File<Node>, D::File: AsType<FD> + AsType<FS>, A: SparseAccess<FD, FS, D, T>, D::FileClass: From<BTreeType> + From<TensorType>,

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::File: AsType<FD> + AsType<FS>, D::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::File: AsType<FD> + AsType<FS>, D::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::File: AsType<FD> + AsType<FS>, D::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::File: AsType<FD> + AsType<FS>, D::FileClass: 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>, 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 T where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

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

fn cast_from(f: F) -> T

impl<T, F> CastInto<F> for T where 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 T where U: From<T>,

fn into(self) -> U

impl<F> Match for F

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

impl<T> Same<T> for T

type Output = T

impl<T> ToOwned for T where T: Clone,

type Owned = T

fn to_owned(&self) -> T

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

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

default fn to_string(&self) -> String

impl<F, T> TryCastFrom<F> for T where 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 F where T: TryCastFrom<F>,

fn can_cast_into(&self) -> bool

fn opt_cast_into(self) -> Option<T>

impl<FD, FS, D, T> SparseTable<FD, FS, D, T> where
D: Dir,
T: Transaction<D>,
FD: File<Array>,
FS: File<Node>,
D::File: AsType<FD> + AsType<FS>,
D::FileClass: From<BTreeType>,

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

impl<FD, FS, D, T, A> CopyFrom<D, SparseTensor<FD, FS, D, T, A>> for SparseTable<FD, FS, D, T> where
D: Dir,
T: Transaction<D>,
FD: File<Array>,
FS: File<Node>,
D::File: AsType<FD> + AsType<FS>,
A: SparseAccess<FD, FS, D, T>,
D::FileClass: From<BTreeType> + From<TensorType>,

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::File: AsType<FD> + AsType<FS>,
D::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::File: AsType<FD> + AsType<FS>,
D::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::File: AsType<FD> + AsType<FS>,
D::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::File: AsType<FD> + AsType<FS>,
D::FileClass: 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>,
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 T where
T: 'static + ?Sized,

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

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

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

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

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

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

impl<T> ToOwned for T where
T: Clone,

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

impl<F, T> TryCastFrom<F> for T where
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 F where
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 T where
U: Into<T>,

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

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