rscx 0.1.14

rscx is a HTML templating library for Rust with a JSX-like syntax.
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use std::{
    borrow::Cow,
    convert::Infallible,
    env::VarError,
    fmt,
    io::ErrorKind,
    net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6},
    num::{
        NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128,
        NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize,
    },
    rc::Rc,
    sync::{
        mpsc::{RecvTimeoutError, TryRecvError},
        Arc,
    },
};

pub trait Render {
    fn render(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result;
}

macro_rules! impl_render_for_basic_types {
    ($($t:ty)*) => ($(
        impl Render for $t {
            #[inline(always)]
            fn render(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                fmt::Display::fmt(self, f)
            }
        }
    )*)
}

impl_render_for_basic_types! {
    Infallible
    VarError
    ErrorKind
    IpAddr
    SocketAddr
    RecvTimeoutError
    TryRecvError
    bool
    char
    f32
    f64
    i8
    i16
    i32
    i64
    i128
    isize
    u8
    u16
    u32
    u64
    u128
    usize
    Ipv4Addr
    Ipv6Addr
    SocketAddrV4
    SocketAddrV6
    NonZeroI8
    NonZeroI16
    NonZeroI32
    NonZeroI64
    NonZeroI128
    NonZeroIsize
    NonZeroU8
    NonZeroU16
    NonZeroU32
    NonZeroU64
    NonZeroU128
    NonZeroUsize
    String
    str
}

impl<B: ?Sized> Render for Cow<'_, B>
where
    B: Render + ToOwned,
    <B as ToOwned>::Owned: Render,
{
    fn render(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match *self {
            Cow::Borrowed(ref b) => Render::render(b, f),
            Cow::Owned(ref o) => Render::render(o, f),
        }
    }
}

impl<T: Render> Render for Box<T> {
    #[inline(always)]
    fn render(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        Render::render(&**self, f)
    }
}

impl<T: Render + ?Sized> Render for &T {
    #[inline(always)]
    fn render(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        Render::render(&**self, f)
    }
}

impl<T: Render> Render for &mut T {
    #[inline(always)]
    fn render(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        Render::render(&**self, f)
    }
}

impl<T: Render> Render for Rc<T> {
    #[inline(always)]
    fn render(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        Render::render(&**self, f)
    }
}

impl<T: Render> Render for Arc<T> {
    #[inline(always)]
    fn render(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        Render::render(&**self, f)
    }
}

impl<T: Render> Render for Option<T> {
    #[inline(always)]
    fn render(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if let Some(inner) = self {
            inner.render(f)
        } else {
            Ok(())
        }
    }
}

impl Render for () {
    #[inline(always)]
    fn render(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
        Ok(())
    }
}