Trait byteorder::ReadBytesExt
source · [−]pub trait ReadBytesExt: Read {
Show 33 methods
fn read_u8(&mut self) -> Result<u8> { ... }
fn read_i8(&mut self) -> Result<i8> { ... }
fn read_u16<T: ByteOrder>(&mut self) -> Result<u16> { ... }
fn read_i16<T: ByteOrder>(&mut self) -> Result<i16> { ... }
fn read_u24<T: ByteOrder>(&mut self) -> Result<u32> { ... }
fn read_i24<T: ByteOrder>(&mut self) -> Result<i32> { ... }
fn read_u32<T: ByteOrder>(&mut self) -> Result<u32> { ... }
fn read_i32<T: ByteOrder>(&mut self) -> Result<i32> { ... }
fn read_u48<T: ByteOrder>(&mut self) -> Result<u64> { ... }
fn read_i48<T: ByteOrder>(&mut self) -> Result<i64> { ... }
fn read_u64<T: ByteOrder>(&mut self) -> Result<u64> { ... }
fn read_i64<T: ByteOrder>(&mut self) -> Result<i64> { ... }
fn read_u128<T: ByteOrder>(&mut self) -> Result<u128> { ... }
fn read_i128<T: ByteOrder>(&mut self) -> Result<i128> { ... }
fn read_uint<T: ByteOrder>(&mut self, nbytes: usize) -> Result<u64> { ... }
fn read_int<T: ByteOrder>(&mut self, nbytes: usize) -> Result<i64> { ... }
fn read_uint128<T: ByteOrder>(&mut self, nbytes: usize) -> Result<u128> { ... }
fn read_int128<T: ByteOrder>(&mut self, nbytes: usize) -> Result<i128> { ... }
fn read_f32<T: ByteOrder>(&mut self) -> Result<f32> { ... }
fn read_f64<T: ByteOrder>(&mut self) -> Result<f64> { ... }
fn read_u16_into<T: ByteOrder>(&mut self, dst: &mut [u16]) -> Result<()> { ... }
fn read_u32_into<T: ByteOrder>(&mut self, dst: &mut [u32]) -> Result<()> { ... }
fn read_u64_into<T: ByteOrder>(&mut self, dst: &mut [u64]) -> Result<()> { ... }
fn read_u128_into<T: ByteOrder>(&mut self, dst: &mut [u128]) -> Result<()> { ... }
fn read_i8_into(&mut self, dst: &mut [i8]) -> Result<()> { ... }
fn read_i16_into<T: ByteOrder>(&mut self, dst: &mut [i16]) -> Result<()> { ... }
fn read_i32_into<T: ByteOrder>(&mut self, dst: &mut [i32]) -> Result<()> { ... }
fn read_i64_into<T: ByteOrder>(&mut self, dst: &mut [i64]) -> Result<()> { ... }
fn read_i128_into<T: ByteOrder>(&mut self, dst: &mut [i128]) -> Result<()> { ... }
fn read_f32_into<T: ByteOrder>(&mut self, dst: &mut [f32]) -> Result<()> { ... }
fn read_f32_into_unchecked<T: ByteOrder>(
&mut self,
dst: &mut [f32]
) -> Result<()> { ... }
fn read_f64_into<T: ByteOrder>(&mut self, dst: &mut [f64]) -> Result<()> { ... }
fn read_f64_into_unchecked<T: ByteOrder>(
&mut self,
dst: &mut [f64]
) -> Result<()> { ... }
}Expand description
Extends Read with methods for reading numbers. (For std::io.)
Most of the methods defined here have an unconstrained type parameter that
must be explicitly instantiated. Typically, it is instantiated with either
the BigEndian or LittleEndian types defined in this crate.
Examples
Read unsigned 16 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
assert_eq!(517, rdr.read_u16::<BigEndian>().unwrap());
assert_eq!(768, rdr.read_u16::<BigEndian>().unwrap());Provided methods
Reads an unsigned 8 bit integer from the underlying reader.
Note that since this reads a single byte, no byte order conversions are used. It is included for completeness.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read unsigned 8 bit integers from a Read:
use std::io::Cursor;
use byteorder::ReadBytesExt;
let mut rdr = Cursor::new(vec![2, 5]);
assert_eq!(2, rdr.read_u8().unwrap());
assert_eq!(5, rdr.read_u8().unwrap());Reads a signed 8 bit integer from the underlying reader.
Note that since this reads a single byte, no byte order conversions are used. It is included for completeness.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read signed 8 bit integers from a Read:
use std::io::Cursor;
use byteorder::ReadBytesExt;
let mut rdr = Cursor::new(vec![0x02, 0xfb]);
assert_eq!(2, rdr.read_i8().unwrap());
assert_eq!(-5, rdr.read_i8().unwrap());Reads an unsigned 16 bit integer from the underlying reader.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read unsigned 16 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
assert_eq!(517, rdr.read_u16::<BigEndian>().unwrap());
assert_eq!(768, rdr.read_u16::<BigEndian>().unwrap());Reads a signed 16 bit integer from the underlying reader.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read signed 16 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![0x00, 0xc1, 0xff, 0x7c]);
assert_eq!(193, rdr.read_i16::<BigEndian>().unwrap());
assert_eq!(-132, rdr.read_i16::<BigEndian>().unwrap());Reads an unsigned 24 bit integer from the underlying reader.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read unsigned 24 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![0x00, 0x01, 0x0b]);
assert_eq!(267, rdr.read_u24::<BigEndian>().unwrap());Reads a signed 24 bit integer from the underlying reader.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read signed 24 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![0xff, 0x7a, 0x33]);
assert_eq!(-34253, rdr.read_i24::<BigEndian>().unwrap());Reads an unsigned 32 bit integer from the underlying reader.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read unsigned 32 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![0x00, 0x00, 0x01, 0x0b]);
assert_eq!(267, rdr.read_u32::<BigEndian>().unwrap());Reads a signed 32 bit integer from the underlying reader.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read signed 32 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![0xff, 0xff, 0x7a, 0x33]);
assert_eq!(-34253, rdr.read_i32::<BigEndian>().unwrap());Reads an unsigned 48 bit integer from the underlying reader.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read unsigned 48 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![0xb6, 0x71, 0x6b, 0xdc, 0x2b, 0x31]);
assert_eq!(200598257150769, rdr.read_u48::<BigEndian>().unwrap());Reads a signed 48 bit integer from the underlying reader.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read signed 48 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![0x9d, 0x71, 0xab, 0xe7, 0x97, 0x8f]);
assert_eq!(-108363435763825, rdr.read_i48::<BigEndian>().unwrap());Reads an unsigned 64 bit integer from the underlying reader.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read an unsigned 64 bit big-endian integer from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83]);
assert_eq!(918733457491587, rdr.read_u64::<BigEndian>().unwrap());Reads a signed 64 bit integer from the underlying reader.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a signed 64 bit big-endian integer from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![0x80, 0, 0, 0, 0, 0, 0, 0]);
assert_eq!(i64::min_value(), rdr.read_i64::<BigEndian>().unwrap());Reads an unsigned 128 bit integer from the underlying reader.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read an unsigned 128 bit big-endian integer from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![
0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83,
0x00, 0x03, 0x43, 0x95, 0x4d, 0x60, 0x86, 0x83
]);
assert_eq!(16947640962301618749969007319746179, rdr.read_u128::<BigEndian>().unwrap());Reads a signed 128 bit integer from the underlying reader.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a signed 128 bit big-endian integer from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
assert_eq!(i128::min_value(), rdr.read_i128::<BigEndian>().unwrap());Reads an unsigned n-bytes integer from the underlying reader.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read an unsigned n-byte big-endian integer from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![0x80, 0x74, 0xfa]);
assert_eq!(8418554, rdr.read_uint::<BigEndian>(3).unwrap());Reads a signed n-bytes integer from the underlying reader.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read an unsigned n-byte big-endian integer from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![0xc1, 0xff, 0x7c]);
assert_eq!(-4063364, rdr.read_int::<BigEndian>(3).unwrap());Reads an unsigned n-bytes integer from the underlying reader.
Reads a signed n-bytes integer from the underlying reader.
Reads a IEEE754 single-precision (4 bytes) floating point number from the underlying reader.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a big-endian single-precision floating point number from a Read:
use std::f32;
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![
0x40, 0x49, 0x0f, 0xdb,
]);
assert_eq!(f32::consts::PI, rdr.read_f32::<BigEndian>().unwrap());Reads a IEEE754 double-precision (8 bytes) floating point number from the underlying reader.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a big-endian double-precision floating point number from a Read:
use std::f64;
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![
0x40, 0x09, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18,
]);
assert_eq!(f64::consts::PI, rdr.read_f64::<BigEndian>().unwrap());Reads a sequence of unsigned 16 bit integers from the underlying reader.
The given buffer is either filled completely or an error is returned.
If an error is returned, the contents of dst are unspecified.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a sequence of unsigned 16 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
let mut dst = [0; 2];
rdr.read_u16_into::<BigEndian>(&mut dst).unwrap();
assert_eq!([517, 768], dst);Reads a sequence of unsigned 32 bit integers from the underlying reader.
The given buffer is either filled completely or an error is returned.
If an error is returned, the contents of dst are unspecified.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a sequence of unsigned 32 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![0, 0, 2, 5, 0, 0, 3, 0]);
let mut dst = [0; 2];
rdr.read_u32_into::<BigEndian>(&mut dst).unwrap();
assert_eq!([517, 768], dst);Reads a sequence of unsigned 64 bit integers from the underlying reader.
The given buffer is either filled completely or an error is returned.
If an error is returned, the contents of dst are unspecified.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a sequence of unsigned 64 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![
0, 0, 0, 0, 0, 0, 2, 5,
0, 0, 0, 0, 0, 0, 3, 0,
]);
let mut dst = [0; 2];
rdr.read_u64_into::<BigEndian>(&mut dst).unwrap();
assert_eq!([517, 768], dst);Reads a sequence of unsigned 128 bit integers from the underlying reader.
The given buffer is either filled completely or an error is returned.
If an error is returned, the contents of dst are unspecified.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a sequence of unsigned 128 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 5,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0,
]);
let mut dst = [0; 2];
rdr.read_u128_into::<BigEndian>(&mut dst).unwrap();
assert_eq!([517, 768], dst);Reads a sequence of signed 8 bit integers from the underlying reader.
The given buffer is either filled completely or an error is returned.
If an error is returned, the contents of dst are unspecified.
Note that since each i8 is a single byte, no byte order conversions
are used. This method is included because it provides a safe, simple
way for the caller to read into a &mut [i8] buffer. (Without this
method, the caller would have to either use unsafe code or convert
each byte to i8 individually.)
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a sequence of signed 8 bit integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![2, 251, 3]);
let mut dst = [0; 3];
rdr.read_i8_into(&mut dst).unwrap();
assert_eq!([2, -5, 3], dst);Reads a sequence of signed 16 bit integers from the underlying reader.
The given buffer is either filled completely or an error is returned.
If an error is returned, the contents of dst are unspecified.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a sequence of signed 16 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![2, 5, 3, 0]);
let mut dst = [0; 2];
rdr.read_i16_into::<BigEndian>(&mut dst).unwrap();
assert_eq!([517, 768], dst);Reads a sequence of signed 32 bit integers from the underlying reader.
The given buffer is either filled completely or an error is returned.
If an error is returned, the contents of dst are unspecified.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a sequence of signed 32 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![0, 0, 2, 5, 0, 0, 3, 0]);
let mut dst = [0; 2];
rdr.read_i32_into::<BigEndian>(&mut dst).unwrap();
assert_eq!([517, 768], dst);Reads a sequence of signed 64 bit integers from the underlying reader.
The given buffer is either filled completely or an error is returned.
If an error is returned, the contents of dst are unspecified.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a sequence of signed 64 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![
0, 0, 0, 0, 0, 0, 2, 5,
0, 0, 0, 0, 0, 0, 3, 0,
]);
let mut dst = [0; 2];
rdr.read_i64_into::<BigEndian>(&mut dst).unwrap();
assert_eq!([517, 768], dst);Reads a sequence of signed 128 bit integers from the underlying reader.
The given buffer is either filled completely or an error is returned.
If an error is returned, the contents of dst are unspecified.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a sequence of signed 128 bit big-endian integers from a Read:
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 5,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0,
]);
let mut dst = [0; 2];
rdr.read_i128_into::<BigEndian>(&mut dst).unwrap();
assert_eq!([517, 768], dst);Reads a sequence of IEEE754 single-precision (4 bytes) floating point numbers from the underlying reader.
The given buffer is either filled completely or an error is returned.
If an error is returned, the contents of dst are unspecified.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a sequence of big-endian single-precision floating point number
from a Read:
use std::f32;
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![
0x40, 0x49, 0x0f, 0xdb,
0x3f, 0x80, 0x00, 0x00,
]);
let mut dst = [0.0; 2];
rdr.read_f32_into::<BigEndian>(&mut dst).unwrap();
assert_eq!([f32::consts::PI, 1.0], dst);please use read_f32_into instead
DEPRECATED.
This method is deprecated. Use read_f32_into instead.
Reads a sequence of IEEE754 single-precision (4 bytes) floating point numbers from the underlying reader.
The given buffer is either filled completely or an error is returned.
If an error is returned, the contents of dst are unspecified.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a sequence of big-endian single-precision floating point number
from a Read:
use std::f32;
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![
0x40, 0x49, 0x0f, 0xdb,
0x3f, 0x80, 0x00, 0x00,
]);
let mut dst = [0.0; 2];
rdr.read_f32_into_unchecked::<BigEndian>(&mut dst).unwrap();
assert_eq!([f32::consts::PI, 1.0], dst);Reads a sequence of IEEE754 double-precision (8 bytes) floating point numbers from the underlying reader.
The given buffer is either filled completely or an error is returned.
If an error is returned, the contents of dst are unspecified.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a sequence of big-endian single-precision floating point number
from a Read:
use std::f64;
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![
0x40, 0x09, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18,
0x3f, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]);
let mut dst = [0.0; 2];
rdr.read_f64_into::<BigEndian>(&mut dst).unwrap();
assert_eq!([f64::consts::PI, 1.0], dst);please use read_f64_into instead
DEPRECATED.
This method is deprecated. Use read_f64_into instead.
Reads a sequence of IEEE754 double-precision (8 bytes) floating point numbers from the underlying reader.
The given buffer is either filled completely or an error is returned.
If an error is returned, the contents of dst are unspecified.
Safety
This method is unsafe because there are no guarantees made about the floating point values. In particular, this method does not check for signaling NaNs, which may result in undefined behavior.
Errors
This method returns the same errors as Read::read_exact.
Examples
Read a sequence of big-endian single-precision floating point number
from a Read:
use std::f64;
use std::io::Cursor;
use byteorder::{BigEndian, ReadBytesExt};
let mut rdr = Cursor::new(vec![
0x40, 0x09, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18,
0x3f, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
]);
let mut dst = [0.0; 2];
rdr.read_f64_into_unchecked::<BigEndian>(&mut dst).unwrap();
assert_eq!([f64::consts::PI, 1.0], dst);Implementors
impl<R: Read + ?Sized> ReadBytesExt for R
All types that implement Read get methods defined in ReadBytesExt
for free.