Struct libreda_pnr::db::RcNetlist

pub struct RcNetlist { /* fields omitted */ }

Collection of circuits.

Implementations

impl RcNetlist

pub fn new() -> RcNetlist

Create a new empty netlist.

pub fn create_circuit<S>(
    &mut self,
    name: S,
    pins: Vec<Pin, Global>
) -> Rc<Circuit> where
    S: Into<String>, 

Create a new and empty circuit.

Example

use libreda_db::netlist::prelude::*;

let mut netlist = RcNetlist::new();
let pins = vec![
    Pin::new("Input_A", Direction::Input),
    Pin::new("Output_B", Direction::Output)
];
// Create a circuit with a given name and pin definition.
let top = netlist.create_circuit("TOP", pins);
assert_eq!(top.pin_by_id(0).unwrap().name(), "Input_A");
assert_eq!(top.pin_by_id(1).unwrap().name(), "Output_B");

pub fn circuit_by_id(&self, id: &Index<Circuit>) -> Option<Rc<Circuit>>

Return the circuit with the given id. Returns None if the circuit does not exist.

pub fn circuit_by_name<S>(&self, name: &S) -> Option<Rc<Circuit>> where
    S: Hash + Eq + ?Sized,
    String: Borrow<S>, 

Return the circuit with the given name. Returns None if the circuit does not exist.

pub fn each_circuit(
    &self
) -> impl ExactSizeIterator + Iterator<Item = &Rc<Circuit>>

Iterate over all circuits in this netlist.

pub fn each_circuit_bottom_up(&self)

Iterate over all circuits in this netlist starting with leaf circuits.

pub fn each_circuit_top_down(&self)

Iterate over all circuits in this netlist starting with the root circuits.

pub fn flatten_circuit(&mut self, circuit: &Rc<Circuit>)

Flatten all instances of this circuit by replacing them with their content. Remove the circuit from the netlist afterwards. For top level circuits this is equivalent to removing them.

pub fn purge_nets(&mut self) -> usize

Delete all floating nets in all circuits. Return number of purged nets.

pub fn remove_circuit(&mut self, circuit: &Rc<Circuit>)

Delete the given circuit if it exists.

pub fn top_circuit_count(&self) -> usize

Return number of top circuits (roots).

Trait Implementations

impl Clone for RcNetlist

pub fn clone(&self) -> RcNetlist

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RcNetlist

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

Formats the value using the given formatter.

impl Display for RcNetlist

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

Formats the value using the given formatter.

impl NetlistBase for RcNetlist

type NameType = String

Type for names of circuits, instances, pins, etc.

type PinId = Rc<Pin>

Pin identifier type.

type PinInstId = Rc<PinInstance>

Pin instance identifier type. A pin instance is a pin of a circuit instance.

type TerminalId = ()

Either a pin or a pin instance ID.

type CircuitId = Rc<Circuit>

Circuit identifier type.

type CircuitInstId = Rc<CircuitInstance>

Circuit instance identifier type.

type NetId = Rc<Net>

Net identifier type.

pub fn new() -> RcNetlist

Create a new empty netlist.

pub fn circuit_by_name<N>(&self, name: &N) -> Option<Rc<Circuit>> where
    N: Hash + Eq + ?Sized,
    <RcNetlist as NetlistBase>::NameType: Borrow<N>, 

Find a circuit by its name. Return the circuit with the given name. Returns None if the circuit does not exist.

pub fn circuit_instance_by_name<N>(
    &self,
    parent_circuit: &<RcNetlist as NetlistBase>::CircuitId,
    name: &N
) -> Option<<RcNetlist as NetlistBase>::CircuitInstId> where
    N: Eq + Hash + ?Sized,
    <RcNetlist as NetlistBase>::NameType: Borrow<N>, 

Find a circuit instance by its name. Returns None if the name does not exist.

pub fn template_circuit(
    &self,
    circuit_instance: &<RcNetlist as NetlistBase>::CircuitInstId
) -> <RcNetlist as NetlistBase>::CircuitId

Get the ID of the template circuit of this instance.

