Bool

final def !=(arg0: Any): Boolean

def ##(right: Data): Bits

final def ##(): Int

def &(b: Bool): Bool

Logical AND operator

def &&(b: Bool): Bool

Logical AND

def :=(that: Bool): Unit

def <>(that: Bool): Unit

def =/=(that: Bool): Bool

final def ==(arg0: Any): Boolean

def ===(that: Bool): Bool

def ?[T <: SpinalEnum](whenTrue: SpinalEnumCraft[T]): MuxBuilderEnum[T]

Conditional operation for Enumeration value

def ?[T <: Data](whenTrue: T): MuxBuilder[T]

Conditional operation for Data value

def \(that: Bool): Bool

def ^(b: Bool): Bool

Logical XOR operator

var _spinalTags: Set[SpinalTag]

def addAttribute(attribute: Attribute): Bool.this.type

def addAttribute(name: String, value: String): Bool.this.type

def addAttribute(name: String): Bool.this.type

def addTag(spinalTag: SpinalTag): Bool.this.type

def addTags(tags: Iterable[SpinalTag]): Bool.this.type

def allowPruning(): Unit

def allowSimplifyIt(): Bool.this.type

def asBits: Bits

def asBits(bitCount: BitCount): Bits

Transform a Bool to an Bits of a given width

def asData: Data

def asDirectionLess(): Bool.this.type

def asInput(): Bool.this.type

final def asInstanceOf[T0]: T0

def asOutput(): Bool.this.type

def asSInt: SInt

Transform a Bool to an SInt

def asUInt(bitCount: BitCount): UInt

Transform a Bool to an UInt of a given width

def asUInt: UInt

Transform a Bool to an UInt

def assignDontCare(): Bool.this.type

final def assignFrom(that: AnyRef, conservative: Boolean): Unit

def assignFromBits(bits: Bits, hi: Int, low: Int): Unit

def assignFromBits(bits: Bits): Unit

def assignFromBits(bits: Bits, offset: Int, bitCount: BitCount): Unit

var assignementThrowable: Throwable

def clear(): Unit

Bool is assigned to False

def clearWhen(cond: Bool): Bool

Bool is assigned to False when cond is True

def clone(): Bool.this.type

var component: Component

var compositeAssign: Assignable

val consumers: ArrayBuffer[Node]

def default(that: ⇒ Bool): Bool

var defaultValue: BaseType

def dontSimplifyIt(): Bool.this.type

def edge(): Bool

Edge detection

def edge(initAt: Bool): Bool

Edge detection with an initial value

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def existsTag(cond: (SpinalTag) ⇒ Boolean): Boolean

def fall(): Bool

Falling edge detection

def fall(initAt: Bool): Bool

Falling edge detection with an initial value

def filterTag(cond: (SpinalTag) ⇒ Boolean): Iterable[SpinalTag]

def finalize(): Unit

def findTag(cond: (SpinalTag) ⇒ Boolean): Option[SpinalTag]

def flatten: Seq[BaseType]

def flattenLocalName: Seq[String]

def flip(): Bool.this.type

def forEachNameables(doThat: (Any) ⇒ Unit): Unit

def genIf(cond: Boolean): Bool.this.type

def getAssignementContext(id: Int): Throwable

def getBitsWidth: Int

final def getClass(): Class[_]

def getComponent(): Component

def getComponents(): Seq[Component]

def getDisplayName(): String

def getDrivingReg: Bool.this.type

def getInput(id: Int): Node

def getInputs: Iterator[Node]

def getInputsCount: Int

def getInstanceCounter: Int

def getName(): String

def getName(default: String): String

def getRefOwnersChain(): List[Any]

def getRootParent: Data

def getScalaLocationLong: String

def getScalaLocationShort: String

def getTag[T <: SpinalTag](clazz: Class[T]): Option[T]

def getZero: Bool.this.type

val globalData: GlobalData

def hasTag(spinalTag: SpinalTag): Boolean

def hashCode(): Int

def init(that: Bool): Bool

var input: Node

def instanceAndSyncNodeAttributes: Iterable[Attribute]

def instanceAttributes: Iterable[Attribute]

def isDelay: Boolean

def isDirectionLess: Boolean

def isEmptyOfTag: Boolean

def isInput: Boolean

final def isInstanceOf[T0]: Boolean

def isNamed: Boolean

def isOutput: Boolean

def isReg: Boolean

def isUnnamed: Boolean

def keep(): Bool.this.type

def mux[T <: Data](mappings: (Any, T)*): T

def muxList[T <: Data](mappings: Seq[(Any, T)]): T

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onEachAttributes(doIt: (Attribute) ⇒ Unit): Unit

def onEachInput(doThat: (Node) ⇒ Unit): Unit

def onEachInput(doThat: (Node, Int) ⇒ Unit): Unit

var parent: Data

def pull(): Bool.this.type

def randBoot(): Bool.this.type

var refOwner: RefOwnerType

def removeAssignements(): Unit

def removeTag(spinalTag: SpinalTag): Bool.this.type

def removeTags(tags: Iterable[SpinalTag]): Bool.this.type

def resized: Bool.this.type

def rise(): Bool

Rising edge detection

def rise(initAt: Bool): Bool

Rising edge detection with an initial value

def set(): Unit

Bool is assigned to True

def setAssignementContext(id: Int, that: Throwable): Unit

def setCompositeName(nameable: Nameable, postfix: String, weak: Boolean): Bool.this.type

def setCompositeName(nameable: Nameable, postfix: String): Bool.this.type

def setCompositeName(nameable: Nameable, weak: Boolean): Bool.this.type

def setCompositeName(nameable: Nameable): Bool.this.type

def setInput(id: Int, node: Node): Unit

def setName(name: String, weak: Boolean = false): Bool.this.type

def setPartialName(name: String, weak: Boolean): Bool.this.type

def setPartialName(owner: Nameable, name: String, weak: Boolean): Bool.this.type

def setPartialName(name: String): Bool.this.type

def setPartialName(owner: Nameable, name: String): Bool.this.type

def setRefOwner(that: Any): Unit

def setWeakName(name: String): Bool.this.type

def setWhen(cond: Bool): Bool

Bool is assigned to True when cond is True

def simplifyNode: Unit

def spinalTags: Set[SpinalTag]

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

def toString(): String

def unary_!(): Bool

Logical NOT

def unary_~(): Bool

Inverse operator

def unsetName(): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def wrapCast[T <: BaseType](result: T, node: Cast): T

def |(b: Bool): Bool

Logical OR operator

def ||(b: Bool): Bool

Logical OR

def !==(that: Bool): Bool

def unused: Unit