ExecutionMode

implicit abstract def modeLogger: Log

abstract def sinksToSave(node: CompNode): Seq[Sink]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def addParallelDoForNonFilledSinks: Strategy

add a map to output values to non-filled sink nodes if there are some

def all(name: String, s: ⇒ Strategy): Strategy

macro def all(s: Strategy): Strategy

def allMap[CC[V, W] <: Map[V, W]](s: Strategy, t: CC[Any, Any])(implicit cbf: CanBuildFrom[CC[Any, Any], (Any, Any), CC[Any, Any]]): Option[CC[Any, Any]]

def allProduct(s: Strategy, p: Product): Option[Any]

def allRewritable(s: Strategy, r: Rewritable): Option[Any]

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

collect all the sinks in the computation graph

def allStrategies: Strategy

all the strategies to apply, in sequence

def allTraversable[CC[U] <: Traversable[U]](s: Strategy, t: CC[Any])(implicit cbf: CanBuildFrom[CC[Any], Any, CC[Any]]): Option[CC[Any]]

def allbu(name: String, s: Strategy): Strategy

macro def allbu(s: Strategy): Strategy

def alldownup2(name: String, s1: Strategy, s2: Strategy): Strategy

macro def alldownup2(s1: Strategy, s2: Strategy): Strategy

def alltd(name: String, s: Strategy): Strategy

macro def alltd(s: Strategy): Strategy

def alltdfold(name: String, s1: Strategy, s2: Strategy): Strategy

macro def alltdfold(s1: Strategy, s2: Strategy): Strategy

def and(name: String, s1: Strategy, s2: Strategy): Strategy

macro def and(s1: Strategy, s2: Strategy): Strategy

final def asInstanceOf[T0]: T0

def attempt(name: String, s: Strategy): Strategy

macro def attempt(s: Strategy): Strategy

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

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

def bottomup(name: String, s: Strategy): Strategy

macro def bottomup(s: Strategy): Strategy

def bottomupS(name: String, s: Strategy, stop: (⇒ Strategy) ⇒ Strategy): Strategy

macro def bottomupS(s: Strategy, stop: (⇒ Strategy) ⇒ Strategy): Strategy

def breadthfirst(name: String, s: Strategy): Strategy

macro def breadthfirst(s: Strategy): Strategy

def build(name: String, t: ⇒ Any): Strategy

macro def build(t: Any): Strategy

def checkSourceAndSinks(node: CompNode)(implicit sc: ScoobiConfiguration): Unit

def child(name: String, i: Int, s: ⇒ Strategy): Strategy

macro def child(i: Int, s: Strategy): Strategy

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]

def childProduct(s: Strategy, i: Int, p: Product): Option[Any]

def childSeq[CC[U] <: Seq[U]](s: Strategy, i: Int, t: CC[Any])(implicit cbf: CanBuildFrom[CC[Any], Any, CC[Any]]): Option[CC[Any]]

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

compute the children of a node.

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

macro def collect[CC[X] <: Traversable[X], U](f: ==>[Any, U])(implicit cbf: CanBuildFrom[CC[Any], U, CC[U]]): (Any) ⇒ CC[U]

def collectWithName[CC[X] <: Traversable[X], U](name: String, f: ==>[Any, U])(implicit cbf: CanBuildFrom[CC[Any], U, CC[U]]): (Any) ⇒ CC[U]

macro def collectall[CC[X] <: Traversable[X], U](f: ==>[Any, CC[U]])(implicit cbf: CanBuildFrom[CC[Any], U, CC[U]]): (Any) ⇒ CC[U]

def collectallWithName[CC[X] <: Traversable[X], U](name: String, f: ==>[Any, CC[U]])(implicit cbf: CanBuildFrom[CC[Any], U, CC[U]]): (Any) ⇒ CC[U]

def collectl[U](f: ==>[Any, U]): (Any) ⇒ List[U]

def collects[U](f: ==>[Any, U]): (Any) ⇒ Set[U]

def combineToParDo: Strategy

Combine nodes which are not the output of a GroupByKey must be transformed to a ParallelDo

def congruence(name: String, ss: Strategy*): Strategy

macro def congruence(ss: Strategy*): Strategy

def congruenceProduct(p: Product, ss: Strategy*): Option[Any]

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

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

def count(name: String, f: ==>[Any, Int]): (Any) ⇒ Int