pub fn template_pin(
    &self,
    pin_instance: &<RcNetlist as NetlistBase>::PinInstId
) -> <RcNetlist as NetlistBase>::PinId

Get the ID of the template pin of this pin instance.

pub fn pin_direction(
    &self,
    pin: &<RcNetlist as NetlistBase>::PinId
) -> Direction

Get the signal direction of the pin.

pub fn pin_name(
    &self,
    pin: &<RcNetlist as NetlistBase>::PinId
) -> <RcNetlist as NetlistBase>::NameType

Get the name of the pin.

pub fn pin_by_name<N>(
    &self,
    parent_circuit: &<RcNetlist as NetlistBase>::CircuitId,
    name: &N
) -> Option<<RcNetlist as NetlistBase>::PinId> where
    N: Eq + Hash + ?Sized,
    <RcNetlist as NetlistBase>::NameType: Borrow<N>, 

Find a pin by its name. Returns None if no such pin can be found.

pub fn parent_circuit(
    &self,
    circuit_instance: &<RcNetlist as NetlistBase>::CircuitInstId
) -> <RcNetlist as NetlistBase>::CircuitId

Get the ID of the parent circuit of this instance.

pub fn parent_circuit_of_pin(
    &self,
    pin: &<RcNetlist as NetlistBase>::PinId
) -> <RcNetlist as NetlistBase>::CircuitId

Get the ID of the parent circuit of this pin.

pub fn parent_of_pin_instance(
    &self,
    pin_inst: &<RcNetlist as NetlistBase>::PinInstId
) -> <RcNetlist as NetlistBase>::CircuitInstId

Get the ID of the circuit instance that holds this pin instance.

pub fn net_of_pin(
    &self,
    pin: &<RcNetlist as NetlistBase>::PinId
) -> Option<<RcNetlist as NetlistBase>::NetId>

Get the internal net attached to this pin.

pub fn net_of_pin_instance(
    &self,
    pin: &<RcNetlist as NetlistBase>::PinInstId
) -> Option<<RcNetlist as NetlistBase>::NetId>

Get the external net attached to this pin instance.

pub fn net_zero(
    &self,
    parent_circuit: &<RcNetlist as NetlistBase>::CircuitId
) -> <RcNetlist as NetlistBase>::NetId

Get the net of the logical constant zero.

pub fn net_one(
    &self,
    parent_circuit: &<RcNetlist as NetlistBase>::CircuitId
) -> <RcNetlist as NetlistBase>::NetId

Get the net of the logical constant one.

pub fn net_by_name<N>(
    &self,
    parent: &<RcNetlist as NetlistBase>::CircuitId,
    name: &N
) -> Option<<RcNetlist as NetlistBase>::NetId> where
    N: Eq + Hash + ?Sized,
    <RcNetlist as NetlistBase>::NameType: Borrow<N>, 

Find a net by its name inside the parent circuit. Returns None if no such net can be found.

pub fn net_name(
    &self,
    net: &<RcNetlist as NetlistBase>::NetId
) -> Option<<RcNetlist as NetlistBase>::NameType>

Get the name of the net.

pub fn circuit_name(
    &self,
    circuit: &<RcNetlist as NetlistBase>::CircuitId
) -> <RcNetlist as NetlistBase>::NameType

Get the name of the circuit.

pub fn circuit_instance_name(
    &self,
    circuit_inst: &<RcNetlist as NetlistBase>::CircuitInstId
) -> Option<<RcNetlist as NetlistBase>::NameType>

Get the name of the circuit instance.

pub fn for_each_circuit<F>(&self, f: F) where
    F: FnMut(<RcNetlist as NetlistBase>::CircuitId), 

Call a function on each circuit of the netlist.

pub fn each_circuit(
    &self
) -> Box<dyn Iterator<Item = <RcNetlist as NetlistBase>::CircuitId>, Global>

Iterate over all circuits.

pub fn for_each_instance<F>(
    &self,
    circuit: &<RcNetlist as NetlistBase>::CircuitId,
    f: F
) where
    F: FnMut(<RcNetlist as NetlistBase>::CircuitInstId), 

