process

Type Members

1. sealed trait Connections[R] extends AnyRef

   Trait that represent the free connections of a process, which still need to be connected.

2. case class Connections0x0[R](rchan: RIChan[R]) extends Connections[R] with Product with Serializable

3. case class Connections0x1[I1, R](ochan1: IChan[I1], rchan: RIChan[R]) extends Connections[R] with Product with Serializable

4. case class Connections0x2[I1, I2, R](ochan1: IChan[I1], ochan2: IChan[I2], rchan: RIChan[R]) extends Connections[R] with Product with Serializable

5. case class Connections0x3[I1, I2, I3, R](ochan1: IChan[I1], ochan2: IChan[I2], ochan3: IChan[I3], rchan: RIChan[R]) extends Connections[R] with Product with Serializable

6. case class Connections1x0[O1, R](ichan1: OChan[O1], rchan: RIChan[R]) extends Connections[R] with Product with Serializable

7. case class Connections1x1[O1, I1, R](ichan1: OChan[O1], ochan1: IChan[I1], rchan: RIChan[R]) extends Connections[R] with Product with Serializable

8. case class Connections1x2[O1, I1, I2, R](ichan1: OChan[O1], ochan1: IChan[I1], ochan2: IChan[I2], rchan: RIChan[R]) extends Connections[R] with Product with Serializable

9. case class Connections1x3[O1, I1, I2, I3, R](ichan1: OChan[O1], ochan1: IChan[I1], ochan2: IChan[I2], ochan3: IChan[I3], rchan: RIChan[R]) extends Connections[R] with Product with Serializable

10. case class Connections2x0[O1, O2, R](ichan1: OChan[O1], ichan2: OChan[O2], rchan: RIChan[R]) extends Connections[R] with Product with Serializable

11. case class Connections2x1[O1, O2, I1, R](ichan1: OChan[O1], ichan2: OChan[O2], ochan1: IChan[I1], rchan: RIChan[R]) extends Connections[R] with Product with Serializable

12. case class Connections2x2[O1, O2, I1, I2, R](ichan1: OChan[O1], ichan2: OChan[O2], ochan1: IChan[I1], ochan2: IChan[I2], rchan: RIChan[R]) extends Connections[R] with Product with Serializable

13. case class Connections2x3[O1, O2, I1, I2, I3, R](ichan1: OChan[O1], ichan2: OChan[O2], ochan1: IChan[I1], ochan2: IChan[I2], ochan3: IChan[I3], rchan: RIChan[R]) extends Connections[R] with Product with Serializable

14. case class Connections3x0[O1, O2, O3, R](ichan1: OChan[O1], ichan2: OChan[O2], ichan3: OChan[O3], rchan: RIChan[R]) extends Connections[R] with Product with Serializable

15. case class Connections3x1[O1, O2, O3, I1, R](ichan1: OChan[O1], ichan2: OChan[O2], ichan3: OChan[O3], ochan1: IChan[I1], rchan: RIChan[R]) extends Connections[R] with Product with Serializable

16. case class Connections3x2[O1, O2, O3, I1, I2, R](ichan1: OChan[O1], ichan2: OChan[O2], ichan3: OChan[O3], ochan1: IChan[I1], ochan2: IChan[I2], rchan: RIChan[R]) extends Connections[R] with Product with Serializable

17. case class Connections3x3[O1, O2, O3, I1, I2, I3, R](ichan1: OChan[O1], ichan2: OChan[O2], ichan3: OChan[O3], ochan1: IChan[I1], ochan2: IChan[I2], ochan3: IChan[I3], rchan: RIChan[R]) extends Connections[R] with Product with Serializable

18. abstract class CoreProcess[+R] extends Process[R]

19. trait Process[+R] extends AnyRef

    Instance of a ProcessType that has been bound to input and output channels but not yet running.

20. abstract class Process0x0[R] extends Process[R]

21. abstract class Process0x1[A, R] extends Process[R]

22. abstract class Process0x2[C, D, R] extends Process[R]

23. abstract class Process0x3[D, E, F, R] extends Process[R]

24. abstract class Process0x4[E, F, G, H, R] extends Process[R]

25. abstract class Process1x0[A, R] extends Process[R]

    A Process bound to channels that may be serialized and sent remotely (TBD)

26. abstract class Process1x1[A, B, R] extends Process[R]

27. abstract class Process1x2[A, C, D, R] extends Process[R]

28. abstract class Process1x3[A, D, E, F, R] extends Process[R]

29. abstract class Process1x4[A, E, F, G, H, R] extends Process[R]

30. abstract class Process2x0[A, B, R] extends Process[R]

31. abstract class Process2x1[A, B, C, R] extends Process[R]

32. abstract class Process2x2[A, B, C, D, R] extends Process[R]

