[−][src]Trait omnom::WriteBytes
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.
Implementations on Foreign Types
impl WriteBytes for u8
[src]
fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>
[src]
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>
[src]
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>
[src]
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
[src]
fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>
[src]
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>
[src]
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>
[src]
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
[src]
fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>
[src]
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>
[src]
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>
[src]
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
[src]
fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>
[src]
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>
[src]
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>
[src]
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
[src]
fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>
[src]
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>
[src]
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>
[src]
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
[src]
fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>
[src]
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>
[src]
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>
[src]
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
[src]
fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>
[src]
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>
[src]
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>
[src]
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
[src]
fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>
[src]
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>
[src]
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>
[src]
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
[src]
fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>
[src]
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>
[src]
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>
[src]
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
[src]
fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>
[src]
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>
[src]
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>
[src]
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
[src]
fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>
[src]
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>
[src]
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>
[src]
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
[src]
fn write_be_bytes<W: Write>(&self, writer: &mut W) -> Result<usize>
[src]
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>
[src]
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>
[src]
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();