ReadChannel

Abstract Value Members

abstract def dispose(): Unit

Definition Classes
Disposable
abstract def flush(f: (T) ⇒ Unit): Unit

Call f for each element
Call f for each element

Definition Classes
ReadChannel → Flush
abstract def size: ReadChannel[Int]

Definition Classes
Size
Note
State channels: Produce when a new child is attached and if the size changes. In Opt the size is reset if the value is cleared.
,
Channels: The size is only produced in response to each received value on the channel.
,
Buffers: Produce the row count once a row is added or removed.

Concrete 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
def >>(ch: WriteChannel[T]): ReadChannel[Unit]
def all(value: T): ReadChannel[Boolean]

All elements are equal to value
All elements are equal to value

Definition Classes
Filter
See also
any
def any(value: T): ReadChannel[Boolean]

At least one element is equal to value
At least one element is equal to value

Definition Classes
Filter
See also
all
final def asInstanceOf[T0]: T0

Definition Classes
Any
def attach(f: (T) ⇒ Unit): ReadChannel[Unit]
def buffer: Buffer[T]

Buffers all produced elements
def cache(default: T): ReadStateChannel[T]

Definition Classes
ReadChannel → Cache
def cache: ReadPartialChannel[T]

Definition Classes
ReadChannel → Cache
def child(): ReadChannel[T]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[U](f: PartialFunction[T, U]): ReadChannel[U]

Applies partial function f on each element; if the function is not defined for the current input, it is filtered out
Applies partial function f on each element; if the function is not defined for the current input, it is filtered out

Definition Classes
ReadChannel → MapExtended
def count(value: T): ReadChannel[Int]

Count number of occurrence of value.
Count number of occurrence of value.

Definition Classes
Filter
Note
Channels: With every matching element, the counter is increased.
,
Buffers: When the element is removed, the counter is decreased.
def detach(ch: ChildChannel[T, _]): Unit
def distinct: ReadChannel[T]

Filters out (merges) duplicates
Filters out (merges) duplicates

Definition Classes
ReadChannel → Aggregate
def drop(count: Int): ReadChannel[T]

Definition Classes
ReadChannel → Take
Note
Channels: Skips first count elements, then stop listening. Subscribing to it will always yield the last result as initial value.
,
Buffers: Creates a sub-buffer without the first count elements.
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def exists(f: (T) ⇒ Boolean): ReadChannel[Boolean]

Checks for existence of a value for which f is true
Checks for existence of a value for which f is true

Definition Classes
Filter
Note
Channels: false as long as f returns false, then true
,
Buffers: false as long as no row exists where f is true, then true
See also
forall
def filter(f: (T) ⇒ Boolean): ReadChannel[T]

Only include elements for which f is true
Only include elements for which f is true

Definition Classes
ReadChannel → Filter
def filterCycles: ReadChannel[T]
def filterNot(f: (T) ⇒ Boolean): ReadChannel[T]

Definition Classes
Filter
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def flatMap[U](f: (T) ⇒ ReadChannel[U]): ReadChannel[U]

Applies f on each element and flatten its result into the stream
Applies f on each element and flatten its result into the stream

Definition Classes
ReadChannel → MapExtended
def flatMapBuf[U](f: (T) ⇒ ReadBuffer[U]): ReadBuffer[U]
def flatMapCh[U](f: (T) ⇒ Channel[U]): Channel[U]

flatMap with back-propagation.
def flatMapSeq[U](f: (T) ⇒ Seq[U]): ReadChannel[U]

Definition Classes
ReadChannel → MapExtended
See also
flatMap
def foldLeft[U](acc: U)(f: (U, T) ⇒ U): ReadChannel[U]

Definition Classes
ReadChannel → Fold
Note
Caches the accumulator value.
def forall(f: (T) ⇒ Boolean): ReadChannel[Boolean]

Checks whether f is true for all elements
Checks whether f is true for all elements

Definition Classes
Filter
See also
exists
def forkBiFlat[U](obs: Observer[T, Channel[U]]): Channel[U]

Bi-directional fork for channels
def forkUni[U](observer: Observer[T, U], filterCycles: Boolean = false): ReadChannel[U]

Uni-directional fork for values
def forkUniFlat[U](observer: Observer[T, ReadChannel[U]]): ReadChannel[U]

