Struct libreda_db::chip::Chip

pub struct Chip<C: CoordinateType = Coord> {

    circuits: FnvHashMap<CellId, Circuit<C>>,
    circuits_by_name: HashMap<String, CellId>,
    circuit_instances: FnvHashMap<CellInstId, CircuitInst>,
    nets: FnvHashMap<NetId, Net>,
    pins: FnvHashMap<PinId, Pin>,
    pin_instances: FnvHashMap<PinInstId, PinInst>,
    properties: PropertyStore<String>,
    id_counter_circuit: u32,
    id_counter_circuit_inst: usize,
    id_counter_pin: u32,
    id_counter_pin_inst: usize,
    id_counter_net: usize,
    dbu: C,
    layer_index_generator: IndexGenerator<LayerInfo<String>, u16>,
    layers_by_name: HashMap<String, LayerId>,
    layers_by_index_datatype: FnvHashMap<(UInt, UInt), LayerId>,
    layer_info: FnvHashMap<LayerId, LayerInfo<String>>,
    shape_index_generator: IndexGenerator<Shape<C>>,
    shape_parents: FnvHashMap<ShapeId, (CellId, LayerId)>,
    net_shapes: FnvHashMap<NetId, FnvHashSet<ShapeId>>,
}

A netlist is the container of circuits.

Fields

circuits: FnvHashMap<CellId, Circuit<C>>

circuits_by_name: HashMap<String, CellId>

circuit_instances: FnvHashMap<CellInstId, CircuitInst>

nets: FnvHashMap<NetId, Net>

pins: FnvHashMap<PinId, Pin>

pin_instances: FnvHashMap<PinInstId, PinInst>

properties: PropertyStore<String>

Top-level properties.

id_counter_circuit: u32

id_counter_circuit_inst: usize

id_counter_pin: u32

id_counter_pin_inst: usize

id_counter_net: usize

dbu: C

layer_index_generator: IndexGenerator<LayerInfo<String>, u16>

Counter for generating the next layer index.

layers_by_name: HashMap<String, LayerId>

Lookup table for finding layers by name.

layers_by_index_datatype: FnvHashMap<(UInt, UInt), LayerId>

Lookup table for finding layers by index/datatype numbers.

layer_info: FnvHashMap<LayerId, LayerInfo<String>>

Info structures for all layers.

shape_index_generator: IndexGenerator<Shape<C>>

ID generator for shapes.

shape_parents: FnvHashMap<ShapeId, (CellId, LayerId)>

Link to the cell and layer that contain a shape.

net_shapes: FnvHashMap<NetId, FnvHashSet<ShapeId>>

Link to the shapes of a net.

Implementations

impl Chip<Coord>

pub fn new() -> Self

Create an empty data structure.

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

Find a circuit by its name.

fn rename_cell(&mut self, cell: &CellId, name: String)

Change the name of the cell.

Panics

Panics if the name already exists.

fn rename_cell_instance(&mut self, inst: &CellInstId, name: Option<String>)

Change the name of the cell instance.

Panics

Panics if the name already exists.

fn create_circuit( &mut self, name: String, pins: Vec<(String, Direction)> ) -> CellId

Create a new circuit template.

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

Remove all instances inside the circuit, remove all instances of the circuit and remove finally the circuit itself.

fn create_circuit_instance( &mut self, parent: &CellId, circuit_template: &CellId, name: Option<String> ) -> CellInstId

Create a new instance of circuit_template in the parent circuit.

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

Remove a circuit instance after disconnecting it from the nets.

fn create_net(&mut self, parent: &CellId, name: Option<String>) -> NetId

Create a new net in the parent circuit.

fn rename_net( &mut self, net_id: &NetId, new_name: Option<String> ) -> Option<String>

Change the name of the net.

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

Disconnect all connected terminals and remove the net.

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

Disconnect pin and return the ID of the net that was connected.

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

Connect the pin to a net.

fn disconnect_pin_instance(&mut self, pin: &PinInstId) -> Option<NetId>

Disconnect the pin instance and return the net to which it was connected.

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

Connect the pin to a net.

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

