[−][src]Trait omnom::ReadBytes

pub trait ReadBytes: Sized {
    fn read_be_bytes<R: Read>(reader: &mut R) -> Result<Self>;

    fn read_le_bytes<R: Read>(reader: &mut R) -> Result<Self>;

    fn read_ne_bytes<R: Read>(reader: &mut R) -> Result<Self>;

    fn fill_be_bytes<R: BufRead>(reader: &mut R) -> Result<Self>;

    fn fill_le_bytes<R: BufRead>(reader: &mut R) -> Result<Self>;

    fn fill_ne_bytes<R: BufRead>(reader: &mut R) -> Result<Self>;
}

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.

Loading content...

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);
Loading content...

Implementors

Loading content...