macro def count(f: ==>[Any, Int]): (Any) ⇒ Int

def debug(name: String, msg: String, emitter: Emitter): Strategy

macro def debug(msg: String, emitter: Emitter): Strategy

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

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

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

def doloop(name: String, s: Strategy, r: Strategy): Strategy

macro def doloop(s: Strategy, r: Strategy): Strategy

def dontstop(s: ⇒ Strategy): Strategy

def downup(name: String, s1: Strategy, s2: Strategy): Strategy

def downup(name: String, s: Strategy): Strategy

macro def downup(s1: Strategy, s2: Strategy): Strategy

macro def downup(s: Strategy): Strategy

def downupS(name: String, s1: Strategy, s2: Strategy, stop: (⇒ Strategy) ⇒ Strategy): Strategy

def downupS(name: String, s: Strategy, stop: (⇒ Strategy) ⇒ Strategy): Strategy

macro def downupS(s1: Strategy, s2: Strategy, stop: (⇒ Strategy) ⇒ Strategy): Strategy

macro def downupS(s: Strategy, stop: (⇒ Strategy) ⇒ Strategy): Strategy

def dup[T <: Product](t: T, children: Seq[AnyRef]): T

lazy val duplicate: (CompNode) ⇒ CompNode

duplicate the whole graph by copying all nodes

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

val eq: Strategy

val equal: Strategy

def equals(arg0: Any): Boolean

def everything[T](name: String, v: T)(f: (T, T) ⇒ T)(g: ==>[Any, T])(t: Any): T

macro def everything[T](v: T)(f: (T, T) ⇒ T)(g: ==>[Any, T])(t: Any): T

def everywhere(name: String, s: Strategy): Strategy

macro def everywhere(s: Strategy): Strategy

def everywherebu(name: String, s: Strategy): Strategy

macro def everywherebu(s: Strategy): Strategy

def everywheretd(name: String, s: Strategy): Strategy

macro def everywheretd(s: Strategy): Strategy

val fail: Strategy

lazy val filledSink: CachedAttribute[String, String]

this attribute stores the fact that a Sink has received data

def finalize(): Unit

final def getClass(): Class[_]

lazy val hasBeenFilled: (Sink) ⇒ Boolean

def hashCode(): Int

val id: Strategy

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

initialise the parent/child relationship recursively from node s

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

def innermost(name: String, s: Strategy): Strategy

macro def innermost(s: Strategy): Strategy

def innermost2(name: String, s: Strategy): Strategy

macro def innermost2(s: Strategy): Strategy

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

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

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

def ior(name: String, s1: Strategy, s2: Strategy): Strategy

macro def ior(s1: Strategy, s2: Strategy): Strategy

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

def isDefinedAtArg[T](anyf: ==>[Any, T], t: Any): Boolean

final def isInstanceOf[T0]: Boolean

lazy val isUsedAtMostOnce: CachedAttribute[T, Boolean]

true if a node is used at most once

val isinnernode: Strategy

val isleaf: Strategy

val ispropersubterm: Strategy

val ispropersuperterm: Strategy

val issubterm: Strategy

val issuperterm: Strategy

def lastly(name: String, s: Strategy, f: Strategy): Strategy

macro def lastly(s: Strategy, f: Strategy): Strategy

def leaves(name: String, s: Strategy, isleaf: Strategy, skip: (Strategy) ⇒ Strategy): Strategy

def leaves(name: String, s: Strategy, isleaf: Strategy): Strategy

macro def leaves(s: Strategy, isleaf: Strategy, skip: (Strategy) ⇒ Strategy): Strategy

macro def leaves(s: Strategy, isleaf: Strategy): Strategy

def log(name: String, s: ⇒ Strategy, msg: String, emitter: Emitter): Strategy

macro def log(s: Strategy, msg: String, emitter: Emitter): Strategy

def logfail[T](name: String, s: ⇒ Strategy, msg: String, emitter: Emitter): Strategy

macro def logfail[T](s: Strategy, msg: String, emitter: Emitter): Strategy

def loop(name: String, c: Strategy, s: Strategy): Strategy

macro def loop(r: Strategy, s: Strategy): Strategy

def loopiter(name: String, s: (Int) ⇒ Strategy, low: Int, high: Int): Strategy

def loopiter(name: String, i: Strategy, r: Strategy, s: Strategy): Strategy