Get a circuit reference by its ID.

fn circuit_mut(&mut self, id: &CellId) -> &mut Circuit

Get a mutable reference to the circuit by its ID.

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

Get a reference to a circuit instance.

fn circuit_inst_mut(&mut self, id: &CellInstId) -> &mut CircuitInst

Get a mutable reference to a circuit instance.

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

Get a reference to a net by its ID.

fn net_mut(&mut self, id: &NetId) -> &mut Net

Get a mutable reference to a net by its ID.

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

Get a reference to a pin by its ID.

fn pin_mut(&mut self, id: &PinId) -> &mut Pin

Get a mutable reference to a pin by its ID.

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

Get a reference to a pin instance by its ID.

fn pin_inst_mut(&mut self, id: &PinInstId) -> &mut PinInst

Get a mutable reference to a pin instance by its ID.

fn next_id_counter_usize(ctr: &mut usize) -> usize

Get the value of a counter and increment the counter afterwards.

fn next_id_counter_u32(ctr: &mut u32) -> u32

Get the value of a counter and increment the counter afterwards.

fn create_pin( &mut self, parent: CellId, name: String, direction: Direction ) -> PinId

Append a new pin to the parent circuit. Update all circuit instances with the new pin.

fn create_pin_inst(&mut self, circuit: CellInstId, pin: PinId) -> PinInstId

Insert a new pin instance to a circuit instance.

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

Iterate over all pins connected to a net.

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

Iterate over all pin instances connected to a net.

fn shape_mut(&mut self, shape_id: &ShapeId) -> &mut Shape<Coord>

Get a mutable reference to a shape struct by its ID.

fn shape(&self, shape_id: &ShapeId) -> &Shape<Coord>

Get a reference to a shape struct by its ID.

Trait Implementations

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

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 + CoordinateType> Debug for Chip<C>

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<'de, C> Deserialize<'de> for Chip<C>where C: Deserialize<'de> + CoordinateType,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl HierarchyBase for Chip<Coord>

type NameType = String

Type for names of cells, instances, etc.

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.

fn cell_instance_by_name( &self, parent_circuit: &Self::CellId, name: &str ) -> Option<Self::CellInstId>

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

fn cell_name(&self, circuit: &Self::CellId) -> Self::NameType

Get the name of the cell.

fn cell_instance_name( &self, circuit_inst: &Self::CellInstId ) -> Option<Self::NameType>

Get the name of the cell instance.

fn parent_cell(&self, circuit_instance: &Self::CellInstId) -> Self::CellId

Get the ID of the parent cell of this instance.

fn template_cell(&self, circuit_instance: &Self::CellInstId) -> Self::CellId

Get the ID of the template cell of this instance.

fn for_each_cell<F>(&self, f: F)where F: FnMut(Self::CellId),

Call a function on each cell of the netlist.

fn each_cell(&self) -> Box<dyn Iterator<Item = CellId> + '_>

Iterate over all cells.

fn for_each_cell_instance<F>(&self, circuit: &Self::CellId, f: F)where F: FnMut(Self::CellInstId),

Call a function on each instance in this cell.

fn each_cell_instance( &self, circuit: &Self::CellId ) -> Box<dyn Iterator<Item = Self::CellInstId> + '_>

Iterate over all instances in a cell.

fn for_each_cell_dependency<F>(&self, circuit: &Self::CellId, f: F)where F: FnMut(Self::CellId),

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

fn each_cell_dependency( &self, circuit: &Self::CellId ) -> Box<dyn Iterator<Item = Self::CellId> + '_>

Iterate over all cells that are instantiated in this cell.

fn num_cell_dependencies(&self, cell: &Self::CellId) -> usize

Count all cells that are dependencies of cell.

fn for_each_dependent_cell<F>(&self, circuit: &Self::CellId, f: F)where F: FnMut(Self::CellId),

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

fn each_dependent_cell( &self, circuit: &Self::CellId ) -> Box<dyn Iterator<Item = Self::CellId> + '_>

Iterate over each cell that directly depends on cell.

fn num_dependent_cells(&self, cell: &Self::CellId) -> usize

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

