package internal

Import Path
	net/http/internal (on go.dev)

Dependency Relation
	imports 5 packages, and imported by 2 packages

Involved Source Files

	  d chunked.go
		Package internal contains HTTP internals shared by net/http and
		net/http/httputil.
Package-Level Type Names (only one)

	/* sort by: alphabet | popularity */
	 type FlushAfterChunkWriter (struct)
		FlushAfterChunkWriter signals from the caller of [NewChunkedWriter]
		that each chunk should be followed by a flush. It is used by the
		[net/http.Transport] code to keep the buffering behavior for headers and
		trailers, but flush out chunks aggressively in the middle for
		request bodies which may be generated slowly. See Issue 6574.

		Fields (only one)
			Writer *bufio.Writer
		Methods (total 11)
			( FlushAfterChunkWriter) Available() int
				Available returns how many bytes are unused in the buffer.

			( FlushAfterChunkWriter) AvailableBuffer() []byte
				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.

			( FlushAfterChunkWriter) Buffered() int
				Buffered returns the number of bytes that have been written into the current buffer.

			( FlushAfterChunkWriter) Flush() error
				Flush writes any buffered data to the underlying [io.Writer].

			( FlushAfterChunkWriter) ReadFrom(r io.Reader) (n int64, err 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.

			( FlushAfterChunkWriter) Reset(w io.Writer)
				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.

			( FlushAfterChunkWriter) Size() int
				Size returns the size of the underlying buffer in bytes.

			( FlushAfterChunkWriter) Write(p []byte) (nn int, err error)
				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.

			( FlushAfterChunkWriter) WriteByte(c byte) error
				WriteByte writes a single byte.

			( FlushAfterChunkWriter) WriteRune(r rune) (size int, err error)
				WriteRune writes a single Unicode code point, returning
				the number of bytes written and any error.

			( FlushAfterChunkWriter) WriteString(s string) (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.

		Implements (at least 5)
			 FlushAfterChunkWriter : internal/bisect.Writer
			 FlushAfterChunkWriter : io.ByteWriter
			 FlushAfterChunkWriter : io.ReaderFrom
			 FlushAfterChunkWriter : io.StringWriter
			 FlushAfterChunkWriter : io.Writer


Package-Level Functions (total 2)

	 func NewChunkedReader(r io.Reader) io.Reader
		NewChunkedReader returns a new chunkedReader that translates the data read from r
		out of HTTP "chunked" format before returning it.
		The chunkedReader returns [io.EOF] when the final 0-length chunk is read.
		
		NewChunkedReader is not needed by normal applications. The http package
		automatically decodes chunking when reading response bodies.

	 func NewChunkedWriter(w io.Writer) io.WriteCloser
		NewChunkedWriter returns a new chunkedWriter that translates writes into HTTP
		"chunked" format before writing them to w. Closing the returned chunkedWriter
		sends the final 0-length chunk that marks the end of the stream but does
		not send the final CRLF that appears after trailers; trailers and the last
		CRLF must be written separately.
		
		NewChunkedWriter is not needed by normal applications. The http
		package adds chunking automatically if handlers don't set a
		Content-Length header. Using newChunkedWriter inside a handler
		would result in double chunking or chunking with a Content-Length
		length, both of which are wrong.


Package-Level Variables (only one)

	  var ErrLineTooLong error

The pages are generated with Golds v0.7.0-preview. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.