Struct opcua_server::prelude::MessageChunk

pub struct MessageChunk {
    pub data: Vec<u8>,
}

A chunk holds a message or a portion of a message, if the message has been split into multiple chunks. The chunk's data may be signed and encrypted. To extract the message requires all the chunks to be available in sequence so they can be formed back into the message.

Fields

data: Vec<u8>

All of the chunk's data including headers, payload, padding, signature

Methods

impl MessageChunk

pub fn new(
    sequence_number: u32,
    request_id: u32,
    message_type: MessageChunkType,
    is_final: MessageIsFinalType,
    secure_channel: &SecureChannel,
    data: &[u8]
) -> Result<MessageChunk, StatusCode>

pub fn body_size_from_message_size(
    message_type: MessageChunkType,
    secure_channel: &SecureChannel,
    message_size: usize
) -> Result<usize, ()>

Calculates the body size that fit inside of a message chunk of a particular size. This requires calculating the size of the header, the signature, padding etc. and deducting it to reveal the message size

pub fn message_header(
    &self,
    decoding_limits: &DecodingLimits
) -> Result<MessageChunkHeader, StatusCode>

pub fn security_header(
    &self,
    decoding_limits: &DecodingLimits
) -> Result<SecurityHeader, StatusCode>

pub fn is_open_secure_channel(&self, decoding_limits: &DecodingLimits) -> bool

pub fn chunk_info(
    &self,
    secure_channel: &SecureChannel
) -> Result<ChunkInfo, StatusCode>

Trait Implementations

impl Debug for MessageChunk

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

Formats the value using the given formatter.

impl BinaryEncoder<MessageChunk> for MessageChunk

fn byte_len(&self) -> usize

Returns the byte length of the structure. This calculation should be exact and as efficient as possible.

fn encode<S>(&self, stream: &mut S) -> Result<usize, StatusCode> where
    S: Write, 

Encodes the instance to the write stream.

fn decode<S>(
    in_stream: &mut S,
    decoding_limits: &DecodingLimits
) -> Result<MessageChunk, StatusCode> where
    S: Read, 

Decodes an instance from the read stream. The decoding limits are restrictions set by the server / client on the length of strings, arrays etc. If these limits are exceeded the implementation should return with a BadDecodingError as soon as possible.

fn to_vec(&self) -> Vec<u8>