Call a function on each instance in this circuit.

pub fn for_each_circuit_dependency<F>(
    &self,
    circuit: &<RcNetlist as NetlistBase>::CircuitId,
    f: F
) where
    F: FnMut(<RcNetlist as NetlistBase>::CircuitId), 

Call a function for each circuit that is a child of this circuit.

pub fn for_each_dependent_circuit<F>(
    &self,
    circuit: &<RcNetlist as NetlistBase>::CircuitId,
    f: F
) where
    F: FnMut(<RcNetlist as NetlistBase>::CircuitId), 

Call a function for each circuit that directly depends on circuit.

pub fn for_each_reference<F>(
    &self,
    circuit: &<RcNetlist as NetlistBase>::CircuitId,
    f: F
) where
    F: FnMut(<RcNetlist as NetlistBase>::CircuitInstId), 

Iterate over all instances of this circuit, i.e. instances that use this circuit as a template.

pub fn for_each_pin<F>(
    &self,
    circuit: &<RcNetlist as NetlistBase>::CircuitId,
    f: F
) where
    F: FnMut(<RcNetlist as NetlistBase>::PinId), 

Call a function for each pin of the circuit.

pub fn each_pin_vec(
    &self,
    circuit: &<RcNetlist as NetlistBase>::CircuitId
) -> Vec<<RcNetlist as NetlistBase>::PinId, Global>

Get a Vec with the IDs of all pins of this circuit.

pub fn for_each_pin_instance<F>(
    &self,
    circuit_inst: &<RcNetlist as NetlistBase>::CircuitInstId,
    f: F
) where
    F: FnMut(<RcNetlist as NetlistBase>::PinInstId), 

Call a function for each pin instance of the circuit instance.

pub fn each_pin_instance_vec(
    &self,
    circuit_instance: &<RcNetlist as NetlistBase>::CircuitInstId
) -> Vec<<RcNetlist as NetlistBase>::PinInstId, Global>

Get a Vec with the IDs of all pin instance of this circuit instance.

pub fn for_each_internal_net<F>(
    &self,
    circuit: &<RcNetlist as NetlistBase>::CircuitId,
    f: F
) where
    F: FnMut(<RcNetlist as NetlistBase>::NetId), 

Call a function for net of the circuit.

pub fn num_child_instances(
    &self,
    circuit: &<RcNetlist as NetlistBase>::CircuitId
) -> usize

Get the number of cell instances inside the circuit.

pub fn num_circuits(&self) -> usize

Get the number of cells inside in this netlist.

pub fn num_pins(&self, circuit: &<RcNetlist as NetlistBase>::CircuitId) -> usize

Get the number of pins of a circuit.

pub fn for_each_pin_of_net<F>(
    &self,
    net: &<RcNetlist as NetlistBase>::NetId,
    f: F
) where
    F: FnMut(<RcNetlist as NetlistBase>::PinId), 

Call a function for each pin connected to this net.

pub fn for_each_pin_instance_of_net<F>(
    &self,
    net: &<RcNetlist as NetlistBase>::NetId,
    f: F
) where
    F: FnMut(<RcNetlist as NetlistBase>::PinInstId), 

Call a function for each pin instance connected to this net.

pub fn each_circuit_vec(&self) -> Vec<Self::CircuitId, Global>

Get a Vec of all circuit IDs in this netlist.

pub fn each_instance_vec(
    &self,
    circuit: &Self::CircuitId
) -> Vec<Self::CircuitInstId, Global>

Get a Vec of the IDs of all instances in this circuit.

pub fn each_instance(
    &'a self,
    circuit: &Self::CircuitId
) -> Box<dyn Iterator<Item = Self::CircuitInstId> + 'a, Global>

Iterate over all instances in a circuit.

pub fn each_circuit_dependency_vec(
    &self,
    circuit: &Self::CircuitId
) -> Vec<Self::CircuitId, Global>

Get a Vec of each circuit that is a child of this circuit.

