[−][src]Trait omnom::prelude::ReadBytes
Trait to enable writing bytes to a reader.
Required methods
fn read_be_bytes<R: Read>(reader: &mut R) -> Result<Self>
Read bytes from a reader as big endian.
Returns the amount of bytes read.
fn read_le_bytes<R: Read>(reader: &mut R) -> Result<Self>
Read bytes from a reader as little endian.
Returns the amount of bytes read.
fn read_ne_bytes<R: Read>(reader: &mut R) -> Result<Self>
Read bytes from a reader using native endianness.
Returns the amount of bytes read.
fn fill_be_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
Fill bytes from a reader as big endian.
Returns the amount of bytes read.
fn fill_le_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
Fill bytes from a reader as little endian.
Returns the amount of bytes read.
fn fill_ne_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
Fill bytes from a reader using native endianness.
Returns the amount of bytes read.
Implementations on Foreign Types
impl ReadBytes for u8
[src]
fn read_be_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u8; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u8 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn read_le_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u8; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u8 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn read_ne_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u8; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u8 = buf.read_ne().unwrap(); assert_eq!(num, 12);
fn fill_be_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u8; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u8 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn fill_le_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u8; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u8 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn fill_ne_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u8; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u8 = buf.read_ne().unwrap(); assert_eq!(num, 12);
impl ReadBytes for u16
[src]
fn read_be_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u16; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u16 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn read_le_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u16; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u16 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn read_ne_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u16; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u16 = buf.read_ne().unwrap(); assert_eq!(num, 12);
fn fill_be_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u16; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u16 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn fill_le_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u16; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u16 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn fill_ne_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u16; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u16 = buf.read_ne().unwrap(); assert_eq!(num, 12);
impl ReadBytes for u32
[src]
fn read_be_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u32; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u32 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn read_le_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u32; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u32 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn read_ne_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u32; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u32 = buf.read_ne().unwrap(); assert_eq!(num, 12);
fn fill_be_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u32; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u32 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn fill_le_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u32; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u32 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn fill_ne_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u32; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u32 = buf.read_ne().unwrap(); assert_eq!(num, 12);
impl ReadBytes for u64
[src]
fn read_be_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u64; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u64 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn read_le_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u64; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u64 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn read_ne_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u64; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u64 = buf.read_ne().unwrap(); assert_eq!(num, 12);
fn fill_be_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u64; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u64 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn fill_le_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u64; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u64 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn fill_ne_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u64; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u64 = buf.read_ne().unwrap(); assert_eq!(num, 12);
impl ReadBytes for u128
[src]
fn read_be_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u128; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u128 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn read_le_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u128; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u128 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn read_ne_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u128; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u128 = buf.read_ne().unwrap(); assert_eq!(num, 12);
fn fill_be_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u128; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u128 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn fill_le_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u128; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u128 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn fill_ne_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_u128; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: u128 = buf.read_ne().unwrap(); assert_eq!(num, 12);
impl ReadBytes for usize
[src]
fn read_be_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_usize; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: usize = buf.read_be().unwrap(); assert_eq!(num, 12);
fn read_le_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_usize; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: usize = buf.read_le().unwrap(); assert_eq!(num, 12);
fn read_ne_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_usize; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: usize = buf.read_ne().unwrap(); assert_eq!(num, 12);
fn fill_be_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_usize; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: usize = buf.read_be().unwrap(); assert_eq!(num, 12);
fn fill_le_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_usize; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: usize = buf.read_le().unwrap(); assert_eq!(num, 12);
fn fill_ne_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_usize; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: usize = buf.read_ne().unwrap(); assert_eq!(num, 12);
impl ReadBytes for i8
[src]
fn read_be_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i8; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i8 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn read_le_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i8; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i8 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn read_ne_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i8; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i8 = buf.read_ne().unwrap(); assert_eq!(num, 12);
fn fill_be_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i8; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i8 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn fill_le_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i8; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i8 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn fill_ne_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i8; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i8 = buf.read_ne().unwrap(); assert_eq!(num, 12);
impl ReadBytes for i16
[src]
fn read_be_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i16; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i16 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn read_le_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i16; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i16 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn read_ne_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i16; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i16 = buf.read_ne().unwrap(); assert_eq!(num, 12);
fn fill_be_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i16; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i16 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn fill_le_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i16; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i16 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn fill_ne_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i16; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i16 = buf.read_ne().unwrap(); assert_eq!(num, 12);
impl ReadBytes for i32
[src]
fn read_be_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i32; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i32 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn read_le_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i32; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i32 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn read_ne_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i32; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i32 = buf.read_ne().unwrap(); assert_eq!(num, 12);
fn fill_be_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i32; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i32 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn fill_le_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i32; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i32 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn fill_ne_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i32; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i32 = buf.read_ne().unwrap(); assert_eq!(num, 12);
impl ReadBytes for i64
[src]
fn read_be_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i64; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i64 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn read_le_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i64; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i64 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn read_ne_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i64; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i64 = buf.read_ne().unwrap(); assert_eq!(num, 12);
fn fill_be_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i64; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i64 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn fill_le_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i64; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i64 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn fill_ne_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i64; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i64 = buf.read_ne().unwrap(); assert_eq!(num, 12);
impl ReadBytes for i128
[src]
fn read_be_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i128; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i128 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn read_le_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i128; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i128 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn read_ne_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i128; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i128 = buf.read_ne().unwrap(); assert_eq!(num, 12);
fn fill_be_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i128; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i128 = buf.read_be().unwrap(); assert_eq!(num, 12);
fn fill_le_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i128; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i128 = buf.read_le().unwrap(); assert_eq!(num, 12);
fn fill_ne_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_i128; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: i128 = buf.read_ne().unwrap(); assert_eq!(num, 12);
impl ReadBytes for isize
[src]
fn read_be_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_isize; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: isize = buf.read_be().unwrap(); assert_eq!(num, 12);
fn read_le_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_isize; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: isize = buf.read_le().unwrap(); assert_eq!(num, 12);
fn read_ne_bytes<R: Read>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_isize; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: isize = buf.read_ne().unwrap(); assert_eq!(num, 12);
fn fill_be_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as big endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_isize; buf.write_be(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: isize = buf.read_be().unwrap(); assert_eq!(num, 12);
fn fill_le_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader as little endian.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_isize; buf.write_le(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: isize = buf.read_le().unwrap(); assert_eq!(num, 12);
fn fill_ne_bytes<R: BufRead>(reader: &mut R) -> Result<Self>
[src]
Read bytes from a reader using native endianness.
As the target platform's native endianness is used, portable code
likely wants to use read_be_bytes
or read_le_bytes
, as
appropriate instead.
Examples
use std::io::{Cursor, Seek, SeekFrom}; use omnom::prelude::*; let mut buf = Cursor::new(vec![0; 15]); let num = 12_isize; buf.write_ne(num).unwrap(); buf.seek(SeekFrom::Start(0)).unwrap(); let num: isize = buf.read_ne().unwrap(); assert_eq!(num, 12);