Enum tc_collection::tensor::sparse::SparseBase

pub enum SparseBase<Txn, FE> {
    Bool(SparseBase<Txn, FE, u8>),
    C32((SparseBase<Txn, FE, f32>, SparseBase<Txn, FE, f32>)),
    C64((SparseBase<Txn, FE, f64>, SparseBase<Txn, FE, f64>)),
    F32(SparseBase<Txn, FE, f32>),
    F64(SparseBase<Txn, FE, f64>),
    I16(SparseBase<Txn, FE, i16>),
    I32(SparseBase<Txn, FE, i32>),
    I64(SparseBase<Txn, FE, i64>),
    U8(SparseBase<Txn, FE, u8>),
    U16(SparseBase<Txn, FE, u16>),
    U32(SparseBase<Txn, FE, u32>),
    U64(SparseBase<Txn, FE, u64>),
}

Variants

Bool(SparseBase<Txn, FE, u8>)

C32((SparseBase<Txn, FE, f32>, SparseBase<Txn, FE, f32>))

C64((SparseBase<Txn, FE, f64>, SparseBase<Txn, FE, f64>))

F32(SparseBase<Txn, FE, f32>)

F64(SparseBase<Txn, FE, f64>)

I16(SparseBase<Txn, FE, i16>)

I32(SparseBase<Txn, FE, i32>)

I64(SparseBase<Txn, FE, i64>)

U8(SparseBase<Txn, FE, u8>)

U16(SparseBase<Txn, FE, u16>)

U32(SparseBase<Txn, FE, u32>)

U64(SparseBase<Txn, FE, u64>)

Trait Implementations

impl<Txn, FE> Clone for SparseBase<Txn, FE>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Txn, FE> CopyFrom<FE, SparseView<Txn, FE>> for SparseBase<Txn, FE>

where Txn: Transaction<FE>, FE: DenseCacheFile + AsType<Node> + Clone,

fn copy_from<'life0, 'async_trait>( txn: &'life0 Txn, store: Dir<FE>, instance: SparseView<Txn, FE> ) -> 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<Txn: ThreadSafe, FE: ThreadSafe> Debug for SparseBase<Txn, FE>

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

Formats the value using the given formatter.

impl<Txn, FE> From<SparseBase<Txn, FE>> for SparseView<Txn, FE>

fn from(base: SparseBase<Txn, FE>) -> Self

Converts to this type from the input type.

impl<Txn, FE> FromStream for SparseBase<Txn, FE>

where Txn: Transaction<FE>, FE: AsType<Node> + ThreadSafe + Clone,

type Context = Txn

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, D>( txn: Txn, decoder: &'life0 mut D ) -> Pin<Box<dyn Future<Output = Result<Self, D::Error>> + Send + 'async_trait>>

where D: 'async_trait + Decoder, Self: 'async_trait, 'life0: 'async_trait,

Parse this value using the given Decoder.

impl<Txn: ThreadSafe, FE: ThreadSafe> Instance for SparseBase<Txn, FE>

type Class = TensorType

The Class type of this instance

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

Returns the [Class] of this instance.

impl<Txn, FE> Persist<FE> for SparseBase<Txn, FE>

where Txn: Transaction<FE>, FE: AsType<Node> + ThreadSafe + Clone,

type Txn = Txn

type Schema = Schema

fn create<'async_trait>( txn_id: TxnId, schema: Self::Schema, store: Dir<FE> ) -> Pin<Box<dyn Future<Output = TCResult<Self>> + Send + 'async_trait>>

where Self: 'async_trait,

Create a new instance of Self from an empty Store.

fn load<'async_trait>( txn_id: TxnId, schema: Self::Schema, store: Dir<FE> ) -> Pin<Box<dyn Future<Output = TCResult<Self>> + Send + 'async_trait>>

where Self: 'async_trait,

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

fn dir(&self) -> Inner<FE>

Access the filesystem directory backing this persistent data structure.

fn load_or_create<'async_trait>( txn_id: TxnId, schema: Self::Schema, store: Dir<FE> ) -> Pin<Box<dyn Future<Output = Result<Self, TCError>> + Send + 'async_trait>>

where Self: Send + 'async_trait,

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

impl<Txn, FE> Restore<FE> for SparseBase<Txn, FE>

where Txn: Transaction<FE>, FE: DenseCacheFile + AsType<Node> + Clone,

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<State> Route<State> for SparseBase<State::Txn, State::FE>

where State: StateInstance + From<Tensor<State::Txn, State::FE>> + From<Tuple<Value>>, State::Class: From<NumberType>, State::FE: DenseCacheFile + AsType<Node>, Number: TryCastFrom<State>, Tensor<State::Txn, State::FE>: TryCastFrom<State>, Value: TryCastFrom<State>, bool: TryCastFrom<State>,

fn route<'a>( &'a self, path: &'a [PathSegment] ) -> Option<Box<dyn Handler<'a, State> + 'a>>

impl<Txn, FE> TensorInstance for SparseBase<Txn, FE>

where Txn: ThreadSafe, FE: ThreadSafe,

fn dtype(&self) -> NumberType

fn shape(&self) -> &Shape

fn ndim(&self) -> usize

fn size(&self) -> u64

fn schema(&self) -> Schema

impl<Txn, FE> TensorRead for SparseBase<Txn, FE>

where Txn: Transaction<FE>, FE: DenseCacheFile + AsType<Node>,

fn read_value<'async_trait>( self, txn_id: TxnId, coord: Coord ) -> Pin<Box<dyn Future<Output = TCResult<Number>> + Send + 'async_trait>>

where Self: 'async_trait,

Read a single value from this Tensor.

impl<Txn, FE> TensorWrite for SparseBase<Txn, FE>

where Txn: Transaction<FE>, FE: DenseCacheFile + AsType<Node>,

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

where Self: 'async_trait, 'life0: 'async_trait,

Write a single value to the slice of this Tensor with the given Range.

fn write_value_at<'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,

Overwrite a single element of this Tensor.

impl<Txn, FE> TensorWriteDual<SparseView<Txn, FE>> for SparseBase<Txn, FE>

where Txn: Transaction<FE>, FE: DenseCacheFile + AsType<Node> + ThreadSafe,

fn write<'async_trait>( self, txn_id: TxnId, range: Range, value: SparseView<Txn, FE> ) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>>

where Self: 'async_trait,

Overwrite the slice of this Tensor given by Range with the given value.

impl<Txn, FE> Transact for SparseBase<Txn, FE>

where Txn: Transaction<FE>, FE: AsType<Node> + ThreadSafe + for<'a> FileSave<'a> + Clone,

type 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.