Struct libreda_pnr::db::Chip

pub struct Chip<C = i32> where
    C: CoordinateType,  { /* private fields */ }

A netlist is the container of circuits.

Trait Implementations

impl<C> Clone for Chip<C> where
    C: Clone + CoordinateType, 

pub fn clone(&self) -> Chip<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C> Debug for Chip<C> where
    C: Debug + CoordinateType, 

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

Formats the value using the given formatter.

impl<C> Default for Chip<C> where
    C: CoordinateType + One, 

pub fn default() -> Chip<C>

Returns the “default value” for a type.

impl HierarchyBase for Chip<i32>

type NameType = String

Type for names of cells, instances, etc.

type CellId = CellId

Cell/module identifier type.

type CellInstId = CellInstId

Cell instance identifier type.

pub fn cell_by_name(&self, name: &str) -> Option<CellId>

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

pub fn cell_instance_by_name(
    &self,
    parent_circuit: &<Chip<i32> as HierarchyBase>::CellId,
    name: &str
) -> Option<<Chip<i32> as HierarchyBase>::CellInstId>

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

pub fn cell_name(
    &self,
    circuit: &<Chip<i32> as HierarchyBase>::CellId
) -> <Chip<i32> as HierarchyBase>::NameType

Get the name of the cell.

pub fn cell_instance_name(
    &self,
    circuit_inst: &<Chip<i32> as HierarchyBase>::CellInstId
) -> Option<<Chip<i32> as HierarchyBase>::NameType>

Get the name of the cell instance.

pub fn parent_cell(
    &self,
    circuit_instance: &<Chip<i32> as HierarchyBase>::CellInstId
) -> <Chip<i32> as HierarchyBase>::CellId

Get the ID of the parent cell of this instance.

pub fn template_cell(
    &self,
    circuit_instance: &<Chip<i32> as HierarchyBase>::CellInstId
) -> <Chip<i32> as HierarchyBase>::CellId

Get the ID of the template cell of this instance.

pub fn for_each_cell<F>(&self, f: F) where
    F: FnMut(<Chip<i32> as HierarchyBase>::CellId), 

Call a function on each cell of the netlist.

pub fn each_cell(&self) -> Box<dyn Iterator<Item = CellId>, Global>

Iterate over all cells.

pub fn for_each_cell_instance<F>(
    &self,
    circuit: &<Chip<i32> as HierarchyBase>::CellId,
    f: F
) where
    F: FnMut(<Chip<i32> as HierarchyBase>::CellInstId), 

Call a function on each instance in this cell.

pub fn each_cell_instance(
    &self,
    circuit: &<Chip<i32> as HierarchyBase>::CellId
) -> Box<dyn Iterator<Item = <Chip<i32> as HierarchyBase>::CellInstId>, Global>

Iterate over all instances in a cell.

pub fn for_each_cell_dependency<F>(
    &self,
    circuit: &<Chip<i32> as HierarchyBase>::CellId,
    f: F
) where
    F: FnMut(<Chip<i32> as HierarchyBase>::CellId), 

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

pub fn each_cell_dependency(
    &self,
    circuit: &<Chip<i32> as HierarchyBase>::CellId
) -> Box<dyn Iterator<Item = <Chip<i32> as HierarchyBase>::CellId>, Global>

Iterate over all cells that are instantiated in this cell.

pub fn num_cell_dependencies(
    &self,
    cell: &<Chip<i32> as HierarchyBase>::CellId
) -> usize

Count all cells that are dependencies of cell.

pub fn for_each_dependent_cell<F>(
    &self,
    circuit: &<Chip<i32> as HierarchyBase>::CellId,
    f: F
) where
    F: FnMut(<Chip<i32> as HierarchyBase>::CellId), 

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

pub fn each_dependent_cell(
    &self,
    circuit: &<Chip<i32> as HierarchyBase>::CellId
) -> Box<dyn Iterator<Item = <Chip<i32> as HierarchyBase>::CellId>, Global>

Iterate over each cell that directly depends on cell.

pub fn num_dependent_cells(
    &self,
    cell: &<Chip<i32> as HierarchyBase>::CellId
) -> usize

