Trait webparse::binary::BufMut

pub unsafe trait BufMut {
    // Required methods
    fn remaining_mut(&self) -> usize;
    unsafe fn advance_mut(&mut self, cnt: usize);
    fn chunk_mut(&mut self) -> &mut [MaybeUninit<u8>];

    // Provided methods
    fn has_remaining_mut(&self) -> bool { ... }
    fn put<T: Buf>(&mut self, src: &mut T) -> usize
       where Self: Sized { ... }
    fn inner_put_slice(&mut self, src: &[u8]) -> usize { ... }
    fn put_slice(&mut self, src: &[u8]) -> usize { ... }
    fn put_bytes(&mut self, val: u8, cnt: usize) -> usize { ... }
    fn put_u8(&mut self, n: u8) -> usize { ... }
    fn put_i8(&mut self, n: i8) -> usize { ... }
    fn put_u16(&mut self, n: u16) -> usize { ... }
    fn put_u16_le(&mut self, n: u16) -> usize { ... }
    fn put_u16_ne(&mut self, n: u16) -> usize { ... }
    fn put_i16(&mut self, n: i16) -> usize { ... }
    fn put_i16_le(&mut self, n: i16) -> usize { ... }
    fn put_i16_ne(&mut self, n: i16) -> usize { ... }
    fn put_u32(&mut self, n: u32) -> usize { ... }
    fn put_u32_le(&mut self, n: u32) -> usize { ... }
    fn put_u32_ne(&mut self, n: u32) -> usize { ... }
    fn put_i32(&mut self, n: i32) -> usize { ... }
    fn put_i32_le(&mut self, n: i32) -> usize { ... }
    fn put_i32_ne(&mut self, n: i32) -> usize { ... }
    fn put_u64(&mut self, n: u64) -> usize { ... }
    fn put_u64_le(&mut self, n: u64) -> usize { ... }
    fn put_u64_ne(&mut self, n: u64) -> usize { ... }
    fn put_i64(&mut self, n: i64) -> usize { ... }
    fn put_i64_le(&mut self, n: i64) -> usize { ... }
    fn put_i64_ne(&mut self, n: i64) -> usize { ... }
    fn put_u128(&mut self, n: u128) -> usize { ... }
    fn put_u128_le(&mut self, n: u128) -> usize { ... }
    fn put_u128_ne(&mut self, n: u128) -> usize { ... }
    fn put_i128(&mut self, n: i128) -> usize { ... }
    fn put_i128_le(&mut self, n: i128) -> usize { ... }
    fn put_i128_ne(&mut self, n: i128) -> usize { ... }
    fn put_uint(&mut self, n: u64, nbytes: usize) -> usize { ... }
    fn put_uint_le(&mut self, n: u64, nbytes: usize) -> usize { ... }
    fn put_uint_ne(&mut self, n: u64, nbytes: usize) -> usize { ... }
    fn put_int(&mut self, n: i64, nbytes: usize) -> usize { ... }
    fn put_int_le(&mut self, n: i64, nbytes: usize) -> usize { ... }
    fn put_int_ne(&mut self, n: i64, nbytes: usize) -> usize { ... }
    fn put_f32(&mut self, n: f32) { ... }
    fn put_f32_le(&mut self, n: f32) -> usize { ... }
    fn put_f32_ne(&mut self, n: f32) -> usize { ... }
    fn put_f64(&mut self, n: f64) -> usize { ... }
    fn put_f64_le(&mut self, n: f64) -> usize { ... }
    fn put_f64_ne(&mut self, n: f64) -> usize { ... }
}

Required Methods

fn remaining_mut(&self) -> usize

unsafe fn advance_mut(&mut self, cnt: usize)

fn chunk_mut(&mut self) -> &mut [MaybeUninit<u8>]

Provided Methods

fn has_remaining_mut(&self) -> bool

fn put<T: Buf>(&mut self, src: &mut T) -> usize

where Self: Sized,

fn inner_put_slice(&mut self, src: &[u8]) -> usize

fn put_slice(&mut self, src: &[u8]) -> usize