Uni-directional fork for channels
def forkUniState[U](observer: Observer[T, U], onFlush: ⇒ Option[U]): ReadChannel[U]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def has(value: T): ReadChannel[Boolean]

Stream contains at least one occurrence of value.
Stream contains at least one occurrence of value.

Definition Classes
Filter
Note
Channels: Once true, will never produce any other value.
,
Buffers: When the item is removed, it will produce false.
def hashCode(): Int

Definition Classes
AnyRef → Any
def head: ReadChannel[T]

Wraps first element as a channel
Wraps first element as a channel
Denotes first produced element after the head call; whether head has observers at this point is irrelevant as the value is cached (i.e. attaching repeatedly will always lead the same value)

Definition Classes
ReadChannel → Head
def is(value: T): ReadChannel[Boolean]

Current value is equal to value
Current value is equal to value

Definition Classes
ReadChannel → Is
def isEmpty: ReadChannel[Boolean]

Definition Classes
Size
Note
Partial channels: Produce true if the current value is cleared.
,
Channels: Produce false with the first received value.
,
Buffers: Produce a new value once a row is added or removed.
def isHead(value: T): ReadChannel[Boolean]

Checks whether the given element is the first produced value
Checks whether the given element is the first produced value

Definition Classes
ReadChannel → Head
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isNot(value: T): ReadChannel[Boolean]

Current value is not equal to value
Current value is not equal to value

Definition Classes
ReadChannel → Is
def map[U](f: (T) ⇒ U): ReadChannel[U]

Applies f on each element
Applies f on each element

Definition Classes
ReadChannel → Map
def mapTo[U](f: (T) ⇒ U): DeltaDict[T, U]

Map f on each element and turn stream into a dictionary
Map f on each element and turn stream into a dictionary

Definition Classes
ReadChannel → MapExtended
def max[U >: T](init: U)(implicit num: Numeric[U]): ReadChannel[U]

Calculates maximum value
Calculates maximum value

Definition Classes
Fold
See also
foldLeft
def merge(ch: ReadChannel[T]): ReadChannel[T]
def min[U >: T](init: U)(implicit num: Numeric[U]): ReadChannel[U]

Calculates minimum value
Calculates minimum value

Definition Classes
Fold
See also
foldLeft
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nonEmpty: ReadChannel[Boolean]

Negation of isEmpty
Negation of isEmpty

Definition Classes
Size
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def or(ch: ReadChannel[_]): ReadChannel[Unit]
def partition(f: (T) ⇒ Boolean): (ReadChannel[T], ReadChannel[T])

Partitions stream into two sub-stream
Partitions stream into two sub-stream
The left stream contains all elements for which f is true, all other elements go to the right stream.

Definition Classes
Filter
def product[U >: T](implicit num: Numeric[U]): ReadChannel[U]

Calculates product
Calculates product

Definition Classes
Fold
See also
foldLeft
def publish[U](ch: WriteChannel[T], ignore: ReadChannel[U]): ReadChannel[Unit]
def publish(ch: WriteChannel[T]): ReadChannel[Unit]
def silentAttach(f: (T) ⇒ Unit): ReadChannel[Unit]
def sum[U >: T](implicit num: Numeric[U]): ReadChannel[U]

Sums over all elements
Sums over all elements

Definition Classes
Fold
See also
foldLeft
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tail: ReadChannel[T]

Skips first element
Skips first element

Definition Classes
ReadChannel → Tail
def take(count: Int): ReadChannel[T]

Definition Classes
ReadChannel → Take
Note
Channels: Takes first count elements, then stop listening. Subscribing to it will always yield the last result as initial value.
,
Buffers: Will always contain the first count (or less) elements of the parent buffer.
def takeUntil(ch: ReadChannel[_]): ReadChannel[T]

Take all elements until ch produces any value
Take all elements until ch produces any value

Definition Classes
ReadChannel → Take
def toBuffer: Buffer[T]

Buffers only current element
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( ... )
def writeTo(write: WriteChannel[T]): Channel[T]
def zip[U](other: ReadChannel[U]): ReadChannel[(T, U)]
def |(ch: ReadChannel[_]): ReadChannel[Unit]

Related Doc: package metarx

