PulsarConsumer

Instance Constructors

new PulsarConsumer(topic: Either[String, Regex], patternAutoDiscoveryPeriod: Option[FiniteDuration], subscriptionInitialPosition: Option[SubscriptionInitialPosition], subscriptionInitialPublishTime: Option[Instant], subscriptionName: String, subscriptionType: SubscriptionType, subscriptionMode: SubscriptionMode, redeliverUnacknowledgedMessages: Boolean, consumerBuilder: (ConsumerBuilder[Array[Byte]]) ⇒ ConsumerBuilder[Array[Byte]])(implicit arg0: Concurrent[F], arg1: Timer[F], context: PulsarContext)

Type Members

implicit class ConsumerBuilderExt[T] extends AnyRef
case class IterableSequenceSyntax[T] extends Product with Serializable

Definition Classes
CatsUtils
type MonadErrorWithThrowable[F[_]] = MonadError[F, Throwable]

Definition Classes
CatsUtils

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
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@IntrinsicCandidate() @throws( ... )
val consumer: Consumer[Array[Byte]]
val consumerBuilder: (ConsumerBuilder[Array[Byte]]) ⇒ ConsumerBuilder[Array[Byte]]
def debug(msg: ⇒ String, t: Throwable)(implicit sync: Sync[F]): F[Unit]

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

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

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

Definition Classes
CatsUtils
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def error(msg: ⇒ String, t: Throwable)(implicit sync: Sync[F]): F[Unit]

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

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

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

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

Definition Classes
CatsUtils
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@IntrinsicCandidate()
def guarantee[A](fa: F[A])(finalizer: F[Unit])(implicit bracket: Bracket[F, Throwable]): F[A]

Definition Classes
CatsUtils
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@IntrinsicCandidate()
def info(msg: ⇒ String, t: Throwable)(implicit sync: Sync[F]): F[Unit]

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

Definition Classes
Logging
def initialize: F[Unit]

Definition Classes
DefaultMessageConsumer
final def isInstanceOf[T0]: Boolean

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

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

Definition Classes
CatsUtils
lazy val logger: Logger

Attributes
protected
Definition Classes
LazyLogging
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@IntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@IntrinsicCandidate()
def onStartReceiving: F[Unit]

Definition Classes
PulsarConsumer → DefaultMessageConsumer
val patternAutoDiscoveryPeriod: Option[FiniteDuration]
def printColorLn(msg: String)(implicit sync: Sync[F]): F[Unit]

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

Definition Classes
CatsUtils
def printStr(msg: String)(implicit sync: Sync[F]): F[Unit]

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

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

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

Definition Classes
PulsarConsumer → DefaultMessageConsumer → MessageConsumer
def receiveMessagesUntilCancelled[T](callback: (MessageReceiveResult[F, M]) ⇒ F[T], cancelled: Ref[F, Boolean], receiving: Deferred[F, Unit], receiveTimeout: FiniteDuration, receivingCompleted: Boolean)(implicit u: Unmarshaller[M]): F[Unit]

Definition Classes
DefaultMessageConsumer
val receiveTimeoutInSubscribe: FiniteDuration

Definition Classes
DefaultMessageConsumer
val redeliverUnacknowledgedMessages: Boolean
def sleep(duration: FiniteDuration)(implicit F: Timer[F]): F[Unit]

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

Definition Classes
CatsUtils
def stop: F[Unit]

Definition Classes
PulsarConsumer → MessageConsumer
def subscribe[T](callback: (MessageReceiveResult[F, M]) ⇒ F[T])(implicit u: Unmarshaller[M]): F[MessageSubscription[F, M]]

Definition Classes
DefaultMessageConsumer → MessageConsumer
val subscriptionInitialPosition: Option[SubscriptionInitialPosition]
val subscriptionInitialPublishTime: Option[Instant]
val subscriptionMode: SubscriptionMode
val subscriptionName: String
val subscriptionType: SubscriptionType
final def synchronized[T0](arg0: ⇒ T0): T0

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

Definition Classes
CatsUtils
def toString(): String

Definition Classes
PulsarConsumer → AnyRef → Any
val topic: Either[String, Regex]
def trace(msg: ⇒ String, t: Throwable)(implicit sync: Sync[F]): F[Unit]

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

Definition Classes
Logging
def unit(implicit F: Monad[F]): F[Unit]

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

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def waitFor[A](f: ⇒ F[A])(cond: (A) ⇒ F[Boolean], pollTime: FiniteDuration)(implicit concurrent: Concurrent[F], timer: Timer[F]): F[A]

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

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

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

Definition Classes
CatsUtils

Deprecated Value Members

def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@Deprecated @deprecated @throws( classOf[java.lang.Throwable] )
Deprecated
(Since version ) see corresponding Javadoc for more information.

Related Docs: object PulsarConsumer | package pulsar

class PulsarConsumer[F[_], M] extends DefaultMessageConsumer[F, M]

Instance Constructors

Type Members

implicit class ConsumerBuilderExt[T] extends AnyRef

case class IterableSequenceSyntax[T] extends Product with Serializable

type MonadErrorWithThrowable[F[_]] = MonadError[F, Throwable]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

val consumer: Consumer[Array[Byte]]

val consumerBuilder: (ConsumerBuilder[Array[Byte]]) ⇒ ConsumerBuilder[Array[Byte]]

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]

val patternAutoDiscoveryPeriod: Option[FiniteDuration]

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

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

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

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]]

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

val receiveTimeoutInSubscribe: FiniteDuration

val redeliverUnacknowledgedMessages: Boolean

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]]

val subscriptionInitialPosition: Option[SubscriptionInitialPosition]

val subscriptionInitialPublishTime: Option[Instant]

val subscriptionMode: SubscriptionMode

val subscriptionName: String

val subscriptionType: SubscriptionType

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

val topic: Either[String, Regex]

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]

Deprecated Value Members

def finalize(): Unit

Inherited from DefaultMessageConsumer[F, M]

Inherited from Logging[F]

Inherited from LazyLogging

Inherited from CatsUtils[F]