hyperion 0.2.1

Generic LSystem implementation.
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

use std::{fmt, ops};

use crate::{Operator, Variables};

#[derive(Debug, PartialEq, PartialOrd, Clone)]
pub enum Value {
    Num(f32),
    Var(char),
    Color(f32, f32, f32, f32),
    Expr(Box<Self>, Operator, Box<Self>),
}

impl fmt::Display for Value {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Value::Num(x) => write!(f, "{x}"),
            Value::Var(x) => write!(f, "{x}"),
            Value::Color(r, g, b, a) => write!(f, "rgba({r}, {g}, {b}, {a})"),
            Value::Expr(a, op, b) => write!(f, "{a} {op} {b}"),
        }
    }
}

impl Value {

    /// Evaluate this value fetching variables from first the parameters or the variables
    /// argument.
    pub fn evaluate(&self, parameters: &Variables, variables: &Variables) -> Self {
        match self {
            Value::Var(x) => {
                if let Some(a) = parameters.get(x).cloned() {
                    a
                } else if let Some(b) = variables.get(x).cloned() {
                    b
                } else {
                    Value::Var(*x)
                }
            }
            Value::Expr(a, op, b) => {
                let a = a.evaluate(parameters, variables);
                let b = b.evaluate(parameters, variables);
                // TODO: Remove these unwraps.
                match op {
                    Operator::Add => a + b,
                    Operator::Sub => a - b,
                    Operator::Div => a / b,
                    Operator::Mul => a * b,
                    Operator::Exponent => Value::Num(a.to_float().unwrap().powf(b.to_float().unwrap()))
                }
            }
            s => s.clone(),
        }
    }

    /// Convert the object to a f32.
    /// 
    /// Returns `None` if the value is not `Value::Num`
    pub fn to_float(&self) -> Option<f32> {
        if let Value::Num(x) = self {
            Some(*x)
        } else {
            None
        }
    }
}

impl ops::Add for Value {
    type Output = Value;

    fn add(self, rhs: Self) -> Self::Output {
        if let Value::Num(a) = self {
            if let Value::Num(b) = rhs {
                Value::Num(a + b)
            } else {
                panic!("attempted to add non numeric value {rhs:?}");
            }
        } else {
            panic!("attempted to add non numeric value {self:?}");
        }
    }
}

impl ops::Sub for Value {
    type Output = Value;

    fn sub(self, rhs: Self) -> Self::Output {
        if let Value::Num(a) = self {
            if let Value::Num(b) = rhs {
                Value::Num(a - b)
            } else {
                panic!("attempted to subtract non numeric value {rhs:?}");
            }
        } else {
            panic!("attempted to subtract non numeric value {self:?}");
        }
    }
}

impl ops::Mul for Value {
    type Output = Value;

    fn mul(self, rhs: Self) -> Self::Output {
        if let Value::Num(a) = self {
            if let Value::Num(b) = rhs {
                Value::Num(a * b)
            } else {
                panic!("attempted to multiply non numeric value {rhs:?}");
            }
        } else {
            panic!("attempted to multiply non numeric value {self:?}");
        }
    }
}

impl ops::Div for Value {
    type Output = Value;

    fn div(self, rhs: Self) -> Self::Output {
        if let Value::Num(a) = self {
            if let Value::Num(b) = rhs {
                Value::Num(a / b)
            } else {
                panic!("attempted to divide non numeric value {rhs:?}");
            }
        } else {
            panic!("attempted to divide non numeric value {self:?}");
        }
    }
}