Struct byte_order::EndianWriter

pub struct EndianWriter<W: Write> { /* fields omitted */ }

An EndianWriter wraps some writer and provides it methods to write integers in some defined endianness.

Implementations

impl<W: Write> EndianWriter<W>

pub fn new(writer: W) -> EndianWriter<W>

Creates a new byte writer wrapping the provided writer. Endianness is derived from native byte order.

Since the target platform’s endianness is used, portable code should use EndianWriter::with_order, as appropriate.

Examples

use byte_order::EndianWriter;

let writer = EndianWriter::new(Vec::new());

pub fn with_order(order: Endianness, writer: W) -> EndianWriter<W>

Creates a new endian writer wrapping the provided writer. An order is also required, either Endianness::BE for big-endian or Endianness::LE for little-endian byte ordering.

Examples

use byte_order::{Endianness, EndianWriter};

let be_writer = EndianWriter::with_order(Endianness::BE, Vec::new());
let le_writer = EndianWriter::with_order(Endianness::LE, Vec::new());

pub fn into_inner(self) -> W

Consumes this byte writer, returning the underlying writer.

Examples

use byte_order::EndianWriter;

let writer = EndianWriter::new(Vec::new());

let vec = writer.into_inner();

pub fn get_ref(&self) -> &W

Gets a reference to the underlying writer of this byte writer.

Examples

use byte_order::EndianWriter;

let writer = EndianWriter::new(Vec::new());

let vec_reference = writer.get_ref();

pub fn get_mut(&mut self) -> &mut W

Gets a mutable reference to the underlying writer of this byte writer.

Care should be taken to avoid modifying the internal I/O state of the underlying writer as it may corrupt reading and writing numbers.

use byte_order::EndianWriter;

let mut writer = EndianWriter::new(Vec::new());

let vec_reference = writer.get_mut();

pub fn write_u8(&mut self, value: u8) -> Result<()>

Writes a u8 value to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

Examples

use byte_order::{Endianness, EndianWriter};

let mut be_writer = EndianWriter::with_order(Endianness::BE, Vec::new());
be_writer.write_u8(0x12u8).unwrap();

assert_eq!(be_writer.into_inner(), vec![0x12]);

use byte_order::{Endianness, EndianWriter};

let mut le_writer = EndianWriter::with_order(Endianness::LE, Vec::new());
le_writer.write_u8(0x12u8).unwrap();

assert_eq!(le_writer.into_inner(), vec![0x12]);

pub fn write_i8(&mut self, value: i8) -> Result<()>

Writes a i8 value to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

Examples

use byte_order::{Endianness, EndianWriter};

let mut be_writer = EndianWriter::with_order(Endianness::BE, Vec::new());
be_writer.write_i8(0x12i8).unwrap();

assert_eq!(be_writer.into_inner(), vec![0x12]);

use byte_order::{Endianness, EndianWriter};

let mut le_writer = EndianWriter::with_order(Endianness::LE, Vec::new());
le_writer.write_i8(0x12i8).unwrap();

assert_eq!(le_writer.into_inner(), vec![0x12]);

pub fn write_u16(&mut self, value: u16) -> Result<()>

Writes a u16 value to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

Examples

use byte_order::{Endianness, EndianWriter};

let mut be_writer = EndianWriter::with_order(Endianness::BE, Vec::new());
be_writer.write_u16(0x1234u16).unwrap();

assert_eq!(be_writer.into_inner(), vec![0x12, 0x34]);

use byte_order::{Endianness, EndianWriter};

let mut le_writer = EndianWriter::with_order(Endianness::LE, Vec::new());
le_writer.write_u16(0x1234u16).unwrap();

assert_eq!(le_writer.into_inner(), vec![0x34, 0x12]);

pub fn write_i16(&mut self, value: i16) -> Result<()>

Writes a i16 value to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

Examples

use byte_order::{Endianness, EndianWriter};

let mut be_writer = EndianWriter::with_order(Endianness::BE, Vec::new());
be_writer.write_i16(0x1234i16).unwrap();

assert_eq!(be_writer.into_inner(), vec![0x12, 0x34]);

use byte_order::{Endianness, EndianWriter};

let mut le_writer = EndianWriter::with_order(Endianness::LE, Vec::new());
le_writer.write_i16(0x1234i16).unwrap();

assert_eq!(le_writer.into_inner(), vec![0x34, 0x12]);

pub fn write_u32(&mut self, value: u32) -> Result<()>

