Struct Parts 

pub struct Parts<Context, IdType = RandomId> {
    pub task_id: Option<TaskId<IdType>>,
    pub data: Extensions,
    pub attempt: Attempt,
    pub ctx: Context,
    pub status: AtomicStatus,
    pub run_at: u64,
    pub queue: Option<Queue>,
}

Component parts of a Task

Fields

task_id: Option<TaskId<IdType>>

The task’s id if allocated

data: Extensions

The tasks’s extensions

attempt: Attempt

The tasks’s attempts Keeps track of the number of attempts a task has been worked on

ctx: Context

The task specific data provided by the backend

status: AtomicStatus

The task status that is wrapped in an atomic status

run_at: u64

The time a task should be run

queue: Option<Queue>

The queue the task belongs to This is a runtime only field and is not serialized It is set by the backend when the task is fetched from the queue Workers can use this to determine which queue they are processing tasks from Sinks can also use this to determine which queue to send the task to This field is optional as not all backends support queues For example, a simple in-memory backend does not have the concept of queues

Trait Implementations

impl<Ctx, IdType: Clone> Clone for Parts<Ctx, IdType>

where Ctx: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Ctx: Debug, IdType: Debug> Debug for Parts<Ctx, IdType>

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

Formats the value using the given formatter.

impl<Context: Default, IdType: Default> Default for Parts<Context, IdType>

fn default() -> Parts<Context, IdType>

Returns the “default value” for a type.

impl<'de, Context, IdType> Deserialize<'de> for Parts<Context, IdType>

where Context: Deserialize<'de>, IdType: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Context, IdType> Serialize for Parts<Context, IdType>

where Context: Serialize, IdType: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.