fn for_each_cell_reference<F>(&self, circuit: &Self::CellId, f: F)where F: FnMut(Self::CellInstId),

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

fn each_cell_reference( &self, circuit: &Self::CellId ) -> Box<dyn Iterator<Item = Self::CellInstId> + '_>

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

fn num_cell_references(&self, cell: &Self::CellId) -> usize

Count all instantiations of cell.

fn num_child_instances(&self, cell: &Self::CellId) -> usize

Get the number of cell instances inside the cell.

fn num_cells(&self) -> usize

Get the number of cell templates.

fn get_chip_property(&self, key: &Self::NameType) -> Option<PropertyValue>

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

fn get_cell_property( &self, cell: &Self::CellId, key: &Self::NameType ) -> Option<PropertyValue>

Get a property of a cell.

fn get_cell_instance_property( &self, inst: &Self::CellInstId, key: &Self::NameType ) -> Option<PropertyValue>

Get a property of a cell instance.

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

Get a Vec of all cell IDs in this netlist.

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

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

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

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>

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

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

Get a Vec with all cell instances referencing this cell.

impl HierarchyEdit for Chip<Coord>

fn create_cell(&mut self, name: Self::NameType) -> Self::CellId

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

fn remove_cell(&mut self, cell_id: &Self::CellId)

Remove a cell and all the instances of it.

fn create_cell_instance( &mut self, parent_cell: &Self::CellId, template_cell: &Self::CellId, name: Option<Self::NameType> ) -> Self::CellInstId

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

fn remove_cell_instance(&mut self, id: &Self::CellInstId)

Remove cell instance if it exists.

fn rename_cell_instance( &mut self, inst: &Self::CellInstId, new_name: Option<Self::NameType> )

Change the name of a cell instance.

fn rename_cell(&mut self, cell: &Self::CellId, new_name: Self::NameType)

Change the name of a cell.

fn set_chip_property(&mut self, key: Self::NameType, value: PropertyValue)

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

fn set_cell_property( &mut self, cell: &Self::CellId, key: Self::NameType, value: PropertyValue )

Set a property of a cell.

fn set_cell_instance_property( &mut self, inst: &Self::CellInstId, key: Self::NameType, value: PropertyValue )

Set a property of a cell instance.

impl HierarchyIds for Chip<Coord>

type CellId = CellId

Cell/module identifier type.

type CellInstId = CellInstId

Cell instance identifier type.

impl L2NBase for Chip<Coord>

fn shapes_of_net( &self, net_id: &Self::NetId ) -> Box<dyn Iterator<Item = Self::ShapeId> + '_>

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

fn shapes_of_pin( &self, pin_id: &Self::PinId ) -> Box<dyn Iterator<Item = Self::ShapeId> + '_>

Iterate over all shapes that are part of the pin.

fn get_net_of_shape(&self, shape_id: &Self::ShapeId) -> Option<Self::NetId>

Get the net of a shape.

fn get_pin_of_shape(&self, shape_id: &Self::ShapeId) -> Option<Self::PinId>

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

impl L2NEdit for Chip<Coord>

fn set_pin_of_shape( &mut self, shape_id: &Self::ShapeId, pin: Option<Self::PinId> ) -> Option<Self::PinId>

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

fn set_net_of_shape( &mut self, shape_id: &Self::ShapeId, net: Option<Self::NetId> ) -> Option<Self::NetId>

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

impl LayoutBase for Chip<Coord>

fn dbu(&self) -> Self::Coord

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

fn each_layer(&self) -> Box<dyn Iterator<Item = Self::LayerId> + '_>

Iterate over all defined layers.

fn layer_info(&self, layer: &Self::LayerId) -> LayerInfo<Self::NameType>

Get the LayerInfo data structure for this layer.

fn find_layer(&self, index: u32, datatype: u32) -> Option<Self::LayerId>

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

fn layer_by_name(&self, name: &str) -> Option<Self::LayerId>

Find layer index by the name.

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

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

fn each_shape_id( &self, cell: &Self::CellId, layer: &Self::LayerId ) -> Box<dyn Iterator<Item = Self::ShapeId> + '_>

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

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

