Trait ReadBytes 

pub trait ReadBytes: Sized {
    // Required methods
    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>;
}

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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl ReadBytes for i8

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

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>

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>

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

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

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>

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>

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

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

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>

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>

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

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

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>

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>

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

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

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>

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>

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

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

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>

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>

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);

impl ReadBytes for u8

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

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>

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>

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

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

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>

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>

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

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

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>

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>

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

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

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>

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>

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

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

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>

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>

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

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

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>

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>

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);

Implementors