macro def loopiter(s: (Int) ⇒ Strategy, low: Int, high: Int): Strategy

macro def loopiter(i: Strategy, r: Strategy, s: Strategy): Strategy

def loopnot(name: String, r: Strategy, s: Strategy): Strategy

macro def loopnot(r: Strategy, s: Strategy): Strategy

def makechild(c: Any): AnyRef

def manybu(name: String, s: Strategy): Strategy

macro def manybu(s: Strategy): Strategy

def manytd(name: String, s: Strategy): Strategy

macro def manytd(s: Strategy): Strategy

def map(name: String, s: Strategy): Strategy

macro def map(s: Strategy): Strategy

def markSinkAsFilled: (Sink) ⇒ String

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

def memo(name: String, s: ⇒ Strategy): Strategy

macro def memo(s: Strategy): Strategy

def mkStrategy(name: String, f: (Any) ⇒ Option[Any]): Strategy

def mustBeRead(pd: ParallelDo): Boolean

final def ne(arg0: AnyRef): Boolean

lazy val nodeHasBeenFilled: (CompNode) ⇒ Boolean

def not(name: String, s: Strategy): Strategy

macro def not(s: Strategy): Strategy

final def notify(): Unit

final def notifyAll(): Unit

def oncebu(name: String, s: Strategy): Strategy

macro def oncebu(s: Strategy): Strategy

def oncetd(name: String, s: Strategy): Strategy

macro def oncetd(s: Strategy): Strategy

def one(name: String, s: ⇒ Strategy): Strategy

macro def one(s: Strategy): Strategy

def oneMap[CC[V, W] <: Map[V, W]](s: Strategy, t: CC[Any, Any])(implicit cbf: CanBuildFrom[CC[Any, Any], (Any, Any), CC[Any, Any]]): Option[CC[Any, Any]]

def oneProduct(s: Strategy, p: Product): Option[Any]

def oneRewritable(s: Strategy, r: Rewritable): Option[Any]

def oneTraversable[CC[U] <: Traversable[U]](s: Strategy, t: CC[Any])(implicit cbf: CanBuildFrom[CC[Any], Any, CC[Any]]): Option[CC[Any]]

def optimise(outputs: Seq[CompNode]): Seq[CompNode]

Optimise a set of CompNodes, starting from the set of outputs

def option(name: String, o: ⇒ Option[Any]): Strategy

macro def option(o: Option[Any]): Strategy

def or(name: String, s1: Strategy, s2: Strategy): Strategy

macro def or(s1: Strategy, s2: Strategy): Strategy

def outermost(name: String, s: Strategy): Strategy

macro def outermost(s: Strategy): Strategy

def parDoFuse: Strategy

Nested ParallelDos must be fused but only if pd1 is not used anywhere else.

def parDoFuseRule: Strategy

def parDoFuseSource: Strategy

def parDoFuseSourceRule: Strategy

def para[T](f: (Any, Seq[T]) ⇒ T): (Any) ⇒ T

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]]

compute the parent of a node.

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

def prepare(node: CompNode)(implicit sc: ScoobiConfiguration): CompNode

prepare the execution graph by: - initialising the nodes - truncating the graph if some nodes have already been executed - checking the sources and sinks

def pretty(node: CompNode): (prettyPrinter)#Layout

def prettyGraph: (CompNode) ⇒ (prettyPrinter)#Layout

val prettyPrinter: PrettyPrinter

macro def query[T](f: ==>[T, Unit]): Strategy

def queryWithName[T](name: String, f: ==>[T, Unit]): Strategy

def queryf(name: String, f: (Any) ⇒ Unit): Strategy

macro def queryf(f: (Any) ⇒ Unit): Strategy

def reduce(name: String, s: Strategy): Strategy

macro def reduce(s: Strategy): Strategy

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

reinitialise all the attributes related to a node, starting from all the parent/children relationships

def repeat(name: String, s: Strategy, n: Int): Strategy

def repeat(name: String, s: Strategy, r: Strategy): Strategy

def repeat(name: String, s: Strategy): Strategy

macro def repeat(s: Strategy, n: Int): Strategy

macro def repeat(s: Strategy, r: Strategy): Strategy

macro def repeat(s: Strategy): Strategy

def repeat1(name: String, s: Strategy, r: Strategy): Strategy

def repeat1(name: String, s: Strategy): Strategy

