Struct Cursor

pub struct Cursor<T> { /* private fields */ }

A std::io::Cursor like buffer interface with byteorder support and no_std compatibility.

Implementations

impl<T: AsRef<[u8]>> Cursor<T>

pub fn new(buffer: T) -> Self

Constructs a new cursor object on top of a slice.

Examples found in repository

examples/basic.rs (line 5)

fn main() {
    let mut buffer = [0u8; 16];
    let mut cursor = Cursor::new(&mut buffer[..]);

    cursor.write_u8(1);
    cursor.write_u16::<BigEndian>(5);
    cursor.write_u32::<LittleEndian>(16);
    cursor.write_bytes(&[1, 2, 3, 4, 5]);

    println!("Remaining space in cursor is {} bytes", cursor.remaining());
    cursor.set_position(0);

    let x = cursor.read_u8();
    let y = cursor.read_u16::<BigEndian>();
    let z = cursor.read_u32::<LittleEndian>();

    let mut w = [0u8; 5];
    cursor.read_bytes(&mut w);

    println!("Read-back from buffer: {x}, {y}, {z}, {w:?}");
    println!("Cursor is now at position {}", cursor.position());
}

pub fn len(&self) -> usize

Returns the length of the underlying buffer.

pub fn remaining(&self) -> usize

Returns the remaining length in bytes of the underlying buffer.

Examples found in repository

examples/basic.rs (line 12)

fn main() {
    let mut buffer = [0u8; 16];
    let mut cursor = Cursor::new(&mut buffer[..]);

    cursor.write_u8(1);
    cursor.write_u16::<BigEndian>(5);
    cursor.write_u32::<LittleEndian>(16);
    cursor.write_bytes(&[1, 2, 3, 4, 5]);

    println!("Remaining space in cursor is {} bytes", cursor.remaining());
    cursor.set_position(0);

    let x = cursor.read_u8();
    let y = cursor.read_u16::<BigEndian>();
    let z = cursor.read_u32::<LittleEndian>();

    let mut w = [0u8; 5];
    cursor.read_bytes(&mut w);

    println!("Read-back from buffer: {x}, {y}, {z}, {w:?}");
    println!("Cursor is now at position {}", cursor.position());
}

pub fn check_remaining(&self, expected: usize) -> Result<(), BufferTooSmall>

Checks if the underlying buffer has the expected amount of space left.

pub fn position(&self) -> usize

Returns the cursor position in the underlying buffer.

Examples found in repository

examples/basic.rs (line 23)

fn main() {
    let mut buffer = [0u8; 16];
    let mut cursor = Cursor::new(&mut buffer[..]);

    cursor.write_u8(1);
    cursor.write_u16::<BigEndian>(5);
    cursor.write_u32::<LittleEndian>(16);
    cursor.write_bytes(&[1, 2, 3, 4, 5]);

    println!("Remaining space in cursor is {} bytes", cursor.remaining());
    cursor.set_position(0);

    let x = cursor.read_u8();
    let y = cursor.read_u16::<BigEndian>();
    let z = cursor.read_u32::<LittleEndian>();

    let mut w = [0u8; 5];
    cursor.read_bytes(&mut w);

    println!("Read-back from buffer: {x}, {y}, {z}, {w:?}");
    println!("Cursor is now at position {}", cursor.position());
}

pub fn set_position(&mut self, position: usize)

Sets the cursor position in the underlying buffer.

Examples found in repository

examples/basic.rs (line 13)

fn main() {
    let mut buffer = [0u8; 16];
    let mut cursor = Cursor::new(&mut buffer[..]);

    cursor.write_u8(1);
    cursor.write_u16::<BigEndian>(5);
    cursor.write_u32::<LittleEndian>(16);
    cursor.write_bytes(&[1, 2, 3, 4, 5]);

    println!("Remaining space in cursor is {} bytes", cursor.remaining());
    cursor.set_position(0);

    let x = cursor.read_u8();
    let y = cursor.read_u16::<BigEndian>();
    let z = cursor.read_u32::<LittleEndian>();

    let mut w = [0u8; 5];
    cursor.read_bytes(&mut w);

    println!("Read-back from buffer: {x}, {y}, {z}, {w:?}");
    println!("Cursor is now at position {}", cursor.position());
}

pub fn skip(&mut self, count: usize)

Advances it cursor position by the given amount of bytes.

pub fn read_bytes(&mut self, dst: &mut [u8])

Reads data from the underlying buffer to the given slice and advances cursor position. Panics if there is not enough data remaining to fill the slice.

Examples found in repository

examples/basic.rs (line 20)

