Struct TableRow 

pub struct TableRow<T>(/* private fields */);

Implementations

impl<T> TableRow<T>

pub fn from_element(element: T, length: usize) -> Self

where T: Clone,

pub fn from_vec(data: Vec<T>, expected_length: usize) -> Self

Constructs a TableRow from a Vec<T>, panicking if the length does not match expected_length.

Use this when you want to ensure at construction time that the row has the correct number of columns. This enforces the rectangular invariant for table data, preventing accidental creation of malformed rows.

Panics

Panics if data.len() != expected_length.

pub fn try_from_vec(data: Vec<T>, expected_len: usize) -> Result<Self, String>

Attempts to construct a TableRow from a Vec<T>, returning an error if the length does not match expected_len.

This is a fallible alternative to from_vec, allowing you to handle inconsistent row lengths gracefully. Returns Ok(TableRow) if the length matches, or an Err with a descriptive message otherwise.

pub fn expect_get(&self, col: impl Into<usize>) -> &T

Returns reference to element by column index.

Panics

Panics if col is out of bounds (i.e., col >= self.cols()).

pub fn get(&self, col: impl Into<usize>) -> Option<&T>

pub fn as_slice(&self) -> &[T]

pub fn into_vec(self) -> Vec<T>

pub fn map_cloned<F, U>(&self, f: F) -> TableRow<U>

where F: FnMut(T) -> U, T: Clone,

Like [map], but borrows the row and clones each element before mapping.

This is useful when you want to map over a borrowed row without consuming it, but your mapping function requires ownership of each element.

Difference

• map_cloned takes &self, clones each element, and applies f(T) -> U.
• [map] takes self by value and applies f(T) -> U directly, consuming the row.
• [map_ref] takes &self and applies f(&T) -> U to references of each element.

pub fn map<F, U>(self, f: F) -> TableRow<U>

where F: FnMut(T) -> U,

Consumes the row and transforms all elements within it in a length-safe way.

Difference

• map takes ownership of the row (self) and applies f(T) -> U to each element.
• Use this when you want to transform and consume the row in one step.
• See also [map_cloned] (for mapping over a borrowed row with cloning) and [map_ref] (for mapping over references).

pub fn map_ref<F, U>(&self, f: F) -> TableRow<U>

where F: FnMut(&T) -> U,

Borrows the row and transforms all elements by reference in a length-safe way.

Difference

• map_ref takes &self and applies f(&T) -> U to each element by reference.
• Use this when you want to map over a borrowed row without cloning or consuming it.
• See also [map] (for consuming the row) and [map_cloned] (for mapping with cloning).

pub fn cols(&self) -> usize

Number of columns (alias to len() with more semantic meaning)

Trait Implementations

impl<T: Clone> Clone for TableRow<T>

fn clone(&self) -> TableRow<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for TableRow<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for TableRow<T>

impl<T> Index<Range<usize>> for TableRow<T>

type Output = [T]

The returned type after indexing.

fn index(&self, index: Range<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> Index<RangeFrom<usize>> for TableRow<T>

type Output = [T]

The returned type after indexing.

fn index(&self, index: RangeFrom<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> Index<RangeFull> for TableRow<T>

type Output = [T]

The returned type after indexing.

fn index(&self, index: RangeFull) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> Index<RangeInclusive<usize>> for TableRow<T>

type Output = [T]

The returned type after indexing.

fn index(&self, index: RangeInclusive<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> Index<RangeTo<usize>> for TableRow<T>

type Output = [T]

The returned type after indexing.

fn index(&self, index: RangeTo<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> Index<RangeToInclusive<usize>> for TableRow<T>

type Output = [T]

The returned type after indexing.

fn index(&self, index: RangeToInclusive<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> Index<usize> for TableRow<T>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<RangeInclusive<usize>> for TableRow<T>

fn index_mut(&mut self, index: RangeInclusive<usize>) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T> IndexMut<usize> for TableRow<T>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T: PartialEq> PartialEq for TableRow<T>

fn eq(&self, other: &TableRow<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T: PartialEq> StructuralPartialEq for TableRow<T>