pub struct NumberReader<R: Read> { /* private fields */ }
Expand description
A NumberReader
wraps a reader and provides methods for reading numbers.
Unlike many libraries, which take byte order as a parameter per operation, a
NumberReader
takes byte order as a parameter upon initialization.
§Examples
We can create a new NumberReader
using the target endianness using
NumberReader::new
:
use std::io::Cursor;
use byte_order::NumberReader;
let src = Cursor::new(vec![]);
let mut reader = NumberReader::new(src);
Or, to read numbers with a certain endianness, we can create NumberReader
structures using NumberReader::with_order
:
use std::io::Cursor;
use byte_order::{ByteOrder, NumberReader};
let src = Cursor::new(vec![]);
let mut be_reader = NumberReader::with_order(ByteOrder::BE, src.clone());
let mut le_reader = NumberReader::with_order(ByteOrder::LE, src.clone());
let mut ne_reader = NumberReader::with_order(ByteOrder::NE, src.clone());
To read numbers from the underlying reader, use any of the read_*
methods that are provided:
use std::io::Cursor;
use byte_order::{ByteOrder, NumberReader};
let src = Cursor::new(vec![0xA1, 0xB2]);
let mut be_reader = NumberReader::with_order(ByteOrder::BE, src.clone());
assert_eq!(0xA1B2, be_reader.read_u16()?);
let mut le_reader = NumberReader::with_order(ByteOrder::LE, src.clone());
assert_eq!(0xB2A1, le_reader.read_u16()?);
let mut ne_reader = NumberReader::with_order(ByteOrder::NE, src.clone());
assert_eq!(
if cfg!(target_endian = "big") {
0xA1B2
} else {
0xB2A1
},
ne_reader.read_u16()?
);
Implementations§
Source§impl<R: Read> NumberReader<R>
impl<R: Read> NumberReader<R>
Sourcepub fn new(src: R) -> NumberReader<R> ⓘ
pub fn new(src: R) -> NumberReader<R> ⓘ
Creates a new NumberReader
by wrapping the given reader.
Since the target platform’s native endianness is used, portable code
should use with_order
, as appropriate, instead.
Note: If you want to explicitly mark in your code that the target
platform’s endianness is desired, consider creating the NumberReader
using with_order
and ByteOrder::NE
.
§Examples
use std::io::{self, Cursor};
use byte_order::NumberReader;
fn main() -> io::Result<()> {
let src = Cursor::new(vec![0xA1, 0xB2]);
let mut reader = NumberReader::new(src);
assert_eq!(
reader.read_u16()?,
if cfg!(target_endian = "big") {
0xA1B2
} else {
0xB2A1
}
);
Ok(())
}
Sourcepub fn with_order(order: ByteOrder, src: R) -> NumberReader<R> ⓘ
pub fn with_order(order: ByteOrder, src: R) -> NumberReader<R> ⓘ
Creates a new NumberReader
by wrapping the given reader with the
specified byte order.
Use either ByteOrder::BE
for big-endian byte ordering,
ByteOrder::LE
for little-endian byte ordering, or ByteOrder::NE
to explicitly use the target platform’s endianness.
§Examples
use std::io::{self, Cursor};
use byte_order::{ByteOrder, NumberReader};
fn main() -> io::Result<()> {
let src = Cursor::new(vec![0xA1, 0xB2]);
let mut be_reader = NumberReader::with_order(ByteOrder::BE, src.clone());
assert_eq!(0xA1B2, be_reader.read_u16()?);
let mut le_reader = NumberReader::with_order(ByteOrder::LE, src.clone());
assert_eq!(0xB2A1, le_reader.read_u16()?);
let mut ne_reader = NumberReader::with_order(ByteOrder::NE, src.clone());
assert_eq!(
if cfg!(target_endian = "big") {
0xA1B2
} else {
0xB2A1
},
ne_reader.read_u16()?
);
Ok(())
}
Sourcepub fn into_inner(self) -> R
pub fn into_inner(self) -> R
Consumes this NumberReader
, returning the underlying value.
§Examples
use std::io::Cursor;
use byte_order::NumberReader;
let reader = NumberReader::new(Cursor::new(vec![]));
let cursor = reader.into_inner();
Sourcepub fn get_ref(&self) -> &R
pub fn get_ref(&self) -> &R
Gets a reference to the underlying value in this NumberReader
.
§Examples
use std::io::Cursor;
use byte_order::NumberReader;
let reader = NumberReader::new(Cursor::new(vec![]));
let reference = reader.get_ref();
Sourcepub fn get_mut(&mut self) -> &mut R
pub fn get_mut(&mut self) -> &mut R
Gets a mutable reference to the underlying value in this NumberReader
.
§Examples
use std::io::Cursor;
use byte_order::NumberReader;
let mut reader = NumberReader::new(Cursor::new(vec![]));
let reference = reader.get_mut();
Sourcepub fn read_u8(&mut self) -> Result<u8>
pub fn read_u8(&mut self) -> Result<u8>
Reads an unsigned 8-bit integer from the underlying reader.
Note: Since this method reads a single byte, no byte order conversions are used. It is included for completeness.
§Errors
This method propagates any error recieved from the internal call to
Read::read_exact
.
§Examples
use std::io::{self, Cursor};
use byte_order::NumberReader;
fn main() -> io::Result<()> {
let mut reader = NumberReader::new(Cursor::new(vec![0x12]));
assert_eq!(0x12u8, reader.read_u8()?);
Ok(())
}
Sourcepub fn read_i8(&mut self) -> Result<i8>
pub fn read_i8(&mut self) -> Result<i8>
Reads a signed 8-bit integer from the underlying reader.
Note: Since this method reads a single byte, no byte order conversions are used. It is included for completeness.
§Errors
This method propagates any error recieved from the internal call to
Read::read_exact
.
§Examples
use std::io::{self, Cursor};
use byte_order::NumberReader;
fn main() -> io::Result<()> {
let mut reader = NumberReader::new(Cursor::new(vec![0x12]));
assert_eq!(0x12i8, reader.read_i8()?);
Ok(())
}
Sourcepub fn read_u16(&mut self) -> Result<u16>
pub fn read_u16(&mut self) -> Result<u16>
Reads an unsigned 16-bit integer from the underlying reader.
§Errors
This method propagates any error recieved from the internal call to
Read::read_exact
.
§Examples
use std::io::{self, Cursor};
use byte_order::{ByteOrder, NumberReader};
fn main() -> io::Result<()> {
let src = Cursor::new(vec![0x12, 0x34]);
let mut be_reader = NumberReader::with_order(ByteOrder::BE, src.clone());
assert_eq!(0x1234u16, be_reader.read_u16()?);
let mut le_reader = NumberReader::with_order(ByteOrder::LE, src.clone());
assert_eq!(0x3412u16, le_reader.read_u16()?);
Ok(())
}
Sourcepub fn read_i16(&mut self) -> Result<i16>
pub fn read_i16(&mut self) -> Result<i16>
Reads a signed 16-bit integer from the underlying reader.
§Errors
This method propagates any error recieved from the internal call to
Read::read_exact
.
§Examples
use std::io::{self, Cursor};
use byte_order::{ByteOrder, NumberReader};
fn main() -> io::Result<()> {
let src = Cursor::new(vec![0x12, 0x34]);
let mut be_reader = NumberReader::with_order(ByteOrder::BE, src.clone());
assert_eq!(0x1234i16, be_reader.read_i16()?);
let mut le_reader = NumberReader::with_order(ByteOrder::LE, src.clone());
assert_eq!(0x3412i16, le_reader.read_i16()?);
Ok(())
}
Sourcepub fn read_u32(&mut self) -> Result<u32>
pub fn read_u32(&mut self) -> Result<u32>
Reads an unsigned 32-bit integer from the underlying reader.
§Errors
This method propagates any error recieved from the internal call to
Read::read_exact
.
§Examples
use std::io::{self, Cursor};
use byte_order::{ByteOrder, NumberReader};
fn main() -> io::Result<()> {
let src = Cursor::new(vec![0x12, 0x34, 0x56, 0x78]);
let mut be_reader = NumberReader::with_order(ByteOrder::BE, src.clone());
assert_eq!(0x12345678u32, be_reader.read_u32()?);
let mut le_reader = NumberReader::with_order(ByteOrder::LE, src.clone());
assert_eq!(0x78563412u32, le_reader.read_u32()?);
Ok(())
}
Sourcepub fn read_i32(&mut self) -> Result<i32>
pub fn read_i32(&mut self) -> Result<i32>
Reads a signed 32-bit integer from the underlying reader.
§Errors
This method propagates any error recieved from the internal call to
Read::read_exact
.
§Examples
use std::io::{self, Cursor};
use byte_order::{ByteOrder, NumberReader};
fn main() -> io::Result<()> {
let src = Cursor::new(vec![0x12, 0x34, 0x56, 0x78]);
let mut be_reader = NumberReader::with_order(ByteOrder::BE, src.clone());
assert_eq!(0x12345678i32, be_reader.read_i32()?);
let mut le_reader = NumberReader::with_order(ByteOrder::LE, src.clone());
assert_eq!(0x78563412i32, le_reader.read_i32()?);
Ok(())
}
Sourcepub fn read_u64(&mut self) -> Result<u64>
pub fn read_u64(&mut self) -> Result<u64>
Reads an unsigned 64-bit integer from the underlying reader.
§Errors
This method propagates any error recieved from the internal call to
Read::read_exact
.
§Examples
use std::io::{self, Cursor};
use byte_order::{ByteOrder, NumberReader};
fn main() -> io::Result<()> {
let src = Cursor::new(vec![0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]);
let mut be_reader = NumberReader::with_order(ByteOrder::BE, src.clone());
assert_eq!(0x1234567890123456u64, be_reader.read_u64()?);
let mut le_reader = NumberReader::with_order(ByteOrder::LE, src.clone());
assert_eq!(0x5634129078563412u64, le_reader.read_u64()?);
Ok(())
}
Sourcepub fn read_i64(&mut self) -> Result<i64>
pub fn read_i64(&mut self) -> Result<i64>
Reads a signed 64-bit integer from the underlying reader.
§Errors
This method propagates any error recieved from the internal call to
Read::read_exact
.
§Examples
use std::io::{self, Cursor};
use byte_order::{ByteOrder, NumberReader};
fn main() -> io::Result<()> {
let src = Cursor::new(vec![0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]);
let mut be_reader = NumberReader::with_order(ByteOrder::BE, src.clone());
assert_eq!(0x1234567890123456i64, be_reader.read_i64()?);
let mut le_reader = NumberReader::with_order(ByteOrder::LE, src.clone());
assert_eq!(0x5634129078563412i64, le_reader.read_i64()?);
Ok(())
}
Sourcepub fn read_u128(&mut self) -> Result<u128>
pub fn read_u128(&mut self) -> Result<u128>
Reads an unsigned 128-bit integer from the underlying reader.
§Errors
This method propagates any error recieved from the internal call to
Read::read_exact
.
§Examples
use std::io::{self, Cursor};
use byte_order::{ByteOrder, NumberReader};
fn main() -> io::Result<()> {
let src = Cursor::new(vec![
0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56,
0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12,
]);
let mut be_reader = NumberReader::with_order(ByteOrder::BE, src.clone());
assert_eq!(0x12345678901234567890123456789012u128, be_reader.read_u128()?);
let mut le_reader = NumberReader::with_order(ByteOrder::LE, src.clone());
assert_eq!(0x12907856341290785634129078563412u128, le_reader.read_u128()?);
Ok(())
}
Sourcepub fn read_i128(&mut self) -> Result<i128>
pub fn read_i128(&mut self) -> Result<i128>
Reads a signed 128-bit integer from the underlying reader.
§Errors
This method propagates any error recieved from the internal call to
Read::read_exact
.
§Examples
use std::io::{self, Cursor};
use byte_order::{ByteOrder, NumberReader};
fn main() -> io::Result<()> {
let src = Cursor::new(vec![
0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56,
0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12,
]);
let mut be_reader = NumberReader::with_order(ByteOrder::BE, src.clone());
assert_eq!(0x12345678901234567890123456789012u128, be_reader.read_u128()?);
let mut le_reader = NumberReader::with_order(ByteOrder::LE, src.clone());
assert_eq!(0x12907856341290785634129078563412u128, le_reader.read_u128()?);
Ok(())
}
Sourcepub fn read_f32(&mut self) -> Result<f32>
pub fn read_f32(&mut self) -> Result<f32>
Reads a IEEE754 single-precision floating point number from the underlying reader.
§Errors
This method propagates any error recieved from the internal call to
Read::read_exact
.
§Examples
use std::io::{self, Cursor};
use byte_order::{ByteOrder, NumberReader};
fn main() -> io::Result<()> {
let be_src = Cursor::new(vec![0x41, 0x48, 0x00, 0x00]);
let mut be_reader = NumberReader::with_order(ByteOrder::BE, be_src);
assert_eq!(12.5f32, be_reader.read_f32()?);
let le_src = Cursor::new(vec![0x00, 0x00, 0x48, 0x41]);
let mut le_reader = NumberReader::with_order(ByteOrder::LE, le_src);
assert_eq!(12.5f32, le_reader.read_f32()?);
Ok(())
}
Sourcepub fn read_f64(&mut self) -> Result<f64>
pub fn read_f64(&mut self) -> Result<f64>
Reads a IEEE754 double-precision floating point number from the underlying reader.
§Errors
This method propagates any error recieved from the internal call to
Read::read_exact
.
§Examples
use std::io::{self, Cursor};
use byte_order::{ByteOrder, NumberReader};
fn main() -> io::Result<()> {
let be_src = Cursor::new(vec![0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
let mut be_reader = NumberReader::with_order(ByteOrder::BE, be_src);
assert_eq!(12.5f64, be_reader.read_f64()?);
let le_src = Cursor::new(vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]);
let mut le_reader = NumberReader::with_order(ByteOrder::LE, le_src);
assert_eq!(12.5f64, le_reader.read_f64()?);
Ok(())
}
Trait Implementations§
Source§impl<R: Read> Read for NumberReader<R>
impl<R: Read> Read for NumberReader<R>
Source§fn read(&mut self, buf: &mut [u8]) -> Result<usize>
fn read(&mut self, buf: &mut [u8]) -> Result<usize>
1.36.0 · Source§fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
read
, except that it reads into a slice of buffers. Read moreSource§fn is_read_vectored(&self) -> bool
fn is_read_vectored(&self) -> bool
can_vector
)1.0.0 · Source§fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
buf
. Read more1.0.0 · Source§fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
buf
. Read more1.6.0 · Source§fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
buf
. Read moreSource§fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>
read_buf
)Source§fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
read_buf
)cursor
. Read more1.0.0 · Source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
Read
. Read more