Struct InputPort 

pub struct InputPort<I: Instantiable> { /* private fields */ }

Represent the input port of a primitive

Implementations

impl<I> InputPort<I>

where I: Instantiable,

pub fn get_driver(&self) -> Option<DrivenNet<I>>

Returns the net that is driving this input port

pub fn disconnect(&self) -> Option<DrivenNet<I>>

Disconnects an input port and returns the previous DrivenNet if it was connected.

pub fn get_port(&self) -> Net

Get the input port associated with this connection

pub fn connect(self, output: DrivenNet<I>)

Connects this input port to a driven net.

Examples found in repository

examples/connections.rs (line 30)

fn ripple_adder() -> Netlist<Gate> {
    let netlist = Netlist::new("ripple_adder".to_string());
    let bitwidth = 4;

    // Add the the inputs
    let a_vec = netlist.insert_input_escaped_logic_bus("a".to_string(), bitwidth);
    let b_vec = netlist.insert_input_escaped_logic_bus("b".to_string(), bitwidth);
    let mut carry: DrivenNet<Gate> = netlist.insert_input("cin".into());

    for i in 0..bitwidth {
        // Instantiate a full adder for each bit
        let fa = netlist.insert_gate_disconnected(full_adder(), format_id!("fa_{i}"));

        // Connect A_i and B_i
        fa.get_input(1).connect(a_vec[i].clone());
        fa.get_input(2).connect(b_vec[i].clone());

        // Connect with the prev carry
        carry.connect(fa.get_input(0));

        // Expose the sum
        fa.expose_net(&fa.get_net(0)).unwrap();

        carry = fa.get_output(1);

        if i == bitwidth - 1 {
            // Last full adder, expose the carry out
            fa.get_net_mut(1).set_identifier("cout".into());
            fa.expose_net(&fa.get_net(1)).unwrap();
        }
    }

    netlist.reclaim().unwrap()
}

pub fn unwrap(self) -> NetRef<I>

Return the underlying circuit node

Trait Implementations

impl<I: Clone + Instantiable> Clone for InputPort<I>

fn clone(&self) -> InputPort<I>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I: Debug + Instantiable> Debug for InputPort<I>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I> Display for InputPort<I>

where I: Instantiable,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.