Function write_chunk_data

pub fn write_chunk_data<'a, W: AsyncWrite>(
    writer: Pin<&'a mut W>,
    chunk_id: u16,
    chunk_size: ChunkSize,
    chunk_data: &'a [u8],
) -> ChunkDataWriter<'a, W>

Writes a chunk data into streams.

If a chunk data exceeds specified chunk size, continue headers is inserted between chunk data per chunk size. Note the message length doesn’t count their headers.

Examples

use std::{
    io::Result as IOResult,
    pin::{
        Pin,
        pin
    }
};
use rand::{
    Fill,
    thread_rng
};
use sheave_core::{
    messages::{
        ChunkSize,
        headers::MessageFormat
    },
    writers::write_chunk_data
};

#[tokio::main]
async fn main() -> IOResult<()> {
    // When it's just one chunk.
    let mut writer: Pin<&mut Vec<u8>> = pin!(Vec::new());
    let mut chunk_data: [u8; 128] = [0; 128];
    chunk_data.try_fill(&mut thread_rng()).unwrap();
    write_chunk_data(writer.as_mut(), 2, ChunkSize::default(), &chunk_data).await?;
    assert_eq!(128, writer.len());

    // When it requires the one byte header.
    let mut writer: Pin<&mut Vec<u8>> = pin!(Vec::new());
    let mut chunk_data: [u8; 256] = [0; 256];
    chunk_data.try_fill(&mut thread_rng()).unwrap();
    write_chunk_data(writer.as_mut(), 2, ChunkSize::default(), &chunk_data).await?;
    assert_eq!(257, writer.len());
    let message_format: MessageFormat = (writer[128] >> 6).into();
    assert_eq!(MessageFormat::Continue, message_format);
    let chunk_id = writer[128] << 2 >> 2;
    assert_eq!(2, chunk_id);

    // When it requires the two bytes header.
    let mut writer: Pin<&mut Vec<u8>> = pin!(Vec::new());
    let mut chunk_data: [u8; 256] = [0; 256];
    chunk_data.try_fill(&mut thread_rng()).unwrap();
    write_chunk_data(writer.as_mut(), 64, ChunkSize::default(), &chunk_data).await?;
    assert_eq!(258, writer.len());
    let message_format: MessageFormat = (writer[128] >> 6).into();
    assert_eq!(MessageFormat::Continue, message_format);
    assert_eq!(0, writer[128] << 2 >> 2);
    let chunk_id = writer[129];
    assert_eq!(64, chunk_id + 64);

    // When it requires the three bytes header.
    let mut writer: Pin<&mut Vec<u8>> = pin!(Vec::new());
    let mut chunk_data: [u8; 256] = [0; 256];
    chunk_data.try_fill(&mut thread_rng()).unwrap();
    write_chunk_data(writer.as_mut(), 320, ChunkSize::default(), &chunk_data).await?;
    assert_eq!(259, writer.len());
    let message_format: MessageFormat = (writer[128] >> 6).into();
    assert_eq!(MessageFormat::Continue, message_format);
    assert_eq!(1, writer[128] << 2 >> 2);
    let mut chunk_id_bytes: [u8; 2] = [0; 2];
    chunk_id_bytes.copy_from_slice(&writer[129..131]);
    let chunk_id = u16::from_le_bytes(chunk_id_bytes);
    assert_eq!(320, chunk_id + 64);

    Ok(())
}