// Generated by Lisette bindgen
// Source: io (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.12
/// Copy copies from src to dst until either EOF is reached
/// on src or an error occurs. It returns the number of bytes
/// copied and the first error encountered while copying, if any.
///
/// A successful Copy returns err == nil, not err == EOF.
/// Because Copy is defined to read from src until EOF, it does
/// not treat an EOF from Read as an error to be reported.
///
/// If src implements [WriterTo],
/// the copy is implemented by calling src.WriteTo(dst).
/// Otherwise, if dst implements [ReaderFrom],
/// the copy is implemented by calling dst.ReadFrom(src).
pub fn Copy(dst: Writer, src: Reader) -> Result<int64, error>
/// CopyBuffer is identical to Copy except that it stages through the
/// provided buffer (if one is required) rather than allocating a
/// temporary one. If buf is nil, one is allocated; otherwise if it has
/// zero length, CopyBuffer panics.
///
/// If either src implements [WriterTo] or dst implements [ReaderFrom],
/// buf will not be used to perform the copy.
pub fn CopyBuffer(dst: Writer, src: Reader, mut buf: Slice<uint8>) -> Result<int64, error>
/// CopyN copies n bytes (or until an error) from src to dst.
/// It returns the number of bytes copied and the earliest
/// error encountered while copying.
/// On return, written == n if and only if err == nil.
///
/// If dst implements [ReaderFrom], the copy is implemented using it.
pub fn CopyN(dst: Writer, src: Reader, n: int64) -> Result<int64, error>
pub fn LimitReader(r: Reader, n: int64) -> Reader
pub fn MultiReader(readers: VarArgs<Reader>) -> Reader
pub fn MultiWriter(writers: VarArgs<Writer>) -> Writer
pub fn NewOffsetWriter(w: WriterAt, off: int64) -> Ref<OffsetWriter>
pub fn NewSectionReader(r: ReaderAt, off: int64, n: int64) -> Ref<SectionReader>
pub fn NopCloser(r: Reader) -> ReadCloser
/// Pipe creates a synchronous in-memory pipe.
/// It can be used to connect code expecting an [io.Reader]
/// with code expecting an [io.Writer].
///
/// Reads and Writes on the pipe are matched one to one
/// except when multiple Reads are needed to consume a single Write.
/// That is, each Write to the [PipeWriter] blocks until it has satisfied
/// one or more Reads from the [PipeReader] that fully consume
/// the written data.
/// The data is copied directly from the Write to the corresponding
/// Read (or Reads); there is no internal buffering.
///
/// It is safe to call Read and Write in parallel with each other or with Close.
/// Parallel calls to Read and parallel calls to Write are also safe:
/// the individual calls will be gated sequentially.
pub fn Pipe() -> (Ref<PipeReader>, Ref<PipeWriter>)
/// ReadAll reads from r until an error or EOF and returns the data it read.
/// A successful call returns err == nil, not err == EOF. Because ReadAll is
/// defined to read from src until EOF, it does not treat an EOF from Read
/// as an error to be reported.
pub fn ReadAll(r: Reader) -> Result<Slice<uint8>, error>
/// ReadAtLeast reads from r into buf until it has read at least min bytes.
/// It returns the number of bytes copied and an error if fewer bytes were read.
/// The error is EOF only if no bytes were read.
/// If an EOF happens after reading fewer than min bytes,
/// ReadAtLeast returns [ErrUnexpectedEOF].
/// If min is greater than the length of buf, ReadAtLeast returns [ErrShortBuffer].
/// On return, n >= min if and only if err == nil.
/// If r returns an error having read at least min bytes, the error is dropped.
pub fn ReadAtLeast(r: Reader, mut buf: Slice<uint8>, min: int) -> Partial<int, error>
/// ReadFull reads exactly len(buf) bytes from r into buf.
/// It returns the number of bytes copied and an error if fewer bytes were read.
/// The error is EOF only if no bytes were read.
/// If an EOF happens after reading some but not all the bytes,
/// ReadFull returns [ErrUnexpectedEOF].
/// On return, n == len(buf) if and only if err == nil.
/// If r returns an error having read at least len(buf) bytes, the error is dropped.
pub fn ReadFull(r: Reader, mut buf: Slice<uint8>) -> Partial<int, error>
pub fn TeeReader(r: Reader, w: Writer) -> Reader
/// WriteString writes the contents of the string s to w, which accepts a slice of bytes.
/// If w implements [StringWriter], [StringWriter.WriteString] is invoked directly.
/// Otherwise, [Writer.Write] is called exactly once.
pub fn WriteString(w: Writer, s: string) -> Result<int, error>
/// ByteReader is the interface that wraps the ReadByte method.
///
/// ReadByte reads and returns the next byte from the input or
/// any error encountered. If ReadByte returns an error, no input
/// byte was consumed, and the returned byte value is undefined.
///
/// ReadByte provides an efficient interface for byte-at-time
/// processing. A [Reader] that does not implement ByteReader
/// can be wrapped using bufio.NewReader to add this method.
pub interface ByteReader {
fn ReadByte() -> Result<uint8, error>
}
/// ByteScanner is the interface that adds the UnreadByte method to the
/// basic ReadByte method.
///
/// UnreadByte causes the next call to ReadByte to return the last byte read.
/// If the last operation was not a successful call to ReadByte, UnreadByte may
/// return an error, unread the last byte read (or the byte prior to the
/// last-unread byte), or (in implementations that support the [Seeker] interface)
/// seek to one byte before the current offset.
pub interface ByteScanner {
fn ReadByte() -> Result<uint8, error>
fn UnreadByte() -> Result<(), error>
}
/// ByteWriter is the interface that wraps the WriteByte method.
pub interface ByteWriter {
fn WriteByte(c: uint8) -> Result<(), error>
}
/// Closer is the interface that wraps the basic Close method.
///
/// The behavior of Close after the first call is undefined.
/// Specific implementations may document their own behavior.
pub interface Closer {
fn Close() -> Result<(), error>
}
/// A LimitedReader reads from R but limits the amount of
/// data returned to just N bytes. Each call to Read
/// updates N to reflect the new amount remaining.
/// Read returns EOF when N <= 0 or when the underlying R returns EOF.
pub struct LimitedReader {
pub R: Option<Reader>,
pub N: int64,
}
/// An OffsetWriter maps writes at offset base to offset base+off in the underlying writer.
pub type OffsetWriter
/// A PipeReader is the read half of a pipe.
pub type PipeReader
/// A PipeWriter is the write half of a pipe.
pub type PipeWriter
/// ReadCloser is the interface that groups the basic Read and Close methods.
pub interface ReadCloser {
fn Close() -> Result<(), error>
fn Read(mut p: Slice<uint8>) -> Partial<int, error>
}
/// ReadSeekCloser is the interface that groups the basic Read, Seek and Close
/// methods.
pub interface ReadSeekCloser {
fn Close() -> Result<(), error>
fn Read(mut p: Slice<uint8>) -> Partial<int, error>
fn Seek(offset: int64, whence: int) -> Result<int64, error>
}
/// ReadSeeker is the interface that groups the basic Read and Seek methods.
pub interface ReadSeeker {
fn Read(mut p: Slice<uint8>) -> Partial<int, error>
fn Seek(offset: int64, whence: int) -> Result<int64, error>
}
/// ReadWriteCloser is the interface that groups the basic Read, Write and Close methods.
pub interface ReadWriteCloser {
fn Close() -> Result<(), error>
fn Read(mut p: Slice<uint8>) -> Partial<int, error>
fn Write(p: Slice<uint8>) -> Partial<int, error>
}
/// ReadWriteSeeker is the interface that groups the basic Read, Write and Seek methods.
pub interface ReadWriteSeeker {
fn Read(mut p: Slice<uint8>) -> Partial<int, error>
fn Seek(offset: int64, whence: int) -> Result<int64, error>
fn Write(p: Slice<uint8>) -> Partial<int, error>
}
/// ReadWriter is the interface that groups the basic Read and Write methods.
pub interface ReadWriter {
fn Read(mut p: Slice<uint8>) -> Partial<int, error>
fn Write(p: Slice<uint8>) -> Partial<int, error>
}
/// Reader is the interface that wraps the basic Read method.
///
/// Read reads up to len(p) bytes into p. It returns the number of bytes
/// read (0 <= n <= len(p)) and any error encountered. Even if Read
/// returns n < len(p), it may use all of p as scratch space during the call.
/// If some data is available but not len(p) bytes, Read conventionally
/// returns what is available instead of waiting for more.
///
/// When Read encounters an error or end-of-file condition after
/// successfully reading n > 0 bytes, it returns the number of
/// bytes read. It may return the (non-nil) error from the same call
/// or return the error (and n == 0) from a subsequent call.
/// An instance of this general case is that a Reader returning
/// a non-zero number of bytes at the end of the input stream may
/// return either err == EOF or err == nil. The next Read should
/// return 0, EOF.
///
/// Callers should always process the n > 0 bytes returned before
/// considering the error err. Doing so correctly handles I/O errors
/// that happen after reading some bytes and also both of the
/// allowed EOF behaviors.
///
/// If len(p) == 0, Read should always return n == 0. It may return a
/// non-nil error if some error condition is known, such as EOF.
///
/// Implementations of Read are discouraged from returning a
/// zero byte count with a nil error, except when len(p) == 0.
/// Callers should treat a return of 0 and nil as indicating that
/// nothing happened; in particular it does not indicate EOF.
///
/// Implementations must not retain p.
pub interface Reader {
fn Read(mut p: Slice<uint8>) -> Partial<int, error>
}
/// ReaderAt is the interface that wraps the basic ReadAt method.
///
/// ReadAt reads len(p) bytes into p starting at offset off in the
/// underlying input source. It returns the number of bytes
/// read (0 <= n <= len(p)) and any error encountered.
///
/// When ReadAt returns n < len(p), it returns a non-nil error
/// explaining why more bytes were not returned. In this respect,
/// ReadAt is stricter than Read.
///
/// Even if ReadAt returns n < len(p), it may use all of p as scratch
/// space during the call. If some data is available but not len(p) bytes,
/// ReadAt blocks until either all the data is available or an error occurs.
/// In this respect ReadAt is different from Read.
///
/// If the n = len(p) bytes returned by ReadAt are at the end of the
/// input source, ReadAt may return either err == EOF or err == nil.
///
/// If ReadAt is reading from an input source with a seek offset,
/// ReadAt should not affect nor be affected by the underlying
/// seek offset.
///
/// Clients of ReadAt can execute parallel ReadAt calls on the
/// same input source.
///
/// Implementations must not retain p.
pub interface ReaderAt {
fn ReadAt(mut p: Slice<uint8>, off: int64) -> Partial<int, error>
}
/// ReaderFrom is the interface that wraps the ReadFrom method.
///
/// ReadFrom reads data from r until EOF or error.
/// The return value n is the number of bytes read.
/// Any error except EOF encountered during the read is also returned.
///
/// The [Copy] function uses [ReaderFrom] if available.
pub interface ReaderFrom {
fn ReadFrom(r: Reader) -> Result<int64, error>
}
/// RuneReader is the interface that wraps the ReadRune method.
///
/// ReadRune reads a single encoded Unicode character
/// and returns the rune and its size in bytes. If no character is
/// available, err will be set.
pub interface RuneReader {
fn ReadRune() -> Result<(int32, int), error>
}
/// RuneScanner is the interface that adds the UnreadRune method to the
/// basic ReadRune method.
///
/// UnreadRune causes the next call to ReadRune to return the last rune read.
/// If the last operation was not a successful call to ReadRune, UnreadRune may
/// return an error, unread the last rune read (or the rune prior to the
/// last-unread rune), or (in implementations that support the [Seeker] interface)
/// seek to the start of the rune before the current offset.
pub interface RuneScanner {
fn ReadRune() -> Result<(int32, int), error>
fn UnreadRune() -> Result<(), error>
}
/// SectionReader implements Read, Seek, and ReadAt on a section
/// of an underlying [ReaderAt].
pub type SectionReader
/// Seeker is the interface that wraps the basic Seek method.
///
/// Seek sets the offset for the next Read or Write to offset,
/// interpreted according to whence:
/// [SeekStart] means relative to the start of the file,
/// [SeekCurrent] means relative to the current offset, and
/// [SeekEnd] means relative to the end
/// (for example, offset = -2 specifies the penultimate byte of the file).
/// Seek returns the new offset relative to the start of the
/// file or an error, if any.
///
/// Seeking to an offset before the start of the file is an error.
/// Seeking to any positive offset may be allowed, but if the new offset exceeds
/// the size of the underlying object the behavior of subsequent I/O operations
/// is implementation-dependent.
pub interface Seeker {
fn Seek(offset: int64, whence: int) -> Result<int64, error>
}
/// StringWriter is the interface that wraps the WriteString method.
pub interface StringWriter {
fn WriteString(s: string) -> Result<int, error>
}
/// WriteCloser is the interface that groups the basic Write and Close methods.
pub interface WriteCloser {
fn Close() -> Result<(), error>
fn Write(p: Slice<uint8>) -> Partial<int, error>
}
/// WriteSeeker is the interface that groups the basic Write and Seek methods.
pub interface WriteSeeker {
fn Seek(offset: int64, whence: int) -> Result<int64, error>
fn Write(p: Slice<uint8>) -> Partial<int, error>
}
/// Writer is the interface that wraps the basic Write method.
///
/// Write writes len(p) bytes from p to the underlying data stream.
/// It returns the number of bytes written from p (0 <= n <= len(p))
/// and any error encountered that caused the write to stop early.
/// Write must return a non-nil error if it returns n < len(p).
/// Write must not modify the slice data, even temporarily.
///
/// Implementations must not retain p.
pub interface Writer {
fn Write(p: Slice<uint8>) -> Partial<int, error>
}
/// WriterAt is the interface that wraps the basic WriteAt method.
///
/// WriteAt writes len(p) bytes from p to the underlying data stream
/// at offset off. It returns the number of bytes written from p (0 <= n <= len(p))
/// and any error encountered that caused the write to stop early.
/// WriteAt must return a non-nil error if it returns n < len(p).
///
/// If WriteAt is writing to a destination with a seek offset,
/// WriteAt should not affect nor be affected by the underlying
/// seek offset.
///
/// Clients of WriteAt can execute parallel WriteAt calls on the same
/// destination if the ranges do not overlap.
///
/// Implementations must not retain p.
pub interface WriterAt {
fn WriteAt(p: Slice<uint8>, off: int64) -> Partial<int, error>
}
/// WriterTo is the interface that wraps the WriteTo method.
///
/// WriteTo writes data to w until there's no more data to write or
/// when an error occurs. The return value n is the number of bytes
/// written. Any error encountered during the write is also returned.
///
/// The Copy function uses WriterTo if available.
pub interface WriterTo {
fn WriteTo(w: Writer) -> Result<int64, error>
}
/// Seek whence values.
const SeekCurrent = 1
/// Seek whence values.
const SeekEnd = 2
/// Seek whence values.
const SeekStart = 0
pub var Discard: Writer
/// EOF is the error returned by Read when no more input is available.
/// (Read must return EOF itself, not an error wrapping EOF,
/// because callers will test for EOF using ==.)
/// Functions should return EOF only to signal a graceful end of input.
/// If the EOF occurs unexpectedly in a structured data stream,
/// the appropriate error is either [ErrUnexpectedEOF] or some other error
/// giving more detail.
pub var EOF: error
/// ErrClosedPipe is the error used for read or write operations on a closed pipe.
pub var ErrClosedPipe: error
/// ErrNoProgress is returned by some clients of a [Reader] when
/// many calls to Read have failed to return any data or error,
/// usually the sign of a broken [Reader] implementation.
pub var ErrNoProgress: error
/// ErrShortBuffer means that a read required a longer buffer than was provided.
pub var ErrShortBuffer: error
/// ErrShortWrite means that a write accepted fewer bytes than requested
/// but failed to return an explicit error.
pub var ErrShortWrite: error
/// ErrUnexpectedEOF means that EOF was encountered in the
/// middle of reading a fixed-size block or data structure.
pub var ErrUnexpectedEOF: error
impl LimitedReader {
fn Read(self: Ref<LimitedReader>, mut p: Slice<uint8>) -> Partial<int, error>
}
impl OffsetWriter {
fn Seek(self: Ref<OffsetWriter>, offset: int64, whence: int) -> Result<int64, error>
fn Write(self: Ref<OffsetWriter>, p: Slice<uint8>) -> Partial<int, error>
fn WriteAt(self: Ref<OffsetWriter>, p: Slice<uint8>, off: int64) -> Partial<int, error>
}
impl PipeReader {
/// Close closes the reader; subsequent writes to the
/// write half of the pipe will return the error [ErrClosedPipe].
#[allow(unused_result)]
fn Close(self: Ref<PipeReader>) -> Result<(), error>
/// CloseWithError closes the reader; subsequent writes
/// to the write half of the pipe will return the error err.
///
/// CloseWithError never overwrites the previous error if it exists
/// and always returns nil.
fn CloseWithError(self: Ref<PipeReader>, err: error) -> Result<(), error>
/// Read implements the standard Read interface:
/// it reads data from the pipe, blocking until a writer
/// arrives or the write end is closed.
/// If the write end is closed with an error, that error is
/// returned as err; otherwise err is EOF.
fn Read(self: Ref<PipeReader>, mut data: Slice<uint8>) -> Partial<int, error>
}
impl PipeWriter {
/// Close closes the writer; subsequent reads from the
/// read half of the pipe will return no bytes and EOF.
#[allow(unused_result)]
fn Close(self: Ref<PipeWriter>) -> Result<(), error>
/// CloseWithError closes the writer; subsequent reads from the
/// read half of the pipe will return no bytes and the error err,
/// or EOF if err is nil.
///
/// CloseWithError never overwrites the previous error if it exists
/// and always returns nil.
fn CloseWithError(self: Ref<PipeWriter>, err: error) -> Result<(), error>
/// Write implements the standard Write interface:
/// it writes data to the pipe, blocking until one or more readers
/// have consumed all the data or the read end is closed.
/// If the read end is closed with an error, that err is
/// returned as err; otherwise err is [ErrClosedPipe].
fn Write(self: Ref<PipeWriter>, data: Slice<uint8>) -> Partial<int, error>
}
impl SectionReader {
/// Outer returns the underlying [ReaderAt] and offsets for the section.
///
/// The returned values are the same that were passed to [NewSectionReader]
/// when the [SectionReader] was created.
fn Outer(self: Ref<SectionReader>) -> (ReaderAt, int64, int64)
fn Read(self: Ref<SectionReader>, mut p: Slice<uint8>) -> Partial<int, error>
fn ReadAt(self: Ref<SectionReader>, mut p: Slice<uint8>, off: int64) -> Partial<int, error>
fn Seek(self: Ref<SectionReader>, offset: int64, whence: int) -> Result<int64, error>
/// Size returns the size of the section in bytes.
fn Size(self: Ref<SectionReader>) -> int64
}