pub fn each_circuit_dependency(
    &'a self,
    circuit: &Self::CircuitId
) -> Box<dyn Iterator<Item = Self::CircuitId> + 'a, Global>

Iterate over all circuits that are childs of this circuit.

pub fn each_dependent_circuit_vec(
    &self,
    circuit: &Self::CircuitId
) -> Vec<Self::CircuitId, Global>

Get a Vec of each circuit that directly depends on circuit.

pub fn each_dependent_circuit(
    &'a self,
    circuit: &Self::CircuitId
) -> Box<dyn Iterator<Item = Self::CircuitId> + 'a, Global>

Iterate over each circuit that directly depends on circuit.

pub fn each_reference_vec(
    &self,
    circuit: &Self::CircuitId
) -> Vec<Self::CircuitInstId, Global>

Get a Vec with all circuit instances referencing this circuit.

pub fn each_reference(
    &'a self,
    circuit: &Self::CircuitId
) -> Box<dyn Iterator<Item = Self::CircuitInstId> + 'a, Global>

Iterate over all instances of this circuit, i.e. instances that use this circuit as a template.

pub fn each_pin(
    &'a self,
    circuit: &Self::CircuitId
) -> Box<dyn Iterator<Item = Self::PinId> + 'a, Global>

Iterate over all pins of a circuit.

pub fn each_pin_instance(
    &'a self,
    circuit_instance: &Self::CircuitInstId
) -> Box<dyn Iterator<Item = Self::PinInstId> + 'a, Global>

Iterate over all pin instances of a circuit.

pub fn each_external_net(
    &'a self,
    circuit_instance: &Self::CircuitInstId
) -> Box<dyn Iterator<Item = Self::NetId> + 'a, Global>

Iterate over all external nets connected to the circuit instance. A net might appear more than once.

pub fn each_internal_net_vec(
    &self,
    circuit: &Self::CircuitId
) -> Vec<Self::NetId, Global>

Get a Vec with all nets in this circuit.

pub fn each_internal_net(
    &'a self,
    circuit: &Self::CircuitId
) -> Box<dyn Iterator<Item = Self::NetId> + 'a, Global>

Iterate over all defined nets inside a circuit.

pub fn num_net_pins(&self, net: &Self::NetId) -> usize

Get the number of pins that are connected to this net.

pub fn num_net_pin_instances(&self, net: &Self::NetId) -> usize

Get the number of pin instances that are connected to this net.

pub fn num_net_terminals(&self, net: &Self::NetId) -> usize

Get the number of terminals that are connected to this net.

pub fn num_references(&self, circuit: &Self::CircuitId) -> usize

Get the number of references that point to this circuit, i.e. the number of instances of this circuit.

pub fn each_pin_of_net_vec(&self, net: &Self::NetId) -> Vec<Self::PinId, Global>

Get a Vec with all pin IDs connected to this net.

pub fn each_pin_of_net(
    &'a self,
    net: &Self::NetId
) -> Box<dyn Iterator<Item = Self::PinId> + 'a, Global>

Iterate over all pins of a net.

pub fn each_pin_instance_of_net_vec(
    &self,
    net: &Self::NetId
) -> Vec<Self::PinInstId, Global>

Get a Vec with all pin instance IDs connected to this net.

pub fn each_pin_instance_of_net(
    &'a self,
    net: &Self::NetId
) -> Box<dyn Iterator<Item = Self::PinInstId> + 'a, Global>

Iterate over all pins of a net.

pub fn for_each_circuit_instance_of_net<F>(&self, net: &Self::NetId, f: F) where
    F: FnMut(Self::CircuitInstId), 

Visit all circuit instances connected to this net. An instance is touched not more than once.

pub fn each_circuit_instance_of_net_vec(
    &self,
    net: &Self::NetId
) -> Vec<Self::CircuitInstId, Global>

Iterate over all circuit instances connected to this net. An instance is touched not more than once.

pub fn circuit(
    &self,
    id: Self::CircuitId
) -> Box<dyn CircuitRef<N = Self>, Global>

Return a reference to the circuit with this ID.

