Struct ComputedColumn 

pub struct ComputedColumn<M> { /* private fields */ }

A display-only column rendering any text from the row, with no query predicate.

tablo_core::ComputedColumn::new("Words", |p: &Post| {
    p.body.split_whitespace().count().to_string()
});

A closure that reads a relation declares it with include_unscoped, so the page loads it. One relation’s record or count is a RelationColumn or a CountColumn, which declare their own and show only what the related resource shows the user.

It maps to no column, so it neither searches nor sorts.

A badge shows the text in an outline badge, with a dot in the color the row gives it:

use tablo_core::{Color, ComputedColumn, Reads, lens};

ComputedColumn::new("Size", |o: &Order| {
    if o.total_cents > 100_00 {
        "Large"
    } else {
        "Small"
    }
    .to_string()
})
.badge()
.color(|o: &Order| (o.total_cents > 100_00).then_some(Color::Success))
.reading(Reads::of(lens!(Order.total_cents)));

Implementations

impl<M> ComputedColumn<M>

where M: Model,

pub fn new( label: impl Into<Text>, project: impl Fn(&M) -> String + Send + Sync + 'static, ) -> Self

Declare a column headed label rendering project(row), named after the label: its plain text in lowercase, or its message’s id.

pub fn badge(self) -> Self

Show the text as a badge, with a dot in its color.

pub fn color( self, color: impl Fn(&M) -> Option<Color> + Send + Sync + 'static, ) -> Self

Color the text by color(row): its badge’s dot, or the text itself when it is no badge. reading declares what it reads, beside the projection.

pub fn include_unscoped<T>(self, relation: impl Into<Include<M, T>>) -> Self

Declare a relation the projection reads, so the table loads it. The projection reads whatever the include loads, under no resource’s query or policy, as an unscoped relation column does: another tenant’s record, or one the user may not view, reaches it.

pub fn reading(self, reads: Reads<M>) -> Self

Declare the fields the projection and its color read, which a resource restricting a field with field_access needs: the column shows only to a user who may view every one.

pub fn width(self, width: ColumnWidth) -> Self

Declare this column’s width.

pub fn align(self, alignment: Alignment) -> Self

Align the header and the cells.

pub fn toggleable(self) -> Self

Let each reader hide this column from their list; it starts shown.

pub fn hidden_by_default(self) -> Self

Let each reader show this column in their list; it starts hidden.

Trait Implementations

impl<M> Clone for ComputedColumn<M>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M> Column<M> for ComputedColumn<M>

where M: Model + Send + Sync + 'static,

fn name(&self) -> &str

The column’s identifier, distinct within its table.

fn label(&self) -> Text

The header text.

fn text(&self, _cx: &Cx, row: &M) -> String

The row’s value as plain text.

fn cell<'a>(&self, cx: &'a Cx, row: &M) -> BoxView<'a>

The row’s table cell.

fn column_width(&self) -> ColumnWidth

The width the column claims.

fn toggle(&self) -> ColumnToggle

Whether each reader may hide or show the column in their list, and how it starts. A detail page shows every column.

fn alignment(&self) -> Alignment

Where the header and the cells align their content.

fn includes(&self) -> Includes<M>

The relations text, cell and entry read.

fn reads(&self) -> Option<Reads<M>>

The fields of the row text, cell, entry, search_expr and order_by read, or None when the column does not say.

fn entry<'a>(&self, cx: &'a Cx, row: &M) -> BoxView<'a>

The record’s entry on a detail page: the label over the cell.

fn search_expr(&self, _term: &str) -> Option<Expr<bool>>

The predicate a search for term adds, or None when the column does not join the table’s search. A column that joins it answers Some for every non-empty, trimmed term.

fn order_by(&self, _descending: bool) -> Option<OrderByExpr>

The ordering a sort on this column applies, or None when the header does not link to a sort on it. A sortable column answers Some either way.

impl<M> Debug for ComputedColumn<M>

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

Formats the value using the given formatter.

impl<M> IntoColumns<M> for ComputedColumn<M>

where Self: Column<M> + 'static,

impl<M> IntoDetail<M> for ComputedColumn<M>

where Self: Column<M> + 'static,

fn into_detail(self) -> Detail<M>