tabled 0.20.0

An easy to use library for pretty print tables of Rust `struct`s and `enum`s.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use crate::grid::{
    config::Entity,
    records::{ExactRecords, Records, RecordsMut},
};

/// A trait for configuring a single cell.
///
/// A cell is represented by row and column indexes.
///
/// A cell can be targeted by [`Cell`].
///
/// [`Cell`]: crate::settings::object::Cell
pub trait CellOption<R, C> {
    /// Modification function of a certail part of a grid targeted by [`Entity`].
    fn change(self, records: &mut R, cfg: &mut C, entity: Entity);

    /// A hint whether an [`TableOption`] is going to change table layout.
    ///
    /// Return [`None`] if no changes are being done.
    /// Otherwise return:
    ///
    /// - [Entity::Global] - a grand layout changed.
    /// - [Entity::Row] - a certain row was changed.
    /// - [Entity::Column] - a certain column was changed.
    /// - [Entity::Cell] - a certain cell was changed.
    ///
    /// By default it's considered to be a grand change.
    ///
    /// This methods primarily is used as an optimization,
    /// to not make unnecessary calculations if they're not needed, after using the [`TableOption`].
    ///
    /// [`TableOption`]: crate::settings::TableOption
    fn hint_change(&self) -> Option<Entity> {
        Some(Entity::Global)
    }
}

#[cfg(feature = "std")]
impl<R, C> CellOption<R, C> for String
where
    R: Records + ExactRecords + RecordsMut<String>,
{
    fn change(self, records: &mut R, cfg: &mut C, entity: Entity) {
        (&self).change(records, cfg, entity);
    }
}

#[cfg(feature = "std")]
impl<R, C> CellOption<R, C> for &String
where
    R: Records + ExactRecords + RecordsMut<String>,
{
    fn change(self, records: &mut R, _: &mut C, entity: Entity) {
        let count_rows = records.count_rows();
        let count_cols = records.count_columns();

        for pos in entity.iter(count_rows, count_cols) {
            records.set(pos, self.clone());
        }
    }
}

impl<'a, R, C> CellOption<R, C> for &'a str
where
    R: Records + ExactRecords + RecordsMut<&'a str>,
{
    fn change(self, records: &mut R, _: &mut C, entity: Entity) {
        let count_rows = records.count_rows();
        let count_cols = records.count_columns();

        for pos in entity.iter(count_rows, count_cols) {
            records.set(pos, self);
        }
    }
}

#[cfg(feature = "std")]
macro_rules! tuple_trait_impl {
    ( $($name:ident)+ ) => {
        impl<R, C, $($name: CellOption<R, C>),+> CellOption<R, C> for ($($name,)+) {
            fn change(self, records: &mut R, cfg: &mut C, entity: Entity) {
                #![allow(non_snake_case)]
                let ($($name,)+) = self;
                $(
                    $name::change($name, records, cfg, entity);
                )+
            }

            fn hint_change(&self) -> Option<Entity> {
                #![allow(non_snake_case)]
                let ($($name,)+) = &self;
                let list = [
                    $(
                        $name::hint_change($name),
                    )+
                ];

                crate::settings::table_option::hint_change_list(&list)
            }
        }
    };
}

#[cfg(feature = "std")]
tuple_trait_impl!(T0 T1);
#[cfg(feature = "std")]
tuple_trait_impl!(T0 T1 T2);
#[cfg(feature = "std")]
tuple_trait_impl!(T0 T1 T2 T3);
#[cfg(feature = "std")]
tuple_trait_impl!(T0 T1 T2 T3 T4);
#[cfg(feature = "std")]
tuple_trait_impl!(T0 T1 T2 T3 T4 T5);
#[cfg(feature = "std")]
tuple_trait_impl!(T0 T1 T2 T3 T4 T5 T6);
#[cfg(feature = "std")]
tuple_trait_impl!(T0 T1 T2 T3 T4 T5 T6 T7);
#[cfg(feature = "std")]
tuple_trait_impl!(T0 T1 T2 T3 T4 T5 T6 T7 T8);
#[cfg(feature = "std")]
tuple_trait_impl!(T0 T1 T2 T3 T4 T5 T6 T7 T8 T9);