pub fn circuit_inst(
    &self,
    id: Self::CircuitInstId
) -> Box<dyn CircuitInstRef<N = Self>, Global>

Return a reference to the circuit instance with this ID.

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

Write the netlist in a human readable form.

impl NetlistEdit for RcNetlist

pub fn create_circuit(
    &mut self,
    name: <RcNetlist as NetlistBase>::NameType,
    pins: Vec<(<RcNetlist as NetlistBase>::NameType, Direction), Global>
) -> <RcNetlist as NetlistBase>::CircuitId

Create a new and empty circuit.

pub fn remove_circuit(
    &mut self,
    circuit_id: &<RcNetlist as NetlistBase>::CircuitId
)

Delete the given circuit if it exists.

pub fn create_circuit_instance(
    &mut self,
    parent_circuit: &<RcNetlist as NetlistBase>::CircuitId,
    template_circuit: &<RcNetlist as NetlistBase>::CircuitId,
    name: Option<<RcNetlist as NetlistBase>::NameType>
) -> <RcNetlist as NetlistBase>::CircuitInstId

Create a new circuit instance.

pub fn remove_circuit_instance(
    &mut self,
    circuit_inst: &<RcNetlist as NetlistBase>::CircuitInstId
)

Remove circuit instance if it exists.

pub fn create_net(
    &mut self,
    parent: &<RcNetlist as NetlistBase>::CircuitId,
    name: Option<<RcNetlist as NetlistBase>::NameType>
) -> <RcNetlist as NetlistBase>::NetId

Create a net net that lives in the parent circuit.

pub fn rename_net(
    &mut self,
    parent_circuit: &<RcNetlist as NetlistBase>::CircuitId,
    net_id: &<RcNetlist as NetlistBase>::NetId,
    new_name: Option<<RcNetlist as NetlistBase>::NameType>
)

Set a new name for the net. This might panic if the name already exists.

pub fn remove_net(&mut self, net: &<RcNetlist as NetlistBase>::NetId)

Delete the net if it exists and disconnect all connected terminals.

pub fn connect_pin(
    &mut self,
    pin: &<RcNetlist as NetlistBase>::PinId,
    net: Option<<RcNetlist as NetlistBase>::NetId>
) -> Option<<RcNetlist as NetlistBase>::NetId>

Connect a pin to a net. Returns the old connected net, if any.

pub fn connect_pin_instance(
    &mut self,
    pin_inst: &<RcNetlist as NetlistBase>::PinInstId,
    net: Option<<RcNetlist as NetlistBase>::NetId>
) -> Option<<RcNetlist as NetlistBase>::NetId>

Connect a pin instance to a net. Returns the old connected net, if any.

pub fn disconnect_pin(&mut self, pin: &Self::PinId) -> Option<Self::NetId>

Disconnect the pin from any connected net. Returns the old connected net, if any.

pub fn disconnect_pin_instance(
    &mut self,
    pin_instance: &Self::PinInstId
) -> Option<Self::NetId>

Disconnect the pin instance from any connected net. Returns the old connected net, if any.

pub fn replace_net(&mut self, old_net: &Self::NetId, new_net: &Self::NetId)

Take all terminals that are connected to old_net and connect them to new_net instead. The old net is no longer used and removed.

pub fn flatten_circuit_instance(
    &mut self,
    circuit_instance: &Self::CircuitInstId
)

Replace the circuit instance with its contents. Remove the circuit instance afterwards. Does not purge nets nor unconnected instances. So there could be unconnected nets or unconnected instances.

pub fn flatten_circuit(&mut self, circuit: &Self::CircuitId)

Flatten all instances of this circuit by replacing them with their content. Remove the circuit from the netlist afterwards. For top level circuits this is equivalent to removing them.

pub fn purge_nets_in_circuit(&mut self, circuit_id: &Self::CircuitId) -> usize

Delete all unconnected nets in this circuit. Return number of purged nets.

pub fn purge_nets(&mut self) -> usize

Delete all unconnected nets in all circuits. Return number of purged nets.