anathema-templates 0.2.6

Anathema template parser (aml)
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

use std::fmt::Display;

use anathema_state::Hex;

/// Primitive values such as booleans and integers.
/// These values are all static and resolved at eval time.
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Primitive {
    Bool(bool),
    Char(char),
    Int(i64),
    Float(f64),
    Hex(Hex),
}

impl Display for Primitive {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Bool(v) => write!(f, "{v}"),
            Self::Char(v) => write!(f, "{v}"),
            Self::Int(v) => write!(f, "{v}"),
            Self::Float(v) => write!(f, "{v}"),
            Self::Hex(Hex { r, g, b }) => write!(f, "r: {r}, g: {g}, b: {b}"),
        }
    }
}

macro_rules! from_value {
    ($from_type:tt, $variant:ident) => {
        impl From<$from_type> for Primitive {
            fn from(value: $from_type) -> Self {
                Self::$variant(value)
            }
        }
    };
}

from_value!(f64, Float);
from_value!(i64, Int);
from_value!(bool, Bool);
from_value!(char, Char);
from_value!(Hex, Hex);

impl From<(u8, u8, u8)> for Primitive {
    fn from(value: (u8, u8, u8)) -> Self {
        let (r, g, b) = value;
        Self::Hex(Hex { r, g, b })
    }
}