fn main() {
    let mut buffer = [0u8; 16];
    let mut cursor = Cursor::new(&mut buffer[..]);

    cursor.write_u8(1);
    cursor.write_u16::<BigEndian>(5);
    cursor.write_u32::<LittleEndian>(16);
    cursor.write_bytes(&[1, 2, 3, 4, 5]);

    println!("Remaining space in cursor is {} bytes", cursor.remaining());
    cursor.set_position(0);

    let x = cursor.read_u8();
    let y = cursor.read_u16::<BigEndian>();
    let z = cursor.read_u32::<LittleEndian>();

    let mut w = [0u8; 5];
    cursor.read_bytes(&mut w);

    println!("Read-back from buffer: {x}, {y}, {z}, {w:?}");
    println!("Cursor is now at position {}", cursor.position());
}

pub fn read_u8(&mut self) -> u8

Reads a 8bit integer value from the underlying buffer and advances cursor position. Panics if there is not enough data remaining.

Examples found in repository

examples/basic.rs (line 15)

fn main() {
    let mut buffer = [0u8; 16];
    let mut cursor = Cursor::new(&mut buffer[..]);

    cursor.write_u8(1);
    cursor.write_u16::<BigEndian>(5);
    cursor.write_u32::<LittleEndian>(16);
    cursor.write_bytes(&[1, 2, 3, 4, 5]);

    println!("Remaining space in cursor is {} bytes", cursor.remaining());
    cursor.set_position(0);

    let x = cursor.read_u8();
    let y = cursor.read_u16::<BigEndian>();
    let z = cursor.read_u32::<LittleEndian>();

    let mut w = [0u8; 5];
    cursor.read_bytes(&mut w);

    println!("Read-back from buffer: {x}, {y}, {z}, {w:?}");
    println!("Cursor is now at position {}", cursor.position());
}

pub fn read_u16<B: ByteOrder>(&mut self) -> u16

Reads a 16bit integer value from the underlying buffer and advances cursor position. Panics if there is not enough data remaining.

Examples found in repository

examples/basic.rs (line 16)

fn main() {
    let mut buffer = [0u8; 16];
    let mut cursor = Cursor::new(&mut buffer[..]);

    cursor.write_u8(1);
    cursor.write_u16::<BigEndian>(5);
    cursor.write_u32::<LittleEndian>(16);
    cursor.write_bytes(&[1, 2, 3, 4, 5]);

    println!("Remaining space in cursor is {} bytes", cursor.remaining());
    cursor.set_position(0);

    let x = cursor.read_u8();
    let y = cursor.read_u16::<BigEndian>();
    let z = cursor.read_u32::<LittleEndian>();

    let mut w = [0u8; 5];
    cursor.read_bytes(&mut w);

    println!("Read-back from buffer: {x}, {y}, {z}, {w:?}");
    println!("Cursor is now at position {}", cursor.position());
}

pub fn read_u24<B: ByteOrder>(&mut self) -> u32

Reads a 24bit integer value from the underlying buffer and advances cursor position. Panics if there is not enough data remaining.

pub fn read_u32<B: ByteOrder>(&mut self) -> u32

Reads a 32bit integer value from the underlying buffer and advances cursor position. Panics if there is not enough data remaining.

Examples found in repository

examples/basic.rs (line 17)

fn main() {
    let mut buffer = [0u8; 16];
    let mut cursor = Cursor::new(&mut buffer[..]);

    cursor.write_u8(1);
    cursor.write_u16::<BigEndian>(5);
    cursor.write_u32::<LittleEndian>(16);
    cursor.write_bytes(&[1, 2, 3, 4, 5]);

    println!("Remaining space in cursor is {} bytes", cursor.remaining());
    cursor.set_position(0);

    let x = cursor.read_u8();
    let y = cursor.read_u16::<BigEndian>();
    let z = cursor.read_u32::<LittleEndian>();

    let mut w = [0u8; 5];
    cursor.read_bytes(&mut w);

    println!("Read-back from buffer: {x}, {y}, {z}, {w:?}");
    println!("Cursor is now at position {}", cursor.position());
}

pub fn read_u64<B: ByteOrder>(&mut self) -> u64

Reads a 64bit integer value from the underlying buffer and advances cursor position. Panics if there is not enough data remaining.

pub fn peek_u8(&self, offset: usize) -> u8

Reads a 8bit integer value from the underlying buffer at a given offset from the cursor position without advancing the cursor position. Panics if there is not enough data remaining.

pub fn peek_u16<B: ByteOrder>(&self, offset: usize) -> u16

Reads a 16bit integer value from the underlying buffer at a given offset from the cursor position without advancing the cursor position. Panics if there is not enough data remaining.

pub fn peek_u24<B: ByteOrder>(&self, offset: usize) -> u32

Reads a 24bit integer value from the underlying buffer at a given offset from the cursor position without advancing the cursor position. Panics if there is not enough data remaining.

pub fn peek_u32<B: ByteOrder>(&self, offset: usize) -> u32

