// Generated by Lisette bindgen
// Source: bufio (Go stdlib)
// Go: 1.25.10
// Lisette: 0.3.0
import "go:io"
/// NewReadWriter allocates a new [ReadWriter] that dispatches to r and w.
pub fn NewReadWriter(r: Ref<Reader>, w: Ref<Writer>) -> Ref<ReadWriter>
/// NewReader returns a new [Reader] whose buffer has the default size.
pub fn NewReader(rd: io.Reader) -> Ref<Reader>
/// NewReaderSize returns a new [Reader] whose buffer has at least the specified
/// size. If the argument io.Reader is already a [Reader] with large enough
/// size, it returns the underlying [Reader].
pub fn NewReaderSize(rd: io.Reader, size: int) -> Ref<Reader>
/// NewScanner returns a new [Scanner] to read from r.
/// The split function defaults to [ScanLines].
pub fn NewScanner(r: io.Reader) -> Ref<Scanner>
/// NewWriter returns a new [Writer] whose buffer has the default size.
/// If the argument io.Writer is already a [Writer] with large enough buffer size,
/// it returns the underlying [Writer].
pub fn NewWriter(w: io.Writer) -> Ref<Writer>
/// NewWriterSize returns a new [Writer] whose buffer has at least the specified
/// size. If the argument io.Writer is already a [Writer] with large enough
/// size, it returns the underlying [Writer].
pub fn NewWriterSize(w: io.Writer, size: int) -> Ref<Writer>
/// ScanBytes is a split function for a [Scanner] that returns each byte as a token.
pub fn ScanBytes(data: Slice<byte>, atEOF: bool) -> Result<(int, Slice<byte>), error>
/// ScanLines is a split function for a [Scanner] that returns each line of
/// text, stripped of any trailing end-of-line marker. The returned line may
/// be empty. The end-of-line marker is one optional carriage return followed
/// by one mandatory newline. In regular expression notation, it is `\r?\n`.
/// The last non-empty line of input will be returned even if it has no
/// newline.
pub fn ScanLines(data: Slice<byte>, atEOF: bool) -> Result<(int, Slice<byte>), error>
/// ScanRunes is a split function for a [Scanner] that returns each
/// UTF-8-encoded rune as a token. The sequence of runes returned is
/// equivalent to that from a range loop over the input as a string, which
/// means that erroneous UTF-8 encodings translate to U+FFFD = "\xef\xbf\xbd".
/// Because of the Scan interface, this makes it impossible for the client to
/// distinguish correctly encoded replacement runes from encoding errors.
pub fn ScanRunes(data: Slice<byte>, atEOF: bool) -> Result<(int, Slice<byte>), error>
/// ScanWords is a split function for a [Scanner] that returns each
/// space-separated word of text, with surrounding spaces deleted. It will
/// never return an empty string. The definition of space is set by
/// unicode.IsSpace.
pub fn ScanWords(data: Slice<byte>, atEOF: bool) -> Result<(int, Slice<byte>), error>
/// ReadWriter stores pointers to a [Reader] and a [Writer].
/// It implements [io.ReadWriter].
pub struct ReadWriter {
embed Ref<Reader>,
embed Ref<Writer>,
}
/// Reader implements buffering for an io.Reader object.
/// A new Reader is created by calling [NewReader] or [NewReaderSize];
/// alternatively the zero value of a Reader may be used after calling [Reset]
/// on it.
pub type Reader
/// Scanner provides a convenient interface for reading data such as
/// a file of newline-delimited lines of text. Successive calls to
/// the [Scanner.Scan] method will step through the 'tokens' of a file, skipping
/// the bytes between the tokens. The specification of a token is
/// defined by a split function of type [SplitFunc]; the default split
/// function breaks the input into lines with line termination stripped. [Scanner.Split]
/// functions are defined in this package for scanning a file into
/// lines, bytes, UTF-8-encoded runes, and space-delimited words. The
/// client may instead provide a custom split function.
///
/// Scanning stops unrecoverably at EOF, the first I/O error, or a token too
/// large to fit in the [Scanner.Buffer]. When a scan stops, the reader may have
/// advanced arbitrarily far past the last token. Programs that need more
/// control over error handling or large tokens, or must run sequential scans
/// on a reader, should use [bufio.Reader] instead.
pub type Scanner
/// SplitFunc is the signature of the split function used to tokenize the
/// input. The arguments are an initial substring of the remaining unprocessed
/// data and a flag, atEOF, that reports whether the [Reader] has no more data
/// to give. The return values are the number of bytes to advance the input
/// and the next token to return to the user, if any, plus an error, if any.
///
/// Scanning stops if the function returns an error, in which case some of
/// the input may be discarded. If that error is [ErrFinalToken], scanning
/// stops with no error. A non-nil token delivered with [ErrFinalToken]
/// will be the last token, and a nil token with [ErrFinalToken]
/// immediately stops the scanning.
///
/// Otherwise, the [Scanner] advances the input. If the token is not nil,
/// the [Scanner] returns it to the user. If the token is nil, the
/// Scanner reads more data and continues scanning; if there is no more
/// data--if atEOF was true--the [Scanner] returns. If the data does not
/// yet hold a complete token, for instance if it has no newline while
/// scanning lines, a [SplitFunc] can return (0, nil, nil) to signal the
/// [Scanner] to read more data into the slice and try again with a
/// longer slice starting at the same point in the input.
///
/// The function is never called with an empty data slice unless atEOF
/// is true. If atEOF is true, however, data may be non-empty and,
/// as always, holds unprocessed text.
pub type SplitFunc = fn(Slice<byte>, bool) -> Result<(int, Slice<byte>), error>
/// Writer implements buffering for an [io.Writer] object.
/// If an error occurs writing to a [Writer], no more data will be
/// accepted and all subsequent writes, and [Writer.Flush], will return the error.
/// After all data has been written, the client should call the
/// [Writer.Flush] method to guarantee all data has been forwarded to
/// the underlying [io.Writer].
pub type Writer
pub const MaxScanTokenSize = 65536
/// Errors returned by Scanner.
pub var ErrAdvanceTooFar: error
/// Errors returned by Scanner.
pub var ErrBadReadCount: error
pub var ErrBufferFull: error
/// ErrFinalToken is a special sentinel error value. It is intended to be
/// returned by a Split function to indicate that the scanning should stop
/// with no error. If the token being delivered with this error is not nil,
/// the token is the last token.
///
/// The value is useful to stop processing early or when it is necessary to
/// deliver a final empty token (which is different from a nil token).
/// One could achieve the same behavior with a custom error value but
/// providing one here is tidier.
/// See the emptyFinalToken example for a use of this value.
pub var ErrFinalToken: error
pub var ErrInvalidUnreadByte: error
pub var ErrInvalidUnreadRune: error
/// Errors returned by Scanner.
pub var ErrNegativeAdvance: error
pub var ErrNegativeCount: error
/// Errors returned by Scanner.
pub var ErrTooLong: error
impl Reader {
/// Buffered returns the number of bytes that can be read from the current buffer.
fn Buffered(self: Ref<Reader>) -> int
/// Discard skips the next n bytes, returning the number of bytes discarded.
///
/// If Discard skips fewer than n bytes, it also returns an error.
/// If 0 <= n <= b.Buffered(), Discard is guaranteed to succeed without
/// reading from the underlying io.Reader.
fn Discard(self: Ref<Reader>, n: int) -> Partial<int, error>
/// Peek returns the next n bytes without advancing the reader. The bytes stop
/// being valid at the next read call. If necessary, Peek will read more bytes
/// into the buffer in order to make n bytes available. If Peek returns fewer
/// than n bytes, it also returns an error explaining why the read is short.
/// The error is [ErrBufferFull] if n is larger than b's buffer size.
///
/// Calling Peek prevents a [Reader.UnreadByte] or [Reader.UnreadRune] call from succeeding
/// until the next read operation.
fn Peek(self: Ref<Reader>, n: int) -> Partial<Slice<byte>, error>
/// Read reads data into p.
/// It returns the number of bytes read into p.
/// The bytes are taken from at most one Read on the underlying [Reader],
/// hence n may be less than len(p).
/// To read exactly len(p) bytes, use io.ReadFull(b, p).
/// If the underlying [Reader] can return a non-zero count with io.EOF,
/// then this Read method can do so as well; see the [io.Reader] docs.
fn Read(self: Ref<Reader>, mut p: Slice<byte>) -> Partial<int, error>
/// ReadByte reads and returns a single byte.
/// If no byte is available, returns an error.
fn ReadByte(self: Ref<Reader>) -> Result<byte, error>
/// ReadBytes reads until the first occurrence of delim in the input,
/// returning a slice containing the data up to and including the delimiter.
/// If ReadBytes encounters an error before finding a delimiter,
/// it returns the data read before the error and the error itself (often io.EOF).
/// ReadBytes returns err != nil if and only if the returned data does not end in
/// delim.
/// For simple uses, a Scanner may be more convenient.
fn ReadBytes(self: Ref<Reader>, delim: byte) -> Partial<Slice<byte>, error>
/// ReadLine is a low-level line-reading primitive. Most callers should use
/// [Reader.ReadBytes]('\n') or [Reader.ReadString]('\n') instead or use a [Scanner].
///
/// ReadLine tries to return a single line, not including the end-of-line bytes.
/// If the line was too long for the buffer then isPrefix is set and the
/// beginning of the line is returned. The rest of the line will be returned
/// from future calls. isPrefix will be false when returning the last fragment
/// of the line. The returned buffer is only valid until the next call to
/// ReadLine. ReadLine either returns a non-nil line or it returns an error,
/// never both.
///
/// The text returned from ReadLine does not include the line end ("\r\n" or "\n").
/// No indication or error is given if the input ends without a final line end.
/// Calling [Reader.UnreadByte] after ReadLine will always unread the last byte read
/// (possibly a character belonging to the line end) even if that byte is not
/// part of the line returned by ReadLine.
fn ReadLine(self: Ref<Reader>) -> Result<(Slice<byte>, bool), error>
/// ReadRune reads a single UTF-8 encoded Unicode character and returns the
/// rune and its size in bytes. If the encoded rune is invalid, it consumes one byte
/// and returns unicode.ReplacementChar (U+FFFD) with a size of 1.
fn ReadRune(self: Ref<Reader>) -> Result<(rune, int), error>
/// ReadSlice reads until the first occurrence of delim in the input,
/// returning a slice pointing at the bytes in the buffer.
/// The bytes stop being valid at the next read.
/// If ReadSlice encounters an error before finding a delimiter,
/// it returns all the data in the buffer and the error itself (often io.EOF).
/// ReadSlice fails with error [ErrBufferFull] if the buffer fills without a delim.
/// Because the data returned from ReadSlice will be overwritten
/// by the next I/O operation, most clients should use
/// [Reader.ReadBytes] or ReadString instead.
/// ReadSlice returns err != nil if and only if line does not end in delim.
fn ReadSlice(self: Ref<Reader>, delim: byte) -> Partial<Slice<byte>, error>
/// ReadString reads until the first occurrence of delim in the input,
/// returning a string containing the data up to and including the delimiter.
/// If ReadString encounters an error before finding a delimiter,
/// it returns the data read before the error and the error itself (often io.EOF).
/// ReadString returns err != nil if and only if the returned data does not end in
/// delim.
/// For simple uses, a Scanner may be more convenient.
fn ReadString(self: Ref<Reader>, delim: byte) -> Partial<string, error>
/// Reset discards any buffered data, resets all state, and switches
/// the buffered reader to read from r.
/// Calling Reset on the zero value of [Reader] initializes the internal buffer
/// to the default size.
/// Calling b.Reset(b) (that is, resetting a [Reader] to itself) does nothing.
fn Reset(self: Ref<Reader>, r: io.Reader)
/// Size returns the size of the underlying buffer in bytes.
fn Size(self: Ref<Reader>) -> int
/// UnreadByte unreads the last byte. Only the most recently read byte can be unread.
///
/// UnreadByte returns an error if the most recent method called on the
/// [Reader] was not a read operation. Notably, [Reader.Peek], [Reader.Discard], and [Reader.WriteTo] are not
/// considered read operations.
fn UnreadByte(self: Ref<Reader>) -> Result<(), error>
/// UnreadRune unreads the last rune. If the most recent method called on
/// the [Reader] was not a [Reader.ReadRune], [Reader.UnreadRune] returns an error. (In this
/// regard it is stricter than [Reader.UnreadByte], which will unread the last byte
/// from any read operation.)
fn UnreadRune(self: Ref<Reader>) -> Result<(), error>
/// WriteTo implements io.WriterTo.
/// This may make multiple calls to the [Reader.Read] method of the underlying [Reader].
/// If the underlying reader supports the [Reader.WriteTo] method,
/// this calls the underlying [Reader.WriteTo] without buffering.
fn WriteTo(self: Ref<Reader>, w: io.Writer) -> Partial<int64, error>
}
impl Scanner {
/// Buffer controls memory allocation by the Scanner.
/// It sets the initial buffer to use when scanning
/// and the maximum size of buffer that may be allocated during scanning.
/// The contents of the buffer are ignored.
///
/// The maximum token size must be less than the larger of max and cap(buf).
/// If max <= cap(buf), [Scanner.Scan] will use this buffer only and do no allocation.
///
/// By default, [Scanner.Scan] uses an internal buffer and sets the
/// maximum token size to [MaxScanTokenSize].
///
/// Buffer panics if it is called after scanning has started.
fn Buffer(self: Ref<Scanner>, mut buf: Slice<byte>, max: int)
/// Bytes returns the most recent token generated by a call to [Scanner.Scan].
/// The underlying array may point to data that will be overwritten
/// by a subsequent call to Scan. It does no allocation.
fn Bytes(self: Ref<Scanner>) -> Slice<byte>
/// Err returns the first non-EOF error that was encountered by the [Scanner].
fn Err(self: Ref<Scanner>) -> Option<error>
/// Scan advances the [Scanner] to the next token, which will then be
/// available through the [Scanner.Bytes] or [Scanner.Text] method. It returns false when
/// there are no more tokens, either by reaching the end of the input or an error.
/// After Scan returns false, the [Scanner.Err] method will return any error that
/// occurred during scanning, except that if it was [io.EOF], [Scanner.Err]
/// will return nil.
/// Scan panics if the split function returns too many empty
/// tokens without advancing the input. This is a common error mode for
/// scanners.
fn Scan(self: Ref<Scanner>) -> bool
/// Split sets the split function for the [Scanner].
/// The default split function is [ScanLines].
///
/// Split panics if it is called after scanning has started.
fn Split(self: Ref<Scanner>, split: SplitFunc)
/// Text returns the most recent token generated by a call to [Scanner.Scan]
/// as a newly allocated string holding its bytes.
fn Text(self: Ref<Scanner>) -> string
}
impl Writer {
/// Available returns how many bytes are unused in the buffer.
fn Available(self: Ref<Writer>) -> int
/// AvailableBuffer returns an empty buffer with b.Available() capacity.
/// This buffer is intended to be appended to and
/// passed to an immediately succeeding [Writer.Write] call.
/// The buffer is only valid until the next write operation on b.
fn AvailableBuffer(self: Ref<Writer>) -> Slice<byte>
/// Buffered returns the number of bytes that have been written into the current buffer.
fn Buffered(self: Ref<Writer>) -> int
/// Flush writes any buffered data to the underlying [io.Writer].
#[allow(unused_result)]
fn Flush(self: Ref<Writer>) -> Result<(), error>
/// ReadFrom implements [io.ReaderFrom]. If the underlying writer
/// supports the ReadFrom method, this calls the underlying ReadFrom.
/// If there is buffered data and an underlying ReadFrom, this fills
/// the buffer and writes it before calling ReadFrom.
fn ReadFrom(self: Ref<Writer>, r: io.Reader) -> Partial<int64, error>
/// Reset discards any unflushed buffered data, clears any error, and
/// resets b to write its output to w.
/// Calling Reset on the zero value of [Writer] initializes the internal buffer
/// to the default size.
/// Calling w.Reset(w) (that is, resetting a [Writer] to itself) does nothing.
fn Reset(self: Ref<Writer>, w: io.Writer)
/// Size returns the size of the underlying buffer in bytes.
fn Size(self: Ref<Writer>) -> int
/// Write writes the contents of p into the buffer.
/// It returns the number of bytes written.
/// If nn < len(p), it also returns an error explaining
/// why the write is short.
fn Write(self: Ref<Writer>, p: Slice<byte>) -> Partial<int, error>
/// WriteByte writes a single byte.
fn WriteByte(self: Ref<Writer>, c: byte) -> Result<(), error>
/// WriteRune writes a single Unicode code point, returning
/// the number of bytes written and any error.
fn WriteRune(self: Ref<Writer>, r: rune) -> Partial<int, error>
/// WriteString writes a string.
/// It returns the number of bytes written.
/// If the count is less than len(s), it also returns an error explaining
/// why the write is short.
fn WriteString(self: Ref<Writer>, s: string) -> Partial<int, error>
}