Struct byte_order::NumberReader [−][src]
pub struct NumberReader<R: Read> { /* fields omitted */ }
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
impl<R: Read> NumberReader<R>
[src]
impl<R: Read> NumberReader<R>
[src]pub fn new(src: R) -> NumberReader<R>ⓘNotable traits for NumberReader<R>
impl<R: Read> Read for NumberReader<R>
[src]
pub fn new(src: R) -> NumberReader<R>ⓘNotable traits for NumberReader<R>
impl<R: Read> Read for NumberReader<R>
[src]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(()) }
pub fn with_order(order: ByteOrder, src: R) -> NumberReader<R>ⓘNotable traits for NumberReader<R>
impl<R: Read> Read for NumberReader<R>
[src]
pub fn with_order(order: ByteOrder, src: R) -> NumberReader<R>ⓘNotable traits for NumberReader<R>
impl<R: Read> Read for NumberReader<R>
[src]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(()) }
pub fn into_inner(self) -> R
[src]
pub fn into_inner(self) -> R
[src]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();
pub fn get_ref(&self) -> &R
[src]
pub fn get_ref(&self) -> &R
[src]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();
pub fn get_mut(&mut self) -> &mut R
[src]
pub fn get_mut(&mut self) -> &mut R
[src]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();
pub fn read_u8(&mut self) -> Result<u8>
[src]
pub fn read_u8(&mut self) -> Result<u8>
[src]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(()) }
pub fn read_i8(&mut self) -> Result<i8>
[src]
pub fn read_i8(&mut self) -> Result<i8>
[src]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(()) }
pub fn read_u16(&mut self) -> Result<u16>
[src]
pub fn read_u16(&mut self) -> Result<u16>
[src]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(()) }
pub fn read_i16(&mut self) -> Result<i16>
[src]
pub fn read_i16(&mut self) -> Result<i16>
[src]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(()) }
pub fn read_u32(&mut self) -> Result<u32>
[src]
pub fn read_u32(&mut self) -> Result<u32>
[src]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(()) }
pub fn read_i32(&mut self) -> Result<i32>
[src]
pub fn read_i32(&mut self) -> Result<i32>
[src]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(()) }
pub fn read_u64(&mut self) -> Result<u64>
[src]
pub fn read_u64(&mut self) -> Result<u64>
[src]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(()) }
pub fn read_i64(&mut self) -> Result<i64>
[src]
pub fn read_i64(&mut self) -> Result<i64>
[src]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(()) }
pub fn read_u128(&mut self) -> Result<u128>
[src]
pub fn read_u128(&mut self) -> Result<u128>
[src]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(()) }
pub fn read_i128(&mut self) -> Result<i128>
[src]
pub fn read_i128(&mut self) -> Result<i128>
[src]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(()) }
pub fn read_f32(&mut self) -> Result<f32>
[src]
pub fn read_f32(&mut self) -> Result<f32>
[src]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(()) }
pub fn read_f64(&mut self) -> Result<f64>
[src]
pub fn read_f64(&mut self) -> Result<f64>
[src]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
impl<R: Read> Read for NumberReader<R>
[src]
impl<R: Read> Read for NumberReader<R>
[src]fn read(&mut self, buf: &mut [u8]) -> Result<usize>
[src]
fn read(&mut self, buf: &mut [u8]) -> Result<usize>
[src]Pull some bytes from this source into the specified buffer, returning how many bytes were read. Read more
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
1.36.0[src]
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
1.36.0[src]Like read
, except that it reads into a slice of buffers. Read more
fn is_read_vectored(&self) -> bool
[src]
fn is_read_vectored(&self) -> bool
[src]can_vector
)Determines if this Read
er has an efficient read_vectored
implementation. Read more
unsafe fn initializer(&self) -> Initializer
[src]
unsafe fn initializer(&self) -> Initializer
[src]read_initializer
)Determines if this Read
er can work with buffers of uninitialized
memory. Read more
fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>
1.0.0[src]
fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>
1.0.0[src]Read all bytes until EOF in this source, placing them into buf
. Read more
fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
1.0.0[src]
fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
1.0.0[src]Read all bytes until EOF in this source, appending them to buf
. Read more
fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
1.6.0[src]
fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
1.6.0[src]Read the exact number of bytes required to fill buf
. Read more
fn by_ref(&mut self) -> &mut Self
1.0.0[src]
fn by_ref(&mut self) -> &mut Self
1.0.0[src]Creates a “by reference” adaptor for this instance of Read
. Read more
Auto Trait Implementations
impl<R> RefUnwindSafe for NumberReader<R> where
R: RefUnwindSafe,
R: RefUnwindSafe,
impl<R> Send for NumberReader<R> where
R: Send,
R: Send,
impl<R> Sync for NumberReader<R> where
R: Sync,
R: Sync,
impl<R> Unpin for NumberReader<R> where
R: Unpin,
R: Unpin,
impl<R> UnwindSafe for NumberReader<R> where
R: UnwindSafe,
R: UnwindSafe,