RunLoop

Type Members

type FrameId = Int

An alias for a number representing an ID for the current stack frame.
class Macros extends HygieneUtilMacros with InlineMacros

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
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

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

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
macro def isAlwaysAsync(implicit s: Scheduler): Boolean

Returns true if the run-loop implied by the given Scheduler is always doing asynchronous execution or not.
Returns true if the run-loop implied by the given Scheduler is always doing asynchronous execution or not.
Note that when isAlwaysAsync is true, that means that RunLoop.start, RunLoop.step.
s
is the Scheduler that drives our run-loop.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
macro def start(runnable: (FrameId) ⇒ Unit)(implicit s: Scheduler): Unit

Executes the given callback, effectively starting a run-loop.
Executes the given callback, effectively starting a run-loop.
Depending on Scheduler.batchedExecutionModulus, execution will happen either synchronously (current thread and call-stack) or scheduled for asynchronous execution (by Scheduler.execute). To find out what will happen before calling start, you can use the RunLoop.isAlwaysAsync helper.
runnable
is an expression receiving the next FrameId at the time of execution, to be used in the next runLoop invocation.
s
is the Scheduler that drives our run-loop.
macro def startAsync(runnable: (FrameId) ⇒ Unit)(implicit s: Scheduler): Unit

Executes the given callback, forcing an asynchronous boundary and starting a run-loop.
Executes the given callback, forcing an asynchronous boundary and starting a run-loop.
Compared with RunLoop.start this macro always executes the given runnable asynchronously.
runnable
is an expression receiving the next FrameId at the time of execution, to be used in the next runLoop invocation.
s
is the Scheduler that drives our run-loop.
macro def startNow(runnable: (FrameId) ⇒ Unit)(implicit s: Scheduler): Unit

Executes the given callback immediately, irregardless of the Scheduler configuration.
Executes the given callback immediately, irregardless of the Scheduler configuration.
Compared with RunLoop.start this macro always executes the given runnable immediately.
runnable
is an expression to execute, receiving the next FrameId at the time of execution, to be used in the next runLoop invocation.
s
is the Scheduler that drives our run-loop.
macro def step(frameId: FrameId)(runnable: (FrameId) ⇒ Unit)(implicit s: Scheduler): Unit

Given the current frameId, executes the given callback.
Given the current frameId, executes the given callback.
Depending on Scheduler.batchedExecutionModulus, execution will happen either synchronously (current thread and call-stack) or scheduled for asynchronous execution (by Scheduler.execute).
frameId
is a number identifying the current stack frame. Should start from zero.
runnable
is an expression receiving the next FrameId at the time of execution, to be used in the next runLoop invocation.
s
is the Scheduler that drives our run-loop.
macro def stepInterruptibly(active: BooleanCancelable, frameId: FrameId)(runnable: (FrameId) ⇒ Unit)(implicit s: Scheduler): Unit

Given the current frameId, executes the given callback.
Given the current frameId, executes the given callback. Takes a BooleanCancelable as a parameter that can be used to cancel the loop.
Depending on Scheduler.batchedExecutionModulus, execution will happen either synchronously (current thread and call-stack) or scheduled for asynchronous execution (by Scheduler.execute).
active
is a cancelable that can be used to check if the run-loop is canceled and thus avoid to trigger the next step. Note that checking active.isCanceled is weak and only happens on asynchronous boundaries for performance reasons (in other words don't count on cancellation to be immediate).
frameId
is a number identifying the current stack frame. Should start from zero.
runnable
is a callback receiving the next FrameId at the time of execution, to be used in the next runLoop invocation.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
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 Doc: package execution

object RunLoop

Type Members

type FrameId = Int

class Macros extends HygieneUtilMacros with InlineMacros

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

macro def isAlwaysAsync(implicit s: Scheduler): Boolean

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

macro def start(runnable: (FrameId) ⇒ Unit)(implicit s: Scheduler): Unit

macro def startAsync(runnable: (FrameId) ⇒ Unit)(implicit s: Scheduler): Unit

macro def startNow(runnable: (FrameId) ⇒ Unit)(implicit s: Scheduler): Unit

macro def step(frameId: FrameId)(runnable: (FrameId) ⇒ Unit)(implicit s: Scheduler): Unit

macro def stepInterruptibly(active: BooleanCancelable, frameId: FrameId)(runnable: (FrameId) ⇒ Unit)(implicit s: Scheduler): Unit

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped