Trait std::io::WriterUtil

pub trait WriterUtil {
    fn write_char(&self, ch: char);
    fn write_str(&self, s: &str);
    fn write_line(&self, s: &str);
    fn write_int(&self, n: int);
    fn write_uint(&self, n: uint);
    fn write_le_uint(&self, n: uint);
    fn write_le_int(&self, n: int);
    fn write_be_uint(&self, n: uint);
    fn write_be_int(&self, n: int);
    fn write_be_u64(&self, n: u64);
    fn write_be_u32(&self, n: u32);
    fn write_be_u16(&self, n: u16);
    fn write_be_i64(&self, n: i64);
    fn write_be_i32(&self, n: i32);
    fn write_be_i16(&self, n: i16);
    fn write_be_f64(&self, f: f64);
    fn write_be_f32(&self, f: f32);
    fn write_le_u64(&self, n: u64);
    fn write_le_u32(&self, n: u32);
    fn write_le_u16(&self, n: u16);
    fn write_le_i64(&self, n: i64);
    fn write_le_i32(&self, n: i32);
    fn write_le_i16(&self, n: i16);
    fn write_le_f64(&self, f: f64);
    fn write_le_f32(&self, f: f32);
    fn write_u8(&self, n: u8);
    fn write_i8(&self, n: i8);
}

Generic utility functions defined on writers.

Required Methods

`fn write_char(&self, ch: char)`

Write a single utf-8 encoded char.

`fn write_str(&self, s: &str)`

Write every char in the given str, encoded as utf-8.

`fn write_line(&self, s: &str)`

Write the given str, as utf-8, followed by '\n'.

`fn write_int(&self, n: int)`

Write the result of passing n through int::to_str_bytes.

`fn write_uint(&self, n: uint)`

Write the result of passing n through uint::to_str_bytes.

`fn write_le_uint(&self, n: uint)`

Write a little-endian uint (number of bytes depends on system).

`fn write_le_int(&self, n: int)`

Write a little-endian int (number of bytes depends on system).

`fn write_be_uint(&self, n: uint)`

Write a big-endian uint (number of bytes depends on system).

`fn write_be_int(&self, n: int)`

Write a big-endian int (number of bytes depends on system).

`fn write_be_u64(&self, n: u64)`

Write a big-endian u64 (8 bytes).

`fn write_be_u32(&self, n: u32)`

Write a big-endian u32 (4 bytes).

`fn write_be_u16(&self, n: u16)`

Write a big-endian u16 (2 bytes).

`fn write_be_i64(&self, n: i64)`

Write a big-endian i64 (8 bytes).

`fn write_be_i32(&self, n: i32)`

Write a big-endian i32 (4 bytes).

`fn write_be_i16(&self, n: i16)`

Write a big-endian i16 (2 bytes).

`fn write_be_f64(&self, f: f64)`

Write a big-endian IEEE754 double-precision floating-point (8 bytes).

`fn write_be_f32(&self, f: f32)`

Write a big-endian IEEE754 single-precision floating-point (4 bytes).

`fn write_le_u64(&self, n: u64)`

Write a little-endian u64 (8 bytes).

`fn write_le_u32(&self, n: u32)`

Write a little-endian u32 (4 bytes).

`fn write_le_u16(&self, n: u16)`

Write a little-endian u16 (2 bytes).

`fn write_le_i64(&self, n: i64)`

Write a little-endian i64 (8 bytes).

`fn write_le_i32(&self, n: i32)`

Write a little-endian i32 (4 bytes).

`fn write_le_i16(&self, n: i16)`

Write a little-endian i16 (2 bytes).

`fn write_le_f64(&self, f: f64)`

Write a little-endian IEEE754 double-precision floating-point (8 bytes).

`fn write_le_f32(&self, f: f32)`

Write a little-endian IEEE754 single-precision floating-point (4 bytes).

`fn write_u8(&self, n: u8)`

Write a u8 (1 byte).

`fn write_i8(&self, n: i8)`

Write a i8 (1 byte).

Implementors

impl<T: Writer> WriterUtil for T

Modules

Structs

Enums

Traits

Functions