deploy: 4ae5a0d

js/search.js

@@ -47,25 +47,25 @@ function prepareIdxAndDocMap() {
       "url": "/jms4s/providers/",
       "content": "Providers Currently supported: Active MQ Artemis IBM MQ Supporting a new provider is a task which should be pretty straightforward. I you need a provider which is missing you can: Try contributing! PRs are always welcome! Raise an issue. Let us know, someone may eventually pick that up or we can guide you to a complete PR."
     } ,    
+    {
+      "title": "Auto-Acknowledger Consumer",
+      "url": "/jms4s/programs/auto-ack-consumer/",
+      "content": "Auto Acknowledger Consumer A JmsAutoAcknowledgerConsumer is a consumer that will automatically acknowledge a message after its reception. Its only operation is: def handle(f: (JmsMessage, MessageFactory[F]) => F[AutoAckAction[F]]): F[Unit] This is where the user of the API can specify its business logic, which can be any effectful operation. Creating a message is as effectful operation as well, and the MessageFactory argument will provide the only way in which a client can create a brand new message. This argument can be ignored if the client is only consuming messages. What handle expects is an AutoAckAction[F], which can be either: an AckAction.noOp, which will instructs the lib to do nothing since the message will be acknowledged regardless an AckAction.send in all its forms, which can be used to send 1 or multiple messages to 1 or multiple destinations The consumer can be configured specifying a concurrencyLevel, which is used internally to scale the operations (receive and then process up to concurrencyLevel). A complete example is available in the example project."
+    } ,    
     {
       "title": "Producer",
       "url": "/jms4s/programs/producer/",
       "content": "Producer A JmsProducer is a producer that lets the client publish a message in queues/topics. sendN: to send N messages to N Destinations. def sendN( makeN: MessageFactory[F] => F[NonEmptyList[(JmsMessage, DestinationName)]] ): F[Unit] sendNWithDelay: to send N messages to N Destinations with an optional delay. def sendNWithDelay( makeNWithDelay: MessageFactory[F] => F[NonEmptyList[(JmsMessage, (DestinationName, Option[FiniteDuration]))]] ): F[Unit] sendWithDelay: to send a message to a Destination. def sendWithDelay( make1WithDelay: MessageFactory[F] => F[(JmsMessage, (DestinationName, Option[FiniteDuration]))] ): F[Unit] send: to send a message to a Destination. def send( make1: MessageFactory[F] => F[(JmsMessage, DestinationName)] ): F[Unit] For each operation, the client has to provide a function that knows how to build a JmsMessage given a MessageFactory. This may appear counter-intuitive at first, but the reason behind this design is that creating a JmsMessage is an operation that involves interacting with JMS APIs, and we want to provide a high-level API so that the user can’t do things wrong. A complete example is available in the example project. A note on concurrency A JmsProducer can be used concurrently, performing up to concurrencyLevel concurrent operation."
     } ,    
-    {
-      "title": "Acknowledger Consumer",
-      "url": "/jms4s/programs/ack-consumer/",
-      "content": "Acknowledger Consumer A JmsAcknowledgerConsumer is a consumer which let the client decide whether confirm (a.k.a. ack) or reject (a.k.a. nack) a message after its reception. Its only operation is: def handle(f: (JmsMessage, MessageFactory[F]) => F[AckAction[F]]): F[Unit] This is where the user of the API can specify its business logic, which can be any effectful operation. Creating a message is as effectful operation as well, and the MessageFactory argument will provide the only way in which a client can create a brand new message. This argument can be ignored if the client is only consuming messages. What handle expects is an AckAction[F], which can be either: an AckAction.ack, which will instructs the lib to confirm the message an AckAction.noAck, which will instructs the lib to do nothing an AckAction.send in all its forms, which can be used to instruct the lib to send 1 or multiple messages to 1 or multiple destinations The consumer can be configured specifying a concurrencyLevel, which is used internally to scale the operations (receive and then process up to concurrencyLevel). A complete example is available in the example project."
-    } ,    
     {
       "title": "Transacted Consumer",
       "url": "/jms4s/programs/tx-consumer/",
       "content": "Transacted Consumer A JmsTransactedConsumer is a consumer that will use a local transaction to receive a message and which lets the client decide whether to commit or rollback it. Its only operation is: def handle(f: (JmsMessage, MessageFactory[F]) => F[TransactionAction[F]]): F[Unit] This is where the user of the API can specify its business logic, which can be any effectful operation. Creating a message is as effectful operation as well, and the MessageFactory argument will provide the only way in which a client can create a brand new message. This argument can be ignored if the client is only consuming messages. What handle expects is a TransactionAction[F], which can be either: a TransactionAction.commit, which will instructs the lib to commit the local transaction a TransactionAction.rollback, which will instructs the lib to rollback the local transaction a TransactionAction.send in all its forms, which can be used to send 1 or multiple messages to 1 or multiple destinations and then commit the local transaction The consumer can be configured specifying a concurrencyLevel, which is used internally to scale the operations (receive and then process up to concurrencyLevel). A complete example is available in the example project."
     } ,    
     {
-      "title": "Auto-Acknowledger Consumer",
-      "url": "/jms4s/programs/auto-ack-consumer/",
-      "content": "Auto Acknowledger Consumer A JmsAutoAcknowledgerConsumer is a consumer that will automatically acknowledge a message after its reception. Its only operation is: def handle(f: (JmsMessage, MessageFactory[F]) => F[AutoAckAction[F]]): F[Unit] This is where the user of the API can specify its business logic, which can be any effectful operation. Creating a message is as effectful operation as well, and the MessageFactory argument will provide the only way in which a client can create a brand new message. This argument can be ignored if the client is only consuming messages. What handle expects is an AutoAckAction[F], which can be either: an AckAction.noOp, which will instructs the lib to do nothing since the message will be acknowledged regardless an AckAction.send in all its forms, which can be used to send 1 or multiple messages to 1 or multiple destinations The consumer can be configured specifying a concurrencyLevel, which is used internally to scale the operations (receive and then process up to concurrencyLevel). A complete example is available in the example project."
+      "title": "Acknowledger Consumer",
+      "url": "/jms4s/programs/ack-consumer/",
+      "content": "Acknowledger Consumer A JmsAcknowledgerConsumer is a consumer which let the client decide whether confirm (a.k.a. ack) or reject (a.k.a. nack) a message after its reception. Its only operation is: def handle(f: (JmsMessage, MessageFactory[F]) => F[AckAction[F]]): F[Unit] This is where the user of the API can specify its business logic, which can be any effectful operation. Creating a message is as effectful operation as well, and the MessageFactory argument will provide the only way in which a client can create a brand new message. This argument can be ignored if the client is only consuming messages. What handle expects is an AckAction[F], which can be either: an AckAction.ack, which will instructs the lib to confirm the message an AckAction.noAck, which will instructs the lib to do nothing an AckAction.send in all its forms, which can be used to instruct the lib to send 1 or multiple messages to 1 or multiple destinations The consumer can be configured specifying a concurrencyLevel, which is used internally to scale the operations (receive and then process up to concurrencyLevel). A complete example is available in the example project."
     } ,    
     {
       "title": "Program",