Struct lace::Row

pub struct Row<R: RowIndex, C: ColumnIndex> {
    pub row_ix: R,
    pub values: Vec<Value<C>>,
}

A list of data for insertion into a certain row

Example

use lace::Value;
use lace_data::Datum;

let row = Row::<&str, &str> {
    row_ix: "vampire",
    values: vec![
        Value {
            col_ix: "sucks_blood",
            value: Datum::Categorical(1_u8.into()),
        },
        Value {
            col_ix: "drinks_wine",
            value: Datum::Categorical(0_u8.into()),
        },
    ],
};

assert_eq!(row.len(), 2);

There are converters for convenience.

let row: Row<&str, &str>  = (
    "vampire",
    vec![
        ("sucks_blood", Datum::Categorical(1_u8.into())),
        ("drinks_wine", Datum::Categorical(0_u8.into())),
    ]
).into();

assert_eq!(row.len(), 2);

Fields

row_ix: R

The name of the row

values: Vec<Value<C>>

The cells and values to fill in

Implementations

impl<R: RowIndex, C: ColumnIndex> Row<R, C>

pub fn len(&self) -> usize

The number of values in the Row

pub fn is_empty(&self) -> bool

Return true if there are no values in the Row

Trait Implementations

impl<R: Clone + RowIndex, C: Clone + ColumnIndex> Clone for Row<R, C>

fn clone(&self) -> Row<R, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug + RowIndex, C: Debug + ColumnIndex> Debug for Row<R, C>

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

Formats the value using the given formatter.

impl<'de, R, C> Deserialize<'de> for Row<R, C>where R: Deserialize<'de> + RowIndex, C: Deserialize<'de> + ColumnIndex,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R, C> From<(R, Vec<(C, Datum), Global>)> for Row<R, C>where R: RowIndex, C: ColumnIndex,

fn from(row: (R, Vec<(C, Datum)>)) -> Self

Converts to this type from the input type.

impl<R: RowIndex, C: ColumnIndex> From<(R, Vec<Value<C>, Global>)> for Row<R, C>

fn from(row: (R, Vec<Value<C>>)) -> Self

Converts to this type from the input type.

impl<R: PartialEq + RowIndex, C: PartialEq + ColumnIndex> PartialEq<Row<R, C>> for Row<R, C>

fn eq(&self, other: &Row<R, C>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R, C> Serialize for Row<R, C>where R: Serialize + RowIndex, C: Serialize + ColumnIndex,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<R: RowIndex, C: ColumnIndex> StructuralPartialEq for Row<R, C>