macro def repeat1(s: Strategy, r: Strategy): Strategy

macro def repeat1(s: Strategy): Strategy

def repeatTraversal(traversal: (String, Strategy) ⇒ Strategy, s: Strategy): Strategy

apply a traversal strategy but make sure that:

def repeatuntil(name: String, s: Strategy, r: Strategy): Strategy

macro def repeatuntil(s: Strategy, r: Strategy): Strategy

def resetMemo(): Unit

def resetUses: Unit

reinit usages

def restore(name: String, s: Strategy, rest: Strategy): Strategy

macro def restore(s: Strategy, rest: Strategy): Strategy

def restorealways(name: String, s: Strategy, rest: Strategy): Strategy

macro def restorealways(s: Strategy, rest: Strategy): Strategy

def rewrite[T](s: Strategy)(t: T): T

lazy val root: CachedAttribute[T, T]

the root of the graph, computed from a given node

macro def rule[T](f: ==>[T, T]): Strategy

def ruleWithName[T](name: String, f: ==>[T, T]): Strategy

def rulef(name: String, f: (Any) ⇒ Any): Strategy

macro def rulef(f: (Any) ⇒ Any): Strategy

macro def rulefs[T](f: ==>[T, Strategy]): Strategy

def rulefsWithName[T](name: String, f: ==>[T, Strategy]): Strategy

def saveSinks(values: Seq[Any], node: CompNode)(implicit sc: ScoobiConfiguration): Unit

implicit lazy val showCompNode: Show[CompNode]

Show instance for a CompNode

implicit def showCompNodeInstance[T <: CompNode]: Show[T]

Show is not covariant so it is necessary to add this implicit to prove that we can show subclasses of CompNode

def showPlanOnly(implicit sc: ScoobiConfiguration): Boolean

lazy val showStructure: (CompNode) ⇒ String

show the structure without the ids or type annotations

def some(name: String, s: ⇒ Strategy): Strategy

macro def some(s: Strategy): Strategy

def someMap[CC[V, W] <: Map[V, W]](s: Strategy, t: CC[Any, Any])(implicit cbf: CanBuildFrom[CC[Any, Any], (Any, Any), CC[Any, Any]]): Option[CC[Any, Any]]

def someProduct(s: Strategy, p: Product): Option[Any]

def someRewritable(s: Strategy, r: Rewritable): Option[Any]

def someTraversable[CC[U] <: Traversable[U]](s: Strategy, t: CC[Any])(implicit cbf: CanBuildFrom[CC[Any], Any, CC[Any]]): Option[CC[Any]]

def somebu(name: String, s: Strategy): Strategy

macro def somebu(s: Strategy): Strategy

def somedownup(name: String, s: Strategy): Strategy

macro def somedownup(s: Strategy): Strategy

def sometd(name: String, s: Strategy): Strategy

macro def sometd(s: Strategy): Strategy

def sourcesCanBeFused(ld: Load, pdNodes: Seq[CompNode]): Boolean

macro def strategy[T](f: ==>[T, Option[T]]): Strategy

def strategyWithName[T](name: String, f: ==>[T, Option[T]]): Strategy

def strategyf(name: String, f: (Any) ⇒ Option[Any]): Strategy

macro def strategyf(f: (Any) ⇒ Option[Any]): Strategy

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

macro def term[T](t: T): Strategy

def termWithName[T](name: String, t: T): Strategy

def test(name: String, s: Strategy): Strategy

macro def test(s: Strategy): Strategy

def toString(): String

def topdown(name: String, s: Strategy): Strategy

macro def topdown(s: Strategy): Strategy

def topdownS(name: String, s: Strategy, stop: (⇒ Strategy) ⇒ Strategy): Strategy

macro def topdownS(s: Strategy, stop: (⇒ Strategy) ⇒ Strategy): Strategy

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

def traverseOncebu(s: Strategy): Strategy

def traverseSomebu(s: Strategy): Strategy

def traverseSometd(s: Strategy): Strategy

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]

def truncate(node: CompNode)(condition: (Any) ⇒ Boolean): CompNode

remove nodes from the tree based on a predicate

def truncateAlreadyExecutedNodes(node: CompNode)(implicit sc: ScoobiConfiguration): CompNode

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

the nodes which have this node as a direct child

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

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def where(name: String, s: Strategy): Strategy

macro def where(s: Strategy): Strategy