Trait WriteBytes

pub trait WriteBytes {
    // Required methods
    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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

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

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

Implementors