Function write_message_header

pub fn write_message_header<'a, W: AsyncWrite>(
    writer: Pin<&'a mut W>,
    message_header: &'a MessageHeader,
) -> MessageHeaderWriter<'a, W>

Writes a message header into streams.

Panics

In the specification, timestamps and message lengths are defined as 3 bytes, therefore any value above 0x00ffffff is emitted an assertion error.

Examples

use std::{
    cmp::min,
    io::Result as IOResult,
    pin::{
        Pin,
        pin
    },
    time::Duration
};
use rand::random;
use sheave_core::{
    messages::headers::{
        MessageHeader,
        MessageType
    },
    writers::write_message_header
};

#[tokio::main]
async fn main() -> IOResult<()> {
    // In case of 11 bytes.
    let mut writer: Pin<&mut Vec<u8>> = pin!(Vec::new());
    let timestamp = Duration::from_millis(min(0x00ffffff, random::<u32>()) as u64);
    let message_length = min(0x00ffffff, random::<u32>());
    let message_type: MessageType = random::<u8>().into();
    let message_id = random::<u32>();
    let message_header = MessageHeader::New((timestamp, message_length, message_type, message_id).into());
    write_message_header(writer.as_mut(), &message_header).await?;
    let mut written: [u8; 4] = [0; 4];
    written[1..].copy_from_slice(&writer[..3]);
    let timestamp = Duration::from_millis(u32::from_be_bytes(written) as u64);
    assert_eq!(timestamp, message_header.get_timestamp().unwrap());
    let mut written: [u8; 4] = [0; 4];
    written[1..].copy_from_slice(&writer[3..6]);
    let message_length = u32::from_be_bytes(written);
    assert_eq!(message_length, message_header.get_message_length().unwrap());
    let message_type: MessageType = writer[6].into();
    assert_eq!(message_type, message_header.get_message_type().unwrap());
    let mut written: [u8; 4] = [0; 4];
    written.copy_from_slice(&writer[7..]);
    let message_id = u32::from_le_bytes(written);
    assert_eq!(message_id, message_header.get_message_id().unwrap());

    // In case of 7 bytes.
    let mut writer: Pin<&mut Vec<u8>> = pin!(Vec::new());
    let timestamp = Duration::from_millis(min(0x00ffffff, random::<u32>()) as u64);
    let message_length = min(0x00ffffff, random::<u32>());
    let message_type: MessageType = random::<u8>().into();
    let message_header = MessageHeader::SameSource((timestamp, message_length, message_type).into());
    write_message_header(writer.as_mut(), &message_header).await?;
    let mut written: [u8; 4] = [0; 4];
    written[1..].copy_from_slice(&writer[..3]);
    let timestamp = Duration::from_millis(u32::from_be_bytes(written) as u64);
    assert_eq!(timestamp, message_header.get_timestamp().unwrap());
    let mut written: [u8; 4] = [0; 4];
    written[1..].copy_from_slice(&writer[3..6]);
    let message_length = u32::from_be_bytes(written);
    assert_eq!(message_length, message_header.get_message_length().unwrap());
    let message_type: MessageType = writer[6].into();
    assert_eq!(message_type, message_header.get_message_type().unwrap());

    // In case of 3 bytes.
    let mut writer: Pin<&mut Vec<u8>> = pin!(Vec::new());
    let timestamp = Duration::from_millis(min(0x00ffffff, random::<u32>()) as u64);
    let message_header = MessageHeader::TimerChange(timestamp.into());
    write_message_header(writer.as_mut(), &message_header).await?;
    let mut written: [u8; 4] = [0; 4];
    written[1..].copy_from_slice(&writer[..3]);
    let timestamp = Duration::from_millis(u32::from_be_bytes(written) as u64);
    assert_eq!(timestamp, message_header.get_timestamp().unwrap());

    // In case of 0 bytes. (Continue)
    let mut writer: Pin<&mut Vec<u8>> = pin!(Vec::new());
    let message_header = MessageHeader::Continue;
    write_message_header(writer.as_mut(), &message_header).await?;
    assert!(writer.is_empty());

    Ok(())
}