Struct rustc_serialize::opaque::FileEncoder

source ·
pub struct FileEncoder {
    buf: Box<[u8; 8192]>,
    buffered: usize,
    flushed: usize,
    file: File,
    res: Result<(), Error>,
    path: PathBuf,
    finished: bool,
}
Expand description

FileEncoder encodes data to file via fixed-size buffer.

There used to be a MemEncoder type that encoded all the data into a Vec. FileEncoder is better because its memory use is determined by the size of the buffer, rather than the full length of the encoded data, and because it doesn’t need to reallocate memory along the way.

Fields§

§buf: Box<[u8; 8192]>§buffered: usize§flushed: usize§file: File§res: Result<(), Error>§path: PathBuf§finished: bool

Implementations§

source§

impl FileEncoder

source

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

source

pub fn position(&self) -> usize

source

pub fn flush(&mut self)

source

pub fn file(&self) -> &File

source

pub fn path(&self) -> &Path

source

fn buffer_empty(&mut self) -> &mut [u8]

source

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

source

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

source

pub fn write_with<const N: usize>( &mut self, visitor: impl FnOnce(&mut [u8; N]) -> usize, )

Write up to N bytes to this encoder.

This function can be used to avoid the overhead of calling memcpy for writes that have runtime-variable length, but are small and have a small fixed upper bound.

This can be used to do in-place encoding as is done for leb128 (without this function we would need to write to a temporary buffer then memcpy into the encoder), and it can also be used to implement the varint scheme we use for rmeta and dep graph encoding, where we only want to encode the first few bytes of an integer. Copying in the whole integer then only advancing the encoder state for the few bytes we care about is more efficient than calling FileEncoder::write_all, because variable-size copies are always lowered to memcpy, which has overhead and contains a lot of logic we can bypass with this function. Note that common architectures support fixed-size writes up to 8 bytes with one instruction, so while this does in some sense do wasted work, we come out ahead.

source

fn panic_invalid_write<const N: usize>(written: usize)

source

pub fn write_array<const N: usize>(&mut self, buf: [u8; N])

Helper for calls where FileEncoder::write_with always writes the whole array.

source

pub fn finish(&mut self) -> FileEncodeResult

Trait Implementations§

source§

impl Drop for FileEncoder

source§

fn drop(&mut self)

Executes the destructor for this type. Read more
source§

impl Encodable<FileEncoder> for [u8]

source§

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

source§

impl Encodable<FileEncoder> for IntEncodedWithFixedSize

source§

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

source§

impl Encoder for FileEncoder

source§

fn emit_usize(&mut self, v: usize)

source§

fn emit_u128(&mut self, v: u128)

source§

fn emit_u64(&mut self, v: u64)

source§

fn emit_u32(&mut self, v: u32)

source§

fn emit_u16(&mut self, v: u16)

source§

fn emit_u8(&mut self, v: u8)

source§

fn emit_isize(&mut self, v: isize)

source§

fn emit_i128(&mut self, v: i128)

source§

fn emit_i64(&mut self, v: i64)

source§

fn emit_i32(&mut self, v: i32)

source§

fn emit_i16(&mut self, v: i16)

source§

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

source§

fn emit_i8(&mut self, v: i8)

source§

fn emit_bool(&mut self, v: bool)

source§

fn emit_char(&mut self, v: char)

source§

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

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

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: 64 bytes