Struct UnknownTemplateMessage 

#[non_exhaustive]
pub struct UnknownTemplateMessage {
    pub template_id: i32,
    pub payload: Bytes,
}

A frame whose template_id this crate has no message definition for.

The payload is kept as received, so a template this crate doesn’t map can still be handled downstream: decode_as decodes it into a type you generate yourself, and payload_hex dumps it for later.

Examples

A frame off a subscription stream arrives as RithmicMessage::UnknownTemplate with error: None. Log it, then decode it into a type generated in your own crate from the .proto; crate::prost is re-exported so the generated code can’t drift from the version this crate decodes with.

use rithmic_rs::prost;
use rithmic_rs::rti::messages::RithmicMessage;

// Generated in your crate by prost-build, once you know what 358 maps to.
#[derive(Clone, PartialEq, prost::Message)]
pub struct Template358 {
    #[prost(string, optional, tag = "110100")]
    pub symbol: Option<String>,
}

fn on_message(message: &RithmicMessage) {
    let RithmicMessage::UnknownTemplate(frame) = message else {
        return;
    };

    // template_id=358 (84 bytes) a2e135054d45535536aae13503434d45…+52B
    tracing::warn!(payload = %frame.payload_hex(), "unmapped template: {frame}");

    if frame.template_id == 358 {
        if let Ok(decoded) = frame.decode_as::<Template358>() {
            println!("{:?}", decoded.symbol);
        }
    }
}

payload_hex is untruncated, so a frame captured in production can be replayed in a test through from_payload_hex.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

template_id: i32

The template_id read from the frame header.

payload: Bytes

The complete message body, exactly as received.

Only the 4-byte big-endian length prefix is stripped, as every other decoder here does; it carries nothing beyond payload.len().

Implementations

impl UnknownTemplateMessage

pub fn new(template_id: i32, payload: Bytes) -> Self

Build a frame from its template_id and body.

pub fn decode_as<M: Message + Default>(&self) -> Result<M, DecodeError>

Decode the payload into a caller-supplied protobuf type.

Generate the type from the .proto in your own crate and decode into it. Uses the crate::prost re-export, so types generated against rithmic_rs::prost are compatible by construction.

Errors

prost::DecodeError when the bytes are structurally incompatible with M, such as a wire-type conflict on a field M declares.

Ok is not proof the type was guessed right. Protobuf skips fields the target doesn’t declare, so an unrelated payload usually decodes into a mostly-empty value.

pub fn payload_hex(&self) -> String

The whole payload as lowercase hex, no truncation, no 0x prefix.

Display elides the payload to stay readable in a log line; this doesn’t.

pub fn from_payload_hex(template_id: i32, hex: &str) -> Option<Self>

Rebuild a frame from a payload_hex dump.

Ignores a leading 0x and any whitespace, including newlines from a wrapped log line. None unless hex holds an even number of hex digits; empty input yields an empty payload.

Trait Implementations

impl Clone for UnknownTemplateMessage

fn clone(&self) -> UnknownTemplateMessage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UnknownTemplateMessage

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

Formats the value using the given formatter.

impl Display for UnknownTemplateMessage

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

Formats the value using the given formatter.

impl Eq for UnknownTemplateMessage

impl PartialEq for UnknownTemplateMessage

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for UnknownTemplateMessage