Value Members
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
final
def
++[B >: CommittableMessage[K, V]](other: ⇒ Observable[B]): Observable[B]
-
final
def
+:[B >: CommittableMessage[K, V]](elem: B): Observable[B]
-
final
def
:+[B >: CommittableMessage[K, V]](elem: B): Observable[B]
-
final
def
==(arg0: Any): Boolean
-
def
ackTask(consumer: KafkaConsumer[K, V], out: Subscriber[CommittableMessage[K, V]]): Task[Ack]
-
final
def
ambWith[B >: CommittableMessage[K, V]](other: Observable[B]): Observable[B]
-
final
def
append[B >: CommittableMessage[K, V]](elem: B): Observable[B]
-
final
def
appendAll[B >: CommittableMessage[K, V]](other: Observable[B]): Observable[B]
-
final
def
asInstanceOf[T0]: T0
-
final
def
asyncBoundary[B >: CommittableMessage[K, V]](overflowStrategy: OverflowStrategy[B]): Observable[B]
-
final
def
behavior[B >: CommittableMessage[K, V]](initialValue: B)(implicit s: Scheduler): ConnectableObservable[B]
-
final
def
bracket[B](use: (CommittableMessage[K, V]) ⇒ Observable[B])(release: (CommittableMessage[K, V]) ⇒ Task[Unit]): Observable[B]
-
final
def
bracketCase[B](use: (CommittableMessage[K, V]) ⇒ Observable[B])(release: (CommittableMessage[K, V], ExitCase[Throwable]) ⇒ Task[Unit]): Observable[B]
-
final
def
bracketCaseF[F[_], B](use: (CommittableMessage[K, V]) ⇒ Observable[B])(release: (CommittableMessage[K, V], ExitCase[Throwable]) ⇒ F[Unit])(implicit F: TaskLike[F]): Observable[B]
-
final
def
bracketF[F[_], B](use: (CommittableMessage[K, V]) ⇒ Observable[B])(release: (CommittableMessage[K, V]) ⇒ F[Unit])(implicit F: TaskLike[F]): Observable[B]
-
final
def
bufferIntrospective(maxSize: Int): Observable[List[CommittableMessage[K, V]]]
-
final
def
bufferSliding(count: Int, skip: Int): Observable[Seq[CommittableMessage[K, V]]]
-
-
final
def
bufferTimedAndCounted(timespan: FiniteDuration, maxCount: Int): Observable[Seq[CommittableMessage[K, V]]]
-
-
final
def
bufferTumbling(count: Int): Observable[Seq[CommittableMessage[K, V]]]
-
final
def
bufferWithSelector[S](selector: Observable[S], maxSize: Int): Observable[Seq[CommittableMessage[K, V]]]
-
final
def
bufferWithSelector[S](selector: Observable[S]): Observable[Seq[CommittableMessage[K, V]]]
-
final
def
cache(maxCapacity: Int): Observable[CommittableMessage[K, V]]
-
-
def
clone(): AnyRef
-
-
final
def
combineLatest[B](other: Observable[B]): Observable[(CommittableMessage[K, V], B)]
-
final
def
combineLatestMap[B, R](other: Observable[B])(f: (CommittableMessage[K, V], B) ⇒ R): Observable[R]
-
final
def
completed: Observable[Nothing]
-
final
def
completedL: Task[Unit]
-
final
def
concat[B](implicit ev: <:<[CommittableMessage[K, V], Observable[B]]): Observable[B]
-
final
def
concatDelayErrors[B](implicit ev: <:<[CommittableMessage[K, V], Observable[B]]): Observable[B]
-
final
def
concatMap[B](f: (CommittableMessage[K, V]) ⇒ Observable[B]): Observable[B]
-
final
def
concatMapDelayErrors[B](f: (CommittableMessage[K, V]) ⇒ Observable[B]): Observable[B]
-
-
final
def
consumeWith[R](f: Consumer[CommittableMessage[K, V], R]): Task[R]
-
val
consumer: Task[KafkaConsumer[K, V]]
-
final
def
count: Observable[Long]
-
final
def
countL: Task[Long]
-
-
-
final
def
debounceTo[B](timeout: FiniteDuration, f: (CommittableMessage[K, V]) ⇒ Observable[B]): Observable[B]
-
final
def
defaultIfEmpty[B >: CommittableMessage[K, V]](default: ⇒ B): Observable[B]
-
-
final
def
delayExecutionWith(trigger: Observable[_]): Observable[CommittableMessage[K, V]]
-
final
def
delayExecutionWithF[F[_]](trigger: F[_])(implicit F: ObservableLike[F]): Observable[CommittableMessage[K, V]]
-
-
-
final
def
delayOnNextBySelector[B](selector: (CommittableMessage[K, V]) ⇒ Observable[B]): Observable[CommittableMessage[K, V]]
-
final
def
dematerialize[B](implicit ev: <:<[CommittableMessage[K, V], Notification[B]]): Observable[B]
-
final
def
distinctUntilChanged[AA >: CommittableMessage[K, V]](implicit A: Eq[AA]): Observable[AA]
-
final
def
distinctUntilChangedByKey[K](key: (CommittableMessage[K, V]) ⇒ K)(implicit K: Eq[K]): Observable[CommittableMessage[K, V]]
-
final
def
doAfterSubscribe(task: Task[Unit]): Observable[CommittableMessage[K, V]]
-
final
def
doAfterSubscribeF[F[_]](task: F[Unit])(implicit F: TaskLike[F]): Observable[CommittableMessage[K, V]]
-
final
def
doOnComplete(task: Task[Unit]): Observable[CommittableMessage[K, V]]
-
final
def
doOnCompleteF[F[_]](task: F[Unit])(implicit F: TaskLike[F]): Observable[CommittableMessage[K, V]]
-
final
def
doOnEarlyStop(task: Task[Unit]): Observable[CommittableMessage[K, V]]
-
final
def
doOnEarlyStopF[F[_]](task: F[Unit])(implicit F: TaskLike[F]): Observable[CommittableMessage[K, V]]
-
final
def
doOnError(cb: (Throwable) ⇒ Task[Unit]): Observable[CommittableMessage[K, V]]
-
final
def
doOnErrorF[F[_]](cb: (Throwable) ⇒ F[Unit])(implicit F: TaskLike[F]): Observable[CommittableMessage[K, V]]
-
-
-
final
def
doOnNextAckF[F[_]](cb: (CommittableMessage[K, V], Ack) ⇒ F[Unit])(implicit F: TaskLike[F]): Observable[CommittableMessage[K, V]]
-
final
def
doOnNextF[F[_]](cb: (CommittableMessage[K, V]) ⇒ F[Unit])(implicit F: TaskLike[F]): Observable[CommittableMessage[K, V]]
-
-
final
def
doOnStartF[F[_]](cb: (CommittableMessage[K, V]) ⇒ F[Unit])(implicit F: Effect[F]): Observable[CommittableMessage[K, V]]
-
final
def
doOnSubscribe(task: Task[Unit]): Observable[CommittableMessage[K, V]]
-
final
def
doOnSubscribeF[F[_]](task: F[Unit])(implicit F: TaskLike[F]): Observable[CommittableMessage[K, V]]
-
final
def
doOnSubscriptionCancel(task: Task[Unit]): Observable[CommittableMessage[K, V]]
-
final
def
doOnSubscriptionCancelF[F[_]](task: F[Unit])(implicit F: TaskLike[F]): Observable[CommittableMessage[K, V]]
-
-
-
final
def
dropLast(n: Int): Observable[CommittableMessage[K, V]]
-
final
def
dropUntil(trigger: Observable[Any]): Observable[CommittableMessage[K, V]]
-
-
-
-
final
def
dump(prefix: String, out: PrintStream): Observable[CommittableMessage[K, V]]
-
-
-
final
def
endWith[B >: CommittableMessage[K, V]](elems: Seq[B]): Observable[B]
-
final
def
endWithError(error: Throwable): Observable[CommittableMessage[K, V]]
-
-
-
final
def
executeAsync: Observable[CommittableMessage[K, V]]
-
final
def
executeOn(s: Scheduler, forceAsync: Boolean): Observable[CommittableMessage[K, V]]
-
final
def
executeWithModel(em: ExecutionModel): Observable[CommittableMessage[K, V]]
-
-
-
final
def
failed: Observable[Throwable]
-
-
-
final
def
filterEvalF[F[_]](p: (CommittableMessage[K, V]) ⇒ F[Boolean])(implicit F: TaskLike[F]): Observable[CommittableMessage[K, V]]
-
-
def
finalize(): Unit
-
-
-
-
-
final
def
firstOrElse[B >: CommittableMessage[K, V]](default: ⇒ B): Observable[B]
-
final
def
firstOrElseL[B >: CommittableMessage[K, V]](default: ⇒ B): Task[B]
-
final
def
flatMap[B](f: (CommittableMessage[K, V]) ⇒ Observable[B]): Observable[B]
-
final
def
flatMapDelayErrors[B](f: (CommittableMessage[K, V]) ⇒ Observable[B]): Observable[B]
-
final
def
flatMapLatest[B](f: (CommittableMessage[K, V]) ⇒ Observable[B]): Observable[B]
-
final
def
flatScan[R](seed: ⇒ R)(op: (R, CommittableMessage[K, V]) ⇒ Observable[R]): Observable[R]
-
final
def
flatScan0[R](seed: ⇒ R)(op: (R, CommittableMessage[K, V]) ⇒ Observable[R]): Observable[R]
-
final
def
flatScan0DelayErrors[R](seed: ⇒ R)(op: (R, CommittableMessage[K, V]) ⇒ Observable[R]): Observable[R]
-
final
def
flatScanDelayErrors[R](seed: ⇒ R)(op: (R, CommittableMessage[K, V]) ⇒ Observable[R]): Observable[R]
-
final
def
flatten[B](implicit ev: <:<[CommittableMessage[K, V], Observable[B]]): Observable[B]
-
final
def
flattenDelayErrors[B](implicit ev: <:<[CommittableMessage[K, V], Observable[B]]): Observable[B]
-
final
def
flattenLatest[B](implicit ev: <:<[CommittableMessage[K, V], Observable[B]]): Observable[B]
-
final
def
fold[AA >: CommittableMessage[K, V]](implicit A: Monoid[AA]): Observable[AA]
-
final
def
foldL[AA >: CommittableMessage[K, V]](implicit A: Monoid[AA]): Task[AA]
-
final
def
foldLeft[R](seed: ⇒ R)(op: (R, CommittableMessage[K, V]) ⇒ R): Observable[R]
-
final
def
foldLeftL[R](seed: ⇒ R)(op: (R, CommittableMessage[K, V]) ⇒ R): Task[R]
-
final
def
foldWhileLeft[S](seed: ⇒ S)(op: (S, CommittableMessage[K, V]) ⇒ Either[S, S]): Observable[S]
-
final
def
foldWhileLeftL[S](seed: ⇒ S)(op: (S, CommittableMessage[K, V]) ⇒ Either[S, S]): Task[S]
-
-
-
final
def
foreach(cb: (CommittableMessage[K, V]) ⇒ Unit)(implicit s: Scheduler): CancelableFuture[Unit]
-
-
final
def
getClass(): Class[_]
-
final
def
groupBy[K](keySelector: (CommittableMessage[K, V]) ⇒ K)(implicit os: Synchronous[Nothing]): Observable[GroupedObservable[K, CommittableMessage[K, V]]]
-
final
def
guarantee(f: Task[Unit]): Observable[CommittableMessage[K, V]]
-
final
def
guaranteeCase(f: (ExitCase[Throwable]) ⇒ Task[Unit]): Observable[CommittableMessage[K, V]]
-
final
def
guaranteeCaseF[F[_]](f: (ExitCase[Throwable]) ⇒ F[Unit])(implicit F: TaskLike[F]): Observable[CommittableMessage[K, V]]
-
final
def
guaranteeF[F[_]](f: F[Unit])(implicit F: TaskLike[F]): Observable[CommittableMessage[K, V]]
-
def
hashCode(): Int
-
-
-
-
final
def
headOrElse[B >: CommittableMessage[K, V]](default: ⇒ B): Observable[B]
-
final
def
headOrElseL[B >: CommittableMessage[K, V]](default: ⇒ B): Task[B]
-
final
def
ignoreElements: Observable[Nothing]
-
final
def
interleave[B >: CommittableMessage[K, V]](other: Observable[B]): Observable[B]
-
final
def
intersperse[B >: CommittableMessage[K, V]](start: B, separator: B, end: B): Observable[B]
-
final
def
intersperse[B >: CommittableMessage[K, V]](separator: B): Observable[B]
-
final
def
isEmpty: Observable[Boolean]
-
final
def
isEmptyL: Task[Boolean]
-
final
def
isInstanceOf[T0]: Boolean
-
-
-
-
final
def
lastOrElseL[B >: CommittableMessage[K, V]](default: ⇒ B): Task[B]
-
final
def
liftByOperator[B](operator: Operator[CommittableMessage[K, V], B]): Observable[B]
-
final
def
map[B](f: (CommittableMessage[K, V]) ⇒ B): Observable[B]
-
final
def
mapEval[B](f: (CommittableMessage[K, V]) ⇒ Task[B]): Observable[B]
-
final
def
mapEvalF[F[_], B](f: (CommittableMessage[K, V]) ⇒ F[B])(implicit F: TaskLike[F]): Observable[B]
-
final
def
mapParallelOrdered[B](parallelism: Int)(f: (CommittableMessage[K, V]) ⇒ Task[B])(implicit os: OverflowStrategy[B]): Observable[B]
-
final
def
mapParallelUnordered[B](parallelism: Int)(f: (CommittableMessage[K, V]) ⇒ Task[B])(implicit os: OverflowStrategy[B]): Observable[B]
-
final
def
materialize: Observable[Notification[CommittableMessage[K, V]]]
-
final
def
max[AA >: CommittableMessage[K, V]](implicit A: Order[AA]): Observable[AA]
-
final
def
maxBy[K](key: (CommittableMessage[K, V]) ⇒ K)(implicit K: Order[K]): Observable[CommittableMessage[K, V]]
-
-
final
def
maxL[AA >: CommittableMessage[K, V]](implicit A: Order[AA]): Task[Option[AA]]
-
final
def
merge[B](implicit ev: <:<[CommittableMessage[K, V], Observable[B]], os: OverflowStrategy[B]): Observable[B]
-
final
def
mergeDelayErrors[B](implicit ev: <:<[CommittableMessage[K, V], Observable[B]], os: OverflowStrategy[B]): Observable[B]
-
final
def
mergeMap[B](f: (CommittableMessage[K, V]) ⇒ Observable[B])(implicit os: OverflowStrategy[B]): Observable[B]
-
final
def
mergeMapDelayErrors[B](f: (CommittableMessage[K, V]) ⇒ Observable[B])(implicit os: OverflowStrategy[B]): Observable[B]
-
final
def
min[AA >: CommittableMessage[K, V]](implicit A: Order[AA]): Observable[AA]
-
final
def
minBy[K](key: (CommittableMessage[K, V]) ⇒ K)(implicit K: Order[K]): Observable[CommittableMessage[K, V]]
-
-
final
def
minL[AA >: CommittableMessage[K, V]](implicit A: Order[AA]): Task[Option[AA]]
-
final
def
multicast[B >: CommittableMessage[K, V], R](pipe: Pipe[B, R])(implicit s: Scheduler): ConnectableObservable[R]
-
-
final
def
nonEmpty: Observable[Boolean]
-
final
def
nonEmptyL: Task[Boolean]
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
final
def
observeOn[B >: CommittableMessage[K, V]](s: Scheduler, os: OverflowStrategy[B]): Observable[B]
-
final
def
observeOn(s: Scheduler): Observable[CommittableMessage[K, V]]
-
final
def
onCancelTriggerError: Observable[CommittableMessage[K, V]]
-
final
def
onErrorFallbackTo[B >: CommittableMessage[K, V]](that: Observable[B]): Observable[B]
-
final
def
onErrorHandle[B >: CommittableMessage[K, V]](f: (Throwable) ⇒ B): Observable[B]
-
final
def
onErrorHandleWith[B >: CommittableMessage[K, V]](f: (Throwable) ⇒ Observable[B]): Observable[B]
-
final
def
onErrorRecover[B >: CommittableMessage[K, V]](pf: PartialFunction[Throwable, B]): Observable[B]
-
final
def
onErrorRecoverWith[B >: CommittableMessage[K, V]](pf: PartialFunction[Throwable, Observable[B]]): Observable[B]
-
final
def
onErrorRestart(maxRetries: Long): Observable[CommittableMessage[K, V]]
-
final
def
onErrorRestartIf(p: (Throwable) ⇒ Boolean): Observable[CommittableMessage[K, V]]
-
final
def
onErrorRestartUnlimited: Observable[CommittableMessage[K, V]]
-
final
def
pipeThrough[I >: CommittableMessage[K, V], B](pipe: Pipe[I, B]): Observable[B]
-
final
def
pipeThroughSelector[S >: CommittableMessage[K, V], B, R](pipe: Pipe[S, B], f: (Observable[B]) ⇒ Observable[R]): Observable[R]
-
final
def
prepend[B >: CommittableMessage[K, V]](elem: B): Observable[B]
-
final
def
publish(implicit s: Scheduler): ConnectableObservable[CommittableMessage[K, V]]
-
final
def
publishLast(implicit s: Scheduler): ConnectableObservable[CommittableMessage[K, V]]
-
final
def
publishSelector[R](f: (Observable[CommittableMessage[K, V]]) ⇒ Observable[R]): Observable[R]
-
final
def
reduce[B >: CommittableMessage[K, V]](op: (B, B) ⇒ B): Observable[B]
-
-
final
def
replay(bufferSize: Int)(implicit s: Scheduler): ConnectableObservable[CommittableMessage[K, V]]
-
final
def
replay(implicit s: Scheduler): ConnectableObservable[CommittableMessage[K, V]]
-
-
final
def
runAsyncGetFirst(implicit s: Scheduler, opts: Options): CancelableFuture[Option[CommittableMessage[K, V]]]
-
final
def
runAsyncGetLast(implicit s: Scheduler, opts: Options): CancelableFuture[Option[CommittableMessage[K, V]]]
-
-
final
def
sampleBy[B](sampler: Observable[B]): Observable[CommittableMessage[K, V]]
-
-
final
def
sampleRepeatedBy[B](sampler: Observable[B]): Observable[CommittableMessage[K, V]]
-
final
def
scan[S](seed: ⇒ S)(op: (S, CommittableMessage[K, V]) ⇒ S): Observable[S]
-
final
def
scan0[S](seed: ⇒ S)(op: (S, CommittableMessage[K, V]) ⇒ S): Observable[S]
-
final
def
scanEval[S](seed: Task[S])(op: (S, CommittableMessage[K, V]) ⇒ Task[S]): Observable[S]
-
final
def
scanEval0[S](seed: Task[S])(op: (S, CommittableMessage[K, V]) ⇒ Task[S]): Observable[S]
-
final
def
scanEval0F[F[_], S](seed: F[S])(op: (S, CommittableMessage[K, V]) ⇒ F[S])(implicit F: TaskLike[F], A: Applicative[F]): Observable[S]
-
final
def
scanEvalF[F[_], S](seed: F[S])(op: (S, CommittableMessage[K, V]) ⇒ F[S])(implicit F: TaskLike[F]): Observable[S]
-
final
def
scanMap[B](f: (CommittableMessage[K, V]) ⇒ B)(implicit B: Monoid[B]): Observable[B]
-
final
def
scanMap0[B](f: (CommittableMessage[K, V]) ⇒ B)(implicit B: Monoid[B]): Observable[B]
-
final
def
share(implicit s: Scheduler): Observable[CommittableMessage[K, V]]
-
final
def
startWith[B >: CommittableMessage[K, V]](elems: Seq[B]): Observable[B]
-
final
def
subscribe(nextFn: (CommittableMessage[K, V]) ⇒ Future[Ack], errorFn: (Throwable) ⇒ Unit, completedFn: () ⇒ Unit)(implicit s: Scheduler): Cancelable
-
final
def
subscribe(nextFn: (CommittableMessage[K, V]) ⇒ Future[Ack])(implicit s: Scheduler): Cancelable
-
final
def
subscribe()(implicit s: Scheduler): Cancelable
-
final
def
subscribe(nextFn: (CommittableMessage[K, V]) ⇒ Future[Ack], errorFn: (Throwable) ⇒ Unit)(implicit s: Scheduler): Cancelable
-
final
def
subscribe(subscriber: Subscriber[CommittableMessage[K, V]]): Cancelable
-
final
def
subscribe(observer: Observer[CommittableMessage[K, V]])(implicit s: Scheduler): Cancelable
-
final
def
subscribeOn(scheduler: Scheduler): Observable[CommittableMessage[K, V]]
-
final
def
sum[AA >: CommittableMessage[K, V]](implicit A: Numeric[AA]): Observable[AA]
-
final
def
sumL[B >: CommittableMessage[K, V]](implicit B: Numeric[B]): Task[B]
-
final
def
switch[B](implicit ev: <:<[CommittableMessage[K, V], Observable[B]]): Observable[B]
-
final
def
switchIfEmpty[B >: CommittableMessage[K, V]](backup: Observable[B]): Observable[B]
-
final
def
switchMap[B](f: (CommittableMessage[K, V]) ⇒ Observable[B]): Observable[B]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
-
-
-
final
def
takeEveryNth(n: Int): Observable[CommittableMessage[K, V]]
-
final
def
takeLast(n: Int): Observable[CommittableMessage[K, V]]
-
final
def
takeUntil(trigger: Observable[Any]): Observable[CommittableMessage[K, V]]
-
-
-
final
def
takeWhileNotCanceled(c: BooleanCancelable): Observable[CommittableMessage[K, V]]
-
-
-
-
-
-
final
def
timeoutOnSlowUpstreamTo[B >: CommittableMessage[K, V]](timeout: FiniteDuration, backup: Observable[B]): Observable[B]
-
final
def
toListL: Task[List[CommittableMessage[K, V]]]
-
final
def
toReactivePublisher[B >: CommittableMessage[K, V]](implicit s: Scheduler): Publisher[B]
-
def
toString(): String
-
final
def
uncancelable: Observable[CommittableMessage[K, V]]
-
final
def
unsafeMulticast[B >: CommittableMessage[K, V], R](processor: Subject[B, R])(implicit s: Scheduler): ConnectableObservable[R]
-
final
def
unsafeSubscribeFn(out: Subscriber[CommittableMessage[K, V]]): Cancelable
-
final
def
unsafeSubscribeFn(observer: Observer[CommittableMessage[K, V]])(implicit s: Scheduler): Cancelable
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
final
def
whileBusyBuffer[B >: CommittableMessage[K, V]](overflowStrategy: Synchronous[B]): Observable[B]
-
final
def
whileBusyDropEvents: Observable[CommittableMessage[K, V]]
-
final
def
whileBusyDropEventsAndSignal[B >: CommittableMessage[K, V]](onOverflow: (Long) ⇒ B): Observable[B]
-
final
def
withLatestFrom[B, R](other: Observable[B])(f: (CommittableMessage[K, V], B) ⇒ R): Observable[R]
-
final
def
withLatestFrom2[B1, B2, R](o1: Observable[B1], o2: Observable[B2])(f: (CommittableMessage[K, V], B1, B2) ⇒ R): Observable[R]
-
final
def
withLatestFrom3[B1, B2, B3, R](o1: Observable[B1], o2: Observable[B2], o3: Observable[B3])(f: (CommittableMessage[K, V], B1, B2, B3) ⇒ R): Observable[R]
-
final
def
withLatestFrom4[B1, B2, B3, B4, R](o1: Observable[B1], o2: Observable[B2], o3: Observable[B3], o4: Observable[B4])(f: (CommittableMessage[K, V], B1, B2, B3, B4) ⇒ R): Observable[R]
-
final
def
withLatestFrom5[B1, B2, B3, B4, B5, R](o1: Observable[B1], o2: Observable[B2], o3: Observable[B3], o4: Observable[B4], o5: Observable[B5])(f: (CommittableMessage[K, V], B1, B2, B3, B4, B5) ⇒ R): Observable[R]
-
final
def
withLatestFrom6[B1, B2, B3, B4, B5, B6, R](o1: Observable[B1], o2: Observable[B2], o3: Observable[B3], o4: Observable[B4], o5: Observable[B5], o6: Observable[B6])(f: (CommittableMessage[K, V], B1, B2, B3, B4, B5, B6) ⇒ R): Observable[R]
-
final
def
zip[B](other: Observable[B]): Observable[(CommittableMessage[K, V], B)]
-
final
def
zipMap[B, R](other: Observable[B])(f: (CommittableMessage[K, V], B) ⇒ R): Observable[R]
-
final
def
zipWithIndex: Observable[(CommittableMessage[K, V], Long)]
Inherited from Serializable
KafkaConsumerObservable with ability to manual commit offsets and forcibly disables auto commits in configuration. Such instances emit CommittableMessage instead of Kafka's ConsumerRecord.