Packages

  • package root
    Definition Classes
    root
  • package gopher

    Provides scala API for 'go-like' CSP channels.

    Provides scala API for 'go-like' CSP channels.

    Overview

    see readme for quick introduction.

    Usage

    At first you must receive gopherApi as Akka extension:

    import gopher._
    
    .....
    val gopherApi = Gopher(actorSystem)

    Then you can use CPS channels with blocling operations inside go clauses:

    val channel = gopherApi.makeChannel[Long]
    val n = 10000
    val producer = go {
     @volatile var(x,y) = (0L,1L)
     for( s <- gopherApi.select.forever) {
       case z: channel.write if (z==x) =>
                  x = y
                  y = x+z
                  if (x > n) {
                     channel.close
                     implicitly[FlowTermination[Unit]].doExit()
                  }
     }
    }
    val consumer = for((c,i) <- channel.zip(1 to n)) {
       Console.println(s"fib(${i})=${c}")
    }
    Await.ready(consumer, 10 seconds)

    and defer/recover in go/goScope

    goScope{
      val f = openFile(myFileName)
      defer{
        if (! recover{case ex:FileNotFoundException => Console.println("invalid fname")}) {
           f.close()
        }
      }
    }
    Definition Classes
    root
    See also

    gopher.GopherAPI

    gopher.channels.Channel

    gopher.channels.Input

    gopher.channels.Output

    gopher.channels.SelectorBuilder

    gopher.channels.SelectFactory

  • package transputers

    transputers implementations

    transputers implementations

    Definition Classes
    gopher
    See also

    gopher.transputers.TransputerSupervisor

    gopher.transputers.ReplicatedTransputer

  • abstract class ReplicatedTransputer[T <: Transputer, Self] extends ParTransputer

    Replicated[X] is transputer which keep n instances of X where ports of replicated consumer are connected to appropriative ports of instances in parallel.

    Replicated[X] is transputer which keep n instances of X where ports of replicated consumer are connected to appropriative ports of instances in parallel.

    Definition Classes
    transputers
    See also

    gopher.GopherAPI#replicate

  • InPort
  • InPortWithAdapter
  • OutPort
  • OutPortWithAdapter
  • SelectorRunner

class InPortWithAdapter[A] extends (ReplicatedTransputer.this)#InPort[A]

Linear Supertypes
(ReplicatedTransputer.this)#InPort[A], Input[A], GopherAPIProvider, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. InPortWithAdapter
  2. InPort
  3. Input
  4. GopherAPIProvider
  5. AnyRef
  6. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new InPortWithAdapter(in: Input[A])