Call a function for each shape on this layer.

fn with_shape<F, R>(&self, shape_id: &Self::ShapeId, f: F) -> Rwhere F: FnMut(&Self::LayerId, &Geometry<Self::Coord>) -> R,

Access a shape by its ID.

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

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

fn get_transform( &self, cell_inst: &Self::CellInstId ) -> SimpleTransform<Self::Coord>

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

fn get_shape_property( &self, shape: &Self::ShapeId, key: &Self::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<Coord>

fn set_dbu(&mut self, dbu: Self::Coord)

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

fn create_layer(&mut self, index: u32, datatype: u32) -> Self::LayerId

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

fn create_layer_with_id( &mut self, layer_id: Self::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.

fn set_layer_name( &mut self, layer: &Self::LayerId, name: Option<Self::NameType> ) -> Option<Self::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.

fn insert_shape( &mut self, parent_cell: &Self::CellId, layer: &Self::LayerId, geometry: Geometry<Self::Coord> ) -> Self::ShapeId

Insert a geometric shape into the parent cell.

fn remove_shape( &mut self, shape_id: &Self::ShapeId ) -> Option<Geometry<Self::Coord>>

Remove shape from the parent cell.

fn replace_shape( &mut self, shape_id: &Self::ShapeId, geometry: Geometry<Self::Coord> ) -> Geometry<Self::Coord>

Replace the geometry of a shape.

fn set_transform( &mut self, cell_inst: &Self::CellInstId, tf: SimpleTransform<Self::Coord> )

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

fn set_shape_property( &mut self, shape: &Self::ShapeId, key: Self::NameType, value: PropertyValue )

Set a property of a shape.

impl LayoutIds for Chip<Coord>

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.

impl NetlistBase for Chip

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( &self, parent_circuit: &Self::CellId, name: &str ) -> Option<Self::PinId>

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

fn parent_cell_of_pin(&self, pin: &Self::PinId) -> Self::CellId

Get the ID of the parent circuit of this pin.

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

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

fn parent_cell_of_net(&self, net: &Self::NetId) -> Self::CellId

Get the ID of the parent circuit of this net.

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

Get the internal net attached to this pin.

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

Get the external net attached to this pin instance.

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

Get the net of the logical constant zero.

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

Get the net of the logical constant one.

fn net_by_name( &self, parent_circuit: &Self::CellId, name: &str ) -> Option<Self::NetId>

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 for_each_pin<F>(&self, circuit: &Self::CellId, f: F)where F: FnMut(Self::PinId),

Call a function for each pin of the circuit.

fn each_pin(&self, circuit_id: &CellId) -> Box<dyn Iterator<Item = PinId> + '_>

Iterate over all pins of a circuit.

fn for_each_pin_instance<F>(&self, circuit_inst: &Self::CellInstId, 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::CellInstId ) -> Box<dyn Iterator<Item = Self::PinInstId> + 'a>

Iterate over all pin instances of a circuit.

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

Call a function for net of the circuit.

fn each_internal_net( &self, circuit: &Self::CellId ) -> Box<dyn Iterator<Item = Self::NetId> + '_>

Iterate over all defined nets inside a circuit.

fn num_internal_nets(&self, circuit: &Self::CellId) -> usize

Return the number of nets defined inside a cell.

fn num_pins(&self, circuit: &Self::CellId) -> 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 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 each_pin_vec(&self, circuit: &Self::CellId) -> Vec<Self::PinId>

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>

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

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

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>

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>

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.

impl NetlistEdit for Chip

fn create_pin( &mut self, circuit: &Self::CellId, name: Self::NameType, direction: Direction ) -> Self::PinId

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

fn remove_pin(&mut self, id: &Self::PinId)

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

fn rename_pin( &mut self, pin: &Self::PinId, new_name: Self::NameType ) -> Self::NameType

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

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

Create a net net that lives in the parent circuit.

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

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

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

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

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.

fn connect_pin_instance( &mut self, pin: &PinInstId, net: Option<NetId> ) -> Option<Self::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.

impl NetlistIds for Chip

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.

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.