DataSource

abstract def cached(implicit engine: Engine): Self

abstract def distribute(cluster: Option[ActorRef]): Self

abstract def elements(): Op[Seq[Op[T]]]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def cachedOps(implicit engine: Engine): Op[Seq[Op[T]]]

def clone(): AnyRef

def combine[T1 >: T, B](dss: Seq[DataSource[T1, _]], label: String)(f: (Seq[T1]) ⇒ B): SeqSource[B]

def combine[T1 >: T, B](dss: Seq[DataSource[T1, _]])(f: (Seq[T1]) ⇒ B): SeqSource[B]

def combine[B, C](ds: DataSource[B, _], label: String)(f: (T, B) ⇒ C): SeqSource[C]

def combine[B, C](ds: DataSource[B, _])(f: (T, B) ⇒ C): SeqSource[C]

def combineOp[T1 >: T, B](dss: Seq[DataSource[T1, _]], name: String)(f: (Seq[Op[T1]]) ⇒ Op[B]): SeqSource[B]

def combineOp[B, C](ds: DataSource[B, _], name: String)(f: (Op[T], Op[B]) ⇒ Op[C]): SeqSource[C]

def combineOp[T1 >: T, B](dss: Seq[DataSource[T1, _]])(f: (Seq[Op[T1]]) ⇒ Op[B]): SeqSource[B]

def combineOp[B, C](ds: DataSource[B, _])(f: (Op[T], Op[B]) ⇒ Op[C]): SeqSource[C]

def converge[B](f: (Seq[T]) ⇒ B): ValueSource[B]

def converge(): ValueSource[V]

def distribute(cluster: ActorRef): Self

def distribute: Self

def distributeOps(cluster: Option[ActorRef]): Op[Seq[Op[T]]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def foldLeft[B](z: B)(folder: (B, T) ⇒ B): ValueSource[B]

def foldRight[B](z: B)(folder: (T, B) ⇒ B): ValueSource[B]

def get(implicit engine: Engine): V

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def map[B](f: (T) ⇒ B, label: String): SeqSource[B]

apply a function to elements *

def map[B](f: (T) ⇒ B): SeqSource[B]

apply a function to elements *

def mapOp[B](f: (Op[T]) ⇒ Op[B], name: String): SeqSource[B]

apply a function to element operations *

def mapOp[B](f: (Op[T]) ⇒ Op[B]): SeqSource[B]

apply a function to element operations *

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def reduce[T1 >: T](reducer: (T1, T1) ⇒ T1): ValueSource[T1]

def reduceLeft[T1 >: T](reducer: (T1, T) ⇒ T1): ValueSource[T1]

def reduceRight[T1 >: T](reducer: (T, T1) ⇒ T1): ValueSource[T1]

def run(implicit engine: Engine): OperationResult[V]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withConverge[B](f: (Seq[T]) ⇒ B): DataSource[T, B]