Forbids all operations except writes. One use case is to pass `Vec` as writer without fear that consumer would change previously written content.

The Read trait allows for reading bytes from a source. Implementors of the Read trait are sometimes called 'readers'. Readers are defined by one req

A trait for objects which are byte-oriented sinks. Implementors of the `Write` trait are sometimes called 'writers'. Writers are defined by two requ

Represents reader as iterator over bytes. Note: this iterator is unbuffered, so it's advised to use `BufReader` to improve performance.

Wrapper providing `genio::Read + genio::Write` traits for `std::io::Read + std::io::Write` types.

Wrapper providing `genio::Read` trait for `std::io::Read` types.

Wrapper providing `genio::Write` trait for `std::io::Write` types.

Restarts all interrupted operations. All Read and Write operations that might fail with error indicating interruption (like EINTR) will be restarted

Wrapper providing `std::io::Read + std::io::Write` traits for `genio::Read + genio::Write` types.

Wrapper providing `std::io::Read` trait for `genio::Read` types.

Wrapper providing `std::io::Write` trait for `genio::Write` types.

Represents type that can serve as (possibly uninitialized) buffer

A `BufRead` is a type of `Read`er which has an internal buffer, allowing it to perform extra ways of reading.

When reading from reader, sometimes it's beneficial to read `n` bytes at once. However, BufRead itself doesn't guarantee that more bytes will be avail

When reading from reader, sometimes it's beneficial to read `n` bytes at once. However, BufRead itself doesn't guarantee that more bytes will be avail

When writing, it might be better to serialize directly into a buffer. This trait allows such situation. This triat is `unsafe` because it optimizes b

This trait allows requiring buffer of specified size.

Wrapper that provides buffering for a writer.

Chains two readers. All reads are forwarded to the first reader until it returns end. Then all other reads are forwarded to the second reader.

This reader is empty - always returns 0 from read method.

This trait is similar to slow one. The difference is that thanks to reader guaranteeing correctness, this one can use uninitialized buffer.

Some types can be extended by reading from reader. The most well-known is probably `Vec`. It is possible to implement it manually, but it may be more

Sometimes when serializing data, not all information is known until rest of the data is written. For example, when header containing size of the messa

Trait for custom error types that can also represent interruption.

After reading to buffer, it's often useful to adjust the slice. Also, reading may be done in loop, which ends when reader has no more data. To make h

This marker trait declares that the Read trait is implemented correctly, that means: 1. implementation of `read()` and `read_exact()` doesn't read fr

Result of successful read operation.

Reader that infinitely repeats single byte. It will never fail and never return 0.

Reader repeating a sequence of bytes infinitely.

Silently drops everything that is written to it.

Truncates writing so that at most `n` bytes in total are written into the writer. Excess bytes are silently dropped.