trait ReadChannel[T] extends Head[T] with Tail[ReadChannel, T] with Take[ReadChannel, T] with Fold[T] with Is[T] with Aggregate[ReadChannel, T] with Filter[ReadChannel, T, T] with Map[ReadChannel, T] with MapExtended[ReadChannel, T] with Cache[T] with Size with Flush[T] with Disposable

Abstract Value Members

abstract def dispose(): Unit

abstract def flush(f: (T) ⇒ Unit): Unit

abstract def size: ReadChannel[Int]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def >>(ch: WriteChannel[T]): ReadChannel[Unit]

def all(value: T): ReadChannel[Boolean]

def any(value: T): ReadChannel[Boolean]

final def asInstanceOf[T0]: T0

def attach(f: (T) ⇒ Unit): ReadChannel[Unit]

def buffer: Buffer[T]

def cache(default: T): ReadStateChannel[T]

def cache: ReadPartialChannel[T]

def child(): ReadChannel[T]

def clone(): AnyRef

def collect[U](f: PartialFunction[T, U]): ReadChannel[U]

def count(value: T): ReadChannel[Int]

def detach(ch: ChildChannel[T, _]): Unit

def distinct: ReadChannel[T]

def drop(count: Int): ReadChannel[T]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(f: (T) ⇒ Boolean): ReadChannel[Boolean]

def filter(f: (T) ⇒ Boolean): ReadChannel[T]

def filterCycles: ReadChannel[T]

def filterNot(f: (T) ⇒ Boolean): ReadChannel[T]

def finalize(): Unit

def flatMap[U](f: (T) ⇒ ReadChannel[U]): ReadChannel[U]

def flatMapBuf[U](f: (T) ⇒ ReadBuffer[U]): ReadBuffer[U]

def flatMapCh[U](f: (T) ⇒ Channel[U]): Channel[U]

def flatMapSeq[U](f: (T) ⇒ Seq[U]): ReadChannel[U]

def foldLeft[U](acc: U)(f: (U, T) ⇒ U): ReadChannel[U]

def forall(f: (T) ⇒ Boolean): ReadChannel[Boolean]

def forkBiFlat[U](obs: Observer[T, Channel[U]]): Channel[U]

def forkUni[U](observer: Observer[T, U], filterCycles: Boolean = false): ReadChannel[U]

def forkUniFlat[U](observer: Observer[T, ReadChannel[U]]): ReadChannel[U]

def forkUniState[U](observer: Observer[T, U], onFlush: ⇒ Option[U]): ReadChannel[U]

final def getClass(): Class[_]

def has(value: T): ReadChannel[Boolean]

def hashCode(): Int

def head: ReadChannel[T]

def is(value: T): ReadChannel[Boolean]

def isEmpty: ReadChannel[Boolean]

def isHead(value: T): ReadChannel[Boolean]

final def isInstanceOf[T0]: Boolean

def isNot(value: T): ReadChannel[Boolean]

def map[U](f: (T) ⇒ U): ReadChannel[U]

def mapTo[U](f: (T) ⇒ U): DeltaDict[T, U]

def max[U >: T](init: U)(implicit num: Numeric[U]): ReadChannel[U]

def merge(ch: ReadChannel[T]): ReadChannel[T]

def min[U >: T](init: U)(implicit num: Numeric[U]): ReadChannel[U]

final def ne(arg0: AnyRef): Boolean

def nonEmpty: ReadChannel[Boolean]

final def notify(): Unit

final def notifyAll(): Unit

def or(ch: ReadChannel[_]): ReadChannel[Unit]

def partition(f: (T) ⇒ Boolean): (ReadChannel[T], ReadChannel[T])

def product[U >: T](implicit num: Numeric[U]): ReadChannel[U]

def publish[U](ch: WriteChannel[T], ignore: ReadChannel[U]): ReadChannel[Unit]

def publish(ch: WriteChannel[T]): ReadChannel[Unit]

def silentAttach(f: (T) ⇒ Unit): ReadChannel[Unit]

def sum[U >: T](implicit num: Numeric[U]): ReadChannel[U]

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

def tail: ReadChannel[T]

def take(count: Int): ReadChannel[T]

def takeUntil(ch: ReadChannel[_]): ReadChannel[T]

def toBuffer: Buffer[T]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def writeTo(write: WriteChannel[T]): Channel[T]

def zip[U](other: ReadChannel[U]): ReadChannel[(T, U)]

def |(ch: ReadChannel[_]): ReadChannel[Unit]