Struct tc_tensor::BlockListFile

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

A wrapper around a DenseTensor File

Implementations

impl<FD, FS, D, T> BlockListFile<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>,

pub fn constant(
    file: FD,
    txn_id: TxnId,
    shape: Shape,
    value: Number
) -> TCResult<Self>

Construct a new BlockListFile with the given Shape, filled with the given value.

pub async fn random_normal(
    file: FD,
    txn_id: TxnId,
    shape: Shape,
    dtype: FloatType,
    mean: Float,
    std: Float
) -> TCResult<Self>

Construct a new BlockListFile with the given Shape, with a random normal distribution.

pub fn random_uniform(
    file: FD,
    txn_id: TxnId,
    shape: Shape,
    dtype: FloatType
) -> TCResult<Self>

Construct a new BlockListFile with the given Shape, with a random normal distribution.

pub async fn from_blocks<S: Stream<Item = TCResult<Array>> + Send + Unpin>(
    file: FD,
    txn_id: TxnId,
    shape: Option<Shape>,
    dtype: NumberType,
    blocks: S
) -> TCResult<Self>

Construct a new BlockListFile from the given Stream of Array blocks.

pub async fn from_values<S: Stream<Item = TCResult<Number>> + Send + Unpin>(
    file: FD,
    txn_id: TxnId,
    shape: Shape,
    dtype: NumberType,
    values: S
) -> TCResult<Self>

Construct a new BlockListFile from the given Stream of elements.

pub async fn range(
    file: FD,
    txn_id: TxnId,
    shape: Shape,
    start: Number,
    stop: Number
) -> TCResult<Self>

Construct a new BlockListFile of elements evenly distributed between start and stop.

pub async fn merge_sort(&self, txn_id: TxnId) -> TCResult<()>

Sort the elements in this BlockListFile.

Trait Implementations

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

fn clone(&self) -> BlockListFile<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, B> CopyFrom<D, B> for BlockListFile<FD, FS, D, T>where
    FD: File<Key = u64, Block = Array, Inner = D::Inner> + TryFrom<D::Store, Error = TCError>,
    FS: File<Key = NodeId, Block = Node>,
    D: Dir,
    T: Transaction<D>,
    B: DenseAccess<FD, FS, D, T>,
    D::Store: From<FD>,

fn copy_from<'life0, 'async_trait>(
    txn: &'life0 T,
    store: D::Store,
    other: B
) -> 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> DenseAccess<FD, FS, D, T> for BlockListFile<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 = BlockListFileSlice<FD, FS, D, T>

The type returned by slice

type Transpose = BlockListTranspose<FD, FS, D, T, BlockListFile<FD, FS, D, T>>

The type returned by transpose

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

Return a DenseAccessor enum which contains this accessor.

fn block_stream<'a>(
    self,
    txn: T
) -> TCBoxTryFuture<'a, TCBoxTryStream<'a, Array>>

Return a stream of the Arrays which this DenseTensor comprises.

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

Return a slice of this DenseTensor.

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

Return a transpose of this DenseTensor.

fn read_values<'async_trait>(
    self,
    txn: Self::Txn,
    coords: Coords
) -> Pin<Box<dyn Future<Output = TCResult<Array>> + Send + 'async_trait>>where
    Self: 'async_trait,

Return an Array with the values at the given coordinates.

fn value_stream<'a>(
    self,
    txn: Self::Txn
) -> TCBoxTryFuture<'a, TCBoxTryStream<'a, Number>>

Return a stream of the elements of this DenseTensor.

impl<FD, FS, D, T> DenseWrite<FD, FS, D, T> for BlockListFile<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>,

fn write<'life0, 'async_trait, B>(
    &'life0 self,
    txn: Self::Txn,
    bounds: Bounds,
    value: B
) -> Pin<Box<dyn Future<Output = TCResult<()>> + Send + 'async_trait>>where
    B: 'async_trait + DenseAccess<FD, FS, D, T>,
    Self: 'async_trait,
    'life0: 'async_trait,

Overwrite this accessor’s contents with those of the given accessor.

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

Write a value to the slice of this DenseTensor with the given Bounds.

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

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

Formats the value using the given formatter.

impl<FD, FS, D, T> From<BlockListFile<FD, FS, D, T>> for DenseAccessor<FD, FS, D, T>where
    FD: File<Key = u64, Block = Array>,
    FS: File<Key = NodeId, Block = Node>,
    D: Dir,
    T: Transaction<D>,

fn from(file: BlockListFile<FD, FS, D, T>) -> Self

Converts to this type from the input type.

impl<FD, FS, D, T> FromStream for BlockListFile<FD, FS, D, T>where
    FD: File<Key = u64, Block = Array>,
    FS: Send,
    D: Send,
    T: Send,

type Context = (TxnId, FD, Schema)

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>(
    cxt: (TxnId, FD, Schema),
    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 BlockListFile<FD, FS, D, T>where
    FD: File<Key = u64, Block = Array, Inner = D::Inner> + TryFrom<D::Store, Error = TCError>,
    FS: File<Key = NodeId, Block = Node>,
    D: Dir,
    T: Transaction<D>,
    D::Store: From<FD>,

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

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> TensorAccess for BlockListFile<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 BlockListFile<FD, FS, D, T>where
    FD: File<Key = u64, Block = Array> + Transact,
    FS: File<Key = NodeId, Block = Node>,
    D: Dir,
    T: Transaction<D>,

type Commit = <FD 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.