Examples found in repository

examples/demo.rs (line 26)

    fn serialize1<B: Buf + BufMut>(&self, buf: &mut B) {
        buf.put_slice(self.as_bytes());
    }

fn put_bytes(&mut self, val: u8, cnt: usize) -> usize

fn put_u8(&mut self, n: u8) -> usize

fn put_i8(&mut self, n: i8) -> usize

fn put_u16(&mut self, n: u16) -> usize

Writes an unsigned 16 bit integer to self in big-endian byte order.

The current position is advanced by 2.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_u16(0x0809);
assert_eq!(buf, b"\x08\x09");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_u16_le(&mut self, n: u16) -> usize

Writes an unsigned 16 bit integer to self in little-endian byte order.

The current position is advanced by 2.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_u16_le(0x0809);
assert_eq!(buf, b"\x09\x08");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_u16_ne(&mut self, n: u16) -> usize

Writes an unsigned 16 bit integer to self in native-endian byte order.

The current position is advanced by 2.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_u16_ne(0x0809);
if cfg!(target_endian = "big") {
    assert_eq!(buf, b"\x08\x09");
} else {
    assert_eq!(buf, b"\x09\x08");
}

Panics

This function panics if there is not enough remaining capacity in self.

fn put_i16(&mut self, n: i16) -> usize

Writes a signed 16 bit integer to self in big-endian byte order.

The current position is advanced by 2.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_i16(0x0809);
assert_eq!(buf, b"\x08\x09");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_i16_le(&mut self, n: i16) -> usize

Writes a signed 16 bit integer to self in little-endian byte order.

The current position is advanced by 2.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_i16_le(0x0809);
assert_eq!(buf, b"\x09\x08");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_i16_ne(&mut self, n: i16) -> usize

Writes a signed 16 bit integer to self in native-endian byte order.

The current position is advanced by 2.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_i16_ne(0x0809);
if cfg!(target_endian = "big") {
    assert_eq!(buf, b"\x08\x09");
} else {
    assert_eq!(buf, b"\x09\x08");
}

Panics

This function panics if there is not enough remaining capacity in self.

fn put_u32(&mut self, n: u32) -> usize

Writes an unsigned 32 bit integer to self in big-endian byte order.

The current position is advanced by 4.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_u32(0x0809A0A1);
assert_eq!(buf, b"\x08\x09\xA0\xA1");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_u32_le(&mut self, n: u32) -> usize

Writes an unsigned 32 bit integer to self in little-endian byte order.

The current position is advanced by 4.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_u32_le(0x0809A0A1);
assert_eq!(buf, b"\xA1\xA0\x09\x08");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_u32_ne(&mut self, n: u32) -> usize

Writes an unsigned 32 bit integer to self in native-endian byte order.

The current position is advanced by 4.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_u32_ne(0x0809A0A1);
if cfg!(target_endian = "big") {
    assert_eq!(buf, b"\x08\x09\xA0\xA1");
} else {
    assert_eq!(buf, b"\xA1\xA0\x09\x08");
}

Panics

This function panics if there is not enough remaining capacity in self.

fn put_i32(&mut self, n: i32) -> usize

Writes a signed 32 bit integer to self in big-endian byte order.

The current position is advanced by 4.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_i32(0x0809A0A1);
assert_eq!(buf, b"\x08\x09\xA0\xA1");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_i32_le(&mut self, n: i32) -> usize

Writes a signed 32 bit integer to self in little-endian byte order.

The current position is advanced by 4.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_i32_le(0x0809A0A1);
assert_eq!(buf, b"\xA1\xA0\x09\x08");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_i32_ne(&mut self, n: i32) -> usize

Writes a signed 32 bit integer to self in native-endian byte order.

The current position is advanced by 4.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_i32_ne(0x0809A0A1);
if cfg!(target_endian = "big") {
    assert_eq!(buf, b"\x08\x09\xA0\xA1");
} else {
    assert_eq!(buf, b"\xA1\xA0\x09\x08");
}

Panics

This function panics if there is not enough remaining capacity in self.

fn put_u64(&mut self, n: u64) -> usize

Writes an unsigned 64 bit integer to self in the big-endian byte order.

The current position is advanced by 8.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_u64(0x0102030405060708);
assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_u64_le(&mut self, n: u64) -> usize

Writes an unsigned 64 bit integer to self in little-endian byte order.

The current position is advanced by 8.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_u64_le(0x0102030405060708);
assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_u64_ne(&mut self, n: u64) -> usize

Writes an unsigned 64 bit integer to self in native-endian byte order.

The current position is advanced by 8.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_u64_ne(0x0102030405060708);
if cfg!(target_endian = "big") {
    assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08");
} else {
    assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01");
}

Panics

This function panics if there is not enough remaining capacity in self.

fn put_i64(&mut self, n: i64) -> usize

Writes a signed 64 bit integer to self in the big-endian byte order.

The current position is advanced by 8.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_i64(0x0102030405060708);
assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_i64_le(&mut self, n: i64) -> usize

Writes a signed 64 bit integer to self in little-endian byte order.

The current position is advanced by 8.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_i64_le(0x0102030405060708);
assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_i64_ne(&mut self, n: i64) -> usize

Writes a signed 64 bit integer to self in native-endian byte order.

The current position is advanced by 8.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_i64_ne(0x0102030405060708);
if cfg!(target_endian = "big") {
    assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08");
} else {
    assert_eq!(buf, b"\x08\x07\x06\x05\x04\x03\x02\x01");
}

Panics

This function panics if there is not enough remaining capacity in self.

fn put_u128(&mut self, n: u128) -> usize

Writes an unsigned 128 bit integer to self in the big-endian byte order.

The current position is advanced by 16.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_u128(0x01020304050607080910111213141516);
assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_u128_le(&mut self, n: u128) -> usize

Writes an unsigned 128 bit integer to self in little-endian byte order.

The current position is advanced by 16.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_u128_le(0x01020304050607080910111213141516);
assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_u128_ne(&mut self, n: u128) -> usize

Writes an unsigned 128 bit integer to self in native-endian byte order.

The current position is advanced by 16.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_u128_ne(0x01020304050607080910111213141516);
if cfg!(target_endian = "big") {
    assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16");
} else {
    assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01");
}

Panics

This function panics if there is not enough remaining capacity in self.

fn put_i128(&mut self, n: i128) -> usize

Writes a signed 128 bit integer to self in the big-endian byte order.

The current position is advanced by 16.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_i128(0x01020304050607080910111213141516);
assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_i128_le(&mut self, n: i128) -> usize

Writes a signed 128 bit integer to self in little-endian byte order.

The current position is advanced by 16.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_i128_le(0x01020304050607080910111213141516);
assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_i128_ne(&mut self, n: i128) -> usize

Writes a signed 128 bit integer to self in native-endian byte order.

