Trait omnom::WriteBytes

pub trait WriteBytes {
    fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>;
    fn write_le_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>;
    fn write_ne_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>;
}

Trait to enable writing bytes to a writer.

Required methods

fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as big endian.

Returns the amount of bytes written.

fn write_le_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as little endian.

Returns the amount of bytes written.

fn write_ne_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer using native endianness.

Returns the amount of bytes written.

Loading content...

Implementations on Foreign Types

impl WriteBytes for u8

fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as big endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_u8;
buf.write_be(num).unwrap();

fn write_le_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as little endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_u8;
buf.write_le(num).unwrap();

fn write_ne_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer using native endianness.

As the target platform's native endianness is used, portable code likely wants to use write_be_bytes or write_le_bytes, as appropriate instead.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_u8;
buf.write_ne(num).unwrap();

impl WriteBytes for u16

fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as big endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_u16;
buf.write_be(num).unwrap();

fn write_le_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as little endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_u16;
buf.write_le(num).unwrap();

fn write_ne_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer using native endianness.

As the target platform's native endianness is used, portable code likely wants to use write_be_bytes or write_le_bytes, as appropriate instead.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_u16;
buf.write_ne(num).unwrap();

impl WriteBytes for u32

fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as big endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_u32;
buf.write_be(num).unwrap();

fn write_le_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as little endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_u32;
buf.write_le(num).unwrap();

fn write_ne_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer using native endianness.

As the target platform's native endianness is used, portable code likely wants to use write_be_bytes or write_le_bytes, as appropriate instead.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_u32;
buf.write_ne(num).unwrap();

impl WriteBytes for u64

fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as big endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_u64;
buf.write_be(num).unwrap();

fn write_le_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as little endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_u64;
buf.write_le(num).unwrap();

fn write_ne_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer using native endianness.

As the target platform's native endianness is used, portable code likely wants to use write_be_bytes or write_le_bytes, as appropriate instead.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_u64;
buf.write_ne(num).unwrap();

impl WriteBytes for u128

fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as big endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_u128;
buf.write_be(num).unwrap();

fn write_le_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as little endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_u128;
buf.write_le(num).unwrap();

fn write_ne_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer using native endianness.

As the target platform's native endianness is used, portable code likely wants to use write_be_bytes or write_le_bytes, as appropriate instead.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_u128;
buf.write_ne(num).unwrap();

impl WriteBytes for usize

fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as big endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_usize;
buf.write_be(num).unwrap();

fn write_le_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as little endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_usize;
buf.write_le(num).unwrap();

fn write_ne_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer using native endianness.

As the target platform's native endianness is used, portable code likely wants to use write_be_bytes or write_le_bytes, as appropriate instead.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_usize;
buf.write_ne(num).unwrap();

impl WriteBytes for i8

fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as big endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_i8;
buf.write_be(num).unwrap();

fn write_le_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as little endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_i8;
buf.write_le(num).unwrap();

fn write_ne_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer using native endianness.

As the target platform's native endianness is used, portable code likely wants to use write_be_bytes or write_le_bytes, as appropriate instead.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_i8;
buf.write_ne(num).unwrap();

impl WriteBytes for i16

fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as big endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_i16;
buf.write_be(num).unwrap();

fn write_le_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as little endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_i16;
buf.write_le(num).unwrap();

fn write_ne_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer using native endianness.

As the target platform's native endianness is used, portable code likely wants to use write_be_bytes or write_le_bytes, as appropriate instead.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_i16;
buf.write_ne(num).unwrap();

impl WriteBytes for i32

fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as big endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_i32;
buf.write_be(num).unwrap();

fn write_le_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as little endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_i32;
buf.write_le(num).unwrap();

fn write_ne_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer using native endianness.

As the target platform's native endianness is used, portable code likely wants to use write_be_bytes or write_le_bytes, as appropriate instead.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_i32;
buf.write_ne(num).unwrap();

impl WriteBytes for i64

fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as big endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_i64;
buf.write_be(num).unwrap();

fn write_le_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as little endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_i64;
buf.write_le(num).unwrap();

fn write_ne_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer using native endianness.

As the target platform's native endianness is used, portable code likely wants to use write_be_bytes or write_le_bytes, as appropriate instead.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_i64;
buf.write_ne(num).unwrap();

impl WriteBytes for i128

fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as big endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_i128;
buf.write_be(num).unwrap();

fn write_le_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as little endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_i128;
buf.write_le(num).unwrap();

fn write_ne_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer using native endianness.

As the target platform's native endianness is used, portable code likely wants to use write_be_bytes or write_le_bytes, as appropriate instead.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_i128;
buf.write_ne(num).unwrap();

impl WriteBytes for isize

fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as big endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_isize;
buf.write_be(num).unwrap();

fn write_le_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer as little endian.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_isize;
buf.write_le(num).unwrap();

fn write_ne_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>

Write bytes to a writer using native endianness.

As the target platform's native endianness is used, portable code likely wants to use write_be_bytes or write_le_bytes, as appropriate instead.

Examples

use std::io::Cursor;
use omnom::prelude::*;

let mut buf = Cursor::new(vec![0; 15]);

let num = 12_isize;
buf.write_ne(num).unwrap();

Loading content...

Implementors

Loading content...