Struct Message 

pub struct Message { /* private fields */ }

Builder for constructing ZeroMQ multipart messages.

Provides a fluent API for adding frames to a message with automatic conversions from common types (strings, bytes, JSON, etc.).

Examples

use monocoque_core::message_builder::Message;

// Simple text frames
let msg = Message::new()
    .push_str("topic")
    .push_str("Hello, World!")
    .into_frames();

// Mixed types
let msg = Message::new()
    .push(&b"routing_id"[..])
    .push_str("command:execute")
    .push(&[1u8, 2, 3, 4][..])
    .into_frames();

With Serde JSON (optional)

#[derive(Serialize)]
struct Task {
    id: u64,
    name: String,
}

let task = Task { id: 42, name: "Process data".to_string() };
let msg = Message::new()
    .push_str("tasks")
    .push_json(&task)?
    .into_frames();

Implementations

impl Message

pub const fn new() -> Self

Create a new empty message builder.

Examples

use monocoque_core::message_builder::Message;

let msg = Message::new();

pub fn with_capacity(capacity: usize) -> Self

Create a message with pre-allocated capacity.

Useful when you know the number of frames in advance to avoid reallocations.

Examples

use monocoque_core::message_builder::Message;

let msg = Message::with_capacity(4)
    .push_str("frame1")
    .push_str("frame2")
    .push_str("frame3")
    .push_str("frame4");

pub fn push(self, frame: impl Into<Bytes>) -> Self

Add a frame from any type that can be converted to Bytes.

Examples

use monocoque_core::message_builder::Message;
use bytes::Bytes;

let msg = Message::new()
    .push(&b"raw bytes"[..])
    .push(vec![1, 2, 3])
    .push(Bytes::from_static(b"static"));

pub fn push_str(self, s: &str) -> Self

Add a string frame.

Convenience method for adding UTF-8 strings.

Examples

use monocoque_core::message_builder::Message;

let msg = Message::new()
    .push_str("Hello")
    .push_str("World");

pub fn push_empty(self) -> Self

Add an empty frame.

Empty frames are often used as delimiters in ZeroMQ envelope patterns.

Examples

use monocoque_core::message_builder::Message;

// ROUTER envelope: [identity, empty, body]
let msg = Message::new()
    .push(&b"client-123"[..])
    .push_empty()
    .push_str("Hello");

pub fn push_u32(self, value: u32) -> Self

Add a frame containing a big-endian u32.

Useful for protocol headers, message IDs, etc.

Examples

use monocoque_core::message_builder::Message;

let msg = Message::new()
    .push_u32(12345) // Message ID
    .push_str("payload");

pub fn push_u64(self, value: u64) -> Self

Add a frame containing a big-endian u64.

pub fn len(&self) -> usize

Get the number of frames in the message.

Examples

use monocoque_core::message_builder::Message;

let msg = Message::new()
    .push_str("frame1")
    .push_str("frame2");

assert_eq!(msg.len(), 2);

pub fn is_empty(&self) -> bool

Check if the message is empty (has no frames).

pub fn into_frames(self) -> Vec<Bytes>

Consume the builder and return the frames as a Vec<Bytes>.

This is the final step to get the message ready for sending.

Examples

use monocoque_core::message_builder::Message;

let frames = Message::new()
    .push_str("Hello")
    .push_str("World")
    .into_frames();
assert_eq!(frames.len(), 2);

pub fn frames(&self) -> &[Bytes]

Get a reference to the frames without consuming the builder.

pub const fn from_frames(frames: Vec<Bytes>) -> Self

Create a message from existing frames.

Examples

use monocoque_core::message_builder::Message;
use bytes::Bytes;

let frames = vec![
    Bytes::from_static(b"frame1"),
    Bytes::from_static(b"frame2"),
];

let msg = Message::from_frames(frames);
assert_eq!(msg.len(), 2);

Trait Implementations

impl Clone for Message

fn clone(&self) -> Message

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Message

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

Formats the value using the given formatter.

impl Default for Message

fn default() -> Message

Returns the “default value” for a type.

impl From<Message> for Vec<Bytes>

fn from(msg: Message) -> Self

Converts to this type from the input type.

impl From<Vec<Bytes>> for Message

fn from(frames: Vec<Bytes>) -> Self

Converts to this type from the input type.