Struct InterestQueue 

pub struct InterestQueue<T, C: CodecType> { /* private fields */ }

A typed queue with interest-based retention and configurable codec.

Messages are retained until acknowledged by all consumers that were active when the message was published.

Type Parameters

• T - The message type for this queue
• C - The codec type used for serialization

Example

use intercom::{Client, MsgPackCodec, jetstream::queue::InterestQueue};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
struct Event {
    id: u64,
    data: String,
}

let client = Client::<MsgPackCodec>::connect("nats://localhost:4222").await?;
let jetstream = client.jetstream();

// Create an interest-based queue
let queue = InterestQueue::<Event, MsgPackCodec>::builder(&jetstream, "events")
    .subject("events.>")
    .create()
    .await?;

// Add consumers
let consumer1 = queue.add_consumer("service-a").await?;
let consumer2 = queue.add_consumer("service-b").await?;

// Both consumers must acknowledge for message removal

Implementations

impl<T, C: CodecType> InterestQueue<T, C>

pub fn builder( context: &JetStreamContext<C>, name: &str, ) -> InterestQueueBuilder<T, C>

Create an interest queue builder.

pub fn stream(&self) -> &JsStream<C>

Get the stream backing this queue.

pub fn subject(&self) -> &str

Get the subject for this queue.

pub async fn add_consumer(&self, name: &str) -> Result<PullConsumer<T, C>>

Add a durable consumer to this queue.

pub async fn add_consumer_filtered( &self, name: &str, filter: &str, ) -> Result<PullConsumer<T, C>>

Add a consumer with a filter subject.

impl<T: Serialize, C: CodecType> InterestQueue<T, C>

pub async fn publish(&self, message: &T) -> Result<u64>

Publish a message to the queue.

pub async fn publish_to(&self, subject: &str, message: &T) -> Result<u64>

Publish a message to a specific subject within the queue’s subject space.