chisel
7.9.0+2-5294dafe-SNAPSHOT
API
Generated with
chisel/chisel3/Data

Data

chisel3.Data
See theData companion class
object Data

Attributes

Companion
class
Source
Data.scala
Graph
Supertypes
class Object
trait Matchable
class Any
Self type
Data.type

Members list

Type members

Classlikes

implicit class AsReadOnly[T <: Data](self: T)

Attributes

Source
Data.scala
Supertypes
class Object
trait Matchable
class Any
implicit class ConnectableDefault[T <: Data](consumer: T) extends ConnectableOperators[T]

Provides :<=, :>=, :<>=, and :#= between consumer and producer of the same T <: Data

Provides :<=, :>=, :<>=, and :#= between consumer and producer of the same T <: Data

Attributes

Source
Data.scala
Supertypes
class Object
trait Matchable
class Any
implicit class ConnectableVecDefault[T <: Data](consumer: Vec[T]) extends ConnectableVecOperators[T]

Provides :<>=, :<=, :>=, and :#= between a (consumer: Vec) and (producer: Seq)

Provides :<>=, :<=, :>=, and :#= between a (consumer: Vec) and (producer: Seq)

Attributes

Source
Data.scala
Supertypes
class Object
trait Matchable
class Any
implicit class DataEquality[T <: Data](lhs: T)(implicit sourceInfo: SourceInfo)

Provides generic, recursive equality for Bundle and Vec hardware. This avoids the need to use workarounds such as bundle1.asUInt === bundle2.asUInt by allowing users to instead write bundle1 === bundle2.

Provides generic, recursive equality for Bundle and Vec hardware. This avoids the need to use workarounds such as bundle1.asUInt === bundle2.asUInt by allowing users to instead write bundle1 === bundle2.

Static type safety of this comparison is guaranteed at compile time as the extension method requires the same parameterized type for both the left-hand and right-hand sides. It is, however, possible to get around this type safety using Bundle subtypes that can differ during runtime (e.g. through a generator). These cases are subsequently raised as elaboration errors.

Value parameters

lhs

The Data hardware on the left-hand side of the equality

Attributes

Source
Data.scala
Supertypes
class Object
trait Matchable
class Any

Implicits

Implicits

final implicit def AsReadOnly[T <: Data](self: T): AsReadOnly[T]

Attributes

Source
Data.scala
final implicit def ConnectableDefault[T <: Data](consumer: T): ConnectableDefault[T]

Provides :<=, :>=, :<>=, and :#= between consumer and producer of the same T <: Data

Provides :<=, :>=, :<>=, and :#= between consumer and producer of the same T <: Data

Attributes

Source
Data.scala
final implicit def ConnectableVecDefault[T <: Data](consumer: Vec[T]): ConnectableVecDefault[T]

Provides :<>=, :<=, :>=, and :#= between a (consumer: Vec) and (producer: Seq)

Provides :<>=, :<=, :>=, and :#= between a (consumer: Vec) and (producer: Seq)

Attributes

Source
Data.scala
final implicit def DataEquality[T <: Data](lhs: T)(implicit sourceInfo: SourceInfo): DataEquality[T]

Provides generic, recursive equality for Bundle and Vec hardware. This avoids the need to use workarounds such as bundle1.asUInt === bundle2.asUInt by allowing users to instead write bundle1 === bundle2.

Provides generic, recursive equality for Bundle and Vec hardware. This avoids the need to use workarounds such as bundle1.asUInt === bundle2.asUInt by allowing users to instead write bundle1 === bundle2.

Static type safety of this comparison is guaranteed at compile time as the extension method requires the same parameterized type for both the left-hand and right-hand sides. It is, however, possible to get around this type safety using Bundle subtypes that can differ during runtime (e.g. through a generator). These cases are subsequently raised as elaboration errors.

Value parameters

lhs

The Data hardware on the left-hand side of the equality

Attributes

Source
Data.scala
implicit val dataMatchingZipOfChildren: HasMatchingZipOfChildren[Data]

Typeclass implementation of HasMatchingZipOfChildren for Data

Typeclass implementation of HasMatchingZipOfChildren for Data

The canonical API to iterate through two Chisel types or components, where matching children are provided together, while non-matching members are provided separately

Only zips immediate children (vs members, which are all children/grandchildren etc.)

Attributes

Source
Data.scala
implicit def toConnectableDefault[T <: Data](d: T): Connectable[T]

Can implicitly convert a Data to a Connectable

Can implicitly convert a Data to a Connectable

Originally this was done with an implicit class, but all functions we want to add to Data we also want on Connectable, so an implicit conversion makes the most sense so the ScalaDoc can be shared.

Attributes

Source
Data.scala
Generated with