Struct MessageRef 

pub struct MessageRef<'a> {
    pub headers: MessageHeadersRef<'a>,
    pub properties: MessagePropertiesRef<'a>,
    pub body: Cow<'a, [u8]>,
    pub content_type: Cow<'a, str>,
    pub content_encoding: Cow<'a, str>,
}

Zero-copy Celery message

Uses borrowed data where possible to avoid unnecessary allocations. This is particularly useful when deserializing messages from a buffer that will remain valid for the lifetime of the message.

Fields

headers: MessageHeadersRef<'a>

Message headers (zero-copy)

properties: MessagePropertiesRef<'a>

Message properties (zero-copy)

body: Cow<'a, [u8]>

Message body (zero-copy reference to raw bytes)

content_type: Cow<'a, str>

Content type (zero-copy)

content_encoding: Cow<'a, str>

Content encoding (zero-copy)

Implementations

impl<'a> MessageRef<'a>

pub fn new(task: &'a str, id: Uuid, body: &'a [u8]) -> Self

Create a new zero-copy message reference

pub fn task_id(&self) -> Uuid

Get the task ID

pub fn task_name(&self) -> &str

Get the task name

pub fn body_slice(&self) -> &[u8]

Get body as slice

pub fn has_eta(&self) -> bool

Check if message has ETA

pub fn has_expires(&self) -> bool

Check if message has expiration

pub fn has_parent(&self) -> bool

Check if message has parent

pub fn has_root(&self) -> bool

Check if message has root

pub fn has_group(&self) -> bool

Check if message has group

pub fn into_owned(self) -> Message

Convert to owned message

Trait Implementations

impl<'a> Clone for MessageRef<'a>

fn clone(&self) -> MessageRef<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for MessageRef<'a>

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

Formats the value using the given formatter.

impl<'de: 'a, 'a> Deserialize<'de> for MessageRef<'a>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> Serialize for MessageRef<'a>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.