type io.Reader
338 uses
io (current package)
io.go#L83: type Reader interface {
io.go#L128: Reader
io.go#L134: Reader
io.go#L146: Reader
io.go#L153: Reader
io.go#L160: Reader
io.go#L173: Reader
io.go#L186: ReadFrom(r Reader) (n int64, err error)
io.go#L325: func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error) {
io.go#L349: func ReadFull(r Reader, buf []byte) (n int, err error) {
io.go#L360: func CopyN(dst Writer, src Reader, n int64) (written int64, err error) {
io.go#L384: func Copy(dst Writer, src Reader) (written int64, err error) {
io.go#L395: func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
io.go#L404: func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
io.go#L458: func LimitReader(r Reader, n int64) Reader { return &LimitedReader{r, n} }
io.go#L465: R Reader // underlying reader
io.go#L562: func TeeReader(r Reader, w Writer) Reader {
io.go#L567: r Reader
io.go#L606: func (discard) ReadFrom(r Reader) (n int64, err error) {
io.go#L624: func NopCloser(r Reader) ReadCloser {
io.go#L629: Reader
io.go#L638: func ReadAll(r Reader) ([]byte, error) {
multi.go#L14: readers []Reader
multi.go#L48: func MultiReader(readers ...Reader) Reader {
multi.go#L49: r := make([]Reader, len(readers))
io/ioutil
ioutil.go#L26: func ReadAll(r io.Reader) ([]byte, error) {
ioutil.go#L76: func NopCloser(r io.Reader) io.ReadCloser {
bufio
bufio.go#L34: rd io.Reader // reader provided by the client
bufio.go#L47: func NewReaderSize(rd io.Reader, size int) *Reader {
bufio.go#L62: func NewReader(rd io.Reader) *Reader {
bufio.go#L73: func (b *Reader) Reset(r io.Reader) {
bufio.go#L80: func (b *Reader) reset(buf []byte, r io.Reader) {
bufio.go#L755: func (b *Writer) ReadFrom(r io.Reader) (n int64, err error) {
scan.go#L31: r io.Reader // The reader provided by the client.
scan.go#L88: func NewScanner(r io.Reader) *Scanner {
bytes
buffer.go#L199: func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error) {
compress/flate
inflate.go#L74: Reset(r io.Reader, dict []byte) error
inflate.go#L262: io.Reader
inflate.go#L749: func makeReader(r io.Reader) Reader {
inflate.go#L776: func (f *decompressor) Reset(r io.Reader, dict []byte) error {
inflate.go#L796: func NewReader(r io.Reader) io.ReadCloser {
inflate.go#L815: func NewReaderDict(r io.Reader, dict []byte) io.ReadCloser {
compress/gzip
gunzip.go#L92: func NewReader(r io.Reader) (*Reader, error) {
gunzip.go#L103: func (z *Reader) Reset(r io.Reader) error {
crypto
crypto.go#L198: Sign(rand io.Reader, digest []byte, opts SignerOpts) (signature []byte, err error)
crypto.go#L220: Decrypt(rand io.Reader, msg []byte, opts DecrypterOpts) (plaintext []byte, err error)
crypto/cipher
io.go#L16: R io.Reader
crypto/dsa
dsa.go#L65: func GenerateParameters(params *Parameters, rand io.Reader, sizes ParameterSizes) error {
dsa.go#L159: func GenerateKey(priv *PrivateKey, rand io.Reader) error {
dsa.go#L205: func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err error) {
crypto/ecdsa
ecdsa.go#L109: func (priv *PrivateKey) Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) ([]byte, error) {
ecdsa.go#L127: func randFieldElement(c elliptic.Curve, rand io.Reader) (k *big.Int, err error) {
ecdsa.go#L145: func GenerateKey(c elliptic.Curve, rand io.Reader) (*PrivateKey, error) {
ecdsa.go#L194: func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err error) {
ecdsa.go#L285: func SignASN1(rand io.Reader, priv *PrivateKey, hash []byte) ([]byte, error) {
ecdsa.go#L357: io.Reader
crypto/ed25519
ed25519.go#L85: func (priv PrivateKey) Sign(rand io.Reader, message []byte, opts crypto.SignerOpts) (signature []byte, err error) {
ed25519.go#L95: func GenerateKey(rand io.Reader) (PublicKey, PrivateKey, error) {
crypto/elliptic
elliptic.go#L332: func GenerateKey(curve Curve, rand io.Reader) (priv []byte, x, y *big.Int, err error) {
crypto/internal/randutil
randutil.go#L25: func MaybeReadByte(r io.Reader) {
crypto/rand
rand.go#L20: var Reader io.Reader
rand_unix.go#L41: f io.Reader
rand_unix.go#L85: r io.Reader
rand_unix.go#L108: func newReader(entropy io.Reader) io.Reader {
rand_unix.go#L119: entropy io.Reader
util.go#L31: func Prime(rand io.Reader, bits int) (p *big.Int, err error) {
util.go#L106: func Int(rand io.Reader, max *big.Int) (n *big.Int, err error) {
crypto/rsa
pkcs1v15.go#L39: func EncryptPKCS1v15(rand io.Reader, pub *PublicKey, msg []byte) ([]byte, error) {
pkcs1v15.go#L75: func DecryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) ([]byte, error) {
pkcs1v15.go#L108: func DecryptPKCS1v15SessionKey(rand io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) error {
pkcs1v15.go#L139: func decryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (valid int, em []byte, index int, err error) {
pkcs1v15.go#L178: func nonZeroRandomBytes(s []byte, rand io.Reader) (err error) {
pkcs1v15.go#L231: func SignPKCS1v15(rand io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte) ([]byte, error) {
pss.go#L210: func signPSSWithSalt(rand io.Reader, priv *PrivateKey, hash crypto.Hash, hashed, salt []byte) ([]byte, error) {
pss.go#L264: func SignPSS(rand io.Reader, priv *PrivateKey, hash crypto.Hash, digest []byte, opts *PSSOptions) ([]byte, error) {
rsa.go#L144: func (priv *PrivateKey) Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) ([]byte, error) {
rsa.go#L155: func (priv *PrivateKey) Decrypt(rand io.Reader, ciphertext []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error) {
rsa.go#L241: func GenerateKey(random io.Reader, bits int) (*PrivateKey, error) {
rsa.go#L256: func GenerateMultiPrimeKey(random io.Reader, nprimes int, bits int) (*PrivateKey, error) {
rsa.go#L410: func EncryptOAEP(hash hash.Hash, random io.Reader, pub *PublicKey, msg []byte, label []byte) ([]byte, error) {
rsa.go#L489: func decrypt(random io.Reader, priv *PrivateKey, c *big.Int) (m *big.Int, err error) {
rsa.go#L569: func decryptAndCheck(random io.Reader, priv *PrivateKey, c *big.Int) (m *big.Int, err error) {
rsa.go#L596: func DecryptOAEP(hash hash.Hash, random io.Reader, priv *PrivateKey, ciphertext []byte, label []byte) ([]byte, error) {
crypto/tls
common.go#L523: Rand io.Reader
common.go#L947: func (c *Config) rand() io.Reader {
conn.go#L472: func (hc *halfConn) encrypt(record, payload []byte, rand io.Reader) ([]byte, error) {
conn.go#L776: R io.Reader
conn.go#L797: func (c *Conn) readFromUntil(r io.Reader, n int) error {
key_schedule.go#L112: func generateECDHEParameters(rand io.Reader, curveID CurveID) (ecdheParameters, error) {
crypto/x509
pem_decrypt.go#L195: func EncryptPEMBlock(rand io.Reader, blockType string, data, password []byte, alg PEMCipher) (*pem.Block, error) {
x509.go#L1486: func CreateCertificate(rand io.Reader, template, parent *Certificate, pub, priv any) ([]byte, error) {
x509.go#L1651: func (c *Certificate) CreateCRL(rand io.Reader, priv any, revokedCerts []pkix.RevokedCertificate, now, expiry time.Time) (crlBytes []byte, err error) {
x509.go#L1863: func CreateCertificateRequest(rand io.Reader, template *CertificateRequest, priv any) (csr []byte, err error) {
x509.go#L2129: func CreateRevocationList(rand io.Reader, template *RevocationList, issuer *Certificate, priv crypto.Signer) ([]byte, error) {
encoding/base64
base64.go#L391: r io.Reader
base64.go#L574: wrapped io.Reader
base64.go#L599: func NewDecoder(enc *Encoding, r io.Reader) io.Reader {
encoding/binary
binary.go#L162: func Read(r io.Reader, order ByteOrder, data any) error {
encoding/hex
hex.go#L168: r io.Reader
hex.go#L176: func NewDecoder(r io.Reader) io.Reader {
encoding/json
stream.go#L15: r io.Reader
stream.go#L31: func NewDecoder(r io.Reader) *Decoder {
stream.go#L83: func (dec *Decoder) Buffered() io.Reader {
encoding/xml
xml.go#L202: CharsetReader func(charset string, input io.Reader) (io.Reader, error)
xml.go#L229: func NewDecoder(r io.Reader) *Decoder {
xml.go#L369: func (d *Decoder) switchToReader(r io.Reader) {
xml.go#L643: newr, err := d.CharsetReader(enc, d.r.(io.Reader))
fmt
scan.go#L121: func Fscan(r io.Reader, a ...any) (n int, err error) {
scan.go#L130: func Fscanln(r io.Reader, a ...any) (n int, err error) {
scan.go#L141: func Fscanf(r io.Reader, format string, a ...any) (n int, err error) {
scan.go#L305: reader io.Reader
scan.go#L383: func newScanState(r io.Reader, nlIsSpace, nlIsEnd bool) (s *ss, old ssave) {
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream
decode.go#L47: func (d *Decoder) Decode(reader io.Reader, payloadBuf []byte) (m Message, err error) {
decode.go#L64: func decodeMessage(reader io.Reader, payloadBuf []byte) (m Message, err error) {
decode.go#L127: func decodePrelude(r io.Reader, crc hash.Hash32) (messagePrelude, error) {
decode.go#L155: func decodePayload(buf []byte, r io.Reader) ([]byte, error) {
decode.go#L162: func decodeUint8(r io.Reader) (uint8, error) {
decode.go#L177: func decodeUint16(r io.Reader) (uint16, error) {
decode.go#L187: func decodeUint32(r io.Reader) (uint32, error) {
decode.go#L197: func decodeUint64(r io.Reader) (uint64, error) {
decode.go#L207: func validateCRC(r io.Reader, expect uint32) error {
header.go#L64: func decodeHeaders(r io.Reader) (Headers, error) {
header.go#L88: func decodeHeaderName(r io.Reader) (string, error) {
header.go#L105: func decodeHeaderValue(r io.Reader) (Value, error) {
header_value.go#L132: func decodeFixedBytesValue(r io.Reader, buf []byte) error {
header_value.go#L137: func decodeBytesValue(r io.Reader) ([]byte, error) {
header_value.go#L154: func decodeStringValue(r io.Reader) (string, error) {
header_value.go#L222: func (v *Int8Value) decode(r io.Reader) error {
header_value.go#L259: func (v *Int16Value) decode(r io.Reader) error {
header_value.go#L296: func (v *Int32Value) decode(r io.Reader) error {
header_value.go#L333: func (v *Int64Value) decode(r io.Reader) error {
header_value.go#L371: func (v *BytesValue) decode(r io.Reader) error {
header_value.go#L409: func (v *StringValue) decode(r io.Reader) error {
header_value.go#L455: func (v *TimestampValue) decode(r io.Reader) error {
header_value.go#L518: func (v *UUIDValue) decode(r io.Reader) error {
github.com/aws/aws-sdk-go-v2/aws/protocol/xml
error_utils.go#L18: func GetErrorResponseComponents(r io.Reader, noErrorWrapping bool) (ErrorComponents, error) {
github.com/aws/aws-sdk-go-v2/internal/rand
rand.go#L15: var Reader io.Reader
rand.go#L20: func Float64(reader io.Reader) (float64, error) {
github.com/aws/aws-sdk-go-v2/service/internal/checksum
algorithms.go#L143: func computeMD5Checksum(r io.Reader) ([]byte, error) {
algorithms.go#L158: stream io.Reader
algorithms.go#L171: func newComputeChecksumReader(stream io.Reader, algorithm Algorithm) (*computeChecksumReader, error) {
algorithms.go#L251: body io.Reader
aws_chunked_encoding.go#L82: encodedStream io.Reader
aws_chunked_encoding.go#L91: stream io.Reader,
aws_chunked_encoding.go#L103: var chunkReader io.Reader
aws_chunked_encoding.go#L270: func newUnsignedChunkReader(reader io.Reader, payloadSize int64) io.Reader {
aws_chunked_encoding.go#L300: reader io.Reader
aws_chunked_encoding.go#L307: multiReader io.Reader
aws_chunked_encoding.go#L314: func newBufferedAWSChunkReader(reader io.Reader, chunkSize int) *bufferedAWSChunkReader {
aws_chunked_encoding.go#L356: func (r *bufferedAWSChunkReader) newMultiReader() (io.Reader, int, error) {
middleware_compute_input_checksum.go#L391: func computeStreamChecksum(algorithm Algorithm, stream io.Reader, computePayloadHash bool) (
github.com/aws/aws-sdk-go-v2/service/internal/s3shared
xml_utils.go#L21: func GetUnwrappedErrorResponseComponents(r io.Reader) (ErrorComponents, error) {
xml_utils.go#L31: func GetWrappedErrorResponseComponents(r io.Reader) (ErrorComponents, error) {
xml_utils.go#L52: func GetErrorResponseComponents(r io.Reader, options ErrorResponseDeserializerOptions) (ErrorComponents, error) {
github.com/aws/aws-sdk-go-v2/service/s3
api_op_PutObject.go#L151: Body io.Reader
api_op_UploadPart.go#L171: Body io.Reader
api_op_WriteGetObjectResponse.go#L90: Body io.Reader
github.com/aws/smithy-go/encoding/xml
error_utils.go#L17: func GetErrorResponseComponents(r io.Reader, noErrorWrapping bool) (ErrorComponents, error) {
github.com/aws/smithy-go/rand
rand.go#L15: var Reader io.Reader
rand.go#L18: func Int63n(reader io.Reader, max int64) (int64, error) {
uuid.go#L18: func NewUUIDIdempotencyToken(r io.Reader) *UUIDIdempotencyToken {
uuid.go#L30: randSrc io.Reader
uuid.go#L35: func NewUUID(r io.Reader) *UUID {
github.com/aws/smithy-go/transport/http
md5_checksum.go#L12: func computeMD5Checksum(r io.Reader) ([]byte, error) {
request.go#L19: stream io.Reader
request.go#L60: func streamLength(stream io.Reader, seekable bool, startPos int64) (size int64, ok bool, err error) {
request.go#L110: func (r *Request) GetStream() io.Reader {
request.go#L122: func (r *Request) SetStream(reader io.Reader) (rc *Request, err error) {
github.com/go-pg/migrations/v8
migrations.go#L22: CopyFrom(r io.Reader, query interface{}, params ...interface{}) (orm.Result, error)
github.com/go-pg/pg/v10
base.go#L362: func (db *baseDB) CopyFrom(r io.Reader, query interface{}, params ...interface{}) (res Result, err error) {
base.go#L373: ctx context.Context, cn *pool.Conn, r io.Reader, query interface{}, params ...interface{},
messages.go#L1213: func writeCopyData(buf *pool.WriteBuffer, r io.Reader) error {
pg.go#L118: CopyFrom(r io.Reader, query interface{}, params ...interface{}) (Result, error)
tx.go#L292: func (tx *Tx) CopyFrom(r io.Reader, query interface{}, params ...interface{}) (res Result, err error) {
github.com/go-pg/pg/v10/internal/pool
reader_buf.go#L14: rd io.Reader // reader provided by the client
reader_buf.go#L57: func (b *BufReader) Reset(rd io.Reader) {
write_buffer.go#L110: func (buf *WriteBuffer) ReadFrom(r io.Reader) (int64, error) {
github.com/go-pg/pg/v10/orm
orm.go#L53: CopyFrom(r io.Reader, query interface{}, params ...interface{}) (Result, error)
query.go#L1287: func (q *Query) CopyFrom(r io.Reader, query interface{}, params ...interface{}) (Result, error) {
github.com/go-pg/pg/v10/pgjson
json.go#L24: func (StdProvider) NewDecoder(r io.Reader) Decoder {
provider.go#L17: NewDecoder(r io.Reader) Decoder
provider.go#L41: func NewDecoder(r io.Reader) Decoder {
github.com/go-pg/pg/v10/types
hex.go#L62: func NewHexDecoder(rd Reader, n int) (io.Reader, error) {
github.com/golang/protobuf/jsonpb
decode.go#L33: func Unmarshal(r io.Reader, m proto.Message) error {
decode.go#L67: func (u *Unmarshaler) Unmarshal(r io.Reader, m proto.Message) error {
github.com/vmihailenco/bufpool
buffer.go#L148: func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error) {
github.com/vmihailenco/msgpack/v5
decode.go#L28: io.Reader
decode.go#L67: r io.Reader
decode.go#L84: func NewDecoder(r io.Reader) *Decoder {
decode.go#L92: func (d *Decoder) Reset(r io.Reader) {
decode.go#L97: func (d *Decoder) ResetDict(r io.Reader, dict []string) {
decode.go#L113: func (d *Decoder) resetReader(r io.Reader) {
decode.go#L166: func (d *Decoder) Buffered() io.Reader {
decode.go#L617: func readN(r io.Reader, b []byte, n int) ([]byte, error) {
go.pact.im/x/crypt
argon2.go#L19: rand io.Reader
go.pact.im/x/extraio
count.go#L18: reader io.Reader
count.go#L23: func NewCountReader(r io.Reader) *CountReader {
discard.go#L14: reader io.Reader
discard.go#L18: func NewDiscardReader(r io.Reader) *DiscardReader {
extraio.go#L7: _ io.Reader = (ByteReader)(0)
extraio.go#L8: _ io.Reader = (*CountReader)(nil)
extraio.go#L9: _ io.Reader = (*DiscardReader)(nil)
extraio.go#L10: _ io.Reader = (*HardLimitedReader)(nil)
extraio.go#L11: _ io.Reader = (*HashReader)(nil)
extraio.go#L12: _ io.Reader = (*PadReader)(nil)
extraio.go#L13: _ io.Reader = (ReaderFunc)(nil)
extraio.go#L14: _ io.Reader = (*TailReader)(nil)
extraio.go#L15: _ io.Reader = (*UnpadReader)(nil)
hardlimit.go#L16: reader io.Reader
hardlimit.go#L23: func HardLimitReader(r io.Reader, n uint64) *HardLimitedReader {
hash.go#L19: func NewStrippedHashReader(h hash.Hash, n int64) io.Reader {
pad.go#L10: reader io.Reader
pad.go#L21: func NewPadReader(r io.Reader, blockSize uint8) *PadReader {
tail.go#L16: reader io.Reader
tail.go#L23: func NewTailReader(r io.Reader, n uint) *TailReader {
unpad.go#L20: func NewUnpadReader(r io.Reader, blockSize uint8) *UnpadReader {
go.uber.org/zap
http_handler.go#L121: func decodePutJSON(body io.Reader) (zapcore.Level, error) {
go/build
read.go#L34: func newImportReader(name string, r io.Reader) *importReader {
read.go#L380: func readComments(f io.Reader) ([]byte, error) {
read.go#L397: func readGoInfo(f io.Reader, info *fileInfo) error {
go/parser
interface.go#L37: case io.Reader:
golang.org/x/crypto/blake2b
blake2x.go#L22: io.Reader
golang.org/x/crypto/sha3
shake.go#L33: io.Reader
golang.org/x/net/http2
frame.go#L230: func ReadFrameHeader(r io.Reader) (FrameHeader, error) {
frame.go#L236: func readFrameHeader(buf []byte, r io.Reader) (FrameHeader, error) {
frame.go#L266: r io.Reader
frame.go#L430: func NewFramer(w io.Writer, r io.Reader) *Framer {
pipe.go#L30: io.Reader
golang.org/x/text/transform
transform.go#L111: r io.Reader
transform.go#L134: func NewReader(r io.Reader, t Transformer) *Reader {
golang.org/x/text/unicode/norm
readwriter.go#L74: r io.Reader
readwriter.go#L119: func (f Form) Reader(r io.Reader) io.Reader {
golang.org/x/tools/go/gcexportdata
gcexportdata.go#L65: func NewReader(r io.Reader) (io.Reader, error) {
gcexportdata.go#L91: func readAll(r io.Reader) ([]byte, error) {
gcexportdata.go#L116: func Read(in io.Reader, fset *token.FileSet, imports map[string]*types.Package, path string) (*types.Package, error) {
gcexportdata.go#L173: func ReadBundle(in io.Reader, fset *token.FileSet, imports map[string]*types.Package) ([]*types.Package, error) {
google.golang.org/grpc
rpc_util.go#L108: Do(r io.Reader) ([]byte, error)
rpc_util.go#L124: func (d *gzipDecompressor) Do(r io.Reader) ([]byte, error) {
rpc_util.go#L539: r io.Reader
google.golang.org/grpc/encoding
encoding.go#L49: Decompress(r io.Reader) (io.Reader, error)
google.golang.org/grpc/internal/transport
http_util.go#L368: var r io.Reader = conn
proxy.go#L61: r io.Reader
transport.go#L256: trReader io.Reader
transport.go#L487: reader io.Reader
internal/profile
legacy_profile.go#L1025: func (p *Profile) ParseMemoryMap(rd io.Reader) error {
profile.go#L126: func Parse(r io.Reader) (*Profile, error) {
mellium.im/sasl
nonce.go#L14: func nonce(n int, r io.Reader) []byte {
mime
encodedword.go#L194: CharsetReader func(charset string, input io.Reader) (io.Reader, error)
mime/multipart
formdata.go#L168: io.Reader
multipart.go#L49: r io.Reader
multipart.go#L102: func NewReader(r io.Reader, boundary string) *Reader {
multipart.go#L119: r io.Reader
mime/quotedprintable
reader.go#L24: func NewReader(r io.Reader) *Reader {
net
net.go#L660: func genericReadFrom(w io.Writer, r io.Reader) (n int64, err error) {
net.go#L703: _ io.Reader = (*Buffers)(nil)
nss.go#L78: func parseNSSConf(r io.Reader) *nssConf {
parse.go#L331: func readFull(r io.Reader) (all []byte, err error) {
sendfile_linux.go#L20: func sendFile(c *netFD, r io.Reader) (written int64, err error, handled bool) {
splice_linux.go#L17: func splice(c *netFD, r io.Reader) (written int64, err error, handled bool) {
tcpsock.go#L126: func (c *TCPConn) ReadFrom(r io.Reader) (int64, error) {
tcpsock_posix.go#L47: func (c *TCPConn) readFrom(r io.Reader) (int64, error) {
net/http
client.go#L834: func Post(url, contentType string, body io.Reader) (resp *Response, err error) {
client.go#L852: func (c *Client) Post(url, contentType string, body io.Reader) (resp *Response, err error) {
fs.go#L104: io.Reader
fs.go#L260: var sendContent io.Reader = content
h2_bundle.go#L1559: func http2ReadFrameHeader(r io.Reader) (http2FrameHeader, error) {
h2_bundle.go#L1565: func http2readFrameHeader(buf []byte, r io.Reader) (http2FrameHeader, error) {
h2_bundle.go#L1595: r io.Reader
h2_bundle.go#L1762: func http2NewFramer(w io.Writer, r io.Reader) *http2Framer {
h2_bundle.go#L3617: io.Reader
request.go#L830: func NewRequest(method, url string, body io.Reader) (*Request, error) {
request.go#L856: func NewRequestWithContext(ctx context.Context, method, url string, body io.Reader) (*Request, error) {
request.go#L1206: var reader io.Reader = r.Body
response.go#L278: io.Reader
server.go#L567: func (w *response) ReadFrom(src io.Reader) (n int64, err error) {
server.go#L817: func newBufioReader(r io.Reader) *bufio.Reader {
transfer.go#L61: Body io.Reader
transfer.go#L207: go func(body io.Reader) {
transfer.go#L410: func (t *transferWriter) doBodyCopy(dst io.Writer, src io.Reader) (n int64, err error) {
transfer.go#L423: func (t *transferWriter) unwrapBody() io.Reader {
transfer.go#L425: return reflect.ValueOf(t.Body).Field(0).Interface().(io.Reader)
transfer.go#L811: src io.Reader
transfer.go#L1087: func isKnownInMemoryReader(r io.Reader) bool {
transfer.go#L1093: return isKnownInMemoryReader(reflect.ValueOf(r).Field(0).Interface().(io.Reader))
transport.go#L1774: func (w persistConnWriter) ReadFrom(r io.Reader) (n int64, err error) {
net/http/httptest
httptest.go#L40: func NewRequest(method, target string, body io.Reader) *http.Request {
net/http/httputil
dump.go#L43: io.Reader
dump.go#L116: dr := &delegateReader{c: make(chan io.Reader)}
dump.go#L173: c chan io.Reader
dump.go#L175: r io.Reader // nil until received from c
httputil.go#L20: func NewChunkedReader(r io.Reader) io.Reader {
reverseproxy.go#L428: func (p *ReverseProxy) copyResponse(dst io.Writer, src io.Reader, flushInterval time.Duration) error {
reverseproxy.go#L456: func (p *ReverseProxy) copyBuffer(dst io.Writer, src io.Reader, buf []byte) (int64, error) {
net/http/internal
chunked.go#L29: func NewChunkedReader(r io.Reader) io.Reader {
net/textproto
reader.go#L311: func (r *Reader) DotReader() io.Reader {
os
file.go#L150: func (f *File) ReadFrom(r io.Reader) (n int64, err error) {
file.go#L161: func genericReadFrom(f *File, r io.Reader) (int64, error) {
readfrom_linux.go#L14: func (f *File) readFrom(r io.Reader) (written int64, handled bool, err error) {
os/exec
exec.go#L98: Stdin io.Reader
testing/iotest
logger.go#L36: r io.Reader
logger.go#L52: func NewReadLogger(prefix string, r io.Reader) io.Reader {
reader.go#L17: func OneByteReader(r io.Reader) io.Reader { return &oneByteReader{r} }
reader.go#L20: r io.Reader
reader.go#L32: func HalfReader(r io.Reader) io.Reader { return &halfReader{r} }
reader.go#L35: r io.Reader
reader.go#L47: func DataErrReader(r io.Reader) io.Reader { return &dataErrReader{r, nil, make([]byte, 1024)} }
reader.go#L50: r io.Reader
reader.go#L78: func TimeoutReader(r io.Reader) io.Reader { return &timeoutReader{r, 0} }
reader.go#L81: r io.Reader
reader.go#L94: func ErrReader(err error) io.Reader {
reader.go#L107: r io.Reader
reader.go#L136: func TestReader(r io.Reader, content []byte) error {
vendor/golang.org/x/crypto/hkdf
hkdf.go#L83: func Expand(hash func() hash.Hash, pseudorandomKey, info []byte) io.Reader {
hkdf.go#L90: func New(hash func() hash.Hash, secret, salt, info []byte) io.Reader {
vendor/golang.org/x/text/transform
transform.go#L111: r io.Reader
transform.go#L134: func NewReader(r io.Reader, t Transformer) *Reader {
vendor/golang.org/x/text/unicode/norm
readwriter.go#L74: r io.Reader
readwriter.go#L119: func (f Form) Reader(r io.Reader) io.Reader {