Struct substrate::schematic::CellBuilder

pub struct CellBuilder<S: Schema + ?Sized> { /* private fields */ }

A builder for creating a schematic cell.

Implementations

impl<S: Schema + ?Sized> CellBuilder<S>

pub fn flatten(&mut self)

Marks this cell to be flattened.

pub fn signal<TY: HardwareType>( &mut self, name: impl Into<ArcStr>, ty: TY ) -> <TY as HardwareType>::Bundle

Create a new signal with the given name and hardware type.

pub fn connect<D1, D2>(&mut self, s1: D1, s2: D2)

where D1: Flatten<Node> + Connect<D2>, D2: Flatten<Node>,

Connect all signals in the given data instances.

pub fn connect_multiple<D>(&mut self, s2: &[D])

where D: Flatten<Node>,

Connect all signals in the given data instances.

pub fn set_scir(&mut self, scir: ScirBinding<S>)

Marks this cell as a SCIR cell.

pub fn set_primitive(&mut self, primitive: PrimitiveBinding<S>)

Marks this cell as a primitive.

pub fn ctx(&self) -> &Context

Gets the global context.

pub fn generate<B: Schematic<S>>(&mut self, block: B) -> SchemaCellHandle<S, B>

Starts generating a block in a new thread and returns a handle to its cell.

Can be used to check data stored in the cell or other generated results before adding the cell to the current schematic with CellBuilder::add.

To generate and add the block simultaneously, use CellBuilder::instantiate.

pub fn generate_blocking<B: Schematic<S>>( &mut self, block: B ) -> Result<SchemaCellHandle<S, B>>

Generates a cell corresponding to block and returns a handle to it.

Blocks on generation. Useful for handling errors thrown by the generation of a cell immediately.

As with CellBuilder::generate, the resulting handle must be added to the schematic with CellBuilder::add before it can be connected as an instance.

pub fn add<B: ExportsNestedData>( &mut self, cell: SchemaCellHandle<S, B> ) -> Instance<B>

Adds a cell generated with CellBuilder::generate to the current schematic.

Does not block on generation. If immediate error recovery is desired, check errors before calling this function using CellHandle::try_cell.

Panics

If the instantiated cell fails to generate, this function will eventually cause a panic after the parent cell’s generator completes. To avoid this, return errors using Instance::try_data before your generator returns.

pub fn instantiate<B: Schematic<S>>(&mut self, block: B) -> Instance<B>

Instantiates a schematic view of the given block.

This function generates and adds the cell to the schematic. If checks need to be done on the generated cell before it is added to the schematic, use CellBuilder::generate and CellBuilder::add.

Spawns a thread that generates the underlying cell. If immediate error recovery is desired, use the generate and add workflow mentioned above.

Panics

If the instantiated cell fails to generate, this function will eventually cause a panic after the parent cell’s generator completes. To avoid this, return errors using Instance::try_data before your generator returns.

If an error is not returned from the enclosing generator, but this function returns an error, the enclosing generator will panic since the instantiation irrecoverably failed.

pub fn instantiate_named<B: Schematic<S>>( &mut self, block: B, name: impl Into<ArcStr> ) -> Instance<B>

Instantiates a block and assigns a name to the instance.

See CellBuilder::instantiate for details.

Callers must ensure that instance names are unique.

pub fn instantiate_blocking<B: Schematic<S>>( &mut self, block: B ) -> Result<Instance<B>>

Instantiates a schematic view of the given block, blocking on generator for underlying cell. Returns an error if the generator returned an error.

See SubCellBuilder::instantiate for details.

Panics

If an error is not returned from the enclosing generator, but this function returns an error, the enclosing generator will panic since the instantiation irrecoverably failed.

pub fn instantiate_connected<B, C>(&mut self, block: B, io: C)

where B: Schematic<S>, C: IsBundle, <B::Io as HardwareType>::Bundle: Connect<C>,

Creates an instance using CellBuilder::instantiate and immediately connects its ports.

pub fn instantiate_connected_named<B, C>( &mut self, block: B, io: C, name: impl Into<ArcStr> )

where B: Schematic<S>, C: IsBundle, <B::Io as HardwareType>::Bundle: Connect<C>,

Creates an instance using CellBuilder::instantiate and immediately connects its ports.

pub fn sub_builder<S2: Schema + ?Sized>(&mut self) -> SubCellBuilder<'_, S, S2>

where S: FromSchema<S2>,

Creates a SubCellBuilder for instantiating blocks from schema S2.