Struct TableState 

pub struct TableState {
    pub query: String,
    pub page: i32,
    /* private fields */
}

The signals a DataTable or ServerTable keeps: filter text, page, and sort.

Put one in the page’s signals for each table. A ServerTable sends it to the server, which reads the sort with TableState::sorting.

use hypersig::Signals;
use hypersig_ui::TableState;
use serde::{Deserialize, Serialize};

#[derive(Signals, Serialize, Deserialize)]
struct Users {
    table: TableState,
}

let users = Users { table: TableState::default() };
assert_eq!(users.table.page, 0);

Fields

query: String

What the filter field holds.

page: i32

The page shown, counted from 0.

Implementations

impl TableState

pub fn query() -> Sig<Self, String>

Typed reference to the query signal.

pub fn page() -> Sig<Self, i32>

Typed reference to the page signal.

impl TableState

pub fn sorting<K: Segment>(&self) -> Option<(K, SortOrder)>

The key of the column a ServerTable is sorted by, and its order.

Returns None while the table is unsorted, and where the sorted column is not one of K, such as for a state a DataTable wrote.

use hypersig::Segment;
use hypersig_ui::{SortOrder, TableState};
use serde::{Deserialize, Serialize};

#[derive(Segment, Serialize, Deserialize, Debug, PartialEq)]
enum By {
    Email,
    Amount,
}

let state = TableState::default().with_sorting(&By::Amount, SortOrder::Descending);
assert_eq!(state.sorting::<By>(), Some((By::Amount, SortOrder::Descending)));
assert_eq!(TableState::default().sorting::<By>(), None);

pub fn with_sorting<K: Segment>(self, key: &K, order: SortOrder) -> Self

This state sorted by the ServerTable column whose key is key, in order.

Use it for the first state of a page whose server sends the rows already sorted, so that the column’s header says so.

Trait Implementations

impl Clone for TableState

fn clone(&self) -> TableState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TableState

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

Formats the value using the given formatter.

impl Default for TableState

fn default() -> TableState

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TableState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for TableState

impl PartialEq for TableState

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for TableState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Signals for TableState

impl StructuralPartialEq for TableState