Writes a u32 value to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

Examples

use byte_order::{Endianness, EndianWriter};

let mut be_writer = EndianWriter::with_order(Endianness::BE, Vec::new());
be_writer.write_u32(0x12345678u32).unwrap();

assert_eq!(be_writer.into_inner(), vec![0x12, 0x34, 0x56, 0x78]);

use byte_order::{Endianness, EndianWriter};

let mut le_writer = EndianWriter::with_order(Endianness::LE, Vec::new());
le_writer.write_u32(0x12345678u32).unwrap();

assert_eq!(le_writer.into_inner(), vec![0x78, 0x56, 0x34, 0x12]);

pub fn write_i32(&mut self, value: i32) -> Result<()>

Writes a i32 value to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

Examples

use byte_order::{Endianness, EndianWriter};

let mut be_writer = EndianWriter::with_order(Endianness::BE, Vec::new());
be_writer.write_i32(0x12345678i32).unwrap();

assert_eq!(be_writer.into_inner(), vec![0x12, 0x34, 0x56, 0x78]);

use byte_order::{Endianness, EndianWriter};

let mut le_writer = EndianWriter::with_order(Endianness::LE, Vec::new());
le_writer.write_i32(0x12345678i32).unwrap();

assert_eq!(le_writer.into_inner(), vec![0x78, 0x56, 0x34, 0x12]);

pub fn write_u64(&mut self, value: u64) -> Result<()>

Writes a u64 value to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

Examples

use byte_order::{Endianness, EndianWriter};

let mut be_writer = EndianWriter::with_order(Endianness::BE, Vec::new());
be_writer.write_u64(0x1234567890123456u64).unwrap();

assert_eq!(be_writer.into_inner(), vec![0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]);

use byte_order::{Endianness, EndianWriter};

let mut le_writer = EndianWriter::with_order(Endianness::LE, Vec::new());
le_writer.write_u64(0x1234567890123456u64).unwrap();

assert_eq!(le_writer.into_inner(), vec![0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]);

pub fn write_i64(&mut self, value: i64) -> Result<()>

Writes a i64 value to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

Examples

use byte_order::{Endianness, EndianWriter};

let mut be_writer = EndianWriter::with_order(Endianness::BE, Vec::new());
be_writer.write_i64(0x1234567890123456i64).unwrap();

assert_eq!(be_writer.into_inner(), vec![0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]);

use byte_order::{Endianness, EndianWriter};

let mut le_writer = EndianWriter::with_order(Endianness::LE, Vec::new());
le_writer.write_i64(0x1234567890123456i64).unwrap();

assert_eq!(le_writer.into_inner(), vec![0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]);

pub fn write_u128(&mut self, value: u128) -> Result<()>

Writes a u128 value to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

Examples

use byte_order::{Endianness, EndianWriter};

let mut be_writer = EndianWriter::with_order(Endianness::BE, Vec::new());
be_writer.write_u128(0x12345678901234567890123456789012u128).unwrap();

assert_eq!(be_writer.into_inner(), vec![0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34,
     0x56, 0x78, 0x90, 0x12]);

use byte_order::{Endianness, EndianWriter};

let mut le_writer = EndianWriter::with_order(Endianness::LE, Vec::new());
le_writer.write_u128(0x12345678901234567890123456789012u128).unwrap();

assert_eq!(le_writer.into_inner(), vec![0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90,
     0x78, 0x56, 0x34, 0x12]);

pub fn write_i128(&mut self, value: i128) -> Result<()>

Writes a i128 value to the underlying writer.

Errors

This method returns the same errors as Write::write_all.

Examples

use byte_order::{Endianness, EndianWriter};

let mut be_writer = EndianWriter::with_order(Endianness::BE, Vec::new());
be_writer.write_i128(0x12345678901234567890123456789012i128).unwrap();

assert_eq!(be_writer.into_inner(), vec![0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34,
     0x56, 0x78, 0x90, 0x12]);

use byte_order::{Endianness, EndianWriter};

let mut le_writer = EndianWriter::with_order(Endianness::LE, Vec::new());
le_writer.write_i128(0x12345678901234567890123456789012i128).unwrap();

assert_eq!(le_writer.into_inner(), vec![0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90,
     0x78, 0x56, 0x34, 0x12]);

Trait Implementations

impl<W: Write> Write for EndianWriter<W>

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a “by reference” adaptor for this instance of Write.