ManipulateNamesAllowlistAnnotation

Annotation to filter name manipulation to only manipulate specific Targets in a transform that subclasses ManipulateNames. Targets will be renamed if they are not listed in a ManipulateNamesBlocklistAnnotation and also listed in this annotation.

Not providing a ManipulateNamesAllowlistAnnotation means that all targets in a circuit may be renamed.

A: a sub-type of ManipulateNames
targets: FIRRTL IR targets to include in name manipulation
transform: the transform that this should apply to

Source: ManipulateNames.scala
Exceptions thrown: java.lang.IllegalArgumentException if any non-local targets are given
Note: All targets must be local. Name modification in a non-local target (e.g., a node in a specific instance) makes no structural modification and will be ignored during deduplication. If you want this behavior, use a combination of a sub-class of this annotation and a NoDedupAnnotation.

Linear Supertypes

Serializable, Serializable, ManipulateNamesListAnnotation[A], MultiTargetAnnotation, Annotation, Product, Equals, AnyRef, Any

Type Hierarchy

Instance Constructors

new ManipulateNamesAllowlistAnnotation(targets: Seq[Seq[Target]], transform: Dependency[A])

targets
FIRRTL IR targets to include in name manipulation
transform
the transform that this should apply to

Exceptions thrown
java.lang.IllegalArgumentException if any non-local targets are given

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate() @throws( ... )
def duplicate(a: Seq[Seq[Target]]): ManipulateNamesAllowlistAnnotation[A]

Create another instance of this Annotation
Create another instance of this Annotation
The inner Seqs correspond to the renames of the inner Seqs of targets

Definition Classes
ManipulateNamesAllowlistAnnotation → MultiTargetAnnotation
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def flat(): AnnotationSeq

Assume RenameMap is Map(TargetA -> Seq(TargetA1, TargetA2, TargetA3), TargetB -> Seq(TargetB1, TargetB2)) After flat, this Annotation will be flat to the AnnotationSeq in the below form Seq(Seq(TargetA1), Seq(TargetB1), Seq(TargetC)); Seq(Seq(TargetA1), Seq(TargetB2), Seq(TargetC)) Seq(Seq(TargetA2), Seq(TargetB1), Seq(TargetC)); Seq(Seq(TargetA2), Seq(TargetB2), Seq(TargetC)) Seq(Seq(TargetA3), Seq(TargetB1), Seq(TargetC)); Seq(Seq(TargetA3), Seq(TargetB2), Seq(TargetC))
Assume RenameMap is Map(TargetA -> Seq(TargetA1, TargetA2, TargetA3), TargetB -> Seq(TargetB1, TargetB2)) After flat, this Annotation will be flat to the AnnotationSeq in the below form Seq(Seq(TargetA1), Seq(TargetB1), Seq(TargetC)); Seq(Seq(TargetA1), Seq(TargetB2), Seq(TargetC)) Seq(Seq(TargetA2), Seq(TargetB1), Seq(TargetC)); Seq(Seq(TargetA2), Seq(TargetB2), Seq(TargetC)) Seq(Seq(TargetA3), Seq(TargetB1), Seq(TargetC)); Seq(Seq(TargetA3), Seq(TargetB2), Seq(TargetC))

Definition Classes
MultiTargetAnnotation
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@HotSpotIntrinsicCandidate()
def getTargets: Seq[Target]

Returns all Target members in this annotation
Returns all Target members in this annotation

Definition Classes
MultiTargetAnnotation → Annotation
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@HotSpotIntrinsicCandidate()
def serialize: String

Optional pretty print
Optional pretty print

Definition Classes
Annotation
Note
rarely used
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
val targets: Seq[Seq[Target]]

FIRRTL IR targets to include in name manipulation
FIRRTL IR targets to include in name manipulation

Definition Classes
ManipulateNamesAllowlistAnnotation → MultiTargetAnnotation
val transform: Dependency[A]

the transform that this should apply to
the transform that this should apply to

Definition Classes
ManipulateNamesAllowlistAnnotation → ManipulateNamesListAnnotation
def update(renames: RenameMap): Seq[Annotation]

Assume RenameMap is Map(TargetA -> Seq(TargetA1, TargetA2, TargetA3), TargetB -> Seq(TargetB1, TargetB2)) in the update, this Annotation is still one annotation, but the contents are renamed in the below form Seq(Seq(TargetA1, TargetA2, TargetA3), Seq(TargetB1, TargetB2), Seq(TargetC))
Assume RenameMap is Map(TargetA -> Seq(TargetA1, TargetA2, TargetA3), TargetB -> Seq(TargetB1, TargetB2)) in the update, this Annotation is still one annotation, but the contents are renamed in the below form Seq(Seq(TargetA1, TargetA2, TargetA3), Seq(TargetB1, TargetB2), Seq(TargetC))

Definition Classes
MultiTargetAnnotation → Annotation
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Deprecated Value Members

def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@Deprecated @deprecated @throws( classOf[java.lang.Throwable] )
Deprecated
(Since version ) see corresponding Javadoc for more information.

Related Doc: package transforms

case class ManipulateNamesAllowlistAnnotation[A <: ManipulateNames[_]](targets: Seq[Seq[Target]], transform: Dependency[A]) extends ManipulateNamesListAnnotation[A] with Product with Serializable

Instance Constructors

new ManipulateNamesAllowlistAnnotation(targets: Seq[Seq[Target]], transform: Dependency[A])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def duplicate(a: Seq[Seq[Target]]): ManipulateNamesAllowlistAnnotation[A]

final def eq(arg0: AnyRef): Boolean

def flat(): AnnotationSeq

final def getClass(): Class[_]

def getTargets: Seq[Target]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def serialize: String

final def synchronized[T0](arg0: ⇒ T0): T0

val targets: Seq[Seq[Target]]

val transform: Dependency[A]

def update(renames: RenameMap): Seq[Annotation]

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def wait(): Unit

Deprecated Value Members

def finalize(): Unit

Inherited from Serializable

Inherited from Serializable

Inherited from ManipulateNamesListAnnotation[A]

Inherited from MultiTargetAnnotation

Inherited from Annotation

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped