logicsim 0.1.7

composable, modular, digital logic simulation
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

use crate::graph::*;

#[macro_export]
/// Creates a wire with the same variable name and gate name.
macro_rules! wire {
    ($g:expr,$name:ident) => {
        #[allow(unused_mut)]
        let mut $name: Wire = Wire::new($g, stringify!($name));
    };
}

/// Data structure that helps with connecting wires to many different components.
///
/// It is basically syntactic sugar for an or gate.
/// # Example
/// ```
/// # use logicsim::{GateGraphBuilder,counter,Wire,ON,OFF,zeros};
/// # let mut g = GateGraphBuilder::new();
/// let mut reset = Wire::new(&mut g, "reset");
/// let reset_lever = reset.make_lever(&mut g);
/// let clock = g.lever("clock");
///
/// let counter_output = counter(
///     &mut g,
///     clock.bit(),
///     ON,  // enable
///     OFF, // write
///     ON,  // read
///     reset.bit(),
///     &zeros(4), // input
///     "counter"
/// );
/// // Notice I connect the third (index 2) bit of the output to reset.
/// // so as soon as the counter reaches 4 (0b100) it will reset.
/// reset.connect(&mut g, counter_output[2]);
///
/// let output = g.output(&counter_output, "result");
///
/// let ig = &mut g.init();
/// ig.pulse_lever_stable(reset_lever);
///
/// assert_eq!(output.u8(ig), 0);
///
/// ig.pulse_lever_stable(clock);
/// assert_eq!(output.u8(ig), 1);
///
/// ig.pulse_lever_stable(clock);
/// assert_eq!(output.u8(ig), 2);
///
/// ig.pulse_lever_stable(clock);
/// assert_eq!(output.u8(ig), 3);
///
/// ig.pulse_lever_stable(clock);
/// assert_eq!(output.u8(ig), 0);
/// ```
#[derive(Debug, Clone)]
pub struct Wire {
    bit: GateIndex,
    lever: Option<LeverHandle>,
    pub name: String,
}
impl Wire {
    /// Returns a new [Wire] with name `name`.
    pub fn new<S: Into<String>>(g: &mut GateGraphBuilder, name: S) -> Self {
        let name = name.into();
        Self {
            bit: g.or(format!("WIRE:{}", name)),
            lever: None,
            name,
        }
    }

    /// Makes a new lever for the wire, stores it for easy access later and returns
    /// its [LeverHandle].
    pub fn make_lever(&mut self, g: &mut GateGraphBuilder) -> LeverHandle {
        match self.lever {
            Some(lever) => lever,
            None => {
                let lever = g.lever(&self.name);
                self.connect(g, lever.bit());
                self.lever = Some(lever);
                lever
            }
        }
    }
    /// Returns Some(LeverHandle) if [make_lever](Self::make_lever) has been called before.
    /// None otherwise.
    pub fn lever(&self) -> Option<LeverHandle> {
        self.lever
    }

    /// Connects a new [GateIndex] to the wire.
    pub fn connect(&self, g: &mut GateGraphBuilder, other: GateIndex) {
        g.dpush(self.bit, other);
    }

    /// Returns the [GateIndex] of the wire.
    pub fn bit(&self) -> GateIndex {
        self.bit
    }
}