package readyreader

Import Path
	google.golang.org/grpc/internal/transport/readyreader (on go.dev)

Dependency Relation
	imports 4 packages, and imported by one package

Involved Source Files

	    raw_conn_linux.go
	  d ready_reader.go
		Package readyreader provides utilities to perform non-memory-pinning reads.
Package-Level Type Names (total 6, in which 1 is exported)

	/* sort exporteds by: alphabet | popularity */
	 type Reader (interface)
		Reader is an optional interface that can be implemented by [net.Conn]
		implementations to enable gRPC to perform non-memory-pinning reads.

		Methods (only one, which is exported)
			( Reader) ReadOnReady(bufSize int, pool mem.BufferPool) (b *[]byte, n int, err error)
				ReadOnReady waits for data to arrive, fetches a buffer, and performs a
				read. When the underlying IO is readable, it allocates a buffer of size
				bufSize from the pool and reads up to bufSize bytes into the buffer.
				
				It returns a pointer to the buffer so it can be returned to the pool
				later, the number of bytes read, and an error.
				
				Callers should always process the n > 0 bytes returned before considering
				the error. Doing so correctly handles I/O errors that happen after
				reading some bytes, as well as both of the allowed EOF behaviors.

		Implemented By (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*blockingReader
			*nonBlockingReader
		As Outputs Of (at least 2, both are exported)
			func New(r io.Reader) Reader
			func NewNonBlocking(r io.Reader) Reader
		As Inputs Of (at least one exported)
			func NewBuffered(rd Reader, size int, pool mem.BufferPool) io.Reader

	/* 5 unexporteds ... *//* 5 unexporteds: */
	 type blockingReader (struct)

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			reader io.Reader
		Methods (only one, which is exported)
			(*blockingReader) ReadOnReady(bufSize int, pool mem.BufferPool) (*[]byte, int, error)
		Implements (at least one exported)
			*blockingReader : Reader

	 type bufReadyReader (struct)
		bufReadyReader implements buffering for a ReadyReader object.
		A new bufReadyReader is created by calling [NewBuffered].

		Fields (total 8, none are exported)
			/* 8 unexporteds ... *//* 8 unexporteds: */
			buf *[]byte
			bufSize int
			constPool constBufferPool
				// stored as a field to avoid heap allocations.

			err error
			pool mem.BufferPool
			r int
				// buf read and write positions

			rd Reader
				// reader provided by the caller

			w int
				// buf read and write positions

		Methods (total 3, in which 1 is exported)
			(*bufReadyReader) Read(p []byte) (n int, err 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 [ReadyReader],
				hence n may be less than len(p). If the underlying [ReadyReader] can return
				a non-zero count with io.EOF, then this Read method can do so as well; see
				the [io.Reader] docs.

			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*bufReadyReader) buffered() int
			(*bufReadyReader) readErr() error
		Implements (at least one exported)
			*bufReadyReader : io.Reader

	 type constBufferPool (struct)

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			buffer []byte
		Methods (total 2, both are exported)
			(*constBufferPool) Get(int) *[]byte
			(*constBufferPool) Put(*[]byte)
		Implements (at least 2, in which 1 is exported)
			*constBufferPool : google.golang.org/grpc/mem.BufferPool
			/* at least one unexported ... *//* at least one unexported: */
			*constBufferPool : google.golang.org/grpc/internal/mem.bufferPool

	 type nonBlockingReader (struct)
		nonBlockingReader is optimized for non-memory-pinning reads using the RawConn
		interface.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			doRead func(fd uintptr) bool
			raw syscall.RawConn
			state readState
				The following fields are stored as field to avoid heap allocations.

		Methods (only one, which is exported)
			(*nonBlockingReader) ReadOnReady(bufSize int, pool mem.BufferPool) (*[]byte, int, error)
		Implements (at least one exported)
			*nonBlockingReader : Reader

	 type readState (struct)

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			buf *[]byte
			bufSize int
				Request params.

			bytesRead int
			pool mem.BufferPool
			readError error
				Response params.



Package-Level Functions (total 6, in which 3 are exported)

	 func New(r io.Reader) Reader
		New detects if [syscall.RawConn] is available for non-memory-pinning reads.
		If [syscall.RawConn] is unavailable, it falls back to using the simpler
		[io.Reader] interface for reads.

	 func NewBuffered(rd Reader, size int, pool mem.BufferPool) io.Reader
		NewBuffered returns a new [io.Reader] with a buffer of the specified size
		which is allocated from the provided pool.

	 func NewNonBlocking(r io.Reader) Reader
		NewNonBlocking returns a ReadyReader if the passed reader supports
		non-memory-pinning reads, else nil.

	/* 3 unexporteds ... *//* 3 unexporteds: */
	 func isRawConnSupported() bool
	 func sysRead(fd uintptr, p []byte) (int, error)
		sysRead uses the standard syscall package rather than the modern unix package
		to avoid triggering the race detector. Because both packages perform sync
		operations on a local variable to satisfy the race detector, mixing them
		for read and write syscalls causes data races. We use syscall here to remain
		consistent with net.Conn implementations in standard library.

	 func wouldBlock(err error) bool
		wouldBlock checks standard Unix non-blocking errors.

The pages are generated with Golds v0.8.4. (GOOS=linux GOARCH=amd64)