Count all cells that are directly dependent on cell, i.e. contain an instance of cell.

pub fn for_each_cell_reference<F>(
    &self,
    circuit: &<Chip<i32> as HierarchyBase>::CellId,
    f: F
) where
    F: FnMut(<Chip<i32> as HierarchyBase>::CellInstId), 

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

pub fn each_cell_reference(
    &self,
    circuit: &<Chip<i32> as HierarchyBase>::CellId
) -> Box<dyn Iterator<Item = <Chip<i32> as HierarchyBase>::CellInstId>, Global>

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

pub fn num_cell_references(
    &self,
    cell: &<Chip<i32> as HierarchyBase>::CellId
) -> usize

Count all instantiations of cell.

pub fn num_child_instances(
    &self,
    cell: &<Chip<i32> as HierarchyBase>::CellId
) -> usize

Get the number of cell instances inside the cell.

pub fn num_cells(&self) -> usize

Get the number of cell templates.

pub fn get_chip_property(
    &self,
    key: &<Chip<i32> as HierarchyBase>::NameType
) -> Option<PropertyValue>

Get a property of the top-level chip data structure.

pub fn get_cell_property(
    &self,
    cell: &<Chip<i32> as HierarchyBase>::CellId,
    key: &<Chip<i32> as HierarchyBase>::NameType
) -> Option<PropertyValue>

Get a property of a cell.

pub fn get_cell_instance_property(
    &self,
    inst: &<Chip<i32> as HierarchyBase>::CellInstId,
    key: &<Chip<i32> as HierarchyBase>::NameType
) -> Option<PropertyValue>

Get a property of a cell instance.

fn each_cell_vec(&self) -> Vec<Self::CellId, Global>

Get a Vec of all cell IDs in this netlist.

fn each_cell_instance_vec(
    &self,
    cell: &Self::CellId
) -> Vec<Self::CellInstId, Global>

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

fn each_cell_dependency_vec(
    &self,
    cell: &Self::CellId
) -> Vec<Self::CellId, Global>

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

fn each_dependent_cell_vec(
    &self,
    cell: &Self::CellId
) -> Vec<Self::CellId, Global>

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

fn each_cell_reference_vec(
    &self,
    cell: &Self::CellId
) -> Vec<Self::CellInstId, Global>

Get a Vec with all cell instances referencing this cell.

impl HierarchyEdit for Chip<i32>

pub fn new() -> Chip<i32>

Create a new empty data structure.

pub fn create_cell(
    &mut self,
    name: <Chip<i32> as HierarchyBase>::NameType
) -> <Chip<i32> as HierarchyBase>::CellId

Create a new and empty cell template. A cell template can be be instantiated in other cells.

pub fn remove_cell(&mut self, cell_id: &<Chip<i32> as HierarchyBase>::CellId)

Remove a cell and all the instances of it.

pub fn create_cell_instance(
    &mut self,
    parent_cell: &<Chip<i32> as HierarchyBase>::CellId,
    template_cell: &<Chip<i32> as HierarchyBase>::CellId,
    name: Option<<Chip<i32> as HierarchyBase>::NameType>
) -> <Chip<i32> as HierarchyBase>::CellInstId

Create a new instance of template_cell in parent_cell. Recursive instantiation is forbidden and might panic.

pub fn remove_cell_instance(
    &mut self,
    id: &<Chip<i32> as HierarchyBase>::CellInstId
)

Remove cell instance if it exists.

pub fn rename_cell_instance(
    &mut self,
    inst: &<Chip<i32> as HierarchyBase>::CellInstId,
    new_name: Option<<Chip<i32> as HierarchyBase>::NameType>
)

Change the name of a cell instance.

pub fn rename_cell(
    &mut self,
    cell: &<Chip<i32> as HierarchyBase>::CellId,
    new_name: <Chip<i32> as HierarchyBase>::NameType
)

Change the name of a cell.

pub fn set_chip_property(
    &mut self,
    key: <Chip<i32> as HierarchyBase>::NameType,
    value: PropertyValue
)

Set a property of the top-level chip data structure..

