Struct tc_tensor::BlockListFile

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

A wrapper around a DenseTensor File

Implementations

impl<FD, FS, D, T> BlockListFile<FD, FS, D, T> where
    FD: File<Array>,
    FS: File<Node>,
    D: Dir,
    T: Transaction<D>, 

pub async 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 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 fn into_stream(
    self,
    txn_id: TxnId
) -> impl Stream<Item = TCResult<Array>> + Unpin

Consume this BlockListFile handle and return a Stream of Array blocks.

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<Array>,
    FS: File<Node>,
    D: Dir,
    T: Transaction<D>,
    B: DenseAccess<FD, FS, D, T>, 

fn copy_from<'life0, 'async_trait>(
    other: B,
    file: FD,
    txn: &'life0 T
) -> Pin<Box<dyn Future<Output = TCResult<Self>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: '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<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 = BlockListFileSlice<FD, FS, D, T>

The type returned by slice

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

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

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

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

impl<FD, FS, D, T> From<BlockListFile<FD, FS, D, T>> for DenseAccessor<FD, FS, D, T> where
    FD: File<Array>,
    FS: File<Node>,
    D: Dir,
    T: Transaction<D>, 

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

Performs the conversion.

impl<FD, FS, D, T> FromStream for BlockListFile<FD, FS, D, T> where
    FD: File<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: Decoder>(
    cxt: (TxnId, FD, Schema),
    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, 

Parse this value using the given Decoder.

impl<FD, FS, D, T> Persist<D> for BlockListFile<FD, FS, D, T> where
    FD: File<Array>,
    FS: File<Node>,
    D: Dir,
    T: Transaction<D>, 

type Schema = Schema

type Store = FD

type Txn = T

fn schema(&self) -> &Schema

Return the schema of this persistent state.

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

Load a saved state from persistent storage.

impl<FD, FS, D, T> Restore<D> for BlockListFile<FD, FS, D, T> where
    FD: File<Array>,
    FS: File<Node>,
    D: Dir,
    T: Transaction<D>, 

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: Send, FS: Send, D: Send, T: Send> 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<Array> + Transact,
    FS: File<Node>,
    D: Dir,
    T: Transaction<D>, 

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, 

Commit this transaction.

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, 

Delete any version data specific to this transaction.