Struct NonZeroDuration 

pub struct NonZeroDuration(/* private fields */);

A Duration that is known not to be zero.

JetStreamSubject::pull_expires and JetStreamSubject::ack_wait take one. A fetch that expires the instant it is issued turns the batch loop into a hot spin, so the zero is kept out of the type instead of being caught when the subscription opens.

Examples

use ruststream_nats::prelude::*;
use serde::Deserialize;

#[derive(Deserialize)]
struct Order {
    amount: u64,
}

#[subscriber(
    JetStreamSubject::new("orders.*", "ORDERS")
        .durable("reconciler")
        .ack_wait(NonZeroDuration::from_secs(nonzero!(60)))
        .pull_expires(NonZeroDuration::from_millis(nonzero!(300)))
)]
async fn reconcile(orders: &[Order]) -> HandlerOutcome {
    let total: u64 = orders.iter().map(|order| order.amount).sum();
    tracing::info!(count = orders.len(), total, "reconciled");
    HandlerOutcome::ack()
}

#[ruststream::app]
fn app() -> impl App {
    RustStream::new(AppInfo::new("orders", "0.1.0")).with_broker(
        NatsBroker::new("nats://localhost:4222"),
        |b| {
            b.include(reconcile.batch(nonzero!(50)));
        },
    )
}

A literal is checked while the crate compiles, so a zero window does not build:

use ruststream::nonzero;
use ruststream_nats::NonZeroDuration;

let window = NonZeroDuration::from_millis(nonzero!(0));

Implementations

impl NonZeroDuration

pub const fn new(value: Duration) -> Option<Self>

Wraps value, or returns None when it is zero.

This is the entry for a duration that arrives at run time, from configuration or from a calculation. A literal reads better through from_secs or from_millis.

pub const fn from_secs(secs: NonZeroU64) -> Self

Builds a duration of secs seconds.

pub const fn from_millis(millis: NonZeroU64) -> Self

Builds a duration of millis milliseconds.

pub const fn get(self) -> Duration

The duration itself.

Trait Implementations

impl Clone for NonZeroDuration

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for NonZeroDuration

impl Debug for NonZeroDuration

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for NonZeroDuration

impl From<NonZeroDuration> for Duration

fn from(value: NonZeroDuration) -> Self

Converts to this type from the input type.

impl Hash for NonZeroDuration

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for NonZeroDuration

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for NonZeroDuration

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for NonZeroDuration

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for NonZeroDuration