Struct rustc_serialize::opaque::FileEncoder

pub struct FileEncoder {
    buf: Box<[MaybeUninit<u8>]>,
    buffered: usize,
    flushed: usize,
    file: File,
    res: Result<(), Error>,
}

FileEncoder encodes data to file via fixed-size buffer.

When encoding large amounts of data to a file, using FileEncoder may be preferred over using MemEncoder to encode to a Vec, and then writing the Vec to file, as the latter uses as much memory as there is encoded data, while the former uses the fixed amount of memory allocated to the buffer. FileEncoder also has the advantage of not needing to reallocate as data is appended to it, but the disadvantage of requiring more error handling, which has some runtime overhead.

Fields

buf: Box<[MaybeUninit<u8>]>

The input buffer. For adequate performance, we need more control over buffering than BufWriter offers. If BufWriter ever offers a raw buffer access API, we can use it, and remove buf and buffered.

buffered: usize

flushed: usize

file: File

res: Result<(), Error>

Implementations

impl FileEncoder

pub fn new<P: AsRef<Path>>(path: P) -> Result<Self>

pub fn with_capacity<P: AsRef<Path>>(path: P, capacity: usize) -> Result<Self>

pub fn position(&self) -> usize

pub fn flush(&mut self)

pub fn file(&self) -> &File

fn capacity(&self) -> usize

fn write_one(&mut self, value: u8)

fn write_all(&mut self, buf: &[u8])

fn write_all_unbuffered(&mut self, buf: &[u8])

pub fn finish(self) -> Result<usize, Error>

Trait Implementations

impl Drop for FileEncoder

fn drop(&mut self)

Executes the destructor for this type.

impl Encodable<FileEncoder> for [u8]

fn encode(&self, e: &mut FileEncoder)

impl Encodable<FileEncoder> for IntEncodedWithFixedSize

fn encode(&self, e: &mut FileEncoder)

impl Encoder for FileEncoder

fn emit_usize(&mut self, v: usize)

fn emit_u128(&mut self, v: u128)

fn emit_u64(&mut self, v: u64)

fn emit_u32(&mut self, v: u32)

fn emit_u16(&mut self, v: u16)

fn emit_u8(&mut self, v: u8)

fn emit_isize(&mut self, v: isize)

fn emit_i128(&mut self, v: i128)

fn emit_i64(&mut self, v: i64)

fn emit_i32(&mut self, v: i32)

fn emit_i16(&mut self, v: i16)

fn emit_i8(&mut self, v: i8)

fn emit_bool(&mut self, v: bool)

fn emit_f64(&mut self, v: f64)

fn emit_f32(&mut self, v: f32)

fn emit_char(&mut self, v: char)

fn emit_str(&mut self, v: &str)

fn emit_raw_bytes(&mut self, s: &[u8])

fn emit_enum_variant<F>(&mut self, v_id: usize, f: F)where
    F: FnOnce(&mut Self),

fn emit_fieldless_enum_variant<const ID: usize>(&mut self)

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.

Size: 48 bytes