fips-md 0.3.0

A framework for simulating arbitrary particle dynamics
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

//! Structs for compile time constants

use std::fmt::Display;

/// A compile time constant, i.e. a literal, some pre-defined constant (or an expression of such, TODO)
#[derive(Clone,Eq,PartialEq,Debug)]
pub enum CompileTimeConstant<T:PartialEq> {
    /// A literal (i.e. some concrete value)
    Literal(T),
    /// An identifier (i.e. some not yet substituted value)
    Identifier(String),
    /// An identifier after substitution (the old name is saved for debugging)
    Substituted(T,String)
}

impl<T:PartialEq> CompileTimeConstant<T> {
    /// In-place-ish substitution (does nothing, if substitution not possible)
    pub fn substitute(&mut self, value: T) {
        match self {
            CompileTimeConstant::Identifier(old_name) => {
                // Switch names around
                let mut tmp = String::new();
                std::mem::swap(&mut tmp, old_name);
                // Create new variant
                let new = CompileTimeConstant::Substituted(value, tmp);
                // Switch around round 2
                *self = new;
            }
            _ => {}
        }

    }
}

impl<T:Display+PartialEq> Display for CompileTimeConstant<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            CompileTimeConstant::Literal(x) => x.fmt(f),
            CompileTimeConstant::Identifier(ident) => f.write_str(&ident),
            CompileTimeConstant::Substituted(x, ident) => f.write_fmt(format_args!("{} (substituted from '{}')", x, ident))
        }
    }
}

impl<T:PartialEq> From<T> for CompileTimeConstant<T> {
    fn from(val: T) -> Self {
        CompileTimeConstant::Literal(val)
    }
}