Struct byte_order::EndianReader

pub struct EndianReader<R: Read> { /* fields omitted */ }

Implementations

impl<R: Read> EndianReader<R>

pub fn new(reader: R) -> EndianReader<R>

Creates a new byte reader wrapping the provided reader. Endianness is derived from native byte order.

Since the target platform’s endianness is used, portable code should use EndianReader::with_order, as appropriate.

Examples

use std::io::Cursor;
use byte_order::EndianReader;

let rdr = EndianReader::new(Cursor::new(vec![]));

pub fn with_order(order: Endianness, reader: R) -> EndianReader<R>

Creates a new endian reader wrapping the provided reader. An order is also required, either Endianness::BE for big-endian or Endianness::LE for little-endian byte ordering.

Examples

use std::io::Cursor;
use byte_order::{Endianness, EndianReader};

let be_reader = EndianReader::with_order(Endianness::BE, Cursor::new(vec![]));
let le_reader = EndianReader::with_order(Endianness::LE, Cursor::new(vec![]));

pub fn into_inner(self) -> R

Consumes this byte reader, returning the underlying reader.

Examples

use std::io::Cursor;
use byte_order::EndianReader;

let reader = EndianReader::new(Cursor::new(vec![]));

let cursor = reader.into_inner();

pub fn get_ref(&self) -> &R

Gets a reference to the underlying reader of this byte reader.

Examples

use std::io::Cursor;
use byte_order::EndianReader;

let reader = EndianReader::new(Cursor::new(vec![]));

let cursor_reference = reader.get_ref();

pub fn get_mut(&mut self) -> &mut R

Gets a mutable reference to the underlying reader of this byte reader.

Care should be taken to avoid modifying the internal I/O state of the underlying reader as it may corrupt reading and writing numbers.

use std::io::Cursor;
use byte_order::EndianReader;

let mut reader = EndianReader::new(Cursor::new(vec![]));

let cursor_reference = reader.get_mut();

pub fn read_u8(&mut self) -> Result<u8>

Reads a u8 value from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

Examples

use byte_order::{Endianness, EndianReader};

let be_bytes: &[u8] = &[0x12];
let mut be_reader = EndianReader::with_order(Endianness::BE, be_bytes);
let value = be_reader.read_u8().unwrap();

assert_eq!(value, 0x12u8);

use byte_order::{Endianness, EndianReader};

let le_bytes: &[u8] = &[0x12];
let mut le_reader = EndianReader::with_order(Endianness::LE, le_bytes);
let value = le_reader.read_u8().unwrap();

assert_eq!(value, 0x12u8);

pub fn read_i8(&mut self) -> Result<i8>

Reads a i8 value from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

Examples

use byte_order::{Endianness, EndianReader};

let be_bytes: &[u8] = &[0x12];
let mut be_reader = EndianReader::with_order(Endianness::BE, be_bytes);
let value = be_reader.read_i8().unwrap();

assert_eq!(value, 0x12i8);

use byte_order::{Endianness, EndianReader};

let le_bytes: &[u8] = &[0x12];
let mut le_reader = EndianReader::with_order(Endianness::LE, le_bytes);
let value = le_reader.read_i8().unwrap();

assert_eq!(value, 0x12i8);

pub fn read_u16(&mut self) -> Result<u16>

Reads a u16 value from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

Examples

use byte_order::{Endianness, EndianReader};

let be_bytes: &[u8] = &[0x12, 0x34];
let mut be_reader = EndianReader::with_order(Endianness::BE, be_bytes);
let value = be_reader.read_u16().unwrap();

assert_eq!(value, 0x1234u16);

use byte_order::{Endianness, EndianReader};

let le_bytes: &[u8] = &[0x34, 0x12];
let mut le_reader = EndianReader::with_order(Endianness::LE, le_bytes);
let value = le_reader.read_u16().unwrap();

assert_eq!(value, 0x1234u16);

pub fn read_i16(&mut self) -> Result<i16>

Reads a i16 value from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

Examples

use byte_order::{Endianness, EndianReader};

let be_bytes: &[u8] = &[0x12, 0x34];
let mut be_reader = EndianReader::with_order(Endianness::BE, be_bytes);
let value = be_reader.read_i16().unwrap();

assert_eq!(value, 0x1234i16);

use byte_order::{Endianness, EndianReader};

let le_bytes: &[u8] = &[0x34, 0x12];
let mut le_reader = EndianReader::with_order(Endianness::LE, le_bytes);
let value = le_reader.read_i16().unwrap();

