Struct IggyMessage 

pub struct IggyMessage {
    pub header: IggyMessageHeader,
    pub payload: Bytes,
    pub user_headers: Option<Bytes>,
}

The Apache Iggy producer/consumer escape hatch: same types Topic::iggy_producer/Topic::iggy_consumer/Topic::iggy_consumer_group return, and the stored message a failed publish hands back, re-exported so reaching for them doesn’t need an iggy dependency of your own. A message stored in the Iggy messaging system.

IggyMessage represents a single message that can be sent to or received from a stream. Each message consists of:

• A header with message metadata
• A payload (the actual content)
• Optional user-defined headers for additional context

Examples

use iggy_common::*;
use std::str::FromStr;
use std::collections::BTreeMap;
use bytes::Bytes;

// Create a simple text message
let message = IggyMessage::builder()
    .payload("Hello world!".into())
    .build()
    .unwrap();

// Create a simple message with raw binary payload
let message = IggyMessage::builder()
    .payload(Bytes::from(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
    .build()
    .unwrap();

// Create a message with custom ID
let message = IggyMessage::builder()
    .id(42)
    .payload("Custom message".into())
    .build()
    .unwrap();

// Create a message with headers
let key = HeaderKey::from_str("content-type").unwrap();
let value = HeaderValue::from_str("text/plain").unwrap();
let user_headers = BTreeMap::from([(key, value)]);

let message = IggyMessage::builder()
    .payload("Message with metadata".into())
    .user_headers(user_headers)
    .build()
    .unwrap();

Fields

header: IggyMessageHeader

Message metadata

payload: Bytes

Message content

user_headers: Option<Bytes>

Optional user-defined headers

Implementations

impl IggyMessage

pub fn builder() -> IggyMessageBuilder

Creates a new message with customizable parameters.

Arguments

• id - Optional message ID (defaults to 0 if None)
• payload - The message content
• user_headers - Optional user-defined headers

Returns

A Result containing the new message or an error

Examples

use iggy_common::*;
use bytes::Bytes;
use std::collections::BTreeMap;
use std::str::FromStr;

// Simple message with just payload
let msg = IggyMessage::builder()
    .payload("Hello world".into())
    .build()
    .unwrap();

// Message with custom ID
let msg = IggyMessage::builder()
    .id(42)
    .payload("Hello".into())
    .build()
    .unwrap();

// Message with headers
let key = HeaderKey::from_str("content-type").unwrap();
let value = HeaderValue::from_str("text/plain").unwrap();
let user_headers = BTreeMap::from([(key, value)]);
let msg = IggyMessage::builder()
    .payload("Hello".into())
    .user_headers(user_headers)
    .build()
    .unwrap();

impl IggyMessage

pub fn user_headers_map( &self, ) -> Result<Option<BTreeMap<HeaderField<KeyMarker>, HeaderField<ValueMarker>>>, IggyError>

Gets the user headers as a typed BTreeMap.

This method parses the binary header data into a typed BTreeMap for easy access.

Returns

• Ok(Some(BTreeMap)) - Successfully parsed headers
• Ok(None) - No headers present
• Err(IggyError) - Error parsing headers

Examples

use iggy_common::*;
use std::str::FromStr;
use std::collections::BTreeMap;

let key = HeaderKey::from_str("content-type").unwrap();
let value = HeaderValue::from_str("text/plain").unwrap();
let user_headers_map = BTreeMap::from([(key.clone(), value)]);

let message = IggyMessage::builder()
    .payload("Hello".into())
    .user_headers(user_headers_map)
    .build()
    .unwrap();

let headers = message.user_headers_map().unwrap().unwrap();
assert!(headers.contains_key(&key));

pub fn get_user_header( &self, key: &HeaderField<KeyMarker>, ) -> Result<Option<HeaderField<ValueMarker>>, IggyError>

Retrieves a specific user header value by key.

This is a convenience method to get a specific user header without handling the full map.

Arguments

• key - The user header key to look up

Returns

• Ok(Some(HeaderValue)) - User header found with its value
• Ok(None) - User header not found or no user headers present
• Err(IggyError) - Error accessing user headers

Examples

use iggy_common::*;
use std::str::FromStr;
use std::collections::BTreeMap;

let key = HeaderKey::from_str("content-type").unwrap();
let value = HeaderValue::from_str("text/plain").unwrap();
let user_headers_map = BTreeMap::from([(key.clone(), value.clone())]);

let message = IggyMessage::builder()
    .payload("Hello".into())
    .user_headers(user_headers_map)
    .build()
    .unwrap();

let header_value = message.get_user_header(&key).unwrap().unwrap();
assert_eq!(header_value, value);

pub fn has_user_header( &self, key: &HeaderField<KeyMarker>, ) -> Result<bool, IggyError>

Checks if this message contains a specific user header key.

Arguments

• key - The user header key to check for

Returns

• Ok(true) - User header exists
• Ok(false) - User header doesn’t exist or user headers couldn’t be parsed
• Err(IggyError) - Error accessing user headers

Examples

use iggy_common::*;
use std::str::FromStr;
use std::collections::BTreeMap;

let key = HeaderKey::from_str("content-type").unwrap();
let value = HeaderValue::from_str("text/plain").unwrap();
let user_headers_map = BTreeMap::from([(key.clone(), value)]);

let message = IggyMessage::builder()
    .payload("Hello".into())
    .user_headers(user_headers_map)
    .build()
    .unwrap();

assert!(message.has_user_header(&key).unwrap());
assert!(!message.has_user_header(&HeaderKey::from_str("non-existent").unwrap()).unwrap());

pub fn payload_as_string(&self) -> Result<String, IggyError>

Gets the payload as a UTF-8 string, if valid.

Returns

• Ok(String) - Successfully converted payload to string
• Err(IggyError) - Payload is not valid UTF-8

Examples

use iggy_common::*;

let message = IggyMessage::builder()
    .payload("Hello world".into())
    .build()
    .unwrap();

assert_eq!(message.payload_as_string().unwrap(), "Hello world");

pub fn to_bytes(&self) -> Bytes

pub fn from_bytes(bytes: Bytes) -> Result<IggyMessage, IggyError>

pub fn write_to_buffer(&self, buf: &mut BytesMut)

Serializes the message into buf.

buf need not be preallocated: the whole message is reserved up front so an empty buffer grows once rather than once per appended field.

Trait Implementations

impl Debug for IggyMessage

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

Formats the value using the given formatter.

impl Default for IggyMessage

fn default() -> IggyMessage

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for IggyMessage

fn deserialize<D>( deserializer: D, ) -> Result<IggyMessage, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for IggyMessage

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

Formats the value using the given formatter.

impl From<&[u8]> for IggyMessage

fn from(bytes: &[u8]) -> IggyMessage

Converts to this type from the input type.

impl From<&str> for IggyMessage

fn from(s: &str) -> IggyMessage

Converts to this type from the input type.

impl From<String> for IggyMessage

fn from(s: String) -> IggyMessage

Converts to this type from the input type.

impl From<Vec<u8>> for IggyMessage

fn from(v: Vec<u8>) -> IggyMessage

Converts to this type from the input type.

impl FromStr for IggyMessage

type Err = IggyError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<IggyMessage, <IggyMessage as FromStr>::Err>

Parses a string s to return a value of this type.

impl PartialEq for IggyMessage

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for IggyMessage

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Sizeable for IggyMessage

fn get_size_bytes(&self) -> IggyByteSize

impl StructuralPartialEq for IggyMessage

impl TryFrom<&IggyMessage> for Provenance

type Error = ProvenanceError

The type returned in the event of a conversion error.

fn try_from(message: &IggyMessage) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Bytes> for IggyMessage

type Error = IggyError

The type returned in the event of a conversion error.

fn try_from( bytes: Bytes, ) -> Result<IggyMessage, <IggyMessage as TryFrom<Bytes>>::Error>

Performs the conversion.