Write u32 as a big endian integer Returning an error if the underlying buffer cannot support a u32 write.

Write u32 as a little endian integer Returning an error if the underlying buffer cannot support a u32 write.

Write u32 as a big endian integer Or don't write anything if the reader cannot support a u32 write.

Write u32 as a little endian integer Or don't write anything if the reader cannot support a u32 write.

Write bytes from the buf into the bytestream and return how many bytes were written

Arguments

• buf: The bytes to be written to the bytestream

Returns

• Ok(usize) - Number of bytes written This number may be less than buf.len() if the length of the buffer is greater than the internal bytestream length

If you want to be sure that all bytes were written, see write_all

Write all bytes from buf into the bytestream and return and panic if not all bytes were written to the bytestream

Arguments

• buf: The bytes to be written into the bytestream

Returns

• Ok(()): Indicates all bytes were written into the bytestream
• Err(&static str): In case all the bytes could not be written to the stream

Create a new bytestream writer Bytes are written from the start to the end and not assumptions are made of the nature of the underlying stream

Arguments

Write a single byte into the bytestream or error out if there is not enough space

Example

use zune_core::bytestream::ZWriter;
let mut buf = [0;10];
let mut stream  =  ZWriter::new(&mut buf[..]);
assert!(stream.write_u8_err(34).is_ok());

No space

use zune_core::bytestream::ZWriter;
let mut no_space = [];
let mut stream = ZWriter::new(&mut no_space[..]);
assert!(stream.write_u8_err(32).is_err());

Write a fixed compile time known number of bytes to the sink

This is provided since some implementations can optimize such writes by eliminating some redundant code.

Write a single byte in the stream or don't write anything if the buffer is full and cannot support the byte read

Return the number of bytes written by this encoder

The encoder keeps information of how many bytes were written and this method returns that value.

Returns

Number of bytes written

Reserve some additional space to write.

Some sinks like Vec<u8> allow reallocation and to prevent too much reallocation one can use this to reserve additional space to encode

Example

use zune_core::bytestream::ZWriter;
let space_needed = 10; // Assume the image will fit into 10 bytes
let mut output = Vec::new();
let mut sink = ZWriter::new(&mut output);
// now reserve some space
sink.reserve(space_needed).unwrap();
// at this point, we can assume that ZWriter allocated space for output

Consume the writer and return the inner sink we were writing to.

After this, the writer can no longer be used

Return an immutable reference to the inner sink

Return a mutable reference to the inner sink

Write u16 as a big endian integer Returning an error if the underlying buffer cannot support a u16 write.

Write u16 as a little endian integer Returning an error if the underlying buffer cannot support a u16 write.

Write u16 as a big endian integer Or don't write anything if the reader cannot support a u16 write.

Write u16 as a little endian integer Or don't write anything if the reader cannot support a u16 write.

Write u64 as a big endian integer Returning an error if the underlying buffer cannot support a u64 write.

Write u64 as a little endian integer Returning an error if the underlying buffer cannot support a u64 write.

Write u64 as a big endian integer Or don't write anything if the reader cannot support a u64 write.

Write u64 as a little endian integer Or don't write anything if the reader cannot support a u64 write.