Struct WithCodec 

pub struct WithCodec<B, NewCodec> { /* private fields */ }

A Backend wrapper that swaps out the serialization codec entirely (JSON, MessagePack, Protobuf, …) without touching storage logic.

Features

Feature	Status	Description
Backend	✅	Basic Backend functionality
TaskSink	✅	Ability to push new tasks
InheritsFeatures	✅ ❗	Inherits features from the underlying backend

Key: ✅ : Supported | ⚠️ : Not implemented | ❌ : Not Supported | ❗ Limited support

Tests:

Implementations

impl<B, NewCodec> WithCodec<B, NewCodec>

pub fn new(backend: B, codec: NewCodec) -> Self

Create a new WithCodec wrapping the given backend and codec.

Trait Implementations

impl<B, NewCodec> Backend for WithCodec<B, NewCodec>

where B: Backend,

type Task = <B as Backend>::Task

The type of task the backend emits.

type Error = <B as Backend>::Error

The error type returned by backend operations

fn poll_ready( &mut self, cx: &mut Context<'_>, worker: &WorkerContext, ) -> Poll<Result<(), Self::Error>>

Polls whether the backend is ready for the worker to request more work.

fn poll_next( &mut self, cx: &mut Context<'_>, worker: &WorkerContext, ) -> Poll<Option<Result<Self::Task, Self::Error>>>

Polls the backend for the next available task for this worker.

fn poll_close( &mut self, cx: &mut Context<'_>, worker: &WorkerContext, ) -> Poll<Result<(), Self::Error>>

Flushes/releases any resources the backend holds (pending acks, open subscriptions, connections) before the worker fully shuts down.

impl<B, NewCodec> BackendConfig for WithCodec<B, NewCodec>

where B: BackendConfig,

type Id = <B as BackendConfig>::Id

The internal type of this Backend’s TaskId

type Args = <B as BackendConfig>::Args

The type of argument this backend emits

type Kind = <B as BackendConfig>::Kind

This defines the kind of Backend

type Config = <B as BackendConfig>::Config

The config for the backend

type Layer = <B as BackendConfig>::Layer

The type representing backend middleware layer.

fn config(&self) -> &Self::Config

Returns the config associated with the backend.

fn middleware(&mut self, worker: &mut WorkerContext) -> Self::Layer

Returns the backend’s middleware layer.

impl<B: Clone, NewCodec: Clone> Clone for WithCodec<B, NewCodec>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Debug, NewCodec: Debug> Debug for WithCodec<B, NewCodec>

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

Formats the value using the given formatter.

impl<B, NewCodec> Deref for WithCodec<B, NewCodec>

type Target = B

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<B, NewCodec> DerefMut for WithCodec<B, NewCodec>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<B, C> FetchById for WithCodec<B, C>

where B: FetchById + Send + Sync + Backend + BackendConfig + WireFormatBackend, B::Task: Send, C: Send + Sync + 'static + Codec<B::Args, Compact = B::Compact>,

async fn fetch_by_id( &mut self, task_id: &TaskId, ) -> Result<Option<B::Task>, Self::Error>

Fetch a task by its unique identifier

impl<B, C> ListAllTasks for WithCodec<B, C>

where B: ListAllTasks + Send + Sync + Backend + BackendConfig + WireFormatBackend, C: Send + Sync + 'static + Codec<B::Args, Compact = B::Compact>,

async fn list_all_tasks( &self, filter: &Filter, ) -> Result<Vec<Task<Self::Compact>>, Self::Error>

List tasks matching the given filter in all queues

impl<B, C> ListQueues for WithCodec<B, C>

where B: ListQueues + Send + Sync + Backend + BackendConfig + WireFormatBackend, C: Send + Sync + 'static + Codec<B::Args, Compact = B::Compact>,

async fn list_queues(&self) -> Result<Vec<QueueInfo>, Self::Error>

List all available queues in the backend

impl<B, C> ListTasks for WithCodec<B, C>

where B: ListTasks + Send + Sync + Backend + BackendConfig + WireFormatBackend, C: Send + Sync + 'static + Codec<B::Args, Compact = B::Compact>,

async fn list_tasks( &self, filter: &Filter, ) -> Result<Vec<Task<Self::Compact>>, Self::Error>

List tasks matching the given filter in the current queue

impl<B, C> ListWorkers for WithCodec<B, C>

where B: ListWorkers + Send + Sync + Backend + BackendConfig + WireFormatBackend, C: Send + Sync + 'static + Codec<B::Args, Compact = B::Compact>,

async fn list_workers(&self) -> Result<Vec<RunningWorker>, Self::Error>

List all registered workers in the current queue

async fn list_all_workers(&self) -> Result<Vec<RunningWorker>, Self::Error>

List all registered workers in all queues

impl<B, C> Metrics for WithCodec<B, C>

where B: Metrics + Send + Sync + Backend + BackendConfig + WireFormatBackend, C: Send + Sync + 'static + Codec<B::Args, Compact = B::Compact>,

async fn global(&self) -> Result<Vec<Statistic>, Self::Error>

Collects and returns global statistics from the backend

async fn fetch_by_queue(&self) -> Result<Vec<Statistic>, Self::Error>

Collects and returns statistics for a specific queue

impl<B, C> RegisterWorker for WithCodec<B, C>

where B: RegisterWorker + Send + Sync + Backend + BackendConfig + WireFormatBackend, C: Send + Sync + 'static + Codec<B::Args, Compact = B::Compact>,

async fn register_worker( &mut self, worker_id: String, ) -> Result<(), Self::Error>

Registers a worker

impl<B, C> Reschedule for WithCodec<B, C>

where B: Reschedule + Send + Sync + Backend + BackendConfig + WireFormatBackend, B::Task: Send, C: Send + Sync + 'static + Codec<B::Args, Compact = B::Compact>,

async fn reschedule( &mut self, task: Self::Task, wait: Duration, ) -> Result<(), Self::Error>

Reschedule the task after a specified duration

impl<B, C> ResumeAbandoned for WithCodec<B, C>

where B: ResumeAbandoned + Send + Sync + Backend + BackendConfig + WireFormatBackend, C: Send + Sync + 'static + Codec<B::Args, Compact = B::Compact>,

async fn resume_abandoned(&mut self) -> Result<usize, Self::Error>

Resume all abandoned tasks

impl<B, C> ResumeById for WithCodec<B, C>

where B: ResumeById + Send + Sync + Backend + BackendConfig + WireFormatBackend, C: Send + Sync + 'static + Codec<B::Args, Compact = B::Compact>,

async fn resume_by_id(&mut self, id: TaskId) -> Result<bool, Self::Error>

Resume a task by its ID

impl<B, NewCodec, T, Err> Sink<T> for WithCodec<B, NewCodec>

where B: Sink<T, Error = Err> + Unpin, NewCodec: Unpin,

type Error = Err

The type of value produced by the sink when an error occurs.

fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

impl<B, C> Update for WithCodec<B, C>

where B: Update + Send + Sync + Backend + BackendConfig + WireFormatBackend, B::Task: Send, C: Send + Sync + 'static + Codec<B::Args, Compact = B::Compact>,

async fn update(&mut self, task: Self::Task) -> Result<(), Self::Error>

Update the given task

impl<B, C> Vacuum for WithCodec<B, C>

where B: Vacuum + Send + Sync + Backend + BackendConfig + WireFormatBackend, C: Send + Sync + 'static + Codec<B::Args, Compact = B::Compact>,

async fn vacuum(&mut self) -> Result<usize, Self::Error>

Cleans up all resources and returns the number of tasks vacuumed

async fn vacuum_before( &mut self, duration: Duration, ) -> Result<usize, Self::Error>

Cleans up all resources committed before a specific duration and returns the number of tasks vacuumed

impl<Output, B, C> WaitForCompletion<Output> for WithCodec<B, C>

where B: WaitForCompletion<Output> + Sync + Send + Backend + BackendConfig + WireFormatBackend, Output: 'static, C: Send + Sync + 'static + Codec<B::Args, Compact = B::Compact>,

type ResultStream = Pin<Box<dyn Stream<Item = Result<TaskResult<Output>, <WithCodec<B, C> as Backend>::Error>> + Send>>

The result stream type yielding task results

fn wait_for( &mut self, task_ids: impl IntoIterator<Item = TaskId>, ) -> Self::ResultStream

Wait for multiple tasks to complete, yielding results as they become available

async fn check_status( &mut self, task_ids: impl IntoIterator<Item = TaskId> + Send, ) -> Result<Vec<TaskResult<Output>>, Self::Error>

Check current status of tasks without waiting

fn wait_for_single(&mut self, task_id: TaskId) -> Self::ResultStream

Wait for a single task to complete, yielding its result

impl<B, NewCodec, Args> WireFormatBackend for WithCodec<B, NewCodec>

where NewCodec: Codec<Args> + Send + 'static, B: BackendConfig<Args = Args>,

type Codec = NewCodec

The codec used to encode and decode tasks.

type Compact = <NewCodec as Codec<Args>>::Compact

The compact representation of task arguments.

fn codec(&self) -> &Self::Codec

Returns a reference to the codec used by the backend.