CompNodes

Type Members

class CachedAttribute[T, U] extends Attribute[T, U] with org.kiama.attribution.AttributionCore.IdMemoised[T, Option[U]]

Definition Classes
AttributionCore
class CachedDynamicAttribute[T, U] extends CachedAttribute[T, U]

Definition Classes
AttributionCore
class CachedParamAttribute[A, T, U] extends (A) ⇒ Attribute[T, U] with org.kiama.attribution.AttributionCore.Memoised[ParamAttributeKey, Option[U]]

Definition Classes
AttributionCore
class CircularAttribute[T, U] extends Attribute[T, U] with org.kiama.attribution.AttributionCore.IdMemoised[T, U]

Definition Classes
AttributionCore
class ConstantAttribute[T, U] extends Attribute[T, U]

Definition Classes
AttributionCommon
trait IdMemoised[T, U] extends MemoisedBase[T, U]

Definition Classes
Memoiser
trait Memoised[T, U] extends MemoisedBase[T, U]

Definition Classes
Memoiser
trait MemoisedBase[T, U] extends AnyRef

Definition Classes
Memoiser
type T = CompNode

Definition Classes
CompNodes → GraphNodes

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
lazy val allSinks: CachedAttribute[CompNode, Seq[Sink]]

collect all the sinks in the computation graph
collect all the sinks in the computation graph

Attributes
protected
Definition Classes
CompNodes
final def asInstanceOf[T0]: T0

Definition Classes
Any
def attr[T, U](name: String, f: (T) ⇒ U): CachedAttribute[T, U]

Definition Classes
AttributionCore
macro def attr[T, U](f: (T) ⇒ U): CachedAttribute[T, U]

Definition Classes
AttributionCore
def childAttr[T <: Attributable, U](name: String, f: (T) ⇒ (Attributable) ⇒ U): CachedAttribute[T, U]

Definition Classes
AttributionCore
macro def childAttr[T <: Attributable, U](f: (T) ⇒ (Attributable) ⇒ U): CachedAttribute[T, U]

Definition Classes
AttributionCore
lazy val children: CachedAttribute[T, Seq[T]]

compute the children of a node.
compute the children of a node.
This is similar to calling the initTree method on the node but this stores the information as an attribute instead of storing it as a tree. This is a way to avoid conflicts if we have 2 processes trying to initialise the same graph

Definition Classes
GraphNodes
def circular[T, U](name: String, init: U)(f: (T) ⇒ U): CircularAttribute[T, U]

Definition Classes
AttributionCore
macro def circular[T, U](init: U)(f: (T) ⇒ U): CircularAttribute[T, U]

Definition Classes
AttributionCore
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def constant[T, U](name: String, u: ⇒ U): Attribute[T, U]

Definition Classes
AttributionCommon
macro def constant[T, U](u: ⇒ U): Attribute[T, U]

Definition Classes
AttributionCommon
lazy val descendents: CachedAttribute[T, Seq[T]]

compute all the descendents of a node They are all the recursive children reachable from this node
compute all the descendents of a node They are all the recursive children reachable from this node

Definition Classes
GraphNodes
lazy val descendentsUntil: CachedParamAttribute[(T) ⇒ Boolean, T, Seq[T]]

Definition Classes
GraphNodes
def dynAttr[T, U](name: String, f: (T) ⇒ U): CachedDynamicAttribute[T, U]

Definition Classes
AttributionCore
macro def dynAttr[T, U](f: (T) ⇒ U): CachedDynamicAttribute[T, U]

Definition Classes
AttributionCore
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
lazy val filledSink: CachedAttribute[String, String]

this attribute stores the fact that a Sink has received data
this attribute stores the fact that a Sink has received data

Attributes
protected
Definition Classes
CompNodes
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
lazy val hasBeenFilled: (Sink) ⇒ Boolean

returns
true if a given Sink has already received data

Attributes
protected
Definition Classes
CompNodes
def hashCode(): Int

Definition Classes
AnyRef → Any
def initAttributable[S <: T](s: S): S

initialise the parent/child relationship recursively from node s
initialise the parent/child relationship recursively from node s

Definition Classes
GraphNodes
def initTree[T <: Attributable](t: T): Unit

