PollBuffer

Abstract Value Members

abstract val changes: ReadChannel[Delta[T]]
abstract def map[U](f: (T) ⇒ U): DeltaBuffer[U]
abstract 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
MapExtended

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def ++(buffer: ReadBuffer[T]): ReadBuffer[T]

Definition Classes
Concatenate
def -(other: ReadBufSet[T]): ReadBuffer[T]

Definition Classes
FilterOrdered
final def ==(arg0: Any): Boolean

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

Definition Classes
PollBuffer → RelativeOrder
Note
Channels: Value that is produced right after each value
,
Buffers: Current row after value
def after$(value: T): T

Row after value
Row after value

Definition Classes
PollBuffer → RelativeOrder
def afterOption(value: T): ReadChannel[T]

Definition Classes
PollBuffer → RelativeOrder
See also
after
def afterOption$(value: T): Option[T]

Row after value with the possibility of non-existence
Row after value with the possibility of non-existence

Definition Classes
PollBuffer → RelativeOrder
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
def apply(index: Int): T

Definition Classes
Index
See also
value
final def asInstanceOf[T0]: T0

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

Definition Classes
PollBuffer → RelativeOrder
Note
Channels: Value that is produced right before each value
,
Buffers: Current row before value
def before$(value: T): T

Row before value
Row before value

Definition Classes
PollBuffer → RelativeOrder
def beforeOption(value: T): ReadChannel[T]

Definition Classes
PollBuffer → RelativeOrder
See also
before
def beforeOption$(value: T): Option[T]

Row before value with the possibility of non-existence
Row before value with the possibility of non-existence

