Struct tc_tensor::SparseTable[−][src]

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

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.

The type of a slice of this accessor

The type of a transpose 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 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

Performs the conversion.

Performs the conversion.

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)

recently added

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[−][src]

Implementations

impl<FD, FS, D, T> SparseTable<FD, FS, D, T> where FD: File<Array> + TryFrom<D::File, Error = TCError>, FS: File<Node> + TryFrom<D::File, Error = TCError>, D: Dir, T: Transaction<D>, 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)

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 FD: File<Array> + TryFrom<D::File, Error = TCError>, FS: File<Node> + TryFrom<D::File, Error = TCError>, D: Dir, T: Transaction<D>, D::FileClass: From<BTreeType> + From<TensorType>,

type Context = (Self, TxnId)

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

impl<FD, FS, D, T> Persist<D> for SparseTable<FD, FS, D, T> where FD: File<Array> + TryFrom<D::File, Error = TCError>, FS: File<Node> + TryFrom<D::File, Error = TCError>, D: Dir, T: Transaction<D>, 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 FD: File<Array> + TryFrom<D::File, Error = TCError>, FS: File<Node> + TryFrom<D::File, Error = TCError>, D: Dir, T: Transaction<D>, 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 FD: File<Array> + TryFrom<D::File, Error = TCError>, FS: File<Node> + TryFrom<D::File, Error = TCError>, D: Dir, T: Transaction<D>, D::FileClass: From<TensorType>,

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

type Transpose = SparseTranspose<FD, FS, D, T, Self>

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 slice(self, bounds: Bounds) -> TCResult<Self::Slice>

fn transpose(self, permutation: Option<Vec<usize>>) -> TCResult<Self::Transpose>

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> where D: RefUnwindSafe, FD: RefUnwindSafe, FS: RefUnwindSafe, T: RefUnwindSafe,

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> where D: RefUnwindSafe, FD: UnwindSafe, FS: RefUnwindSafe, T: RefUnwindSafe,

Blanket Implementations

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

pub fn type_id(&self) -> TypeId

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

pub fn borrow(&self) -> &T

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

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

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

pub fn cast_from(f: F) -> T

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

pub fn cast_into(self) -> F

impl<T> From<T> for T

pub fn from(t: T) -> T

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

pub 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

pub fn to_owned(&self) -> T

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

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

pub default fn to_string(&self) -> String

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

pub fn can_cast_from(&F) -> bool

pub 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>,

pub fn can_cast_into(&self) -> bool

pub 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> + TryFrom<D::File, Error = TCError>,
FS: File<Node> + TryFrom<D::File, Error = TCError>,
D: Dir,
T: Transaction<D>,
D::FileClass: From<BTreeType>,

pub async fn create(
context: &D,
schema: Schema,
txn_id: TxnId
) -> TCResult<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> FromStream for SparseTable<FD, FS, D, T> where
FD: File<Array> + TryFrom<D::File, Error = TCError>,
FS: File<Node> + TryFrom<D::File, Error = TCError>,
D: Dir,
T: Transaction<D>,
D::FileClass: From<BTreeType> + From<TensorType>,

type Context = (Self, TxnId )

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

impl<FD, FS, D, T> Persist<D> for SparseTable<FD, FS, D, T> where
FD: File<Array> + TryFrom<D::File, Error = TCError>,
FS: File<Node> + TryFrom<D::File, Error = TCError>,
D: Dir,
T: Transaction<D>,
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
FD: File<Array> + TryFrom<D::File, Error = TCError>,
FS: File<Node> + TryFrom<D::File, Error = TCError>,
D: Dir,
T: Transaction<D>,
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
FD: File<Array> + TryFrom<D::File, Error = TCError>,
FS: File<Node> + TryFrom<D::File, Error = TCError>,
D: Dir,
T: Transaction<D>,
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,

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> RefUnwindSafe for SparseTable<FD, FS, D, T> where
D: RefUnwindSafe,
FD: RefUnwindSafe,
FS: RefUnwindSafe,
T: RefUnwindSafe,

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> where
D: RefUnwindSafe,
FD: UnwindSafe,
FS: RefUnwindSafe,
T: RefUnwindSafe,

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>,