Enum Data 

pub enum Data {
    Bool(Buf<u8>),
    I64(Buf<i64>),
    Ext(Buf<Ext>),
    Rat(Buf<Rat>),
    F64(Buf<f64>),
    Complex(Buf<Cx>),
    Char(Buf<char>),
    Symbol(Buf<Id>),
    Box(Buf<Array>),
}

Variants

Bool(Buf<u8>)

I64(Buf<i64>)

Ext(Buf<Ext>)

Arbitrary-precision integers. Like boxes, these are heap-backed pointers rather than machine words: never foreign, never fused, never vectorised.

Rat(Buf<Rat>)

Exact ratios, each in lowest terms. Heap-backed, as Ext is.

F64(Buf<f64>)

Complex(Buf<Cx>)

Complex numbers, interleaved [re, im] — the layout numpy, C and a pair of Arrow float columns all share.

Char(Buf<char>)

Symbol(Buf<Id>)

Symbols: every element is an index into the process-wide symbol table (see crate::symbol), so the buffer is as flat and as cheap to copy as one of integers and the names live once each.

Box(Buf<Array>)

Boxes: every element is a whole array. Foreign memory never holds these, so a boxed buffer is always owned and cloning it is a refcount bump like any other.

Implementations

impl Data

pub fn dtype(&self) -> DType

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn is_foreign(&self) -> bool

True while the payload still borrows foreign memory.

pub fn owner(&self) -> Option<&Owner>

The handle keeping this payload’s memory alive, for a borrowed one. See Buf::owner.

pub fn slice(&self, start: usize, end: usize) -> Data

pub fn empty(dtype: DType) -> Data

pub fn push_fill(&mut self)

The fill element used by overtaking and framing. The boxed fill is J’s a:, a box holding an empty numeric list.

pub fn push_from(&mut self, src: &Data, i: usize)

Append element i of src, which must hold the same type. Nothing happens if the types disagree; every caller has checked already.

pub fn extend_from(&mut self, other: &Data) -> bool

pub fn join(columns: &[Data], rows: usize) -> Option<Data>

The columns end to end, as the flat buffer of a Layout::ColMajor array of shape [rows, columns.len()].

Nothing is copied: each column keeps borrowing whatever memory it arrived in, and the buffer joins them only if some reader asks for the flat slice. This is the table boundary that does no work.

None on the same disagreements Data::interleave refuses.

pub fn columns(&self, rows: usize, cols: usize) -> Vec<Data>

The cols runs of rows elements this buffer holds, each as a buffer of its own: the columns of a Layout::ColMajor array. Slicing a joined buffer at a seam copies nothing, so a table that arrived as columns is read back as the columns it arrived as.

pub fn interleave(columns: &[Data], rows: usize) -> Option<Data>

Weave column-major buffers into one row-major block of shape [rows, columns.len()].

This is the table boundary: a DataFrame arrives as one buffer per column and libjay works rows-leading, so the elements have to be woven once. The weave reads every column in order and writes its result straight through, split across threads at the sizes that pay.

None when the columns disagree on element type, when one is shorter than rows, or when there are no columns at all — the importing side has already reported that.

pub fn cast(&self, to: DType) -> Option<Data>

Widen to to. Returns None for unsupported conversions.

Trait Implementations

impl Clone for Data

fn clone(&self) -> Data

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Data

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

Formats the value using the given formatter.

impl PartialEq for Data

fn eq(&self, other: &Data) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Data