Definition Classes
AttributionCommon
lazy val inputs: CachedAttribute[CompNode, Seq[CompNode]]

compute the inputs of a given node For a ParallelDo node this does not consider its environment
compute the inputs of a given node For a ParallelDo node this does not consider its environment

Definition Classes
CompNodes
implicit def internalToDynamicAttribute[T, U](f: (T) ⇒ U): CachedDynamicAttribute[T, U]

Definition Classes
AttributionCore
lazy val isCyclic: CachedAttribute[T, Boolean]

return true if a CompNode has a cycle in its graph, this will be detected by Kiama throwing an exception when fetching the descendents of a node
return true if a CompNode has a cycle in its graph, this will be detected by Kiama throwing an exception when fetching the descendents of a node

Definition Classes
GraphNodes
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
lazy val isUsedAtMostOnce: CachedAttribute[T, Boolean]

true if a node is used at most once
true if a node is used at most once

Definition Classes
GraphNodes
def markSinkAsFilled: (Sink) ⇒ String

mark a sink as filled so it doesn't have to be recomputed
mark a sink as filled so it doesn't have to be recomputed

Attributes
protected
Definition Classes
CompNodes
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
lazy val nodeHasBeenFilled: (CompNode) ⇒ Boolean

returns
true if a process node has been filled

Attributes
protected
Definition Classes
CompNodes
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def paramAttr[V, T, U](name: String, f: (V) ⇒ (T) ⇒ U): CachedParamAttribute[V, T, U]

Definition Classes
AttributionCore
macro def paramAttr[V, T, U](f: (V) ⇒ (T) ⇒ U): CachedParamAttribute[V, T, U]

Definition Classes
AttributionCore
lazy val parent: CachedAttribute[T, Option[T]]

compute the parent of a node.
compute the parent of a node. This relationship is actually maintained while getting the children of a node if the parent node has not been set while recursing for children, then it is None

Definition Classes
GraphNodes
lazy val parents: CachedAttribute[T, Seq[T]]

compute the parents of a node, that is all the chain of parents from this node up to the root of the graph
compute the parents of a node, that is all the chain of parents from this node up to the root of the graph

Definition Classes
GraphNodes
def reinit[S <: T](s: S): S

reinitialise all the attributes related to a node, starting from all the parent/children relationships
reinitialise all the attributes related to a node, starting from all the parent/children relationships
reset the attributes, then recreate the parent/children relationships recursively

Definition Classes
GraphNodes
def resetMemo(): Unit

Definition Classes
Memoiser
def resetUses: Unit

reinit usages
reinit usages

Attributes
protected
Definition Classes
GraphNodes
lazy val root: CachedAttribute[T, T]

the root of the graph, computed from a given node
the root of the graph, computed from a given node

Definition Classes
GraphNodes
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
lazy val transitiveUses: CachedAttribute[T, Set[T]]

compute all the indirect uses of a given node, that is all the nodes which have this node as a descendent
compute all the indirect uses of a given node, that is all the nodes which have this node as a descendent

Definition Classes
GraphNodes
def tree[T <: Attributable, U <: Attributable](name: String, f: (T) ⇒ U): CachedAttribute[T, U]

Definition Classes
AttributionCore
macro def tree[T <: Attributable, U <: Attributable](f: (T) ⇒ U): CachedAttribute[T, U]

Definition Classes
AttributionCore
lazy val uses: CachedAttribute[T, Set[T]]

the nodes which have this node as a direct child
the nodes which have this node as a direct child
for efficiency, this uses a table of all the nodes using a given one, computed from the root

Definition Classes
GraphNodes
def usesAsEnvironment: CachedAttribute[CompNode, Seq[ParallelDo]]

compute all the nodes which use a given node as an environment
compute all the nodes which use a given node as an environment

Definition Classes
CompNodes
final def wait(): Unit

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

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

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: trait CompNodes | package comp

object CompNodes extends CompNodes

Type Members

class CachedAttribute[T, U] extends Attribute[T, U] with org.kiama.attribution.AttributionCore.IdMemoised[T, Option[U]]

class CachedDynamicAttribute[T, U] extends CachedAttribute[T, U]

