Struct Writer 

pub struct Writer<'a, L> {
    pub writer: DeferredWriter<'a>,
    pub code: usize,
    /* private fields */
}

Fields

writer: DeferredWriter<'a>

code: usize

Implementations

impl<'a, L> Writer<'a, L>

where L: Lit,

pub fn new(writer: DeferredWriter<'a>) -> Self

Examples found in repository

examples/aagtoaig.rs (line 33)

fn main_err() -> Result<(), Error<u32>> {
    let stdin = std::io::stdin();
    let stdout = std::io::stdout();

    let aag_reader = ascii::Parser::<u32>::from_read(stdin.lock(), ascii::Config::default())?;

    let aag = aag_reader.parse()?;

    let (aig, _) = Renumber::renumber_aig(
        RenumberConfig::default()
            .trim(true)
            .structural_hash(true)
            .const_fold(true),
        &aag,
    )?;

    let aig_writer = DeferredWriter::from_write(stdout.lock());
    let mut aag_writer = binary::Writer::<u32>::new(aig_writer);

    aag_writer.write_ordered_aig(&aig);

    aag_writer.flush()?;
    Ok(())
}

pub fn write_header(&mut self, header: &Header)

pub fn write_lit(&mut self, lit: L)

pub fn write_latch(&mut self, latch: OrderedLatch<L>)

pub fn write_count(&mut self, count: usize)

pub fn write_and_gate(&mut self, and_gate: OrderedAndGate<L>)

pub fn write_symbol(&mut self, symbol: &Symbol<'_>)

pub fn write_comment(&mut self, comment: &str)

pub fn write_ordered_aig(&mut self, aig: &OrderedAig<L>)

Examples found in repository

examples/aagtoaig.rs (line 35)

fn main_err() -> Result<(), Error<u32>> {
    let stdin = std::io::stdin();
    let stdout = std::io::stdout();

    let aag_reader = ascii::Parser::<u32>::from_read(stdin.lock(), ascii::Config::default())?;

    let aag = aag_reader.parse()?;

    let (aig, _) = Renumber::renumber_aig(
        RenumberConfig::default()
            .trim(true)
            .structural_hash(true)
            .const_fold(true),
        &aag,
    )?;

    let aig_writer = DeferredWriter::from_write(stdout.lock());
    let mut aag_writer = binary::Writer::<u32>::new(aig_writer);

    aag_writer.write_ordered_aig(&aig);

    aag_writer.flush()?;
    Ok(())
}

Methods from Deref<Target = DeferredWriter<'a>>

pub fn flush_defer_err(&mut self)

Flush the buffered data to the underlying Write instance, deferring IO errors.

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

Write a slice of bytes, deferring IO errors.

Both, write and write_all directly call this method. Unlike them, this does not return a #[must_use] value, making it clear that this cannot return an error.

pub fn buf_write_ptr(&mut self, len: usize) -> *mut u8

Returns a pointer to the current write pointer within the internal buffer if sufficient space is available.

If only fewer than len bytes are available, this returns a null pointer.

Can be used in conjunction with advance_unchecked to construct output data directly within the output buffer, potentially avoiding a redundant copy.

pub unsafe fn advance_unchecked(&mut self, len: usize)

Advances the write pointer within the internal buffer.

Safety

This assumes that a) there is sufficient space left in the buffer and b) that the bytes the pointer is advanced over were initialized prior to calling this (via buf_write_ptr).

If either assumption does not hold calling this results in undefined behavior.

pub fn check_io_error(&mut self) -> Result<(), Error>

Returns an encountered IO errors as Err(io_err).

This resets the stored IO error and returns Ok(()) if no IO error is stored.

Trait Implementations

impl<'a, L> Deref for Writer<'a, L>

type Target = DeferredWriter<'a>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, L> DerefMut for Writer<'a, L>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.