pub fn set_cell_property(
    &mut self,
    cell: &<Chip<i32> as HierarchyBase>::CellId,
    key: <Chip<i32> as HierarchyBase>::NameType,
    value: PropertyValue
)

Set a property of a cell.

pub fn set_cell_instance_property(
    &mut self,
    inst: &<Chip<i32> as HierarchyBase>::CellInstId,
    key: <Chip<i32> as HierarchyBase>::NameType,
    value: PropertyValue
)

Set a property of a cell instance.

impl L2NBase for Chip<i32>

pub fn shapes_of_net(
    &self,
    net_id: &<Chip<i32> as NetlistBase>::NetId
) -> Box<dyn Iterator<Item = <Chip<i32> as LayoutBase>::ShapeId>, Global>

Iterate over all shapes that are marked to belong to the specified net.

pub fn shapes_of_pin(
    &self,
    pin_id: &<Chip<i32> as NetlistBase>::PinId
) -> Box<dyn Iterator<Item = <Chip<i32> as LayoutBase>::ShapeId>, Global>

Iterate over all shapes that are part of the pin.

pub fn get_net_of_shape(
    &self,
    shape_id: &<Chip<i32> as LayoutBase>::ShapeId
) -> Option<<Chip<i32> as NetlistBase>::NetId>

Get the net of a shape.

pub fn get_pin_of_shape(
    &self,
    shape_id: &<Chip<i32> as LayoutBase>::ShapeId
) -> Option<<Chip<i32> as NetlistBase>::PinId>

Get the pin that belongs to the shape (if any).

impl L2NEdit for Chip<i32>

pub fn set_pin_of_shape(
    &mut self,
    shape_id: &<Chip<i32> as LayoutBase>::ShapeId,
    pin: Option<<Chip<i32> as NetlistBase>::PinId>
) -> Option<<Chip<i32> as NetlistBase>::PinId>

Create the link between a circuit pin and its shapes in the layout. Return the current pin.

pub fn set_net_of_shape(
    &mut self,
    shape_id: &<Chip<i32> as LayoutBase>::ShapeId,
    net: Option<<Chip<i32> as NetlistBase>::NetId>
) -> Option<<Chip<i32> as NetlistBase>::NetId>

Set the net of a shape. Return the current net.

impl LayoutBase for Chip<i32>

type Coord = i32

Number type used for coordinates and distances.

type Area = i64

Number type for areas. This is possibly another type then Coord for the following reasons:

type LayerId = Index<LayerInfo<String>, u16>

Layer identifier type.

type ShapeId = Index<Shape<i32, ()>, u32>

Shape identifier type.

pub fn dbu(&self) -> <Chip<i32> as LayoutBase>::Coord

Get the distance unit used in this layout in ‘pixels per micron’.

pub fn each_layer(
    &self
) -> Box<dyn Iterator<Item = <Chip<i32> as LayoutBase>::LayerId>, Global>

Iterate over all defined layers.

pub fn layer_info(
    &self,
    layer: &<Chip<i32> as LayoutBase>::LayerId
) -> LayerInfo<<Chip<i32> as HierarchyBase>::NameType>

Get the LayerInfo data structure for this layer.

pub fn find_layer(
    &self,
    index: u32,
    datatype: u32
) -> Option<<Chip<i32> as LayoutBase>::LayerId>

Find layer index by the (index, data type) tuple.

pub fn layer_by_name(
    &self,
    name: &str
) -> Option<<Chip<i32> as LayoutBase>::LayerId>

Find layer index by the name.

pub fn bounding_box_per_layer(
    &self,
    cell: &<Chip<i32> as HierarchyBase>::CellId,
    layer: &<Chip<i32> as LayoutBase>::LayerId
) -> Option<Rect<i32>>

Compute the bounding box of the shapes on one layer. The bounding box also includes all child cell instances.

pub fn each_shape_id(
    &self,
    cell: &<Chip<i32> as HierarchyBase>::CellId,
    layer: &<Chip<i32> as LayoutBase>::LayerId
) -> Box<dyn Iterator<Item = <Chip<i32> as LayoutBase>::ShapeId>, Global>