Type Members

  1. class Filtered extends Input[A]
    Definition Classes
    Input
  2. class FutureMapped[B] extends Input[B]
    Definition Classes
    Input
  3. class Mapped[B] extends Input[B]
    Definition Classes
    Input
  4. case class Read(value: A) extends Product with Serializable
    Definition Classes
    Input
  5. type <~ = A
    Definition Classes
    Input
  6. type read = A
    Definition Classes
    Input

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. def *!: Output[A]
    Definition Classes
    InPort
  4. def <~~<(x: OutPort[A]): Unit
    Definition Classes
    InPort
  5. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  6. macro def ?: A

    synonym for read.

    synonym for read.

    Definition Classes
    Input
  7. var adapter: PortAdapter[Input, A]
  8. macro def afold[S, B](s0: S)(f: (S, A) => S): Future[S]

    async incarnation of fold.

    async incarnation of fold. Fold return future, which successed when channel is closed. Operations withing fold applyed on result on each other, starting with s0. val fsum = ch.afold(0){ (s, n) => s+n } Here in fsum will be future with value: sum of all elements in channel until one has been closed.

    Definition Classes
    Input
  9. def afoldAsync[S, B](s0: S)(f: (S, A) => Future[S])(implicit ec: ExecutionContext): Future[S]
    Definition Classes
    Input
  10. def afoldSync[S, B](s0: S)(f: (S, A) => S): Future[S]
    Definition Classes
    Input
  11. macro def aforeach(f: (A) => Unit): Future[Unit]
    Definition Classes
    Input
  12. def amap[B](g: (A) => Future[B]): Input[B]
    Definition Classes
    Input
  13. def api: GopherAPI

    instance of gopher API

    instance of gopher API

    Definition Classes
    InPortInputGopherAPIProvider
  14. def append(other: Input[A]): Input[A]

    when the first channel is exhaused, read from second.

    when the first channel is exhaused, read from second.

    Definition Classes
    Input
  15. def aread: Future[A]

    async version of read.

    async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException in case of stream is closed.

    Definition Classes
    Input
  16. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  17. def async: AnyRef { ... /* 3 definitions in type refinement */ }
    Definition Classes
    Input
  18. def atake(n: Int): Future[IndexedSeq[A]]

    return feature which contains sequence from first n elements.

    return feature which contains sequence from first n elements.

    Definition Classes
    Input
  19. def cbread[B](f: (ContRead[A, B]) => Option[(In[A]) => Future[Continuated[B]]], ft: FlowTermination[B]): Unit

    apply f, when input will be ready and send result to API processor

    apply f, when input will be ready and send result to API processor

    Definition Classes
    InPortInput
  20. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
  21. lazy val closeless: Input[A]

    returns

    Input without close event: i.e. reading from closeless channel after channel close will wait forever instead throwing CloseChannelException

    Definition Classes
    Input
  22. def connect(outPort: OutPort[A], bufferSize: Int = 1): Unit
    Definition Classes
    InPort
  23. def connect(x: Input[A]): Unit
    Definition Classes
    InPort
  24. def dup(): (Input[A], Input[A])

    duplicate input

    duplicate input

    Definition Classes
    Input
  25. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  26. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  27. def filter(p: (A) => Boolean): Input[A]
    Definition Classes
    Input
  28. def flatFold(fun: (Input[A], A) => Input[A]): Input[A]
    Definition Classes
    Input
  29. def flatMap[B](g: (A) => Input[B]): Input[B]
    Definition Classes
    Input
  30. def flatMapOp[B](g: (A) => Input[B])(op: (Input[B], Input[B]) => Input[B]): Input[B]
    Definition Classes
    Input
  31. macro def fold[S, B](s0: S)(f: (S, A) => S): S

    fold opeations, available inside async bloc.

    fold opeations, available inside async bloc. go { val sum = ch.fold(0){ (s,n) => s+n } }

    Definition Classes
    Input
  32. macro def foreach(f: (A) => Unit): Unit

    run f each time when new object is arrived.

    run f each time when new object is arrived. Ended when input closes.

    must be inside go/async/action block.

    Definition Classes
    Input
  33. def foreachAsync(f: (A) => Future[Unit])(implicit ec: ExecutionContext): Future[Unit]
    Definition Classes
    Input
  34. def foreachSync(f: (A) => Unit): Future[Unit]
    Definition Classes
    Input
  35. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  36. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  37. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  38. def map[B](g: (A) => B): Input[B]
    Definition Classes
    Input
  39. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  40. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  41. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  42. def or(other: Input[A]): Input[A]

    synonim for non-deteremenistics choice.

    synonim for non-deteremenistics choice.

    Definition Classes
    Input
  43. def outputSide: Option[Output[A]]
    Definition Classes
    InPort
  44. def owner: Self
  45. def prepend(a: A): Input[A]
    Definition Classes
    Input
  46. macro def read: A

    read object from channel.

    read object from channel. Must be situated inside async/go/action block.

    Definition Classes
    Input
  47. def seq: AnyRef { def flatMap[B](g: A => gopher.channels.Input[B]): gopher.channels.Input[B] }
    Definition Classes
    Input
  48. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  49. def timedAread(waitTime: FiniteDuration): Future[A]
    Definition Classes
    Input
  50. def toString(): String
    Definition Classes
    AnyRef → Any
  51. var v: Input[A]
    Definition Classes
    InPort
  52. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  53. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  54. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  55. def withFilter(p: (A) => Boolean): Input[A]
    Definition Classes
    Input
  56. def withInputTimeouts(timeout: FiniteDuration): (Input[A], Input[FiniteDuration])

    return pair of inputs (ready, timeouts), such that when you read from ready you receive element from this and if during reading you wait more than specified timeout, than timeout message is appear in timeouts

    return pair of inputs (ready, timeouts), such that when you read from ready you receive element from this and if during reading you wait more than specified timeout, than timeout message is appear in timeouts

    val (inReady, inTimeouts) = in withInputTimeouts (10 seconds) select.forever { case x: inReady.read => Console.println(s"received value ${value}") case x: inTimeouts.read => Console.println(s"timeout occured") }

    Definition Classes
    Input
  57. def zip[B](x: Input[B]): Input[(A, B)]
    Definition Classes
    Input
  58. def zip[B](x: Iterable[B]): Input[(A, B)]
    Definition Classes
    Input
  59. def |(other: Input[A]): Input[A]

    return input merged with 'other'.

    return input merged with 'other'. (i.e. non-determenistics choice)

    Definition Classes
    Input

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

Inherited from (ReplicatedTransputer.this)#InPort[A]

Inherited from Input[A]

Inherited from GopherAPIProvider

Inherited from AnyRef

Inherited from Any

Ungrouped