33. abstract class Process2x3[A, B, D, E, F, R] extends Process[R]

34. abstract class Process2x4[A, B, E, F, G, H, R] extends Process[R]

35. abstract class Process3x0[A, B, C, R] extends Process[R]

36. abstract class Process3x1[A, B, C, D, R] extends Process[R]

37. abstract class Process3x2[A, B, C, D, E, R] extends Process[R]

38. abstract class Process3x3[A, B, C, D, E, F, R] extends Process[R]

39. abstract class Process3x4[A, B, C, E, F, G, H, R] extends Process[R]

40. abstract class Process4x0[A, B, C, D, R] extends Process[R]

41. abstract class Process4x1[A, B, C, D, E, R] extends Process[R]

42. abstract class Process4x2[A, B, C, D, E, F, R] extends Process[R]

43. abstract class Process4x3[A, B, C, D, E, F, G, R] extends Process[R]

44. abstract class Process4x4[A, B, C, D, E, F, G, H, R] extends Process[R]

45. trait ProcessFactories extends AnyRef

46. trait ProcessType extends AnyRef

    Base interface for process types.

47. abstract class ProcessType0x0[R] extends ProcessType with () ⇒ Process0x0[R]

    Process types

48. abstract class ProcessType0x1[A, R] extends ProcessType with (OChan[A]) ⇒ Process0x1[A, R]

49. abstract class ProcessType0x2[E, F, R] extends ProcessType with (OChan[E], OChan[F]) ⇒ Process0x2[E, F, R]

50. abstract class ProcessType0x3[E, F, G, R] extends ProcessType with (OChan[E], OChan[F], OChan[G]) ⇒ Process0x3[E, F, G, R]

51. abstract class ProcessType0x4[E, F, G, H, R] extends ProcessType

52. abstract class ProcessType1x0[A, R] extends ProcessType with (IChan[A]) ⇒ Process1x0[A, R]

53. abstract class ProcessType1x1[A, B, R] extends ProcessType with (IChan[A], OChan[B]) ⇒ Process1x1[A, B, R]

54. abstract class ProcessType1x2[A, E, F, R] extends ProcessType with (IChan[A], OChan[E], OChan[F]) ⇒ Process1x2[A, E, F, R]

55. abstract class ProcessType1x3[A, E, F, G, R] extends ProcessType with (IChan[A], OChan[E], OChan[F], OChan[G]) ⇒ Process1x3[A, E, F, G, R]

56. abstract class ProcessType1x4[A, E, F, G, H, R] extends ProcessType

57. abstract class ProcessType2x0[A, B, R] extends ProcessType with (IChan[A], IChan[B]) ⇒ Process2x0[A, B, R]

58. abstract class ProcessType2x1[A, B, E, R] extends ProcessType with (IChan[A], IChan[B], OChan[E]) ⇒ Process2x1[A, B, E, R]

59. abstract class ProcessType2x2[A, B, E, F, R] extends ProcessType with (IChan[A], IChan[B], OChan[E], OChan[F]) ⇒ Process2x2[A, B, E, F, R]

60. abstract class ProcessType2x3[A, B, E, F, G, R] extends ProcessType with (IChan[A], IChan[B], OChan[E], OChan[F], OChan[G]) ⇒ Process2x3[A, B, E, F, G, R]

61. abstract class ProcessType2x4[A, B, E, F, G, H, R] extends ProcessType

62. abstract class ProcessType3x0[A, B, C, R] extends ProcessType with (IChan[A], IChan[B], IChan[C]) ⇒ Process3x0[A, B, C, R]

63. abstract class ProcessType3x1[A, B, C, E, R] extends ProcessType with (IChan[A], IChan[B], IChan[C], OChan[E]) ⇒ Process3x1[A, B, C, E, R]

64. abstract class ProcessType3x2[A, B, C, E, F, R] extends ProcessType with (IChan[A], IChan[B], IChan[C], OChan[E], OChan[F]) ⇒ Process3x2[A, B, C, E, F, R]

65. abstract class ProcessType3x3[A, B, C, E, F, G, R] extends ProcessType with (IChan[A], IChan[B], IChan[C], OChan[E], OChan[F], OChan[G]) ⇒ Process3x3[A, B, C, E, F, G, R]

66. abstract class ProcessType3x4[A, B, C, E, F, G, H, R] extends ProcessType

67. abstract class ProcessType4x0[A, B, C, D, R] extends ProcessType

68. abstract class ProcessType4x1[A, B, C, D, E, R] extends ProcessType

69. abstract class ProcessType4x2[A, B, C, D, E, F, R] extends ProcessType

70. abstract class ProcessType4x3[A, B, C, D, E, F, G, R] extends ProcessType

71. abstract class ProcessType4x4[A, B, C, D, E, F, G, H, R] extends ProcessType