type io.Reader
602 uses
io (current package)
io.go#L83: type Reader interface {
io.go#L127: Reader
io.go#L133: Reader
io.go#L145: Reader
io.go#L152: Reader
io.go#L159: Reader
io.go#L172: Reader
io.go#L185: ReadFrom(r Reader) (n int64, err error)
io.go#L322: func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error) {
io.go#L346: func ReadFull(r Reader, buf []byte) (n int, err error) {
io.go#L357: func CopyN(dst Writer, src Reader, n int64) (written int64, err error) {
io.go#L381: func Copy(dst Writer, src Reader) (written int64, err error) {
io.go#L392: func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
io.go#L401: func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
io.go#L455: func LimitReader(r Reader, n int64) Reader { return &LimitedReader{r, n} }
io.go#L462: R Reader // underlying reader
io.go#L550: func TeeReader(r Reader, w Writer) Reader {
io.go#L555: r Reader
io.go#L594: func (discard) ReadFrom(r Reader) (n int64, err error) {
io.go#L612: func NopCloser(r Reader) ReadCloser {
io.go#L617: Reader
io.go#L626: 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 {
archive/zip
reader.go#L183: var desr io.Reader
reader.go#L201: desr io.Reader // if non-nil, where to read the data descriptor
reader.go#L268: func readDirectoryHeader(f *File, r io.Reader) error {
reader.go#L438: func readDataDescriptor(r io.Reader, f *File) error {
register.go#L26: type Decompressor func(r io.Reader) io.ReadCloser
register.go#L68: func newFlateReader(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#L71: func (b *Reader) Reset(r io.Reader) {
bufio.go#L75: func (b *Reader) reset(buf []byte, r io.Reader) {
bufio.go#L724: 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#L87: func NewScanner(r io.Reader) *Scanner {
bytes
buffer.go#L199: func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error) {
compress/bzip2
bit_reader.go#L25: func newBitReader(r io.Reader) bitReader {
bzip2.go#L46: func NewReader(r io.Reader) io.Reader {
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 {
compress/zlib
reader.go#L60: Reset(r io.Reader, dict []byte) error
reader.go#L70: func NewReader(r io.Reader) (io.ReadCloser, error) {
reader.go#L79: func NewReaderDict(r io.Reader, dict []byte) (io.ReadCloser, error) {
reader.go#L129: func (z *reader) Reset(r io.Reader, dict []byte) error {
crypto
crypto.go#L178: Sign(rand io.Reader, digest []byte, opts SignerOpts) (signature []byte, err error)
crypto.go#L200: 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#L115: func (priv *PrivateKey) Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) ([]byte, error) {
ecdsa.go#L133: func randFieldElement(c elliptic.Curve, rand io.Reader) (k *big.Int, err error) {
ecdsa.go#L149: func GenerateKey(c elliptic.Curve, rand io.Reader) (*PrivateKey, error) {
ecdsa.go#L200: 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#L356: io.Reader
crypto/ed25519
ed25519.go#L88: func (priv PrivateKey) Sign(rand io.Reader, message []byte, opts crypto.SignerOpts) (signature []byte, err error) {
ed25519.go#L98: func GenerateKey(rand io.Reader) (PublicKey, PrivateKey, error) {
crypto/elliptic
elliptic.go#L285: 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#L19: 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#L504: Rand io.Reader
common.go#L911: func (c *Config) rand() io.Reader {
conn.go#L464: func (hc *halfConn) encrypt(record, payload []byte, rand io.Reader) ([]byte, error) {
conn.go#L768: R io.Reader
conn.go#L789: 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#L196: func EncryptPEMBlock(rand io.Reader, blockType string, data, password []byte, alg PEMCipher) (*pem.Block, error) {
x509.go#L2140: func CreateCertificate(rand io.Reader, template, parent *Certificate, pub, priv interface{}) (cert []byte, err error) {
x509.go#L2292: func (c *Certificate) CreateCRL(rand io.Reader, priv interface{}, revokedCerts []pkix.RevokedCertificate, now, expiry time.Time) (crlBytes []byte, err error) {
x509.go#L2504: func CreateCertificateRequest(rand io.Reader, template *CertificateRequest, priv interface{}) (csr []byte, err error) {
x509.go#L2770: func CreateRevocationList(rand io.Reader, template *RevocationList, issuer *Certificate, priv crypto.Signer) ([]byte, error) {
encoding/base32
base32.go#L383: r io.Reader
base32.go#L391: func readEncodedData(r io.Reader, buf []byte, min int, expectsPadding bool) (n int, err error) {
base32.go#L489: wrapped io.Reader
base32.go#L521: func NewDecoder(enc *Encoding, r io.Reader) io.Reader {
encoding/base64
base64.go#L393: r io.Reader
base64.go#L576: wrapped io.Reader
base64.go#L601: func NewDecoder(enc *Encoding, r io.Reader) io.Reader {
encoding/binary
binary.go#L162: func Read(r io.Reader, order ByteOrder, data interface{}) error {
encoding/gob
decode.go#L118: func decodeUintReader(r io.Reader, buf []byte) (x uint64, width int, err error) {
decoder.go#L29: r io.Reader // source of the data
decoder.go#L42: func NewDecoder(r io.Reader) *Decoder {
decoder.go#L221: var debugFunc func(io.Reader)
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 ...interface{}) (n int, err error) {
scan.go#L130: func Fscanln(r io.Reader, a ...interface{}) (n int, err error) {
scan.go#L141: func Fscanf(r io.Reader, format string, a ...interface{}) (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/aws
types.go#L23: func ReadSeekCloser(r io.Reader) ReaderSeekerCloser {
types.go#L30: r io.Reader
types.go#L36: func IsReaderSeekable(r io.Reader) bool {
types.go#L58: case io.Reader:
github.com/aws/aws-sdk-go/aws/awsutil
copy.go#L44: if _, ok := src.Interface().(io.Reader); ok {
prettify.go#L108: case io.ReadSeeker, io.Reader:
github.com/aws/aws-sdk-go/aws/client
logger.go#L38: io.Reader
github.com/aws/aws-sdk-go/aws/credentials/processcreds
provider.go#L416: func readInput(r io.Reader, w io.Writer, read chan error) {
github.com/aws/aws-sdk-go/aws/endpoints
decode.go#L40: func DecodeModel(r io.Reader, optFns ...func(*DecodeModelOptions)) (Resolver, error) {
github.com/aws/aws-sdk-go/aws/session
session.go#L241: CustomCABundle io.Reader
session.go#L532: func loadCustomCABundle(s *Session, bundle io.Reader) error {
session.go#L564: func loadCertPool(r io.Reader) (*x509.CertPool, error) {
github.com/aws/aws-sdk-go/internal/ini
ini.go#L24: func Parse(f io.Reader) (Sections, error) {
ini_lexer.go#L59: func (l *iniLexer) Tokenize(r io.Reader) ([]Token, error) {
ini_parser.go#L115: func ParseAST(r io.Reader) ([]AST, error) {
github.com/aws/aws-sdk-go/private/protocol
payload.go#L16: UnmarshalPayload(io.Reader, interface{}) error
payload.go#L29: func (h HandlerPayloadUnmarshal) UnmarshalPayload(r io.Reader, v interface{}) error {
github.com/aws/aws-sdk-go/private/protocol/json/jsonutil
unmarshal.go#L24: func UnmarshalJSONError(v interface{}, stream io.Reader) error {
unmarshal.go#L42: func UnmarshalJSON(v interface{}, stream io.Reader) error {
unmarshal.go#L59: func UnmarshalJSONCaseInsensitive(v interface{}, stream io.Reader) error {
github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil
unmarshal.go#L22: func UnmarshalXMLError(v interface{}, stream io.Reader) error {
github.com/go-git/gcfg
read.go#L226: func ReadWithCallback(reader io.Reader, callback func(string, string, string, string, bool) error) error {
read.go#L241: func ReadInto(config interface{}, reader io.Reader) error {
github.com/go-git/go-billy/v5
fs.go#L167: io.Reader
github.com/go-git/go-git/v5
remote.go#L893: func buildSidebandIfSupported(l *capability.List, reader io.Reader, p sideband.Progress) io.Reader {
github.com/go-git/go-git/v5/config
config.go#L122: func ReadConfig(r io.Reader) (*Config, error) {
github.com/go-git/go-git/v5/internal/revision
parser.go#L115: func NewParser(r io.Reader) *Parser {
scanner.go#L54: func newScanner(r io.Reader) *scanner {
github.com/go-git/go-git/v5/plumbing/format/config
decoder.go#L11: io.Reader
decoder.go#L15: func NewDecoder(r io.Reader) *Decoder {
github.com/go-git/go-git/v5/plumbing/format/idxfile
decoder.go#L31: func NewDecoder(r io.Reader) *Decoder {
decoder.go#L41: flow := []func(*MemoryIndex, io.Reader) error{
decoder.go#L59: func validateHeader(r io.Reader) error {
decoder.go#L72: func readVersion(idx *MemoryIndex, r io.Reader) error {
decoder.go#L86: func readFanout(idx *MemoryIndex, r io.Reader) error {
decoder.go#L100: func readObjectNames(idx *MemoryIndex, r io.Reader) error {
decoder.go#L129: func readCRC32(idx *MemoryIndex, r io.Reader) error {
decoder.go#L141: func readOffsets(idx *MemoryIndex, r io.Reader) error {
decoder.go#L167: func readChecksums(idx *MemoryIndex, r io.Reader) error {
github.com/go-git/go-git/v5/plumbing/format/index
decoder.go#L43: r io.Reader
decoder.go#L51: func NewDecoder(r io.Reader) *Decoder {
decoder.go#L309: func validateHeader(r io.Reader) (version uint32, err error) {
github.com/go-git/go-git/v5/plumbing/format/objfile
reader.go#L23: multi io.Reader
reader.go#L29: func NewReader(r io.Reader) (*Reader, error) {
github.com/go-git/go-git/v5/plumbing/format/packfile
common.go#L29: func UpdateObjectStorage(s storer.Storer, packfile io.Reader) error {
common.go#L47: packfile io.Reader,
scanner.go#L57: func NewScanner(r io.Reader) *Scanner {
scanner.go#L68: func (s *Scanner) Reset(r io.Reader) {
scanner.go#L395: reader io.Reader
scanner.go#L402: func newScannerReader(r io.Reader, h io.Writer) *scannerReader {
scanner.go#L413: func (r *scannerReader) Reset(reader io.Reader) {
github.com/go-git/go-git/v5/plumbing/format/pktline
scanner.go#L26: r io.Reader // The reader provided by the client
scanner.go#L33: func NewScanner(r io.Reader) *Scanner {
github.com/go-git/go-git/v5/plumbing/object
rename.go#L586: func (i *similarityIndex) hashContent(r io.Reader, size int64, isBin bool) error {
github.com/go-git/go-git/v5/plumbing/protocol/packp
advrefs_decode.go#L16: func (a *AdvRefs) Decode(r io.Reader) error {
advrefs_decode.go#L38: func newAdvRefsDecoder(r io.Reader) *advRefsDecoder {
report_status.go#L62: func (s *ReportStatus) Decode(r io.Reader) error {
shallowupd.go#L22: func (r *ShallowUpdate) Decode(reader io.Reader) error {
ulreq_decode.go#L17: func (u *UploadRequest) Decode(r io.Reader) error {
ulreq_decode.go#L30: func newUlReqDecoder(r io.Reader) *ulReqDecoder {
updreq_decode.go#L79: func (req *ReferenceUpdateRequest) Decode(r io.Reader) error {
github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband
demux.go#L35: r io.Reader
demux.go#L46: func NewDemuxer(t Type, r io.Reader) *Demuxer {
github.com/go-git/go-git/v5/plumbing/transport/file
client.go#L111: func (c *command) StderrPipe() (io.Reader, error) {
client.go#L124: func (c *command) StdoutPipe() (io.Reader, error) {
github.com/go-git/go-git/v5/plumbing/transport/git
common.go#L76: func (c *command) StderrPipe() (io.Reader, error) {
common.go#L88: func (c *command) StdoutPipe() (io.Reader, error) {
github.com/go-git/go-git/v5/plumbing/transport/http
receive_pack.go#L82: var body io.Reader
upload_pack.go#L80: var body io.Reader
github.com/go-git/go-git/v5/plumbing/transport/internal/common
common.go#L52: StderrPipe() (io.Reader, error)
common.go#L60: StdoutPipe() (io.Reader, error)
common.go#L101: Stdout io.Reader
common.go#L145: func (c *client) listenFirstError(r io.Reader) chan string {
common.go#L277: func (s *session) StdoutContext(ctx context.Context) io.Reader {
common.go#L433: func uploadPack(w io.WriteCloser, r io.Reader, req *packp.UploadPackRequest) error {
server.go#L17: Stdin io.Reader
github.com/go-git/go-git/v5/storage/filesystem/dotgit
dotgit.go#L587: func (d *DotGit) readReferenceFrom(rd io.Reader, name string) (ref *plumbing.Reference, err error) {
github.com/go-git/go-git/v5/utils/binary
read.go#L16: func Read(r io.Reader, data ...interface{}) error {
read.go#L27: func ReadUntil(r io.Reader, delim byte) ([]byte, error) {
read.go#L87: func ReadVariableWidthInt(r io.Reader) (int64, error) {
read.go#L113: func ReadUint64(r io.Reader) (uint64, error) {
read.go#L123: func ReadUint32(r io.Reader) (uint32, error) {
read.go#L133: func ReadUint16(r io.Reader) (uint16, error) {
read.go#L143: func ReadHash(r io.Reader) (plumbing.Hash, error) {
read.go#L156: func IsBinary(r io.Reader) (bool, error) {
github.com/go-git/go-git/v5/utils/ioutil
common.go#L14: io.Reader
common.go#L25: func NonEmptyReader(r io.Reader) (io.Reader, error) {
common.go#L44: io.Reader
common.go#L54: func NewReadCloser(r io.Reader, c io.Closer) io.ReadCloser {
common.go#L104: func NewContextReader(ctx context.Context, r io.Reader) io.Reader {
common.go#L121: io.Reader
common.go#L127: func NewReaderOnError(r io.Reader, notify func(error)) io.Reader {
github.com/go-redis/redis/v8/internal/proto
reader.go#L38: func NewReader(rd io.Reader) *Reader {
reader.go#L53: func (r *Reader) Reset(rd io.Reader) {
github.com/golang-migrate/migrate/v4
migration.go#L34: BufferedBody io.Reader
github.com/golang-migrate/migrate/v4/database
driver.go#L65: Run(migration io.Reader) error
github.com/golang-migrate/migrate/v4/database/postgres
postgres.go#L182: func (p *Postgres) Run(migration io.Reader) error {
github.com/google/pprof/profile
legacy_profile.go#L969: func ParseProcMaps(rd io.Reader) ([]*Mapping, error) {
legacy_profile.go#L1020: func (p *Profile) ParseMemoryMap(rd io.Reader) error {
profile.go#L145: func Parse(r io.Reader) (*Profile, error) {
github.com/jackc/chunkreader/v2
chunkreader.go#L16: r io.Reader
chunkreader.go#L30: func New(r io.Reader) *ChunkReader {
chunkreader.go#L40: func NewConfig(r io.Reader, config Config) (*ChunkReader, error) {
github.com/jackc/pgconn
config.go#L676: return func(r io.Reader, w io.Writer) Frontend {
pgconn.go#L51: type BuildFrontendFunc func(r io.Reader, w io.Writer) Frontend
pgconn.go#L1152: func (pgConn *PgConn) CopyFrom(ctx context.Context, r io.Reader, sql string) (CommandTag, error) {
github.com/jackc/pgpassfile
pgpass.go#L38: func ParsePassfile(r io.Reader) (*Passfile, error) {
github.com/jackc/pgproto3/v2
chunkreader.go#L17: func NewChunkReader(r io.Reader) ChunkReader {
github.com/jackc/pgservicefile
pgservicefile.go#L44: func ParseServicefile(r io.Reader) (*Servicefile, error) {
github.com/jbenet/go-context/io
ctxio.go#L75: io.Reader
ctxio.go#L79: r io.Reader
ctxio.go#L98: func NewReader(ctx context.Context, r io.Reader) *ctxReader {
github.com/kevinburke/ssh_config
config.go#L213: func Decode(r io.Reader) (*Config, error) {
github.com/lib/pq
conn.go#L210: scanner := bufio.NewScanner(io.Reader(file))
github.com/matttproud/golang_protobuf_extensions/pbutil
decode.go#L38: func ReadDelimited(r io.Reader, m proto.Message) (n int, err error) {
github.com/microcosm-cc/bluemonday
sanitize.go#L81: func (p *Policy) SanitizeReader(r io.Reader) *bytes.Buffer {
sanitize.go#L86: func (p *Policy) sanitize(r io.Reader) *bytes.Buffer {
github.com/prometheus/client_golang/prometheus/promhttp
delegator.go#L97: func (d readerFromDelegator) ReadFrom(re io.Reader) (int64, error) {
github.com/prometheus/common/expfmt
decode.go#L74: func NewDecoder(r io.Reader, format Format) Decoder {
decode.go#L84: r io.Reader
decode.go#L117: r io.Reader
text_parse.go#L100: func (p *TextParser) TextToMetricFamilies(in io.Reader) (map[string]*dto.MetricFamily, error) {
text_parse.go#L121: func (p *TextParser) reset(in io.Reader) {
github.com/prometheus/procfs
buddyinfo.go#L45: func parseBuddyInfo(r io.Reader) ([]BuddyInfo, error) {
ipvs.go#L79: func parseIPVSStats(r io.Reader) (IPVSStats, error) {
ipvs.go#L137: func parseIPVSBackendStatus(file io.Reader) ([]IPVSBackendStatus, error) {
meminfo.go#L161: func parseMemInfo(r io.Reader) (*Meminfo, error) {
mountstats.go#L237: func parseMountStats(r io.Reader) ([]*Mount, error) {
net_sockstat.go#L80: func parseSockstat(r io.Reader) (*NetSockstat, error) {
net_unix.go#L112: func NewNetUnixByReader(reader io.Reader) (*NetUnix, error) {
proc_psi.go#L69: func parsePSIStats(resource string, r io.Reader) (PSIStats, error) {
go/build
read.go#L31: func newImportReader(name string, r io.Reader) *importReader {
read.go#L348: func readComments(f io.Reader) ([]byte, error) {
read.go#L365: func readGoInfo(f io.Reader, info *fileInfo) error {
go/parser
interface.go#L37: case io.Reader:
golang.org/x/crypto/ed25519
ed25519_go113.go#L52: func GenerateKey(rand io.Reader) (PublicKey, PrivateKey, error) {
golang.org/x/crypto/openpgp
keys.go#L236: func ReadArmoredKeyRing(r io.Reader) (EntityList, error) {
keys.go#L253: func ReadKeyRing(r io.Reader) (el EntityList, err error) {
read.go#L24: func readArmored(r io.Reader, expectedType string) (body io.Reader, err error) {
read.go#L48: UnverifiedBody io.Reader // the contents of the message.
read.go#L86: func ReadMessage(r io.Reader, keyring KeyRing, prompt PromptFunction, config *packet.Config) (md *MessageDetails, err error) {
read.go#L363: func CheckDetachedSignature(keyring KeyRing, signed, signature io.Reader) (signer *Entity, err error) {
read.go#L435: func CheckArmoredDetachedSignature(keyring KeyRing, signed, signature io.Reader) (signer *Entity, err error) {
write.go#L23: func DetachSign(w io.Writer, signer *Entity, message io.Reader, config *packet.Config) error {
write.go#L30: func ArmoredDetachSign(w io.Writer, signer *Entity, message io.Reader, config *packet.Config) (err error) {
write.go#L38: func DetachSignText(w io.Writer, signer *Entity, message io.Reader, config *packet.Config) error {
write.go#L46: func ArmoredDetachSignText(w io.Writer, signer *Entity, message io.Reader, config *packet.Config) error {
write.go#L50: func armoredDetachSign(w io.Writer, signer *Entity, message io.Reader, sigType packet.SignatureType, config *packet.Config) (err error) {
write.go#L62: func detachSign(w io.Writer, signer *Entity, message io.Reader, sigType packet.SignatureType, config *packet.Config) (err error) {
golang.org/x/crypto/openpgp/armor
armor.go#L33: Body io.Reader // A Reader from which the contents can be read
armor.go#L143: b64Reader io.Reader
armor.go#L162: func Decode(in io.Reader) (p *Block, err error) {
golang.org/x/crypto/openpgp/elgamal
elgamal.go#L37: func Encrypt(random io.Reader, pub *PublicKey, msg []byte) (c1, c2 *big.Int, err error) {
elgamal.go#L108: func nonZeroRandomBytes(s []byte, rand io.Reader) (err error) {
golang.org/x/crypto/openpgp/packet
compressed.go#L19: Body io.Reader
compressed.go#L42: func (c *Compressed) parse(r io.Reader) error {
config.go#L19: Rand io.Reader
config.go#L51: func (c *Config) Random() io.Reader {
encrypted_key.go#L32: func (e *EncryptedKey) parse(r io.Reader) (err error) {
encrypted_key.go#L166: func serializeEncryptedKeyRSA(w io.Writer, rand io.Reader, header [10]byte, pub *rsa.PublicKey, keyBlock []byte) error {
encrypted_key.go#L185: func serializeEncryptedKeyElGamal(w io.Writer, rand io.Reader, header [10]byte, pub *elgamal.PublicKey, keyBlock []byte) error {
literal.go#L17: Body io.Reader
literal.go#L26: func (l *LiteralData) parse(r io.Reader) (err error) {
one_pass_signature.go#L28: func (ops *OnePassSignature) parse(r io.Reader) (err error) {
opaque.go#L28: func (op *OpaquePacket) parse(r io.Reader) (err error) {
opaque.go#L63: r io.Reader
opaque.go#L66: func NewOpaqueReader(r io.Reader) *OpaqueReader {
packet.go#L25: func readFull(r io.Reader, buf []byte) (n int, err error) {
packet.go#L34: func readLength(r io.Reader) (length int64, isPartial bool, err error) {
packet.go#L70: r io.Reader
packet.go#L174: r io.Reader
packet.go#L195: func readHeader(r io.Reader) (tag packetType, length int64, contents io.Reader, err error) {
packet.go#L291: parse(io.Reader) error
packet.go#L296: func consumeAll(r io.Reader) (n int64, err error) {
packet.go#L337: func peekVersion(r io.Reader) (bufr *bufio.Reader, ver byte, err error) {
packet.go#L349: func Read(r io.Reader) (p Packet, err error) {
packet.go#L530: func readMPI(r io.Reader) (mpi []byte, bitLength uint16, err error) {
private_key.go#L89: func (pk *PrivateKey) parse(r io.Reader) (err error) {
public_key.go#L50: func parseOID(r io.Reader) (oid []byte, err error) {
public_key.go#L65: func (f *ecdsaKey) parse(r io.Reader) (err error) {
public_key.go#L115: func (f *ecdhKdf) parse(r io.Reader) (err error) {
public_key.go#L258: func (pk *PublicKey) parse(r io.Reader) (err error) {
public_key.go#L316: func (pk *PublicKey) parseRSA(r io.Reader) (err error) {
public_key.go#L344: func (pk *PublicKey) parseDSA(r io.Reader) (err error) {
public_key.go#L373: func (pk *PublicKey) parseElGamal(r io.Reader) (err error) {
public_key_v3.go#L53: func (pk *PublicKeyV3) parse(r io.Reader) (err error) {
public_key_v3.go#L90: func (pk *PublicKeyV3) parseRSA(r io.Reader) (err error) {
reader.go#L16: readers []io.Reader
reader.go#L58: func (r *Reader) Push(reader io.Reader) (err error) {
reader.go#L71: func NewReader(r io.Reader) *Reader {
reader.go#L74: readers: []io.Reader{r},
signature.go#L82: func (sig *Signature) parse(r io.Reader) (err error) {
signature_v3.go#L35: func (sig *SignatureV3) parse(r io.Reader) (err error) {
symmetric_key_encrypted.go#L31: func (ske *SymmetricKeyEncrypted) parse(r io.Reader) error {
symmetrically_encrypted.go#L22: contents io.Reader
symmetrically_encrypted.go#L28: func (se *SymmetricallyEncrypted) parse(r io.Reader) error {
symmetrically_encrypted.go#L92: in io.Reader
symmetrically_encrypted.go#L110: in io.Reader
userattribute.go#L57: func (uat *UserAttribute) parse(r io.Reader) (err error) {
userid.go#L67: func (uid *UserId) parse(r io.Reader) (err error) {
golang.org/x/crypto/openpgp/s2k
s2k.go#L156: func Parse(r io.Reader) (f func(out, in []byte), err error) {
s2k.go#L207: func Serialize(w io.Writer, key []byte, rand io.Reader, passphrase []byte, c *Config) error {
golang.org/x/crypto/ssh
certs.go#L249: func (s *openSSHCertSigner) Sign(rand io.Reader, data []byte) (*Signature, error) {
certs.go#L257: func (s *algorithmOpenSSHCertSigner) SignWithAlgorithm(rand io.Reader, data []byte, algorithm string) (*Signature, error) {
certs.go#L419: func (c *Certificate) SignCert(rand io.Reader, authority Signer) error {
cipher.go#L152: func (s *streamPacketCipher) readCipherPacket(seqNum uint32, r io.Reader) ([]byte, error) {
cipher.go#L224: func (s *streamPacketCipher) writeCipherPacket(seqNum uint32, w io.Writer, rand io.Reader, packet []byte) error {
cipher.go#L329: func (c *gcmCipher) writeCipherPacket(seqNum uint32, w io.Writer, rand io.Reader, packet []byte) error {
cipher.go#L372: func (c *gcmCipher) readCipherPacket(seqNum uint32, r io.Reader) ([]byte, error) {
cipher.go#L488: func (c *cbcCipher) readCipherPacket(seqNum uint32, r io.Reader) ([]byte, error) {
cipher.go#L502: func (c *cbcCipher) readCipherPacketLeaky(seqNum uint32, r io.Reader) ([]byte, error) {
cipher.go#L578: func (c *cbcCipher) writeCipherPacket(seqNum uint32, w io.Writer, rand io.Reader, packet []byte) error {
cipher.go#L663: func (c *chacha20Poly1305Cipher) readCipherPacket(seqNum uint32, r io.Reader) ([]byte, error) {
cipher.go#L729: func (c *chacha20Poly1305Cipher) writeCipherPacket(seqNum uint32, w io.Writer, rand io.Reader, payload []byte) error {
client_auth.go#L96: auth(session []byte, user string, p packetConn, rand io.Reader) (authResult, []string, error)
client_auth.go#L105: func (n *noneAuth) auth(session []byte, user string, c packetConn, rand io.Reader) (authResult, []string, error) {
client_auth.go#L125: func (cb passwordCallback) auth(session []byte, user string, c packetConn, rand io.Reader) (authResult, []string, error) {
client_auth.go#L192: func (cb publicKeyCallback) auth(session []byte, user string, c packetConn, rand io.Reader) (authResult, []string, error) {
client_auth.go#L398: func (cb KeyboardInteractiveChallenge) auth(session []byte, user string, c packetConn, rand io.Reader) (authResult, []string, error) {
client_auth.go#L500: func (r *retryableAuthMethod) auth(session []byte, user string, c packetConn, rand io.Reader) (ok authResult, methods []string, err error) {
client_auth.go#L545: func (g *gssAPIWithMICCallback) auth(session []byte, user string, c packetConn, rand io.Reader) (authResult, []string, error) {
common.go#L217: Rand io.Reader
kex.go#L79: Server(p packetConn, rand io.Reader, magics *handshakeMagics, s Signer) (*kexResult, error)
kex.go#L83: Client(p packetConn, rand io.Reader, magics *handshakeMagics) (*kexResult, error)
kex.go#L98: func (group *dhGroup) Client(c packetConn, randSource io.Reader, magics *handshakeMagics) (*kexResult, error) {
kex.go#L153: func (group *dhGroup) Server(c packetConn, randSource io.Reader, magics *handshakeMagics, priv Signer) (result *kexResult, err error) {
kex.go#L224: func (kex *ecdh) Client(c packetConn, rand io.Reader, magics *handshakeMagics) (*kexResult, error) {
kex.go#L317: func (kex *ecdh) Server(c packetConn, rand io.Reader, magics *handshakeMagics, priv Signer) (result *kexResult, err error) {
kex.go#L427: func (kp *curve25519KeyPair) generate(rand io.Reader) error {
kex.go#L440: func (kex *curve25519sha256) Client(c packetConn, rand io.Reader, magics *handshakeMagics) (*kexResult, error) {
kex.go#L489: func (kex *curve25519sha256) Server(c packetConn, rand io.Reader, magics *handshakeMagics, priv Signer) (result *kexResult, err error) {
kex.go#L573: func (gex dhGEXSHA) Client(c packetConn, randSource io.Reader, magics *handshakeMagics) (*kexResult, error) {
kex.go#L673: func (gex dhGEXSHA) Server(c packetConn, randSource io.Reader, magics *handshakeMagics, priv Signer) (result *kexResult, err error) {
keys.go#L320: Sign(rand io.Reader, data []byte) (*Signature, error)
keys.go#L333: SignWithAlgorithm(rand io.Reader, data []byte, algorithm string) (*Signature, error)
keys.go#L501: func (k *dsaPrivateKey) Sign(rand io.Reader, data []byte) (*Signature, error) {
keys.go#L505: func (k *dsaPrivateKey) SignWithAlgorithm(rand io.Reader, data []byte, algorithm string) (*Signature, error) {
keys.go#L963: func (s *wrappedSigner) Sign(rand io.Reader, data []byte) (*Signature, error) {
keys.go#L967: func (s *wrappedSigner) SignWithAlgorithm(rand io.Reader, data []byte, algorithm string) (*Signature, error) {
server.go#L216: func signAndMarshal(k Signer, rand io.Reader, data []byte) ([]byte, error) {
session.go#L120: Stdin io.Reader
session.go#L483: var stdin io.Reader
session.go#L558: func (s *Session) StdoutPipe() (io.Reader, error) {
session.go#L575: func (s *Session) StderrPipe() (io.Reader, error) {
transport.go#L48: rand io.Reader
transport.go#L58: writeCipherPacket(seqnum uint32, w io.Writer, rand io.Reader, packet []byte) error
transport.go#L63: readCipherPacket(seqnum uint32, r io.Reader) ([]byte, error)
transport.go#L175: func (s *connectionState) writePacket(w *bufio.Writer, rand io.Reader, packet []byte) error {
transport.go#L197: func newTransport(rwc io.ReadWriteCloser, rand io.Reader, isClient bool) *transport {
transport.go#L311: func readVersion(r io.Reader) ([]byte, error) {
golang.org/x/crypto/ssh/agent
client.go#L769: func (s *agentKeyringSigner) Sign(rand io.Reader, data []byte) (*ssh.Signature, error) {
client.go#L774: func (s *agentKeyringSigner) SignWithOpts(rand io.Reader, data []byte, opts crypto.SignerOpts) (*ssh.Signature, error) {
golang.org/x/crypto/ssh/knownhosts
knownhosts.go#L392: func (db *hostKeyDB) Read(r io.Reader, filename string) error {
golang.org/x/net/context/ctxhttp
ctxhttp.go#L59: func Post(ctx context.Context, client *http.Client, url string, bodyType string, body io.Reader) (*http.Response, error) {
golang.org/x/net/html
parse.go#L2321: func Parse(r io.Reader) (*Node, error) {
parse.go#L2330: func ParseFragment(r io.Reader, context *Node) ([]*Node, error) {
parse.go#L2348: func ParseWithOptions(r io.Reader, opts ...ParseOption) (*Node, error) {
parse.go#L2370: func ParseFragmentWithOptions(r io.Reader, context *Node, opts ...ParseOption) ([]*Node, error) {
token.go#L129: r io.Reader
token.go#L297: func readAtLeastOneByte(r io.Reader, b []byte) (int, error) {
token.go#L1200: func NewTokenizer(r io.Reader) *Tokenizer {
token.go#L1212: func NewTokenizerFragment(r io.Reader, contextTag string) *Tokenizer {
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#L425: func NewFramer(w io.Writer, r io.Reader) *Framer {
pipe.go#L30: io.Reader
transport.go#L1308: func (cs *clientStream) writeRequestBody(body io.Reader, bodyCloser io.Closer) (err error) {
transport.go#L2599: func (t *Transport) getBodyWriterState(cs *clientStream, body io.Reader) (s bodyWriterState) {
golang.org/x/oauth2/google
sdk.go#L150: func parseINI(ini io.Reader) (map[string]map[string]string, error) {
golang.org/x/pkgsite/internal/frontend
overview.go#L93: func legacySanitizeHTML(r io.Reader) safehtml.HTML {
golang.org/x/pkgsite/internal/middleware
caching.go#L164: func (c *cache) get(ctx context.Context, key string) (io.Reader, bool) {
golang.org/x/pkgsite/internal/proxy
client.go#L208: err = c.executeRequest(ctx, u, func(body io.Reader) error {
client.go#L228: collect := func(body io.Reader) error {
client.go#L243: func (c *Client) executeRequest(ctx context.Context, u string, bodyFunc func(body io.Reader) error) (err error) {
golang.org/x/pkgsite/internal/source
meta-tags.go#L61: func parseMeta(importPath string, r io.Reader) (sm *sourceMeta, err error) {
golang.org/x/pkgsite/internal/stdlib
stdlib.go#L474: func writeZipFile(z *zip.Writer, pathname string, src io.Reader) (err error) {
golang.org/x/pkgsite/internal/testing/htmlcheck
htmlcheck.go#L24: func Run(reader io.Reader, checker Checker) error {
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 {
google.golang.org/api/googleapi
googleapi.go#L189: func (wrap MarshalStyle) JSONReader(v interface{}) (io.Reader, error) {
google.golang.org/api/internal/gensupport
buffer.go#L17: media io.Reader
buffer.go#L27: func NewMediaBuffer(media io.Reader, chunkSize int) *MediaBuffer {
buffer.go#L34: func (mb *MediaBuffer) Chunk() (chunk io.Reader, off int64, size int, err error) {
buffer.go#L66: io.Reader
buffer.go#L73: func ReaderAtToReader(ra io.ReaderAt, size int64) io.Reader {
media.go#L24: func newContentSniffer(r io.Reader) *contentSniffer {
media.go#L30: r io.Reader
media.go#L83: func DetermineContentType(media io.Reader, ctype string) (io.Reader, string) {
media.go#L106: io.Reader
media.go#L170: func CombineBodyMedia(body io.Reader, bodyContentType string, media io.Reader, mediaContentType string) (io.ReadCloser, string) {
media.go#L175: func combineBodyMedia(body io.Reader, bodyContentType string, media io.Reader, mediaContentType, mimeBoundary string) (io.ReadCloser, string) {
media.go#L203: func PrepareUpload(media io.Reader, chunkSize int) (r io.Reader, mb *MediaBuffer, singleChunk bool) {
media.go#L220: media io.Reader
media.go#L231: func NewInfoFromMedia(r io.Reader, options []googleapi.MediaOption) *MediaInfo {
media.go#L273: func (mi *MediaInfo) UploadRequest(reqHeaders http.Header, body io.Reader) (newBody io.Reader, getBody func() (io.ReadCloser, error), cleanup func()) {
media.go#L278: var media io.Reader
media.go#L328: func readerFunc(r io.Reader) func() io.Reader {
media.go#L332: return func() io.Reader { return bytes.NewReader(buf) }
media.go#L335: return func() io.Reader { r := snapshot; return &r }
media.go#L338: return func() io.Reader { r := snapshot; return &r }
resumable.go#L73: func (rx *ResumableUpload) doUploadRequest(ctx context.Context, data io.Reader, off, size int64, final bool) (*http.Response, error) {
google.golang.org/api/storage/v1
storage-gen.go#L2452: var body io.Reader = nil
storage-gen.go#L2603: var body io.Reader = nil
storage-gen.go#L2767: var body io.Reader = nil
storage-gen.go#L2943: var body io.Reader = nil
storage-gen.go#L3101: var body io.Reader = nil
storage-gen.go#L3275: var body io.Reader = nil
storage-gen.go#L3461: var body io.Reader = nil
storage-gen.go#L3643: var body io.Reader = nil
storage-gen.go#L3849: var body io.Reader = nil
storage-gen.go#L4063: var body io.Reader = nil
storage-gen.go#L4323: var body io.Reader = nil
storage-gen.go#L4530: var body io.Reader = nil
storage-gen.go#L4765: var body io.Reader = nil
storage-gen.go#L4994: var body io.Reader = nil
storage-gen.go#L5172: var body io.Reader = nil
storage-gen.go#L5409: var body io.Reader = nil
storage-gen.go#L5621: var body io.Reader = nil
storage-gen.go#L5738: var body io.Reader = nil
storage-gen.go#L5889: var body io.Reader = nil
storage-gen.go#L6054: var body io.Reader = nil
storage-gen.go#L6247: var body io.Reader = nil
storage-gen.go#L6417: var body io.Reader = nil
storage-gen.go#L6591: var body io.Reader = nil
storage-gen.go#L6763: var body io.Reader = nil
storage-gen.go#L6914: var body io.Reader = nil
storage-gen.go#L7081: var body io.Reader = nil
storage-gen.go#L7259: var body io.Reader = nil
storage-gen.go#L7429: var body io.Reader = nil
storage-gen.go#L7604: var body io.Reader = nil
storage-gen.go#L7792: var body io.Reader = nil
storage-gen.go#L7992: var body io.Reader = nil
storage-gen.go#L8174: var body io.Reader = nil
storage-gen.go#L8372: var body io.Reader = nil
storage-gen.go#L8607: var body io.Reader = nil
storage-gen.go#L8950: var body io.Reader = nil
storage-gen.go#L9278: var body io.Reader = nil
storage-gen.go#L9514: var body io.Reader = nil
storage-gen.go#L9764: var body io.Reader = nil
storage-gen.go#L10012: func (c *ObjectsInsertCall) Media(r io.Reader, options ...googleapi.MediaOption) *ObjectsInsertCall {
storage-gen.go#L10078: var body io.Reader = nil
storage-gen.go#L10454: var body io.Reader = nil
storage-gen.go#L10768: var body io.Reader = nil
storage-gen.go#L11160: var body io.Reader = nil
storage-gen.go#L11463: var body io.Reader = nil
storage-gen.go#L11666: var body io.Reader = nil
storage-gen.go#L11924: var body io.Reader = nil
storage-gen.go#L12242: var body io.Reader = nil
storage-gen.go#L12458: var body io.Reader = nil
storage-gen.go#L12608: var body io.Reader = nil
storage-gen.go#L12746: var body io.Reader = nil
storage-gen.go#L12946: var body io.Reader = nil
storage-gen.go#L13138: var body io.Reader = nil
storage-gen.go#L13318: var body io.Reader = nil
google.golang.org/grpc
proxy.go#L67: r io.Reader
rpc_util.go#L110: Do(r io.Reader) ([]byte, error)
rpc_util.go#L126: func (d *gzipDecompressor) Do(r io.Reader) ([]byte, error) {
rpc_util.go#L482: r io.Reader
google.golang.org/grpc/credentials/alts
utils.go#L56: manufacturerReader = func() (io.Reader, error) {
google.golang.org/grpc/encoding
encoding.go#L44: Decompress(r io.Reader) (io.Reader, error)
google.golang.org/grpc/internal/transport
http_util.go#L591: var r io.Reader = conn
transport.go#L249: trReader io.Reader
transport.go#L474: reader io.Reader
gopkg.in/yaml.v2
apic.go#L66: func yaml_parser_set_input_reader(parser *yaml_parser_t, r io.Reader) {
decode.go#L56: func newParserFromReader(r io.Reader) *parser {
yaml.go#L102: func NewDecoder(r io.Reader) *Decoder {
yamlh.go#L546: input_reader io.Reader // File input data.
image
format.go#L21: decode func(io.Reader) (Image, error)
format.go#L22: decodeConfig func(io.Reader) (Config, error)
format.go#L37: func RegisterFormat(name, magic string, decode func(io.Reader) (Image, error), decodeConfig func(io.Reader) (Config, error)) {
format.go#L46: io.Reader
format.go#L51: func asReader(r io.Reader) reader {
format.go#L87: func Decode(r io.Reader) (Image, string, error) {
format.go#L101: func DecodeConfig(r io.Reader) (Config, string, error) {
image/jpeg
reader.go#L96: io.Reader
reader.go#L109: r io.Reader
reader.go#L526: func (d *decoder) decode(r io.Reader, configOnly bool) (image.Image, error) {
reader.go#L777: func Decode(r io.Reader) (image.Image, error) {
reader.go#L784: func DecodeConfig(r io.Reader) (image.Config, error) {
mime
encodedword.go#L194: CharsetReader func(charset string, input io.Reader) (io.Reader, error)
mime/multipart
formdata.go#L168: io.Reader
multipart.go#L48: r io.Reader
multipart.go#L94: func NewReader(r io.Reader, boundary string) *Reader {
multipart.go#L111: r io.Reader
mime/quotedprintable
reader.go#L24: func NewReader(r io.Reader) *Reader {
net
net.go#L653: func genericReadFrom(w io.Writer, r io.Reader) (n int64, err error) {
net.go#L696: _ io.Reader = (*Buffers)(nil)
nss.go#L78: func parseNSSConf(r io.Reader) *nssConf {
parse.go#L347: func readFull(r io.Reader) (all []byte, err error) {
sendfile_stub.go#L11: func sendFile(c *netFD, r io.Reader) (n int64, err error, handled bool) {
splice_stub.go#L11: func splice(c *netFD, r io.Reader) (int64, error, bool) {
tcpsock.go#L99: 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#L824: func Post(url, contentType string, body io.Reader) (resp *Response, err error) {
client.go#L839: 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#L1470: func http2ReadFrameHeader(r io.Reader) (http2FrameHeader, error) {
h2_bundle.go#L1476: func http2readFrameHeader(buf []byte, r io.Reader) (http2FrameHeader, error) {
h2_bundle.go#L1506: r io.Reader
h2_bundle.go#L1668: func http2NewFramer(w io.Writer, r io.Reader) *http2Framer {
h2_bundle.go#L3480: io.Reader
h2_bundle.go#L7811: func (cs *http2clientStream) writeRequestBody(body io.Reader, bodyCloser io.Closer) (err error) {
h2_bundle.go#L9103: func (t *http2Transport) getBodyWriterState(cs *http2clientStream, body io.Reader) (s http2bodyWriterState) {
request.go#L827: func NewRequest(method, url string, body io.Reader) (*Request, error) {
request.go#L853: func NewRequestWithContext(ctx context.Context, method, url string, body io.Reader) (*Request, error) {
request.go#L1201: var reader io.Reader = r.Body
response.go#L281: io.Reader
server.go#L567: func (w *response) ReadFrom(src io.Reader) (n int64, err error) {
server.go#L837: func newBufioReader(r io.Reader) *bufio.Reader {
transfer.go#L60: Body io.Reader
transfer.go#L206: go func(body io.Reader) {
transfer.go#L408: func (t *transferWriter) doBodyCopy(dst io.Writer, src io.Reader) (n int64, err error) {
transfer.go#L421: func (t *transferWriter) unwrapBody() io.Reader {
transfer.go#L423: return reflect.ValueOf(t.Body).Field(0).Interface().(io.Reader)
transfer.go#L809: src io.Reader
transfer.go#L1082: func isKnownInMemoryReader(r io.Reader) bool {
transfer.go#L1088: return isKnownInMemoryReader(reflect.ValueOf(r).Field(0).Interface().(io.Reader))
transport.go#L1767: 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#L417: func (p *ReverseProxy) copyResponse(dst io.Writer, src io.Reader, flushInterval time.Duration) error {
reverseproxy.go#L445: 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#L148: func (f *File) ReadFrom(r io.Reader) (n int64, err error) {
file.go#L159: func genericReadFrom(f *File, r io.Reader) (int64, error) {
readfrom_stub.go#L11: func (f *File) readFrom(r io.Reader) (n int64, handled bool, err error) {
os/exec
exec.go#L98: Stdin io.Reader
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 {
 |
The pages are generated with Golds v0.3.2-preview. (GOOS=darwin 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 @Go100and1 (reachable from the left QR code) to get the latest news of Golds. |