class CachedParamAttribute[A, T, U] extends (A) ⇒ Attribute[T, U] with org.kiama.attribution.AttributionCore.Memoised[ParamAttributeKey, Option[U]]

class CircularAttribute[T, U] extends Attribute[T, U] with org.kiama.attribution.AttributionCore.IdMemoised[T, U]

class ConstantAttribute[T, U] extends Attribute[T, U]

trait IdMemoised[T, U] extends MemoisedBase[T, U]

trait Memoised[T, U] extends MemoisedBase[T, U]

trait MemoisedBase[T, U] extends AnyRef

type T = CompNode

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

lazy val allSinks: CachedAttribute[CompNode, Seq[Sink]]

final def asInstanceOf[T0]: T0

def attr[T, U](name: String, f: (T) ⇒ U): CachedAttribute[T, U]

macro def attr[T, U](f: (T) ⇒ U): CachedAttribute[T, U]

def childAttr[T <: Attributable, U](name: String, f: (T) ⇒ (Attributable) ⇒ U): CachedAttribute[T, U]

macro def childAttr[T <: Attributable, U](f: (T) ⇒ (Attributable) ⇒ U): CachedAttribute[T, U]

lazy val children: CachedAttribute[T, Seq[T]]

def circular[T, U](name: String, init: U)(f: (T) ⇒ U): CircularAttribute[T, U]

macro def circular[T, U](init: U)(f: (T) ⇒ U): CircularAttribute[T, U]

def clone(): AnyRef

def constant[T, U](name: String, u: ⇒ U): Attribute[T, U]

macro def constant[T, U](u: ⇒ U): Attribute[T, U]

lazy val descendents: CachedAttribute[T, Seq[T]]

lazy val descendentsUntil: CachedParamAttribute[(T) ⇒ Boolean, T, Seq[T]]

def dynAttr[T, U](name: String, f: (T) ⇒ U): CachedDynamicAttribute[T, U]

macro def dynAttr[T, U](f: (T) ⇒ U): CachedDynamicAttribute[T, U]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

lazy val filledSink: CachedAttribute[String, String]

def finalize(): Unit

final def getClass(): Class[_]

lazy val hasBeenFilled: (Sink) ⇒ Boolean

def hashCode(): Int

def initAttributable[S <: T](s: S): S

def initTree[T <: Attributable](t: T): Unit

lazy val inputs: CachedAttribute[CompNode, Seq[CompNode]]

implicit def internalToDynamicAttribute[T, U](f: (T) ⇒ U): CachedDynamicAttribute[T, U]

lazy val isCyclic: CachedAttribute[T, Boolean]

final def isInstanceOf[T0]: Boolean

lazy val isUsedAtMostOnce: CachedAttribute[T, Boolean]

def markSinkAsFilled: (Sink) ⇒ String

final def ne(arg0: AnyRef): Boolean

lazy val nodeHasBeenFilled: (CompNode) ⇒ Boolean

final def notify(): Unit

final def notifyAll(): Unit

def paramAttr[V, T, U](name: String, f: (V) ⇒ (T) ⇒ U): CachedParamAttribute[V, T, U]

macro def paramAttr[V, T, U](f: (V) ⇒ (T) ⇒ U): CachedParamAttribute[V, T, U]

lazy val parent: CachedAttribute[T, Option[T]]

lazy val parents: CachedAttribute[T, Seq[T]]

def reinit[S <: T](s: S): S

def resetMemo(): Unit

def resetUses: Unit

lazy val root: CachedAttribute[T, T]

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

def toString(): String

lazy val transitiveUses: CachedAttribute[T, Set[T]]

def tree[T <: Attributable, U <: Attributable](name: String, f: (T) ⇒ U): CachedAttribute[T, U]

macro def tree[T <: Attributable, U <: Attributable](f: (T) ⇒ U): CachedAttribute[T, U]

lazy val uses: CachedAttribute[T, Set[T]]

def usesAsEnvironment: CachedAttribute[CompNode, Seq[ParallelDo]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from CompNodes

Inherited from GraphNodes

Inherited from AttributionCore

Inherited from Memoiser

Inherited from AttributionCommon

Inherited from AnyRef

Inherited from Any

Ungrouped