abstract
class
Data extends Node
Instance Constructors
-
new
Data()
Abstract Value Members
-
abstract
def
asDirectionless(): Data.this.type
-
abstract
def
asOutput(): Data.this.type
-
abstract
def
flatten: Array[(String, Bits)]
Concrete Value Members
-
final
def
!=(arg0: AnyRef): Boolean
-
final
def
!=(arg0: Any): Boolean
-
def
##[T <: Data](right: T): Data.this.type
-
-
final
def
##(): Int
-
def
:=(that: Data): Unit
-
def
<>(src: Node): Unit
-
final
def
==(arg0: AnyRef): Boolean
-
final
def
==(arg0: Any): Boolean
-
def
===[T <: Data](right: T): Bool
-
-
def
^^(src: Node): Unit
-
val
_id: Int
-
def
_isComplementOf(x: Node): Boolean
-
def
addConsumers(): Unit
-
def
apply(name: String): Data
-
def
asInput(): Data.this.type
-
final
def
asInstanceOf[T0]: T0
-
def
assign(src: Node): Unit
-
def
canCSE: Boolean
-
lazy val
chiselName: String
-
var
clock: Clock
-
def
clone(): Data.this.type
-
var
cntrIdx: Int
-
def
colonEquals[T <: Data](that: Iterable[T]): Unit
-
def
colonEquals(that: Bundle): Unit
-
def
colonEquals(that: Bits): Unit
-
var
comp: proc
-
var
component: Module
-
def
componentOf: Module
-
val
consumers: ArrayBuffer[Node]
-
var
counter: Bits
-
def
dblLitValue: Double
-
var
depth: Int
-
var
driveRand: Boolean
-
lazy val
emitIndex: Int
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(that: Any): Boolean
-
def
equalsForCSE(x: Node): Boolean
-
def
extract(b: Bundle): List[Node]
-
def
extract(widths: Array[Int]): List[UInt]
-
def
finalize(): Unit
-
def
flip(): Data.this.type
-
def
floLitValue: Float
-
def
forceMatchingWidths: Unit
-
def
fromBits(b: Bits): Data.this.type
-
def
fromNode(n: Node): Data.this.type
-
final
def
getClass(): Class[_]
-
-
def
getNode: Node
-
def
getWidth(): Int
-
def
hashCode(): Int
-
def
hashCodeForCSE: Int
-
def
illegalAssignment(that: Any): Unit
-
def
infer: Boolean
-
var
inferWidth: (Node) ⇒ Int
-
def
init(n: String, w: Int, ins: Node*): Node
-
def
init(n: String, width: (Node) ⇒ Int, ins: Node*): Node
-
def
initOf(n: String, width: (Node) ⇒ Int, ins: Iterable[Node]): Node
-
val
inputs: ArrayBuffer[Node]
-
def
isByValue: Boolean
-
def
isDirectionless: Boolean
-
lazy val
isInObject: Boolean
-
lazy val
isInVCD: Boolean
-
final
def
isInstanceOf[T0]: Boolean
-
def
isIo: Boolean
-
def
isIo_=(isIo: Boolean): Unit
-
final
def
isLit: Boolean
-
def
isReg: Boolean
-
var
isTypeNode: Boolean
-
def
isUsedByClockHi: Boolean
-
var
isWidthWalked: Boolean
-
val
line: StackTraceElement
-
-
def
litValue(default: BigInt = BigInt(-1)): BigInt
-
def
matchWidth(w: Int): Node
-
def
maxNum: BigInt
-
def
maybeFlatten: Seq[Node]
-
def
minNum: BigInt
-
var
name: String
-
-
def
nameIt(path: String, isNamingIo: Boolean): Unit
-
var
named: Boolean
-
final
def
ne(arg0: AnyRef): Boolean
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
var
pName: String
-
-
def
printTree(writer: PrintStream, depth: Int = 4, indent: String = ""): Unit
-
var
prune: Boolean
-
def
removeTypeNodes(): Unit
-
var
sccIndex: Int
-
var
sccLowlink: Int
-
def
setIsTypeNode: Unit
-
def
setName(n: String): Unit
-
def
setPseudoName(path: String, isNamingIo: Boolean): Unit
-
def
setWidth(w: Int): Unit
-
var
shadow: Bits
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
def
terminate(): Unit
-
def
toBits(): UInt
-
def
toBool(): Bool
-
lazy val
toNode: Node
-
def
toString(): String
-
def
traceNode(c: Module, stack: Stack[() ⇒ Any]): Any
-
def
traceableNodes: Array[Node]
-
def
usesInClockHi(i: Node): Boolean
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
def
width: Int
-
var
width_: Int
-
def
width_=(w: Int): Unit
Inherited from AnyRef
Inherited from Any
*Data* is part of the *Node* Composite Pattern class hierarchy. It is the root of the type system which includes composites (Bundle, Vec) and atomic types (UInt, SInt, etc.).
Instances of Data are meant to help with construction and correctness of a logic graph. They will trimmed out of the graph before a *Backend* generates target code.