Struct libreda_db::flat_view::FlatView

pub struct FlatView<'a, N> {
    path_separator: String,
    base: &'a N,
}

Wrapper around a netlist which provides an on-the-fly flat view of a certain cell. The presented view is flattened until leaf cells. Internally this works by using component IDs that are actually paths through the hierarchy.

Names are constructed by concatenating the names of the path elements with a separator string in between.

Example

use libreda_db::prelude::{Chip, HierarchyBase, HierarchyEdit, FlatView};

// Create a simple hierarchy.
let mut chip = Chip::new();
let top = chip.create_cell("TOP".into());
let intermediate = chip.create_cell("INTERMEDIATE".into());
let leaf1 = chip.create_cell("LEAF1".into());
let leaf2 = chip.create_cell("LEAF2".into());

// The intermediate cell contains two instances of leaf1 and one instance of leaf2.
chip.create_cell_instance(&intermediate, &leaf1, Some("leaf1_inst1".into()));
chip.create_cell_instance(&intermediate, &leaf1, Some("leaf1_inst2".into()));
chip.create_cell_instance(&intermediate, &leaf2, Some("leaf2_inst1".into()));

// Create two instances of the intermediate cell in the TOP cell.
chip.create_cell_instance(&top, &intermediate, Some("intermediate1".into()));
chip.create_cell_instance(&top, &intermediate, Some("intermediate2".into()));

// Create the flat view.

let flat = FlatView::new_with_separator(&chip, ":".to_string());
let flat_top = flat.cell_by_name("TOP").expect("TOP not found in flat view.");
// There are 2 instances of the intermediate cell which contains 3 leaf cells,
// so now the flattened top should contain 2*3 instances.
assert_eq!(flat.num_child_instances(&flat_top), 2*3);

// Get a cell instance with the path string.
let inst = flat.cell_instance_by_name(&flat_top, "intermediate1:leaf1_inst1").expect("Instance not found.");
// Instance names are assembled from the path.
assert_eq!(flat.cell_instance_name(&inst).unwrap().as_str(), "intermediate1:leaf1_inst1");

// There should be 4 instances of the LEAF1 cell now.
assert_eq!(flat.each_cell_reference(&leaf1).count(), 2*2);

Fields

path_separator: String

Sequence used to separate path elements when creating qualified names. Names of the original netlist are not allowed to contain the path separator.

base: &'a N

Underlying netlist data structure.

Implementations

impl<'a, N: HierarchyBase> FlatView<'a, N>

pub fn new(base: &'a N) -> Self

Create a new flat view of base. Use “/” as a path separator in names.

pub fn new_with_separator(base: &'a N, path_separator: String) -> Self

Create a new flat view of base. Use a custom path separator in concatenated names.

fn cell_is_leaf(&self, cell: &N::CellId) -> bool

fn cell_exists_in_flat_view(&self, cell: &N::CellId) -> bool

fn cell_is_flattened(&self, cell: &N::CellId) -> bool

Check if the cell got flattened and does not exist in the flat view.

Trait Implementations

impl<'a, N: HierarchyBase> HierarchyBase for FlatView<'a, N>

type NameType = <N as HierarchyBase>::NameType

Type for names of cells, instances, etc.

type CellId = <N as HierarchyBase>::CellId

Cell/module identifier type.

type CellInstId = Vec<<N as HierarchyBase>::CellInstId, Global>

Cell instance identifier type.

fn cell_by_name(&self, name: &str) -> Option<Self::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_cell: &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, cell: &Self::CellId) -> Self::NameType

Get the name of the cell.

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

Get the name of the cell instance.

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

Get the ID of the parent cell of this instance.

fn template_cell(&self, cell_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 for_each_cell_instance<F>(&self, cell: &Self::CellId, f: F) where
    F: FnMut(Self::CellInstId), 

Call a function on each instance in this cell.

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

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

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

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

fn for_each_cell_reference<F>(&self, cell: &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 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 each_cell_vec(&self) -> Vec<Self::CellId>

Get a Vec of all cell IDs in this netlist.

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

Iterate over all cells.

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_instance(
    &self,
    cell: &Self::CellId
) -> Box<dyn Iterator<Item = Self::CellInstId> + '_>

Iterate over all instances in a 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_cell_dependency<'a>(
    &'a self,
    cell: &Self::CellId
) -> Box<dyn Iterator<Item = Self::CellId> + 'a>

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 each_dependent_cell_vec(&self, cell: &Self::CellId) -> Vec<Self::CellId>

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

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

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 each_cell_reference_vec(&self, cell: &Self::CellId) -> Vec<Self::CellInstId>

Get a Vec with all cell instances referencing this cell.

fn each_cell_reference(
    &self,
    cell: &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 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.