Iterate over the IDs of all shapes in the cell on a specific layer.

pub fn for_each_shape<F>(
    &self,
    cell_id: &<Chip<i32> as HierarchyBase>::CellId,
    layer: &<Chip<i32> as LayoutBase>::LayerId,
    f: F
) where
    F: FnMut(&<Chip<i32> as LayoutBase>::ShapeId, &Geometry<<Chip<i32> as LayoutBase>::Coord>), 

Call a function for each shape on this layer.

pub fn with_shape<F, R>(
    &self,
    shape_id: &<Chip<i32> as LayoutBase>::ShapeId,
    f: F
) -> R where
    F: FnMut(&<Chip<i32> as LayoutBase>::LayerId, &Geometry<<Chip<i32> as LayoutBase>::Coord>) -> R, 

Access a shape by its ID.

pub fn parent_of_shape(
    &self,
    shape_id: &<Chip<i32> as LayoutBase>::ShapeId
) -> (<Chip<i32> as HierarchyBase>::CellId, <Chip<i32> as LayoutBase>::LayerId)

Get the parent cell and the layer of a shape as a (cell, layer) tuple.

pub fn get_transform(
    &self,
    cell_inst: &<Chip<i32> as HierarchyBase>::CellInstId
) -> SimpleTransform<<Chip<i32> as LayoutBase>::Coord>

Get the geometric transform that describes the location of a cell instance relative to its parent.

pub fn get_shape_property(
    &self,
    shape: &<Chip<i32> as LayoutBase>::ShapeId,
    key: &<Chip<i32> as HierarchyBase>::NameType
) -> Option<PropertyValue>

Get a property of a shape.

fn bounding_box(&self, cell: &Self::CellId) -> Option<Rect<Self::Coord>>

Compute the bounding box of the cell over all layers. The bounding box is not defined if the cell is empty. In this case return None.

fn shape_geometry(&self, shape_id: &Self::ShapeId) -> Geometry<Self::Coord>

Get a clone of the shape geometry.

fn shape_layer(&self, shape_id: &Self::ShapeId) -> Self::LayerId

Get the layer of a shape.

fn for_each_shape_recursive<F>(
    &self,
    cell: &Self::CellId,
    layer: &Self::LayerId,
    f: F
) where
    F: FnMut(SimpleTransform<Self::Coord>, &Self::ShapeId, &Geometry<Self::Coord>), 

Call a function f for each shape of this cell and its sub cells. Along to the geometric shape f also gets a transformation as argument. The transformation describes the actual position of the geometric shape relative to the cell.

impl LayoutEdit for Chip<i32>

pub fn set_dbu(&mut self, dbu: <Chip<i32> as LayoutBase>::Coord)

Set the distance unit used in this layout in ‘pixels per micron’.

pub fn create_layer(
    &mut self,
    index: u32,
    datatype: u32
) -> <Chip<i32> as LayoutBase>::LayerId

Create a new layer. Use set_layer_name() to define a name.

pub fn create_layer_with_id(
    &mut self,
    layer_id: <Chip<i32> as LayoutBase>::LayerId,
    index: u32,
    datatype: u32
) -> Result<(), ()>

Create a new layer with a specific ID. This is used to clone layer-stacks between layouts while preserving their IDs. Returns an Err when the ID already exists.

pub fn set_layer_name(
    &mut self,
    layer: &<Chip<i32> as LayoutBase>::LayerId,
    name: Option<<Chip<i32> as HierarchyBase>::NameType>
) -> Option<<Chip<i32> as HierarchyBase>::NameType>

Set the name of a layer or clear the layer name when passing None. This method should not change the ID of the layer. Returns the previous name of the layer.

pub fn insert_shape(
    &mut self,
    parent_cell: &<Chip<i32> as HierarchyBase>::CellId,
    layer: &<Chip<i32> as LayoutBase>::LayerId,
    geometry: Geometry<<Chip<i32> as LayoutBase>::Coord>
) -> <Chip<i32> as LayoutBase>::ShapeId

Insert a geometric shape into the parent cell.

