Packages

  • package root
    Definition Classes
    root
  • package io

    This is the documentation for the ThreadCSO Library.

    This is the documentation for the ThreadCSO Library. Notable packages include:

    Definition Classes
    root
  • package threadcso

    The standard threadCSO API.

    The standard threadCSO API. Most modules using CSO will need only the declaration:

    import io.threadcso._

    The present version of the ThreadCSO library API is 1.2Rr (for some number r)

    The revision number (Rr) will change if bugs are corrected but the code remains consistent with the previous API. Its minor version number will change if there is a correction to the code that breaks consistency with the previous API. Its major version will change if there is a substantial change in the semantics of an important CSO construct.

    August 2017: changes 1.1 => 1.2

    • renaming of very many internal classes and packages
    • basic channel implementations are more efficient, in some case much more so
    • alternation reliability improved
    • debugger registration of alternations is no longer needed
    • home-grown semaphores can specify which component they are part of: this makes interpreting a stack backtrace very much easier
    • there is a flexible logging system that is compatible with the debugger

    April 2016: changes 1.0 => 1.1

    • Extended rendezvous read operator is now ?? (was ?)
    • Extended rendezvous read event notation is now =??=> (was =?=>>)
    • The notation inport ? f is now equivalent to f(inport?()) This makes for a tidier layout when the function f is an explicit functional expression.

    Feb 1 2017: changes 1.1R1 => 1.1R2

    • Removed dependencies on deprecated Java->Scala functions: replaced with .asJava
    @author Bernard Sufrin, Oxford
    $Revision: 286 $
    $Date: 2017-11-18 17:41:30 +0000 (Sat, 18 Nov 2017) $
    Definition Classes
    io
  • package alternation
    Definition Classes
    threadcso
  • package channel

    This package defines channels that can participate in the CSO alternation constructs.

    This package defines channels that can participate in the CSO alternation constructs.

    I have separated syntax and semantics as far as was practical, given my reluctance to get embroiled with the Scala macro system (it was unstable when the CSO work started)

    An io.threadcso.alternation.Run embodies the state of execution of an alternation.

    The guarded event notation: (guard && port) =...=> { .... } is parsed to a Guarded...Port =...=> ... then to an appropriate class of event. The former is achieved by defining the implicit class io.threadcso.Guarded in the top-level CSO API. This provides the appropriate extension to Boolean.

    @author Bernard Sufrin, Oxford
    $Revision: 240 $
    $Date: 2017-10-13 18:12:11 +0100 (Fri, 13 Oct 2017) $
    Definition Classes
    alternation
  • package event

    This package implements the syntax of the CSO alternation notations, and provides hooks for the semantics of that notation.

    This package implements the syntax of the CSO alternation notations, and provides hooks for the semantics of that notation.

    The body of an alternation specification consists of a sequence (possibly empty) of executable event specifications separated by | and possibly followed by:

    | after(timeout) ==> { ... }

    or

    | orelse ==> { ... }

    or

    | after(timeout) ==> { ... } |  orelse ==> { ... }

    An executable event specification takes one of the following forms:

    outport              =!=>  OutEvent
    (guard && outport)   =!=>  OutEvent
    inport               =?=>  InEvent
    (guard && inport)    =?=>  InEvent
    inport               =??=> InEvent     // extended rendezvous form
    (guard && inport)    =??=> InEvent     // extended rendezvous form

    Concessions to readability: a Chan expression may appear in place of a port expression.

    Events and their effects

    OutEvent form:                        Effect when triggered
    {expr}                                outport!expr
    {expr} ==> { command: Unit }          {outport!expr; command}
    InEvent form:                         Effect when triggered
    { bv => body: Unit }                  {val bv=inport?(); body }

    For an extended rendezvous InEvent the correspondence is

    { bv => body: Unit }                  { inport??({ bv => body}) }
    Definition Classes
    alternation
  • AfterDeadline
  • AfterEvent
  • Event
  • ExecutableEvent
  • ExecutableEventSyntax
  • InPortEvent
  • InPortEventExtended
  • InfixEventSyntax
  • NormalAlt
  • OrElseEvent
  • OutPortEvent
  • OutPortEventThen
  • orelse

package event

This package implements the syntax of the CSO alternation notations, and provides hooks for the semantics of that notation.

The body of an alternation specification consists of a sequence (possibly empty) of executable event specifications separated by | and possibly followed by:

| after(timeout) ==> { ... }

or

| orelse ==> { ... }

or

| after(timeout) ==> { ... } |  orelse ==> { ... }

An executable event specification takes one of the following forms:

outport              =!=>  OutEvent
(guard && outport)   =!=>  OutEvent
inport               =?=>  InEvent
(guard && inport)    =?=>  InEvent
inport               =??=> InEvent     // extended rendezvous form
(guard && inport)    =??=> InEvent     // extended rendezvous form

Concessions to readability: a Chan expression may appear in place of a port expression.

Events and their effects

OutEvent form:                        Effect when triggered
{expr}                                outport!expr
{expr} ==> { command: Unit }          {outport!expr; command}
InEvent form:                         Effect when triggered
{ bv => body: Unit }                  {val bv=inport?(); body }

For an extended rendezvous InEvent the correspondence is

{ bv => body: Unit }                  { inport??({ bv => body}) }
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. event
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. class AfterDeadline extends AnyRef

    Syntactic continuation of after(deadline) notation.

  2. case class AfterEvent (deadline: () ⇒ Long, body: () ⇒ Unit) extends Event with Product with Serializable

    An after "event"

  3. trait Event extends AnyRef
  4. abstract case class ExecutableEvent () extends ExecutableEventSyntax with Product with Serializable

    The meaning of an inport or outport events is represented by a (concrete) ExecutableEvent.

    The meaning of an inport or outport events is represented by a (concrete) ExecutableEvent. Alternation constructs work by choosing an executable event that is ready for execution, then running it.

  5. trait ExecutableEventSyntax extends Event

    ExecutableEvents are composed syntactically by infix | and its prefix form.

  6. class InPortEvent [+T] extends ExecutableEvent

    Executable event corresponding to guard && port =?=> body

  7. class InPortEventExtended [+T] extends ExecutableEvent

    Executable event corresponding to guard && port =??=> body

  8. case class InfixEventSyntax (l: Event, r: Event) extends ExecutableEventSyntax with Product with Serializable

    Syntactic composition of events l and r.

    Syntactic composition of events l and r. (These are not really executable, but life's too short to find a way to make the Scala type system do what amounts to a complete syntax check.)

  9. case class NormalAlt (events: Seq[ExecutableEvent], after: AfterEvent, orelse: OrElseEvent) extends Product with Serializable

    Represents the "compiled" body of an alternation

  10. case class OrElseEvent (body: () ⇒ Unit) extends Event with Product with Serializable

    An orelse "event"

  11. class OutPortEvent [-T] extends ExecutableEvent

    Executable event corresponding to guard && port =!=> body

  12. class OutPortEventThen [-T] extends ExecutableEvent

    Executable event corresponding to guard && port =!=> body ==> cont

Value Members

  1. def after(deadline: ⇒ basis.Nanoseconds): AfterDeadline

    Start of after(deadline) notation (unit is nanoseconds).

  2. def |(events: Seq[ExecutableEvent]): ExecutableEventSyntax

    Prefix notation for |: |(e1, ... en) = e1 | ... | en

  3. object orelse

    Start of the orelse notation.

Inherited from AnyRef

Inherited from Any

Ungrouped