Reads a 32bit integer value from the underlying buffer at a given offset from the cursor position without advancing the cursor position. Panics if there is not enough data remaining.

impl Cursor<&mut [u8]>

pub fn write_bytes(&mut self, src: &[u8])

Writes the given slice to the underlying buffer and advances cursor position. Panics if there is not enough space remaining to write the slice.

Examples found in repository

examples/basic.rs (line 10)

fn main() {
    let mut buffer = [0u8; 16];
    let mut cursor = Cursor::new(&mut buffer[..]);

    cursor.write_u8(1);
    cursor.write_u16::<BigEndian>(5);
    cursor.write_u32::<LittleEndian>(16);
    cursor.write_bytes(&[1, 2, 3, 4, 5]);

    println!("Remaining space in cursor is {} bytes", cursor.remaining());
    cursor.set_position(0);

    let x = cursor.read_u8();
    let y = cursor.read_u16::<BigEndian>();
    let z = cursor.read_u32::<LittleEndian>();

    let mut w = [0u8; 5];
    cursor.read_bytes(&mut w);

    println!("Read-back from buffer: {x}, {y}, {z}, {w:?}");
    println!("Cursor is now at position {}", cursor.position());
}

pub fn write_u8(&mut self, val: u8)

Writes a 8bit integer value to the underlying buffer and advances cursor position. Panics if there is not enough space remaining.

Examples found in repository

examples/basic.rs (line 7)

fn main() {
    let mut buffer = [0u8; 16];
    let mut cursor = Cursor::new(&mut buffer[..]);

    cursor.write_u8(1);
    cursor.write_u16::<BigEndian>(5);
    cursor.write_u32::<LittleEndian>(16);
    cursor.write_bytes(&[1, 2, 3, 4, 5]);

    println!("Remaining space in cursor is {} bytes", cursor.remaining());
    cursor.set_position(0);

    let x = cursor.read_u8();
    let y = cursor.read_u16::<BigEndian>();
    let z = cursor.read_u32::<LittleEndian>();

    let mut w = [0u8; 5];
    cursor.read_bytes(&mut w);

    println!("Read-back from buffer: {x}, {y}, {z}, {w:?}");
    println!("Cursor is now at position {}", cursor.position());
}

pub fn write_u16<B: ByteOrder>(&mut self, val: u16)

Writes a 16bit integer value to the underlying buffer and advances cursor position. Panics if there is not enough space remaining.

Examples found in repository

examples/basic.rs (line 8)

fn main() {
    let mut buffer = [0u8; 16];
    let mut cursor = Cursor::new(&mut buffer[..]);

    cursor.write_u8(1);
    cursor.write_u16::<BigEndian>(5);
    cursor.write_u32::<LittleEndian>(16);
    cursor.write_bytes(&[1, 2, 3, 4, 5]);

    println!("Remaining space in cursor is {} bytes", cursor.remaining());
    cursor.set_position(0);

    let x = cursor.read_u8();
    let y = cursor.read_u16::<BigEndian>();
    let z = cursor.read_u32::<LittleEndian>();

    let mut w = [0u8; 5];
    cursor.read_bytes(&mut w);

    println!("Read-back from buffer: {x}, {y}, {z}, {w:?}");
    println!("Cursor is now at position {}", cursor.position());
}

pub fn write_u24<B: ByteOrder>(&mut self, val: u32)

Writes a 24bit integer value to the underlying buffer and advances cursor position. Panics if there is not enough space remaining.

pub fn write_u32<B: ByteOrder>(&mut self, val: u32)

Writes a 32bit integer value to the underlying buffer and advances cursor position. Panics if there is not enough space remaining.

Examples found in repository

examples/basic.rs (line 9)

fn main() {
    let mut buffer = [0u8; 16];
    let mut cursor = Cursor::new(&mut buffer[..]);

    cursor.write_u8(1);
    cursor.write_u16::<BigEndian>(5);
    cursor.write_u32::<LittleEndian>(16);
    cursor.write_bytes(&[1, 2, 3, 4, 5]);

    println!("Remaining space in cursor is {} bytes", cursor.remaining());
    cursor.set_position(0);

    let x = cursor.read_u8();
    let y = cursor.read_u16::<BigEndian>();
    let z = cursor.read_u32::<LittleEndian>();

    let mut w = [0u8; 5];
    cursor.read_bytes(&mut w);

    println!("Read-back from buffer: {x}, {y}, {z}, {w:?}");
    println!("Cursor is now at position {}", cursor.position());
}

pub fn write_u64<B: ByteOrder>(&mut self, val: u64)

Writes a 64bit integer value to the underlying buffer and advances cursor position. Panics if there is not enough space remaining.

Trait Implementations

impl<T: Debug> Debug for Cursor<T>

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

Formats the value using the given formatter.