ReplicatedGossip

abstract def aggregate[A](f: ⇒ A): A

abstract def align[K, V](key: K)(comp: (K) ⇒ V): V

abstract def foldhood[A](init: ⇒ A)(aggr: (A, A) ⇒ A)(expr: ⇒ A): A

abstract def mid(): (StdLib_NewProcesses.this)#ID

abstract def nbr[A](expr: ⇒ A): A

abstract def nbrvar[A](name: (StdLib_NewProcesses.this)#CNAME): A

abstract def rep[A](init: ⇒ A)(fun: (A) ⇒ A): A

abstract def sense[A](name: (StdLib_NewProcesses.this)#CNAME): A

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val LSNS_DELTA_TIME: (StdLib_NewProcesses.this)#CNAME

val LSNS_POSITION: (StdLib_NewProcesses.this)#CNAME

val LSNS_RANDOM: (StdLib_NewProcesses.this)#CNAME

val LSNS_TIME: (StdLib_NewProcesses.this)#CNAME

val LSNS_TIMESTAMP: (StdLib_NewProcesses.this)#CNAME

val NBR_DELAY: (StdLib_NewProcesses.this)#CNAME

val NBR_LAG: (StdLib_NewProcesses.this)#CNAME

val NBR_RANGE: (StdLib_NewProcesses.this)#CNAME

val NBR_VECTOR: (StdLib_NewProcesses.this)#CNAME

object POut extends Serializable

object Spawn

def T[V](initial: V, dt: V)(implicit ev: Numeric[V]): V

def T[V](initial: V)(implicit ev: Numeric[V]): V

def T[V](initial: V, decay: (V) ⇒ V)(implicit ev: Numeric[V]): V

def T[V](initial: V, floor: V, decay: (V) ⇒ V)(implicit ev: Numeric[V]): V

def alignedExecution[K, V](p: (K) ⇒ V)(key: K): V

final def asInstanceOf[T0]: T0

def branch[A](cond: ⇒ Boolean)(th: ⇒ A)(el: ⇒ A): A

def captureChange[T](x: T, initially: Boolean = true): Boolean

def clock[T](length: T, decay: T)(implicit ev: Numeric[T]): Long

def clone(): AnyRef

def constant[T](value: ⇒ T): T

Alias for remember()

def countChanges[T](x: T, initially: Boolean = true): (Long, Boolean)

def cspawn[Key, Args, R](process: (Key) ⇒ (Args) ⇒ (ReplicatedGossip.this)#SpawnReturn[R], newProcesses: Set[Key], args: Args): Map[Key, R]

def csspawn[A, B, C](process: (A) ⇒ (B) ⇒ (C, Status), params: Set[A], args: B): Map[A, C]

def currentPosition(): (StdLib_NewProcesses.this)#P

def currentTime(): (StdLib_NewProcesses.this)#Time

def cuspawn[K, A, R](process: (K) ⇒ (A) ⇒ (ReplicatedGossip.this)#SpawnReturn[R], newKeys: Set[K], args: A): Map[K, R]

def cyclicFunction[T](length: FiniteDuration, f: () ⇒ T, NULL: T): T

Periodically invoke a function.

def cyclicFunctionWithDecay[T, V](length: T, decay: T, f: () ⇒ V, NULL: V)(implicit ev: Numeric[T]): V

Periodically invoke a function.

def cyclicTimer[T](length: T)(implicit ev: Numeric[T]): Boolean

Cyclic timer with a default unitary decay

def cyclicTimerWithDecay[T](length: T, decay: T)(implicit ev: Numeric[T]): Boolean

Cyclic timer.

def delay[T](value: T): T

It is a simple building block which returns the same values it receives in input delayed by one computation round.

def deltaTime(): FiniteDuration

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evaporation[T, V](length: T, info: V)(implicit ev: Numeric[T]): (T, V)

Evaporation pattern.

def evaporation[T, V](length: T, decay: (T) ⇒ T, info: V)(implicit ev: Numeric[T]): (T, V)

Evaporation pattern.

object excludingSelf extends (FieldUtils.this)#FieldOps

def exponentialBackoffFilter[T](signal: T, a: T)(implicit ev: Numeric[T]): T

Exponential back-off filter.

def exportConditionally[R](f: ⇒ (R, Boolean)): (R, Boolean)

def foldhoodPlus[A](init: ⇒ A)(aggr: (A, A) ⇒ A)(expr: ⇒ A): A

final def getClass(): Class[_]

def goesDown(value: Boolean): Boolean

def goesUp(value: Boolean): Boolean

def handleOutput[T](out: (ReplicatedGossip.this)#POut[T]): (ReplicatedGossip.this)#POut[Option[T]]

def handleTermination[T](out: (ReplicatedGossip.this)#POut[T]): (ReplicatedGossip.this)#POut[T]

def handleTerminationWithRep[T](out: (ReplicatedGossip.this)#POut[T]): (ReplicatedGossip.this)#POut[T]

def hashCode(): Int

def impulsesEvery(d: FiniteDuration): Boolean

def impulsesEvery[T](d: T)(implicit arg0: Numeric[T]): Boolean

object includingSelf extends (FieldUtils.this)#FieldOps

final def isInstanceOf[T0]: Boolean

def keep(expr: ⇒ Boolean): Boolean

Remembers the occurrence of some condition or event

def keep[T](expr: ⇒ Option[T]): Option[T]

Remembers the provided optional value, unless empty

def limitedMemory[V, T](value: V, expValue: V, timeout: T)(implicit ev: Numeric[T]): (V, T)

def maxHood[A](expr: ⇒ A)(implicit of: Bounded[A]): A

def maxHoodPlus[A](expr: ⇒ A)(implicit of: Bounded[A]): A

def minHood[A](expr: ⇒ A)(implicit of: Bounded[A]): A

def minHoodLoc[A](default: A)(expr: ⇒ A)(implicit poglb: PartialOrderingWithGLB[A]): A

def minHoodPlus[A](expr: ⇒ A)(implicit of: Bounded[A]): A

def minHoodPlusLoc[A](default: A)(expr: ⇒ A)(implicit poglb: PartialOrderingWithGLB[A]): A

def mux[A](cond: Boolean)(th: A)(el: A): A

def nbrDelay(): FiniteDuration

Time forward view: expected time from the device computation to neighbor's next computation incorporating that information.

def nbrLag(): FiniteDuration

Time backward view: how long ago information from neighbors was received.

def nbrRange(): (StdLib_NewProcesses.this)#D

Get the distance between the current device and its neighbors.

def nbrVector(): (StdLib_NewProcesses.this)#P

Get the direction vectors towards neighbours.

def nbrpath[A](path: (StdLib_NewProcesses.this)#Path)(expr: ⇒ A): A

final def ne(arg0: AnyRef): Boolean

def nextRandom(): Double

final def notify(): Unit

final def notifyAll(): Unit

object on

def once[T](expr: ⇒ T): Option[T]

Returns a non-empty optional with the provided value just once, then None

def processManager[K, A, R](process: (K) ⇒ (A) ⇒ R, generation: () ⇒ Set[K], termination: (K, A, R) ⇒ Boolean): (A) ⇒ Map[K, R]

def randomGenerator(): Random

def recentlyTrue(dur: Duration, cond: ⇒ Boolean): Boolean

def remember[T](value: ⇒ T): T

Remembers the provided value

def replicated[T, R](proc: (T) ⇒ R)(argument: T, period: Double, numReplicates: Int): Map[Long, R]

def replicated2[T, R](proc: (T) ⇒ R)(argument: T, period: Double, numReplicates: Int): Map[Long, R]

def roundCounter(): Long

Counts the number of rounds, refreshing each time the computation is re-entered.

def run[A, B, C](proc: (A) ⇒ (B) ⇒ (ReplicatedGossip.this)#SpawnReturn[C], params: A, args: B): (ReplicatedGossip.this)#SpawnReturn[C]

def runOnSharedKeys[K, A, R](process: (K) ⇒ (R, Boolean), params: Set[K]): Map[K, R]

def runOnSharedKeysWithShare[K, A, R](process: (K) ⇒ (R, Boolean), params: Set[K]): Map[K, R]

def share[A](init: ⇒ A)(f: (A, () ⇒ A) ⇒ A): A

def sharedTimer(period: FiniteDuration): FiniteDuration

def sharedTimerWithDecay[T](period: T, dt: T)(implicit ev: Numeric[T]): T

Timer synchronized within a neighborhood

def simplyReturn[T](expr: ⇒ T): (ReplicatedGossip.this)#IffContinuation[T]

def spawn[K, A, R](process: (K) ⇒ (A) ⇒ (R, Boolean), params: Set[K], args: A): Map[K, R]

def spawn2[K, A, R](process: (K) ⇒ (A) ⇒ (R, Boolean), params: Set[K], args: A): Map[K, R]

def spreadKeys[K, R](newKeys: Set[K])(mapKey: (K) ⇒ (ReplicatedGossip.this)#MapFilter[R]): Map[K, R]

def sspawn[K, A, R](process: (K) ⇒ (A) ⇒ (ReplicatedGossip.this)#POut[R], params: Set[K], args: A): Map[K, R]

def sspawn2[K, A, R](process: (K) ⇒ (A) ⇒ (ReplicatedGossip.this)#POut[R], params: Set[K], args: A): Map[K, R]

def sspawnOld[A, B, C](process: (A) ⇒ (B) ⇒ (C, Status), params: Set[A], args: B): Map[A, C]

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

def timer[V](length: V)(implicit arg0: Numeric[V]): V

def timerLocalTime(dur: Duration): Long

def timestamp(): Long

def toString(): String

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit