Struct DisabledOffload 

pub struct DisabledOffload;

A disabled offload implementation that discards all spawned tasks.

This implementation accepts futures with any lifetime since it doesn’t actually execute them. Use this when:

• Background revalidation is not needed
• Integrating with middleware systems that have non-'static types (e.g., reqwest middleware’s Next<'_>)

Example

use hitbox_core::{Offload, DisabledOffload, OffloadKey};

let offload = DisabledOffload;

// This works even with non-'static futures
let borrowed_data = String::from("hello");
let borrowed_ref = &borrowed_data;
offload.register(OffloadKey::explicit("test", 0), async move {
    // Would use borrowed_ref here
    let _ = borrowed_ref;
});

Trait Implementations

impl Clone for DisabledOffload

fn clone(&self) -> DisabledOffload

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DisabledOffload

impl Debug for DisabledOffload

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

Formats the value using the given formatter.

impl Default for DisabledOffload

fn default() -> DisabledOffload

Returns the “default value” for a type.

impl Eq for DisabledOffload

impl<'a> Offload<'a> for DisabledOffload

fn spawn<F>(&self, _kind: impl Into<SmolStr>, _future: F)

where F: Future<Output = ()> + Send + 'a,

👎Deprecated since 0.2.1:

use register instead, will be removed in 0.3

Spawn a future to be executed in the background.

fn register<K, F>(&self, _key: K, _future: F)

where K: Into<OffloadKey>, F: Future<Output = ()> + Send + 'a,

Register a future to be executed in the background.

impl PartialEq for DisabledOffload

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for DisabledOffload