InMemoryConsumer

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def debug(msg: ⇒ String, t: Throwable)(implicit sync: Sync[F]): F[Unit]

def debug(msg: ⇒ String)(implicit sync: Sync[F]): F[Unit]

def defer[A](f: ⇒ F[A])(implicit F: Sync[F]): F[A]

def delay[A](f: ⇒ A)(implicit F: Sync[F]): F[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(msg: ⇒ String, t: Throwable)(implicit sync: Sync[F]): F[Unit]

def error(msg: ⇒ String)(implicit sync: Sync[F]): F[Unit]

def fromEither[A](e: Either[Throwable, A])(implicit F: MonadErrorWithThrowable[F]): F[A]

def fromFuture[A](f: ⇒ Future[A])(implicit F: Concurrent[F]): F[A]

def fromJavaFuture[A](future: ⇒ Future[A], pollTime: FiniteDuration)(implicit sync: Sync[F]): F[A]

final def getClass(): Class[_]

def guarantee[A](fa: F[A])(finalizer: F[Unit])(implicit bracket: Bracket[F, Throwable]): F[A]

def hashCode(): Int

def info(msg: ⇒ String, t: Throwable)(implicit sync: Sync[F]): F[Unit]

def info(msg: ⇒ String)(implicit sync: Sync[F]): F[Unit]

def initialize: F[Unit]

final def isInstanceOf[T0]: Boolean

implicit def iterableToSequenceSyntax[T](l: Iterable[F[T]])(implicit parallel: Parallel[F], applicative: Applicative[F]): IterableSequenceSyntax[T]

def liftIO[A](f: IO[A])(implicit F: LiftIO[F]): F[A]

lazy val logger: Logger

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onStartReceiving: F[Unit]

def printLn(msg: String)(implicit sync: Sync[F]): F[Unit]

def producer: F[InMemoryProducer[F, M]]

def pure[A](a: A)(implicit F: Monad[F]): F[A]

def raiseError[A](t: Throwable)(implicit F: MonadErrorWithThrowable[F]): F[A]

def receive(timeout: Option[FiniteDuration])(implicit u: Unmarshaller[M]): F[MessageReceiveResult[F, M]]

Receive a message from the consumer.

def receiveMessagesUntilCancelled[T](callback: (MessageReceiveResult[F, M]) ⇒ F[T], cancelled: Ref[F, Boolean], receiving: Deferred[F, Unit], receiveTimeout: FiniteDuration = receiveTimeoutInSubscribe, receivingCompleted: Boolean = false)(implicit u: Unmarshaller[M]): F[Unit]

val receiveResult: MVar[F, MessageReceiveResult[F, M]]

val receiveTimeoutInSubscribe: FiniteDuration

def sleep(duration: FiniteDuration)(implicit F: Timer[F]): F[Unit]

def start[A](f: F[A])(implicit F: Concurrent[F]): F[Fiber[F, A]]

def stop: F[Unit]

def subscribe[T](callback: (MessageReceiveResult[F, M]) ⇒ F[T])(implicit u: Unmarshaller[M]): F[MessageSubscription[F, M]]

Receive messages continuously and call the provided callback function for each message.

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

def take[T](mvar: MVar[F, T], timeout: Option[FiniteDuration], pollTime: FiniteDuration)(implicit concurrent: Concurrent[F], timer: Timer[F]): F[T]

def toString(): String

def trace(msg: ⇒ String, t: Throwable)(implicit sync: Sync[F]): F[Unit]

def trace(msg: ⇒ String)(implicit sync: Sync[F]): F[Unit]

def unit(implicit F: Monad[F]): F[Unit]

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def waitFor[A](f: ⇒ F[A])(cond: (A) ⇒ F[Boolean], pollTime: FiniteDuration)(implicit concurrent: Concurrent[F], timer: Timer[F]): F[A]

def warn(msg: ⇒ String, t: Throwable)(implicit sync: Sync[F]): F[Unit]

def warn(msg: ⇒ String)(implicit sync: Sync[F]): F[Unit]

def whenA[A](cond: Boolean)(f: ⇒ F[A])(implicit F: Monad[F]): F[Unit]

def finalize(): Unit