pub fn remove_shape(
    &mut self,
    shape_id: &<Chip<i32> as LayoutBase>::ShapeId
) -> Option<Geometry<<Chip<i32> as LayoutBase>::Coord>>

Remove shape from the parent cell.

pub fn replace_shape(
    &mut self,
    shape_id: &<Chip<i32> as LayoutBase>::ShapeId,
    geometry: Geometry<<Chip<i32> as LayoutBase>::Coord>
) -> Geometry<<Chip<i32> as LayoutBase>::Coord>

Replace the geometry of a shape.

pub fn set_transform(
    &mut self,
    cell_inst: &<Chip<i32> as HierarchyBase>::CellInstId,
    tf: SimpleTransform<<Chip<i32> as LayoutBase>::Coord>
)

Set the geometric transform that describes the location of a cell instance relative to its parent.

pub fn set_shape_property(
    &mut self,
    shape: &<Chip<i32> as LayoutBase>::ShapeId,
    key: <Chip<i32> as HierarchyBase>::NameType,
    value: PropertyValue
)

Set a property of a shape.

impl NetlistBase for Chip<i32>

type PinId = PinId

Pin identifier type. Uniquely identifies a pin in the whole netlist.

type PinInstId = PinInstId

Pin instance identifier type. Uniquely identifies a pin instance in the whole netlist. A pin instance is a pin of a circuit instance.

type NetId = NetId

Net identifier type. Uniquely identifies a net in the whole netlist.

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

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

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

Get the signal direction of the pin.

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

Get the name of the pin.

pub fn pin_by_name(
    &self,
    parent_circuit: &<Chip<i32> as HierarchyBase>::CellId,
    name: &str
) -> Option<<Chip<i32> as NetlistBase>::PinId>

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

pub fn parent_cell_of_pin(
    &self,
    pin: &<Chip<i32> as NetlistBase>::PinId
) -> <Chip<i32> as HierarchyBase>::CellId

Get the ID of the parent circuit of this pin.

pub fn parent_of_pin_instance(
    &self,
    pin_inst: &<Chip<i32> as NetlistBase>::PinInstId
) -> <Chip<i32> as HierarchyBase>::CellInstId

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

pub fn parent_cell_of_net(
    &self,
    net: &<Chip<i32> as NetlistBase>::NetId
) -> <Chip<i32> as HierarchyBase>::CellId

Get the ID of the parent circuit of this net.

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

Get the internal net attached to this pin.

pub fn net_of_pin_instance(
    &self,
    pin_inst: &<Chip<i32> as NetlistBase>::PinInstId
) -> Option<<Chip<i32> as NetlistBase>::NetId>

Get the external net attached to this pin instance.

pub fn net_zero(
    &self,
    parent_circuit: &<Chip<i32> as HierarchyBase>::CellId
) -> <Chip<i32> as NetlistBase>::NetId

Get the net of the logical constant zero.

pub fn net_one(
    &self,
    parent_circuit: &<Chip<i32> as HierarchyBase>::CellId
) -> <Chip<i32> as NetlistBase>::NetId

Get the net of the logical constant one.

pub fn net_by_name(
    &self,
    parent_circuit: &<Chip<i32> as HierarchyBase>::CellId,
    name: &str
) -> Option<<Chip<i32> as NetlistBase>::NetId>

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: &<Chip<i32> as NetlistBase>::NetId
) -> Option<<Chip<i32> as HierarchyBase>::NameType>

Get the name of the net.

pub fn for_each_pin<F>(
    &self,
    circuit: &<Chip<i32> as HierarchyBase>::CellId,
    f: F
) where
    F: FnMut(<Chip<i32> as NetlistBase>::PinId), 

Call a function for each pin of the circuit.

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

Iterate over all pins of a circuit.

pub fn for_each_pin_instance<F>(
    &self,
    circuit_inst: &<Chip<i32> as HierarchyBase>::CellInstId,
    f: F
) where
    F: FnMut(<Chip<i32> as NetlistBase>::PinInstId), 

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

pub fn each_pin_instance(
    &'a self,
    circuit_inst: &<Chip<i32> as HierarchyBase>::CellInstId
) -> Box<dyn Iterator<Item = <Chip<i32> as NetlistBase>::PinInstId> + 'a, Global>

