Struct libreda_db::netlist::hashmap_netlist::HashMapNetlist

pub struct HashMapNetlist { /* fields omitted */ }

A netlist is the container of circuits.

Implementations

impl HashMapNetlist

pub fn circuit(&self, id: &CircuitId) -> &Circuit

Get a circuit reference by its ID.

pub fn circuit_inst(&self, id: &CircuitInstId) -> &CircuitInst

Get a reference to a circuit instance.

pub fn net(&self, id: &NetId) -> &Net

Get a reference to a net by its ID.

pub fn pin(&self, id: &PinId) -> &Pin

Get a reference to a pin by its ID.

pub fn pin_inst(&self, id: &PinInstId) -> &PinInst

Get a reference to a pin instance by its ID.

pub fn circuit_inst_nets(
    &self,
    circuit_inst_id: &CircuitInstId
) -> impl Iterator<Item = NetId> + '_

Get all nets that are connected to the circuit instance.

pub fn pins_for_net(&self, net: &NetId) -> impl Iterator<Item = PinId> + '_

Iterate over all pins connected to a net.

pub fn pins_instances_for_net(
    &self,
    net: &NetId
) -> impl Iterator<Item = PinInstId> + '_

Iterate over all pin instances connected to a net.

pub fn terminals_for_net(
    &self,
    net: &NetId
) -> impl Iterator<Item = TerminalId> + '_

Iterate over all pins and pin instances connected to a net.

pub fn purge_nets(&mut self) -> usize

Remove all unconnected nets. Return number of purged nets.

pub fn top_circuit_count(&self) -> usize

Return number of top level circuits (roots of the circuit tree).

pub fn each_net(&self) -> impl Iterator<Item = NetId> + '_

Iterate through all nets that are defined in the netlist.

Trait Implementations

impl Debug for HashMapNetlist

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

Formats the value using the given formatter.

impl Default for HashMapNetlist

fn default() -> HashMapNetlist

Returns the "default value" for a type.

impl NetlistBase for HashMapNetlist

type NameType = RcString

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

type PinId = PinId

Pin identifier type.

type PinInstId = PinInstId

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

type TerminalId = TerminalId

Either a pin or a pin instance ID.

type CircuitId = CircuitId

Circuit identifier type.

type CircuitInstId = CircuitInstId

Circuit instance identifier type.

type NetId = NetId

Net identifier type.

fn new() -> Self

Create an empty netlist.

fn circuit_by_name<S: ?Sized + Eq + Hash>(&self, name: &S) -> Option<CircuitId> where
    Self::NameType: Borrow<S>, 

Find a circuit by its name.

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

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

fn template_circuit(
    &self,
    circuit_instance: &Self::CircuitInstId
) -> Self::CircuitId

Get the ID of the template circuit of this instance.

fn template_pin(&self, pin_instance: &Self::PinInstId) -> Self::PinId

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

fn pin_direction(&self, pin: &Self::PinId) -> Direction

Get the signal direction of the pin.

fn pin_name(&self, pin: &Self::PinId) -> Self::NameType

Get the name of the pin.

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

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

fn parent_circuit(
    &self,
    circuit_instance: &Self::CircuitInstId
) -> Self::CircuitId

Get the ID of the parent circuit of this instance.

fn parent_circuit_of_pin(&self, pin: &Self::PinId) -> Self::CircuitId

Get the ID of the parent circuit of this pin.

fn parent_of_pin_instance(
    &self,
    pin_inst: &Self::PinInstId
) -> Self::CircuitInstId

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

fn net_of_pin(&self, pin: &Self::PinId) -> Option<Self::NetId>

Get the net connected to this pin.

fn net_of_pin_instance(&self, pin_inst: &Self::PinInstId) -> Option<Self::NetId>

Get the net connected to this pin instance.

fn net_zero(&self, parent_circuit: &Self::CircuitId) -> Self::NetId

Get the net of the logical constant zero.

fn net_one(&self, parent_circuit: &Self::CircuitId) -> Self::NetId

Get the net of the logical constant one.

fn net_by_name<N: ?Sized + Eq + Hash>(
    &self,
    parent_circuit: &Self::CircuitId,
    name: &N
) -> Option<Self::NetId> where
    Self::NameType: Borrow<N>, 

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

fn net_name(&self, net: &Self::NetId) -> Option<Self::NameType>

Get the name of the net.

fn circuit_name(&self, circuit: &Self::CircuitId) -> Self::NameType

Get the name of the circuit.

fn circuit_instance_name(
    &self,
    circuit_inst: &Self::CircuitInstId
) -> Option<Self::NameType>

Get the name of the circuit instance.

fn for_each_circuit<F>(&self, f: F) where
    F: FnMut(Self::CircuitId), 