assert_eq!(value, 0x1234i16);

pub fn read_u32(&mut self) -> Result<u32>

Reads a u32 value from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

Examples

use byte_order::{Endianness, EndianReader};

let be_bytes: &[u8] = &[0x12, 0x34, 0x56, 0x78];
let mut be_reader = EndianReader::with_order(Endianness::BE, be_bytes);
let value = be_reader.read_u32().unwrap();

assert_eq!(value, 0x12345678u32);

use byte_order::{Endianness, EndianReader};

let le_bytes: &[u8] = &[0x78, 0x56, 0x34, 0x12];
let mut le_reader = EndianReader::with_order(Endianness::LE, le_bytes);
let value = le_reader.read_u32().unwrap();

assert_eq!(value, 0x12345678u32);

pub fn read_i32(&mut self) -> Result<i32>

Reads a i32 value from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

Examples

use byte_order::{Endianness, EndianReader};

let be_bytes: &[u8] = &[0x12, 0x34, 0x56, 0x78];
let mut be_reader = EndianReader::with_order(Endianness::BE, be_bytes);
let value = be_reader.read_i32().unwrap();

assert_eq!(value, 0x12345678i32);

use byte_order::{Endianness, EndianReader};

let le_bytes: &[u8] = &[0x78, 0x56, 0x34, 0x12];
let mut le_reader = EndianReader::with_order(Endianness::LE, le_bytes);
let value = le_reader.read_i32().unwrap();

assert_eq!(value, 0x12345678i32);

pub fn read_u64(&mut self) -> Result<u64>

Reads a u64 value from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

Examples

use byte_order::{Endianness, EndianReader};

let be_bytes: &[u8] = &[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56];
let mut be_reader = EndianReader::with_order(Endianness::BE, be_bytes);
let value = be_reader.read_u64().unwrap();

assert_eq!(value, 0x1234567890123456u64);

use byte_order::{Endianness, EndianReader};

let le_bytes: &[u8] = &[0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12];
let mut le_reader = EndianReader::with_order(Endianness::LE, le_bytes);
let value = le_reader.read_u64().unwrap();

assert_eq!(value, 0x1234567890123456u64);

pub fn read_i64(&mut self) -> Result<i64>

Reads a i64 value from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

Examples

use byte_order::{Endianness, EndianReader};

let be_bytes: &[u8] = &[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56];
let mut be_reader = EndianReader::with_order(Endianness::BE, be_bytes);
let value = be_reader.read_i64().unwrap();

assert_eq!(value, 0x1234567890123456i64);

use byte_order::{Endianness, EndianReader};

let le_bytes: &[u8] = &[0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12];
let mut le_reader = EndianReader::with_order(Endianness::LE, le_bytes);
let value = le_reader.read_i64().unwrap();

assert_eq!(value, 0x1234567890123456i64);

pub fn read_u128(&mut self) -> Result<u128>

Reads a u128 value from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

Examples

use byte_order::{Endianness, EndianReader};

let be_bytes: &[u8] = &[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34,
  0x56, 0x78, 0x90, 0x12];
let mut be_reader = EndianReader::with_order(Endianness::BE, be_bytes);
let value = be_reader.read_u128().unwrap();

assert_eq!(value, 0x12345678901234567890123456789012u128);

use byte_order::{Endianness, EndianReader};

let le_bytes: &[u8] = &[0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90,
  0x78, 0x56, 0x34, 0x12];
let mut le_reader = EndianReader::with_order(Endianness::LE, le_bytes);
let value = le_reader.read_u128().unwrap();

assert_eq!(value, 0x12345678901234567890123456789012u128);

pub fn read_i128(&mut self) -> Result<i128>

Reads a i128 value from the underlying reader.

Errors

This method returns the same errors as Read::read_exact.

Examples

use byte_order::{Endianness, EndianReader};

let be_bytes: &[u8] = &[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34,
  0x56, 0x78, 0x90, 0x12];
let mut be_reader = EndianReader::with_order(Endianness::BE, be_bytes);
let value = be_reader.read_i128().unwrap();

assert_eq!(value, 0x12345678901234567890123456789012i128);

use byte_order::{Endianness, EndianReader};

let le_bytes: &[u8] = &[0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90,
  0x78, 0x56, 0x34, 0x12];
let mut le_reader = EndianReader::with_order(Endianness::LE, le_bytes);
let value = le_reader.read_i128().unwrap();

assert_eq!(value, 0x12345678901234567890123456789012i128);