Iterate over all pin instances of a circuit.

pub fn for_each_internal_net<F>(
    &self,
    circuit: &<Chip<i32> as HierarchyBase>::CellId,
    f: F
) where
    F: FnMut(<Chip<i32> as NetlistBase>::NetId), 

Call a function for net of the circuit.

pub fn each_internal_net(
    &self,
    circuit: &<Chip<i32> as HierarchyBase>::CellId
) -> Box<dyn Iterator<Item = <Chip<i32> as NetlistBase>::NetId>, Global>

Iterate over all defined nets inside a circuit.

pub fn num_internal_nets(
    &self,
    circuit: &<Chip<i32> as HierarchyBase>::CellId
) -> usize

Return the number of nets defined inside a cell.

pub fn num_pins(&self, circuit: &<Chip<i32> as HierarchyBase>::CellId) -> usize

Get the number of pins of a circuit.

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

Call a function for each pin connected to this net.

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

Iterate over all pins of a net.

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

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

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

Iterate over all pins of a net.

fn pin_instance(
    &self,
    cell_inst: &Self::CellInstId,
    pin: &Self::PinId
) -> Self::PinInstId

Get the ID of a pin instance given the cell instance and the pin ID.

fn net_of_terminal(&self, terminal: &TerminalId<Self>) -> Option<Self::NetId>

Get the net that is attached to this terminal.

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

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

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

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

fn each_external_net(
    &'a self,
    circuit_instance: &Self::CellInstId
) -> 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.

fn for_each_external_net<F>(&self, circuit_instance: &Self::CellInstId, f: F) where
    F: FnMut(Self::NetId), 

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

fn each_external_net_vec(
    &self,
    circuit_instance: &Self::CellInstId
) -> Vec<Self::NetId, Global>

Get a vector of all external nets connected to the circuit instance. A net might appear more than once.

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

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 each_pin_of_net_vec(&self, net: &Self::NetId) -> Vec<Self::PinId, Global>

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, Global>

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

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

Call a function for each terminal connected to this net.

fn each_terminal_of_net_vec(
    &self,
    net: &Self::NetId
) -> Vec<TerminalId<Self>, Global>

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

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

Iterate over all terminals of a net.

impl NetlistEdit for Chip<i32>

pub fn create_pin(
    &mut self,
    circuit: &<Chip<i32> as HierarchyBase>::CellId,
    name: <Chip<i32> as HierarchyBase>::NameType,
    direction: Direction
) -> <Chip<i32> as NetlistBase>::PinId

Create a new pin in this cell. Also adds the pin to all instances of the cell.

pub fn remove_pin(&mut self, id: &<Chip<i32> as NetlistBase>::PinId)

Remove the pin from this circuit and from all instances of this circuit.

pub fn rename_pin(
    &mut self,
    pin: &<Chip<i32> as NetlistBase>::PinId,
    new_name: <Chip<i32> as HierarchyBase>::NameType
) -> <Chip<i32> as HierarchyBase>::NameType

Change the name of the pin, returns the old name.

pub fn create_net(
    &mut self,
    parent: &CellId,
    name: Option<<Chip<i32> as HierarchyBase>::NameType>
) -> NetId

Create a net net that lives in the parent circuit.

pub fn rename_net(
    &mut self,
    net_id: &<Chip<i32> as NetlistBase>::NetId,
    new_name: Option<<Chip<i32> as HierarchyBase>::NameType>
) -> Option<<Chip<i32> as HierarchyBase>::NameType>

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

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

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

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

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

pub fn connect_pin_instance(
    &mut self,
    pin: &PinInstId,
    net: Option<NetId>
) -> Option<<Chip<i32> as NetlistBase>::NetId>

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

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 connect_terminal(
    &mut self,
    terminal: &TerminalId<Self>,
    net: Option<Self::NetId>
) -> Option<Self::NetId>

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

fn disconnect_terminal(
    &mut self,
    terminal: &TerminalId<Self>
) -> Option<Self::NetId>

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