Definition Classes
PollBuffer → RelativeOrder
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[U](f: PartialFunction[T, U]): ReadBuffer[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
PollBuffer → MapExtended
def concat(buf: ReadBuffer[T]): ReadBuffer[T]

Definition Classes
PollBuffer → Concatenate
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 diff(other: ReadBufSet[T]): ReadBuffer[T]

Remove all elements from other
Remove all elements from other

Definition Classes
PollBuffer → FilterOrdered
def distinct: ReadBuffer[T]

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

Definition Classes
PollBuffer → Aggregate
def distinct$: ReadBuffer[T]

Filters out duplicates
Filters out duplicates

Definition Classes
PollBuffer → Filter
def drop(count: Int): ReadBuffer[T]
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 exists$(f: (T) ⇒ Boolean): Boolean
def filter(f: (T) ⇒ Boolean): DeltaBuffer[T]

TODO Could this be implemented more efficiently without iterating over elements?
TODO Could this be implemented more efficiently without iterating over elements?

Definition Classes
PollBuffer → Filter
def filter$(f: (T) ⇒ Boolean): ReadBuffer[T]

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

Definition Classes
PollBuffer → Filter
def filterNot(f: (T) ⇒ Boolean): DeltaBuffer[T]

Definition Classes
Filter
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(f: (T) ⇒ Boolean): ReadPartialChannel[T]

Returns first matching row; if it gets deleted, returns next match.
Returns first matching row; if it gets deleted, returns next match.

Definition Classes
PollBuffer → Find
def find$(f: (T) ⇒ Boolean): Option[T]

Finds first value for which f is true
Finds first value for which f is true

Definition Classes
PollBuffer → Filter
def flatMap[U](f: (T) ⇒ ReadBuffer[U]): ReadBuffer[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
PollBuffer → MapExtended
def flatMapCh[U](f: (T) ⇒ ReadPartialChannel[U]): ReadBuffer[U]
def flatMapSeq[U](f: (T) ⇒ Seq[U]): ReadBuffer[U]

Definition Classes
PollBuffer → MapExtended
See also
flatMap
def foldLeft[U](acc: U)(f: (U, T) ⇒ U): ReadChannel[U]
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 forall$(f: (T) ⇒ Boolean): Boolean
def foreach(f: (T) ⇒ Unit): Unit

Iterates over all row values with the given function f
Iterates over all row values with the given function f

Definition Classes
PollBuffer → Iterate
def get: Seq[T]

All rows as a native type
All rows as a native type

Definition Classes
PollBuffer → Index
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 in a channel
Wraps first element in a channel
Produce a value for the first row. If the list is empty, head does not produce any value. When the first row is deleted, the next row will be produced.

Definition Classes
PollBuffer → AbsoluteOrder
def headOption: ReadPartialChannel[T]

First element with the possibility of non-existence
First element with the possibility of non-existence
returns
scala.Some with first row, or scala.None if the list is empty

Definition Classes
PollBuffer → AbsoluteOrder
def indexOf(handle: T): Int

Index of handle
Index of handle

Definition Classes
PollBuffer → Index
def isHead(element: T): ReadChannel[Boolean]

Definition Classes
PollBuffer → AbsoluteOrder
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isLast(element: T): ReadChannel[Boolean]

Definition Classes
PollBuffer → AbsoluteOrder
def last: ReadChannel[T]

Definition Classes
PollBuffer → AbsoluteOrder
def lastOption: ReadPartialChannel[T]

Last element with the possibility of non-existence
Last element with the possibility of non-existence
returns
scala.Some with first row, or scala.None if the list is empty

Definition Classes
PollBuffer → AbsoluteOrder
def mkString(): ReadChannel[String]
def mkString(sep: String): ReadChannel[String]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def partition(f: (T) ⇒ Boolean): (DeltaBuffer[T], DeltaBuffer[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 partition$(f: (T) ⇒ Boolean): (ReadBuffer[T], ReadBuffer[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
PollBuffer → Filter
def reduce[U >: T](op: (U, U) ⇒ U): ReadChannel[U]
def span(f: (T) ⇒ Boolean): (ReadBuffer[T], ReadBuffer[T])

Splits stream into two sub-streams
Splits stream into two sub-streams
The left stream contains all elements as long as f is true, all subsequent elements go to the right stream.

Definition Classes
PollBuffer → FilterOrdered
def span$(f: (T) ⇒ Boolean): (ReadBuffer[T], ReadBuffer[T])

Split container into two sub-containers
Split container into two sub-containers
The left container contains all elements if f is true, all subsequent elements go to the right container.

Definition Classes
PollBuffer → Filter
def splitAt(element: T): (ReadBuffer[T], ReadBuffer[T])

Definition Classes
PollBuffer → AbsoluteOrder
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tail: ReadBuffer[T]

Definition Classes
PollBuffer → AbsoluteOrder
def take(count: Int): ReadBuffer[T]
def toSeq: ReadChannel[Seq[T]]
def toString(): String

Definition Classes
PollBuffer → AnyRef → Any
def value(index: Int): T

N-th row
N-th row

Definition Classes
PollBuffer → Index
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( ... )

Related Doc: package metarx

Abstract Value Members

abstract val changes: ReadChannel[Delta[T]]

abstract def map[U](f: (T) ⇒ U): DeltaBuffer[U]

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

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++(buffer: ReadBuffer[T]): ReadBuffer[T]

def -(other: ReadBufSet[T]): ReadBuffer[T]

final def ==(arg0: Any): Boolean

def after(value: T): ReadChannel[T]

def after$(value: T): T

def afterOption(value: T): ReadChannel[T]

def afterOption$(value: T): Option[T]

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

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

def apply(index: Int): T

final def asInstanceOf[T0]: T0

def before(value: T): ReadChannel[T]

def before$(value: T): T

def beforeOption(value: T): ReadChannel[T]

def beforeOption$(value: T): Option[T]

def clone(): AnyRef

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

def concat(buf: ReadBuffer[T]): ReadBuffer[T]

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

def diff(other: ReadBufSet[T]): ReadBuffer[T]

def distinct: ReadBuffer[T]

def distinct$: ReadBuffer[T]

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def exists$(f: (T) ⇒ Boolean): Boolean

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

def filter$(f: (T) ⇒ Boolean): ReadBuffer[T]

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

def finalize(): Unit

def find(f: (T) ⇒ Boolean): ReadPartialChannel[T]

def find$(f: (T) ⇒ Boolean): Option[T]

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

def flatMapCh[U](f: (T) ⇒ ReadPartialChannel[U]): ReadBuffer[U]

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

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

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

def forall$(f: (T) ⇒ Boolean): Boolean

def foreach(f: (T) ⇒ Unit): Unit

def get: Seq[T]

final def getClass(): Class[_]

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

def hashCode(): Int

def head: ReadChannel[T]

def headOption: ReadPartialChannel[T]

def indexOf(handle: T): Int

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

final def isInstanceOf[T0]: Boolean

def isLast(element: T): ReadChannel[Boolean]

def last: ReadChannel[T]

def lastOption: ReadPartialChannel[T]

def mkString(): ReadChannel[String]

def mkString(sep: String): ReadChannel[String]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

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

def reduce[U >: T](op: (U, U) ⇒ U): ReadChannel[U]

def span(f: (T) ⇒ Boolean): (ReadBuffer[T], ReadBuffer[T])

def span$(f: (T) ⇒ Boolean): (ReadBuffer[T], ReadBuffer[T])

def splitAt(element: T): (ReadBuffer[T], ReadBuffer[T])

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

def tail: ReadBuffer[T]

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

def toSeq: ReadChannel[Seq[T]]

def toString(): String

def value(index: Int): T

final def wait(): Unit

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