The current position is advanced by 16.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_i128_ne(0x01020304050607080910111213141516);
if cfg!(target_endian = "big") {
    assert_eq!(buf, b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16");
} else {
    assert_eq!(buf, b"\x16\x15\x14\x13\x12\x11\x10\x09\x08\x07\x06\x05\x04\x03\x02\x01");
}

Panics

This function panics if there is not enough remaining capacity in self.

fn put_uint(&mut self, n: u64, nbytes: usize) -> usize

Writes an unsigned n-byte integer to self in big-endian byte order.

The current position is advanced by nbytes.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_uint(0x010203, 3);
assert_eq!(buf, b"\x01\x02\x03");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_uint_le(&mut self, n: u64, nbytes: usize) -> usize

Writes an unsigned n-byte integer to self in the little-endian byte order.

The current position is advanced by nbytes.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_uint_le(0x010203, 3);
assert_eq!(buf, b"\x03\x02\x01");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_uint_ne(&mut self, n: u64, nbytes: usize) -> usize

Writes an unsigned n-byte integer to self in the native-endian byte order.

The current position is advanced by nbytes.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_uint_ne(0x010203, 3);
if cfg!(target_endian = "big") {
    assert_eq!(buf, b"\x01\x02\x03");
} else {
    assert_eq!(buf, b"\x03\x02\x01");
}

Panics

This function panics if there is not enough remaining capacity in self.

fn put_int(&mut self, n: i64, nbytes: usize) -> usize

Writes low nbytes of a signed integer to self in big-endian byte order.

The current position is advanced by nbytes.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_int(0x0504010203, 3);
assert_eq!(buf, b"\x01\x02\x03");

Panics

This function panics if there is not enough remaining capacity in self or if nbytes is greater than 8.

fn put_int_le(&mut self, n: i64, nbytes: usize) -> usize

Writes low nbytes of a signed integer to self in little-endian byte order.

The current position is advanced by nbytes.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_int_le(0x0504010203, 3);
assert_eq!(buf, b"\x03\x02\x01");

Panics

This function panics if there is not enough remaining capacity in self or if nbytes is greater than 8.

fn put_int_ne(&mut self, n: i64, nbytes: usize) -> usize

Writes low nbytes of a signed integer to self in native-endian byte order.

The current position is advanced by nbytes.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_int_ne(0x010203, 3);
if cfg!(target_endian = "big") {
    assert_eq!(buf, b"\x01\x02\x03");
} else {
    assert_eq!(buf, b"\x03\x02\x01");
}

Panics

This function panics if there is not enough remaining capacity in self or if nbytes is greater than 8.

fn put_f32(&mut self, n: f32)

Writes an IEEE754 single-precision (4 bytes) floating point number to self in big-endian byte order.

The current position is advanced by 4.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_f32(1.2f32);
assert_eq!(buf, b"\x3F\x99\x99\x9A");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_f32_le(&mut self, n: f32) -> usize

Writes an IEEE754 single-precision (4 bytes) floating point number to self in little-endian byte order.

The current position is advanced by 4.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_f32_le(1.2f32);
assert_eq!(buf, b"\x9A\x99\x99\x3F");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_f32_ne(&mut self, n: f32) -> usize

Writes an IEEE754 single-precision (4 bytes) floating point number to self in native-endian byte order.

The current position is advanced by 4.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_f32_ne(1.2f32);
if cfg!(target_endian = "big") {
    assert_eq!(buf, b"\x3F\x99\x99\x9A");
} else {
    assert_eq!(buf, b"\x9A\x99\x99\x3F");
}

Panics

This function panics if there is not enough remaining capacity in self.

fn put_f64(&mut self, n: f64) -> usize

Writes an IEEE754 double-precision (8 bytes) floating point number to self in big-endian byte order.

The current position is advanced by 8.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_f64(1.2f64);
assert_eq!(buf, b"\x3F\xF3\x33\x33\x33\x33\x33\x33");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_f64_le(&mut self, n: f64) -> usize

Writes an IEEE754 double-precision (8 bytes) floating point number to self in little-endian byte order.

The current position is advanced by 8.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_f64_le(1.2f64);
assert_eq!(buf, b"\x33\x33\x33\x33\x33\x33\xF3\x3F");

Panics

This function panics if there is not enough remaining capacity in self.

fn put_f64_ne(&mut self, n: f64) -> usize

Writes an IEEE754 double-precision (8 bytes) floating point number to self in native-endian byte order.

The current position is advanced by 8.

Examples

use webparse::BufMut;

let mut buf = vec![];
buf.put_f64_ne(1.2f64);
if cfg!(target_endian = "big") {
    assert_eq!(buf, b"\x3F\xF3\x33\x33\x33\x33\x33\x33");
} else {
    assert_eq!(buf, b"\x33\x33\x33\x33\x33\x33\xF3\x3F");
}

Panics

This function panics if there is not enough remaining capacity in self.

Implementations on Foreign Types

impl BufMut for Vec<u8>

fn remaining_mut(&self) -> usize

unsafe fn advance_mut(&mut self, cnt: usize)

fn chunk_mut(&mut self) -> &mut [MaybeUninit<u8>]

Implementors

impl BufMut for BinaryMut

impl<'w> BufMut for Masker<'w>