Call a function on each circuit of the netlist.

fn each_circuit(&self) -> Box<dyn Iterator<Item = CircuitId>>

Iterate over all circuits.

fn for_each_instance<F>(&self, circuit: &Self::CircuitId, f: F) where
    F: FnMut(Self::CircuitInstId), 

Call a function on each instance in this circuit.

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

Iterate over all instances in a circuit.

fn for_each_circuit_dependency<F>(&self, circuit: &Self::CircuitId, f: F) where
    F: FnMut(Self::CircuitId), 

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

fn each_circuit_dependency(
    &self,
    circuit: &Self::CircuitId
) -> Box<dyn Iterator<Item = Self::CircuitId>>

Iterate over all circuits that are childs of this circuit.

fn for_each_dependent_circuit<F>(&self, circuit: &Self::CircuitId, f: F) where
    F: FnMut(Self::CircuitId), 

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

fn each_dependent_circuit(
    &self,
    circuit: &Self::CircuitId
) -> Box<dyn Iterator<Item = Self::CircuitId>>

Iterate over each circuit that directly depends on circuit.

fn for_each_reference<F>(&self, circuit: &Self::CircuitId, f: F) where
    F: FnMut(Self::CircuitInstId), 

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

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

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

fn for_each_pin<F>(&self, circuit: &Self::CircuitId, f: F) where
    F: FnMut(Self::PinId), 

Call a function for each pin of the circuit.

fn each_pin(&self, circuit_id: &CircuitId) -> Box<dyn Iterator<Item = PinId>>

Iterate over all pins of a circuit.

fn for_each_pin_instance<F>(&self, circuit_inst: &Self::CircuitInstId, f: F) where
    F: FnMut(Self::PinInstId), 

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

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

Iterate over all pin instances of a circuit.

fn for_each_internal_net<F>(&self, circuit: &Self::CircuitId, f: F) where
    F: FnMut(Self::NetId), 

Call a function for net of the circuit.

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

Iterate over all defined nets inside a circuit.

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

Get the number of cell instances inside the circuit.

fn num_circuits(&self) -> usize

Get the number of cells inside in this netlist.

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

Get the number of pins of a circuit.

fn for_each_pin_of_net<F>(&self, net: &Self::NetId, f: F) where
    F: FnMut(Self::PinId), 

Call a function for each pin connected to this net.

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

Iterate over all pins of a net.

fn for_each_pin_instance_of_net<F>(&self, net: &Self::NetId, f: F) where
    F: FnMut(Self::PinInstId), 

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

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

Iterate over all pins of a net.

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

Get a Vec of all circuit IDs in this netlist.

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

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

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

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

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

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

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

Get a Vec with all circuit instances referencing this circuit.

fn each_pin_vec(&self, circuit: &Self::CircuitId) -> Vec<Self::PinId>

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

fn each_pin_instance_vec(
    &self,
    circuit_instance: &Self::CircuitInstId
) -> Vec<Self::PinInstId>

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

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

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

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

Get a Vec with all nets in this circuit.

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

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

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

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

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

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

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.

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

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

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

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

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.

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

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

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

Return a reference to the circuit with this ID.

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

Return a reference to the circuit instance with this ID.

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

Write the netlist in a human readable form.

impl NetlistEdit for HashMapNetlist

fn create_circuit(
    &mut self,
    name: Self::NameType,
    pins: Vec<(Self::NameType, Direction)>
) -> CircuitId

Create a new circuit with a given list of pins.

fn remove_circuit(&mut self, circuit_id: &CircuitId)

Remove all instances inside the circuit,

fn create_circuit_instance(
    &mut self,
    parent: &CircuitId,
    circuit_template: &CircuitId,
    name: Option<Self::NameType>
) -> CircuitInstId

Create a new instance of circuit_template in the parent circuit.

fn remove_circuit_instance(&mut self, circuit_inst_id: &CircuitInstId)

Remove a circuit instance after disconnecting it from the nets.

fn create_net(
    &mut self,
    parent: &CircuitId,
    name: Option<Self::NameType>
) -> NetId

Create a new net in the parent circuit.

fn rename_net(
    &mut self,
    parent_circuit: &Self::CircuitId,
    net_id: &Self::NetId,
    new_name: Option<Self::NameType>
)

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

fn remove_net(&mut self, net: &NetId)

Disconnect all connected terminals and remove the net.

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

Connect the pin to a net.

fn connect_pin_instance(
    &mut self,
    pin: &PinInstId,
    net: Option<NetId>
) -> Option<Self::NetId>

Connect the pin to a net.

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.

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.

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.

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.

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.

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

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

fn purge_nets(&mut self) -> usize

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