logical 0.2.1

Library for simulating digital circuit networks.
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

use crate::Resolve;

#[derive(Debug, Default, Clone, Copy)]
pub struct Integer {
    value: u128,
    width: u8,
}

impl<'a, 'b> Resolve<&'b Integer> for &'a Integer {
    type Output = Integer;
    fn resolve(self, other: &'b Integer) -> Self::Output {
        if self.width != other.width {
            panic!("Width mismatch!") //TODO: do not panic
        }
        Integer {
            value: self.value | other.value,
            width: self.width,
        }
    }
}

impl PartialEq for Integer {
    fn eq(&self, other: &Integer) -> bool {
        self.value == other.value
    }
}

impl<T: Into<u128> + Copy> PartialEq<T> for Integer {
    fn eq(&self, other: &T) -> bool {
        self.value == (*other).into()
    }
}

impl Eq for Integer {}

impl Integer {
    pub fn new() -> Self {
        Self { value: 0, width: 128 }
    }

    pub fn new_with_value(value: impl Into<u128>, width: impl Into<Option<u8>>) -> Self {
        Self {
            value: value.into(),
            width: width.into().unwrap_or(128),
        }
    }

    pub fn new_with_width(width: u8) -> Option<Self> {
        if width != 0 && width <= 128 {
            Some(Self { value: 0, width })
        } else {
            None
        }
    }

    pub fn width(&self) -> u8 {
        self.width
    }

    pub fn set_width(&mut self, width: u8) {
        if width != 0 && width <= 128 {
            self.value &= (1 << width) - 1
        }
    }
}