_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q167700 | WriteTo | validation | func (u *URI) WriteTo(w io.Writer) (int64, error) {
n, err := w.Write(u.FullURI())
return int64(n), err
} | go | {
"resource": ""
} |
q167701 | NewWriter | validation | func NewWriter(dstW io.Writer, newWriter NewWriterFunc) Writer {
w := &writer{
dstW: dstW,
}
w.zw = newWriter(&w.xw)
return w
} | go | {
"resource": ""
} |
q167702 | NewPipeConns | validation | func NewPipeConns() *PipeConns {
ch1 := make(chan *byteBuffer, 4)
ch2 := make(chan *byteBuffer, 4)
pc := &PipeConns{
stopCh: make(chan struct{}),
}
pc.c1.rCh = ch1
pc.c1.wCh = ch2
pc.c2.rCh = ch2
pc.c2.wCh = ch1
pc.c1.pc = pc
pc.c2.pc = pc
return pc
} | go | {
"resource": ""
} |
q167703 | Close | validation | func (pc *PipeConns) Close() error {
pc.stopChLock.Lock()
select {
case <-pc.stopCh:
default:
close(pc.stopCh)
}
pc.stopChLock.Unlock()
return nil
} | go | {
"resource": ""
} |
q167704 | LastUseTime | validation | func (c *HostClient) LastUseTime() time.Time {
n := atomic.LoadUint32(&c.lastUseTime)
return time.Unix(startTimeUnix+int64(n), 0)
} | go | {
"resource": ""
} |
q167705 | AcquireRequest | validation | func AcquireRequest() *Request {
v := requestPool.Get()
if v == nil {
return &Request{}
}
return v.(*Request)
} | go | {
"resource": ""
} |
q167706 | AcquireResponse | validation | func AcquireResponse() *Response {
v := responsePool.Get()
if v == nil {
return &Response{}
}
return v.(*Response)
} | go | {
"resource": ""
} |
q167707 | DoDeadline | validation | func (cc *LBClient) DoDeadline(req *Request, resp *Response, deadline time.Time) error {
return cc.get().DoDeadline(req, resp, deadline)
} | go | {
"resource": ""
} |
q167708 | DoTimeout | validation | func (cc *LBClient) DoTimeout(req *Request, resp *Response, timeout time.Duration) error {
deadline := time.Now().Add(timeout)
return cc.get().DoDeadline(req, resp, deadline)
} | go | {
"resource": ""
} |
q167709 | Do | validation | func (cc *LBClient) Do(req *Request, resp *Response) error {
timeout := cc.Timeout
if timeout <= 0 {
timeout = DefaultLBClientTimeout
}
return cc.DoTimeout(req, resp, timeout)
} | go | {
"resource": ""
} |
q167710 | Serve | validation | func Serve(ln net.Listener, handler RequestHandler) error {
s := &Server{
Handler: handler,
}
return s.Serve(ln)
} | go | {
"resource": ""
} |
q167711 | ServeTLS | validation | func ServeTLS(ln net.Listener, certFile, keyFile string, handler RequestHandler) error {
s := &Server{
Handler: handler,
}
return s.ServeTLS(ln, certFile, keyFile)
} | go | {
"resource": ""
} |
q167712 | ServeTLSEmbed | validation | func ServeTLSEmbed(ln net.Listener, certData, keyData []byte, handler RequestHandler) error {
s := &Server{
Handler: handler,
}
return s.ServeTLSEmbed(ln, certData, keyData)
} | go | {
"resource": ""
} |
q167713 | ListenAndServe | validation | func ListenAndServe(addr string, handler RequestHandler) error {
s := &Server{
Handler: handler,
}
return s.ListenAndServe(addr)
} | go | {
"resource": ""
} |
q167714 | ListenAndServeUNIX | validation | func ListenAndServeUNIX(addr string, mode os.FileMode, handler RequestHandler) error {
s := &Server{
Handler: handler,
}
return s.ListenAndServeUNIX(addr, mode)
} | go | {
"resource": ""
} |
q167715 | ListenAndServeTLS | validation | func ListenAndServeTLS(addr, certFile, keyFile string, handler RequestHandler) error {
s := &Server{
Handler: handler,
}
return s.ListenAndServeTLS(addr, certFile, keyFile)
} | go | {
"resource": ""
} |
q167716 | ListenAndServeTLSEmbed | validation | func ListenAndServeTLSEmbed(addr string, certData, keyData []byte, handler RequestHandler) error {
s := &Server{
Handler: handler,
}
return s.ListenAndServeTLSEmbed(addr, certData, keyData)
} | go | {
"resource": ""
} |
q167717 | TimeoutHandler | validation | func TimeoutHandler(h RequestHandler, timeout time.Duration, msg string) RequestHandler {
if timeout <= 0 {
return h
}
return func(ctx *RequestCtx) {
concurrencyCh := ctx.s.concurrencyCh
select {
case concurrencyCh <- struct{}{}:
default:
ctx.Error(msg, StatusTooManyRequests)
return
}
ch := ctx... | go | {
"resource": ""
} |
q167718 | TLSConnectionState | validation | func (ctx *RequestCtx) TLSConnectionState() *tls.ConnectionState {
tlsConn, ok := ctx.c.(connTLSer)
if !ok {
return nil
}
state := tlsConn.ConnectionState()
return &state
} | go | {
"resource": ""
} |
q167719 | String | validation | func (ctx *RequestCtx) String() string {
return fmt.Sprintf("#%016X - %s<->%s - %s %s", ctx.ID(), ctx.LocalAddr(), ctx.RemoteAddr(), ctx.Request.Header.Method(), ctx.URI().FullURI())
} | go | {
"resource": ""
} |
q167720 | SetContentType | validation | func (ctx *RequestCtx) SetContentType(contentType string) {
ctx.Response.Header.SetContentType(contentType)
} | go | {
"resource": ""
} |
q167721 | SetContentTypeBytes | validation | func (ctx *RequestCtx) SetContentTypeBytes(contentType []byte) {
ctx.Response.Header.SetContentTypeBytes(contentType)
} | go | {
"resource": ""
} |
q167722 | FormFile | validation | func (ctx *RequestCtx) FormFile(key string) (*multipart.FileHeader, error) {
mf, err := ctx.MultipartForm()
if err != nil {
return nil, err
}
if mf.File == nil {
return nil, err
}
fhh := mf.File[key]
if fhh == nil {
return nil, ErrMissingFile
}
return fhh[0], nil
} | go | {
"resource": ""
} |
q167723 | SaveMultipartFile | validation | func SaveMultipartFile(fh *multipart.FileHeader, path string) error {
f, err := fh.Open()
if err != nil {
return err
}
if ff, ok := f.(*os.File); ok {
// Windows can't rename files that are opened.
if err := f.Close(); err != nil {
return err
}
// If renaming fails we try the normal copying method.
... | go | {
"resource": ""
} |
q167724 | RemoteAddr | validation | func (ctx *RequestCtx) RemoteAddr() net.Addr {
if ctx.c == nil {
return zeroTCPAddr
}
addr := ctx.c.RemoteAddr()
if addr == nil {
return zeroTCPAddr
}
return addr
} | go | {
"resource": ""
} |
q167725 | Error | validation | func (ctx *RequestCtx) Error(msg string, statusCode int) {
ctx.Response.Reset()
ctx.SetStatusCode(statusCode)
ctx.SetContentTypeBytes(defaultContentType)
ctx.SetBodyString(msg)
} | go | {
"resource": ""
} |
q167726 | Success | validation | func (ctx *RequestCtx) Success(contentType string, body []byte) {
ctx.SetContentType(contentType)
ctx.SetBody(body)
} | go | {
"resource": ""
} |
q167727 | SuccessString | validation | func (ctx *RequestCtx) SuccessString(contentType, body string) {
ctx.SetContentType(contentType)
ctx.SetBodyString(body)
} | go | {
"resource": ""
} |
q167728 | IfModifiedSince | validation | func (ctx *RequestCtx) IfModifiedSince(lastModified time.Time) bool {
ifModStr := ctx.Request.Header.peek(strIfModifiedSince)
if len(ifModStr) == 0 {
return true
}
ifMod, err := ParseHTTPDate(ifModStr)
if err != nil {
return true
}
lastModified = lastModified.Truncate(time.Second)
return ifMod.Before(lastMo... | go | {
"resource": ""
} |
q167729 | NotFound | validation | func (ctx *RequestCtx) NotFound() {
ctx.Response.Reset()
ctx.SetStatusCode(StatusNotFound)
ctx.SetBodyString("404 Page not found")
} | go | {
"resource": ""
} |
q167730 | Write | validation | func (ctx *RequestCtx) Write(p []byte) (int, error) {
ctx.Response.AppendBody(p)
return len(p), nil
} | go | {
"resource": ""
} |
q167731 | WriteString | validation | func (ctx *RequestCtx) WriteString(s string) (int, error) {
ctx.Response.AppendBodyString(s)
return len(s), nil
} | go | {
"resource": ""
} |
q167732 | Logger | validation | func (ctx *RequestCtx) Logger() Logger {
if ctx.logger.ctx == nil {
ctx.logger.ctx = ctx
}
if ctx.logger.logger == nil {
ctx.logger.logger = ctx.s.logger()
}
return &ctx.logger
} | go | {
"resource": ""
} |
q167733 | NextProto | validation | func (s *Server) NextProto(key string, nph ServeHandler) {
if s.nextProtos == nil {
s.nextProtos = make(map[string]ServeHandler)
}
s.configTLS()
s.tlsConfig.NextProtos = append(s.tlsConfig.NextProtos, key)
s.nextProtos[key] = nph
} | go | {
"resource": ""
} |
q167734 | ListenAndServe | validation | func (s *Server) ListenAndServe(addr string) error {
ln, err := net.Listen("tcp4", addr)
if err != nil {
return err
}
if s.TCPKeepalive {
if tcpln, ok := ln.(*net.TCPListener); ok {
return s.Serve(tcpKeepaliveListener{
TCPListener: tcpln,
keepalivePeriod: s.TCPKeepalivePeriod,
})
}
}
retur... | go | {
"resource": ""
} |
q167735 | ListenAndServeUNIX | validation | func (s *Server) ListenAndServeUNIX(addr string, mode os.FileMode) error {
if err := os.Remove(addr); err != nil && !os.IsNotExist(err) {
return fmt.Errorf("unexpected error when trying to remove unix socket file %q: %s", addr, err)
}
ln, err := net.Listen("unix", addr)
if err != nil {
return err
}
if err = o... | go | {
"resource": ""
} |
q167736 | ListenAndServeTLS | validation | func (s *Server) ListenAndServeTLS(addr, certFile, keyFile string) error {
ln, err := net.Listen("tcp4", addr)
if err != nil {
return err
}
if s.TCPKeepalive {
if tcpln, ok := ln.(*net.TCPListener); ok {
return s.ServeTLS(tcpKeepaliveListener{
TCPListener: tcpln,
keepalivePeriod: s.TCPKeepalivePe... | go | {
"resource": ""
} |
q167737 | ListenAndServeTLSEmbed | validation | func (s *Server) ListenAndServeTLSEmbed(addr string, certData, keyData []byte) error {
ln, err := net.Listen("tcp4", addr)
if err != nil {
return err
}
if s.TCPKeepalive {
if tcpln, ok := ln.(*net.TCPListener); ok {
return s.ServeTLSEmbed(tcpKeepaliveListener{
TCPListener: tcpln,
keepalivePeriod:... | go | {
"resource": ""
} |
q167738 | ServeTLS | validation | func (s *Server) ServeTLS(ln net.Listener, certFile, keyFile string) error {
err := s.AppendCert(certFile, keyFile)
if err != nil && err != errNoCertOrKeyProvided {
return err
}
if s.tlsConfig == nil {
return errNoCertOrKeyProvided
}
s.tlsConfig.BuildNameToCertificate()
return s.Serve(
tls.NewListener(ln,... | go | {
"resource": ""
} |
q167739 | ServeTLSEmbed | validation | func (s *Server) ServeTLSEmbed(ln net.Listener, certData, keyData []byte) error {
err := s.AppendCertEmbed(certData, keyData)
if err != nil && err != errNoCertOrKeyProvided {
return err
}
if s.tlsConfig == nil {
return errNoCertOrKeyProvided
}
s.tlsConfig.BuildNameToCertificate()
return s.Serve(
tls.NewLi... | go | {
"resource": ""
} |
q167740 | AppendCertEmbed | validation | func (s *Server) AppendCertEmbed(certData, keyData []byte) error {
if len(certData) == 0 && len(keyData) == 0 {
return errNoCertOrKeyProvided
}
cert, err := tls.X509KeyPair(certData, keyData)
if err != nil {
return fmt.Errorf("cannot load TLS key pair from the provided certData(%d) and keyData(%d): %s",
len... | go | {
"resource": ""
} |
q167741 | Serve | validation | func (s *Server) Serve(ln net.Listener) error {
var lastOverflowErrorTime time.Time
var lastPerIPErrorTime time.Time
var c net.Conn
var err error
s.mu.Lock()
{
if s.ln != nil {
s.mu.Unlock()
return ErrAlreadyServing
}
s.ln = ln
s.done = make(chan struct{})
}
s.mu.Unlock()
maxWorkersCount := s.... | go | {
"resource": ""
} |
q167742 | Shutdown | validation | func (s *Server) Shutdown() error {
s.mu.Lock()
defer s.mu.Unlock()
atomic.StoreInt32(&s.stop, 1)
defer atomic.StoreInt32(&s.stop, 0)
if s.ln == nil {
return nil
}
if err := s.ln.Close(); err != nil {
return err
}
if s.done != nil {
close(s.done)
}
// Closing the listener will make Serve() call St... | go | {
"resource": ""
} |
q167743 | WriteGzip | validation | func WriteGzip(w io.Writer, p []byte) (int, error) {
return WriteGzipLevel(w, p, CompressDefaultCompression)
} | go | {
"resource": ""
} |
q167744 | WriteGunzip | validation | func WriteGunzip(w io.Writer, p []byte) (int, error) {
r := &byteSliceReader{p}
zr, err := acquireGzipReader(r)
if err != nil {
return 0, err
}
n, err := copyZeroAlloc(w, zr)
releaseGzipReader(zr)
nn := int(n)
if int64(nn) != n {
return 0, fmt.Errorf("too much data gunzipped: %d", n)
}
return nn, err
} | go | {
"resource": ""
} |
q167745 | AppendGunzipBytes | validation | func AppendGunzipBytes(dst, src []byte) ([]byte, error) {
w := &byteSliceWriter{dst}
_, err := WriteGunzip(w, src)
return w.b, err
} | go | {
"resource": ""
} |
q167746 | WriteDeflate | validation | func WriteDeflate(w io.Writer, p []byte) (int, error) {
return WriteDeflateLevel(w, p, CompressDefaultCompression)
} | go | {
"resource": ""
} |
q167747 | WriteInflate | validation | func WriteInflate(w io.Writer, p []byte) (int, error) {
r := &byteSliceReader{p}
zr, err := acquireFlateReader(r)
if err != nil {
return 0, err
}
n, err := copyZeroAlloc(w, zr)
releaseFlateReader(zr)
nn := int(n)
if int64(nn) != n {
return 0, fmt.Errorf("too much data inflated: %d", n)
}
return nn, err
} | go | {
"resource": ""
} |
q167748 | AppendInflateBytes | validation | func AppendInflateBytes(dst, src []byte) ([]byte, error) {
w := &byteSliceWriter{dst}
_, err := WriteInflate(w, src)
return w.b, err
} | go | {
"resource": ""
} |
q167749 | SetRequestURI | validation | func (req *Request) SetRequestURI(requestURI string) {
req.Header.SetRequestURI(requestURI)
req.parsedURI = false
} | go | {
"resource": ""
} |
q167750 | SetRequestURIBytes | validation | func (req *Request) SetRequestURIBytes(requestURI []byte) {
req.Header.SetRequestURIBytes(requestURI)
req.parsedURI = false
} | go | {
"resource": ""
} |
q167751 | RequestURI | validation | func (req *Request) RequestURI() []byte {
if req.parsedURI {
requestURI := req.uri.RequestURI()
req.SetRequestURIBytes(requestURI)
}
return req.Header.RequestURI()
} | go | {
"resource": ""
} |
q167752 | SendFile | validation | func (resp *Response) SendFile(path string) error {
f, err := os.Open(path)
if err != nil {
return err
}
fileInfo, err := f.Stat()
if err != nil {
f.Close()
return err
}
size64 := fileInfo.Size()
size := int(size64)
if int64(size) != size64 {
size = -1
}
resp.Header.SetLastModified(fileInfo.ModTime(... | go | {
"resource": ""
} |
q167753 | BodyWriter | validation | func (resp *Response) BodyWriter() io.Writer {
resp.w.r = resp
return &resp.w
} | go | {
"resource": ""
} |
q167754 | BodyWriter | validation | func (req *Request) BodyWriter() io.Writer {
req.w.r = req
return &req.w
} | go | {
"resource": ""
} |
q167755 | Body | validation | func (resp *Response) Body() []byte {
if resp.bodyStream != nil {
bodyBuf := resp.bodyBuffer()
bodyBuf.Reset()
_, err := copyZeroAlloc(bodyBuf, resp.bodyStream)
resp.closeBodyStream()
if err != nil {
bodyBuf.SetString(err.Error())
}
}
return resp.bodyBytes()
} | go | {
"resource": ""
} |
q167756 | BodyWriteTo | validation | func (req *Request) BodyWriteTo(w io.Writer) error {
if req.bodyStream != nil {
_, err := copyZeroAlloc(w, req.bodyStream)
req.closeBodyStream()
return err
}
if req.onlyMultipartForm() {
return WriteMultipartForm(w, req.multipartForm, req.multipartFormBoundary)
}
_, err := w.Write(req.bodyBytes())
return ... | go | {
"resource": ""
} |
q167757 | BodyWriteTo | validation | func (resp *Response) BodyWriteTo(w io.Writer) error {
if resp.bodyStream != nil {
_, err := copyZeroAlloc(w, resp.bodyStream)
resp.closeBodyStream()
return err
}
_, err := w.Write(resp.bodyBytes())
return err
} | go | {
"resource": ""
} |
q167758 | AppendBodyString | validation | func (resp *Response) AppendBodyString(s string) {
resp.closeBodyStream()
resp.bodyBuffer().WriteString(s)
} | go | {
"resource": ""
} |
q167759 | SetBodyString | validation | func (resp *Response) SetBodyString(body string) {
resp.closeBodyStream()
bodyBuf := resp.bodyBuffer()
bodyBuf.Reset()
bodyBuf.WriteString(body)
} | go | {
"resource": ""
} |
q167760 | ResetBody | validation | func (resp *Response) ResetBody() {
resp.bodyRaw = nil
resp.closeBodyStream()
if resp.body != nil {
if resp.keepBodyBuffer {
resp.body.Reset()
} else {
responseBodyPool.Put(resp.body)
resp.body = nil
}
}
} | go | {
"resource": ""
} |
q167761 | SetBodyRaw | validation | func (resp *Response) SetBodyRaw(body []byte) {
resp.ResetBody()
resp.bodyRaw = body
} | go | {
"resource": ""
} |
q167762 | ReleaseBody | validation | func (resp *Response) ReleaseBody(size int) {
resp.bodyRaw = nil
if cap(resp.body.B) > size {
resp.closeBodyStream()
resp.body = nil
}
} | go | {
"resource": ""
} |
q167763 | ReleaseBody | validation | func (req *Request) ReleaseBody(size int) {
if cap(req.body.B) > size {
req.closeBodyStream()
req.body = nil
}
} | go | {
"resource": ""
} |
q167764 | SwapBody | validation | func (resp *Response) SwapBody(body []byte) []byte {
bb := resp.bodyBuffer()
if resp.bodyStream != nil {
bb.Reset()
_, err := copyZeroAlloc(bb, resp.bodyStream)
resp.closeBodyStream()
if err != nil {
bb.Reset()
bb.SetString(err.Error())
}
}
resp.bodyRaw = nil
oldBody := bb.B
bb.B = body
return... | go | {
"resource": ""
} |
q167765 | SwapBody | validation | func (req *Request) SwapBody(body []byte) []byte {
bb := req.bodyBuffer()
if req.bodyStream != nil {
bb.Reset()
_, err := copyZeroAlloc(bb, req.bodyStream)
req.closeBodyStream()
if err != nil {
bb.Reset()
bb.SetString(err.Error())
}
}
oldBody := bb.B
bb.B = body
return oldBody
} | go | {
"resource": ""
} |
q167766 | Body | validation | func (req *Request) Body() []byte {
if req.bodyStream != nil {
bodyBuf := req.bodyBuffer()
bodyBuf.Reset()
_, err := copyZeroAlloc(bodyBuf, req.bodyStream)
req.closeBodyStream()
if err != nil {
bodyBuf.SetString(err.Error())
}
} else if req.onlyMultipartForm() {
body, err := marshalMultipartForm(req.... | go | {
"resource": ""
} |
q167767 | AppendBodyString | validation | func (req *Request) AppendBodyString(s string) {
req.RemoveMultipartFormFiles()
req.closeBodyStream()
req.bodyBuffer().WriteString(s)
} | go | {
"resource": ""
} |
q167768 | SetBodyString | validation | func (req *Request) SetBodyString(body string) {
req.RemoveMultipartFormFiles()
req.closeBodyStream()
req.bodyBuffer().SetString(body)
} | go | {
"resource": ""
} |
q167769 | ResetBody | validation | func (req *Request) ResetBody() {
req.RemoveMultipartFormFiles()
req.closeBodyStream()
if req.body != nil {
if req.keepBodyBuffer {
req.body.Reset()
} else {
requestBodyPool.Put(req.body)
req.body = nil
}
}
} | go | {
"resource": ""
} |
q167770 | CopyTo | validation | func (req *Request) CopyTo(dst *Request) {
req.copyToSkipBody(dst)
if req.body != nil {
dst.bodyBuffer().Set(req.body.B)
} else if dst.body != nil {
dst.body.Reset()
}
} | go | {
"resource": ""
} |
q167771 | CopyTo | validation | func (resp *Response) CopyTo(dst *Response) {
resp.copyToSkipBody(dst)
if resp.bodyRaw != nil {
dst.bodyRaw = resp.bodyRaw
if dst.body != nil {
dst.body.Reset()
}
} else if resp.body != nil {
dst.bodyBuffer().Set(resp.body.B)
} else if dst.body != nil {
dst.body.Reset()
}
} | go | {
"resource": ""
} |
q167772 | WriteMultipartForm | validation | func WriteMultipartForm(w io.Writer, f *multipart.Form, boundary string) error {
// Do not care about memory allocations here, since multipart
// form processing is slow.
if len(boundary) == 0 {
panic("BUG: form boundary cannot be empty")
}
mw := multipart.NewWriter(w)
if err := mw.SetBoundary(boundary); err !... | go | {
"resource": ""
} |
q167773 | Reset | validation | func (resp *Response) Reset() {
resp.Header.Reset()
resp.resetSkipHeader()
resp.SkipBody = false
resp.raddr = nil
resp.laddr = nil
} | go | {
"resource": ""
} |
q167774 | ReadLimitBody | validation | func (resp *Response) ReadLimitBody(r *bufio.Reader, maxBodySize int) error {
resp.resetSkipHeader()
err := resp.Header.Read(r)
if err != nil {
return err
}
if resp.Header.StatusCode() == StatusContinue {
// Read the next response according to http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html .
if err = ... | go | {
"resource": ""
} |
q167775 | WriteTo | validation | func (req *Request) WriteTo(w io.Writer) (int64, error) {
return writeBufio(req, w)
} | go | {
"resource": ""
} |
q167776 | WriteTo | validation | func (resp *Response) WriteTo(w io.Writer) (int64, error) {
return writeBufio(resp, w)
} | go | {
"resource": ""
} |
q167777 | Write | validation | func (req *Request) Write(w *bufio.Writer) error {
if len(req.Header.Host()) == 0 || req.parsedURI {
uri := req.URI()
host := uri.Host()
if len(host) == 0 {
return errRequestHostRequired
}
req.Header.SetHostBytes(host)
req.Header.SetRequestURIBytes(uri.RequestURI())
}
if req.bodyStream != nil {
ret... | go | {
"resource": ""
} |
q167778 | Write | validation | func (resp *Response) Write(w *bufio.Writer) error {
sendBody := !resp.mustSkipBody()
if resp.bodyStream != nil {
return resp.writeBodyStream(w, sendBody)
}
body := resp.bodyBytes()
bodyLen := len(body)
if sendBody || bodyLen > 0 {
resp.Header.SetContentLength(bodyLen)
}
if err := resp.Header.Write(w); er... | go | {
"resource": ""
} |
q167779 | SetLastModified | validation | func (h *ResponseHeader) SetLastModified(t time.Time) {
h.bufKV.value = AppendHTTPDate(h.bufKV.value[:0], t)
h.SetCanonical(strLastModified, h.bufKV.value)
} | go | {
"resource": ""
} |
q167780 | PeekCookie | validation | func (h *ResponseHeader) PeekCookie(key string) []byte {
return peekArgStr(h.cookies, key)
} | go | {
"resource": ""
} |
q167781 | ContentType | validation | func (h *ResponseHeader) ContentType() []byte {
contentType := h.contentType
if !h.noDefaultContentType && len(h.contentType) == 0 {
contentType = defaultContentType
}
return contentType
} | go | {
"resource": ""
} |
q167782 | SetServer | validation | func (h *ResponseHeader) SetServer(server string) {
h.server = append(h.server[:0], server...)
} | go | {
"resource": ""
} |
q167783 | SetServerBytes | validation | func (h *ResponseHeader) SetServerBytes(server []byte) {
h.server = append(h.server[:0], server...)
} | go | {
"resource": ""
} |
q167784 | Host | validation | func (h *RequestHeader) Host() []byte {
if len(h.host) > 0 {
return h.host
}
if !h.rawHeadersParsed {
// fast path without employing full headers parsing.
host := peekRawHeader(h.rawHeaders, strHost)
if len(host) > 0 {
h.host = append(h.host[:0], host...)
return h.host
}
}
// slow path.
h.parseRa... | go | {
"resource": ""
} |
q167785 | SetHost | validation | func (h *RequestHeader) SetHost(host string) {
h.parseRawHeaders()
h.host = append(h.host[:0], host...)
} | go | {
"resource": ""
} |
q167786 | SetHostBytes | validation | func (h *RequestHeader) SetHostBytes(host []byte) {
h.parseRawHeaders()
h.host = append(h.host[:0], host...)
} | go | {
"resource": ""
} |
q167787 | SetUserAgent | validation | func (h *RequestHeader) SetUserAgent(userAgent string) {
h.parseRawHeaders()
h.userAgent = append(h.userAgent[:0], userAgent...)
} | go | {
"resource": ""
} |
q167788 | SetUserAgentBytes | validation | func (h *RequestHeader) SetUserAgentBytes(userAgent []byte) {
h.parseRawHeaders()
h.userAgent = append(h.userAgent[:0], userAgent...)
} | go | {
"resource": ""
} |
q167789 | Method | validation | func (h *RequestHeader) Method() []byte {
if len(h.method) == 0 {
return strGet
}
return h.method
} | go | {
"resource": ""
} |
q167790 | SetMethod | validation | func (h *RequestHeader) SetMethod(method string) {
h.method = append(h.method[:0], method...)
} | go | {
"resource": ""
} |
q167791 | SetMethodBytes | validation | func (h *RequestHeader) SetMethodBytes(method []byte) {
h.method = append(h.method[:0], method...)
} | go | {
"resource": ""
} |
q167792 | RequestURI | validation | func (h *RequestHeader) RequestURI() []byte {
requestURI := h.requestURI
if len(requestURI) == 0 {
requestURI = strSlash
}
return requestURI
} | go | {
"resource": ""
} |
q167793 | SetRequestURI | validation | func (h *RequestHeader) SetRequestURI(requestURI string) {
h.requestURI = append(h.requestURI[:0], requestURI...)
} | go | {
"resource": ""
} |
q167794 | SetRequestURIBytes | validation | func (h *RequestHeader) SetRequestURIBytes(requestURI []byte) {
h.requestURI = append(h.requestURI[:0], requestURI...)
} | go | {
"resource": ""
} |
q167795 | HasAcceptEncoding | validation | func (h *RequestHeader) HasAcceptEncoding(acceptEncoding string) bool {
h.bufKV.value = append(h.bufKV.value[:0], acceptEncoding...)
return h.HasAcceptEncodingBytes(h.bufKV.value)
} | go | {
"resource": ""
} |
q167796 | HasAcceptEncodingBytes | validation | func (h *RequestHeader) HasAcceptEncodingBytes(acceptEncoding []byte) bool {
ae := h.peek(strAcceptEncoding)
n := bytes.Index(ae, acceptEncoding)
if n < 0 {
return false
}
b := ae[n+len(acceptEncoding):]
if len(b) > 0 && b[0] != ',' {
return false
}
if n == 0 {
return true
}
return ae[n-1] == ' '
} | go | {
"resource": ""
} |
q167797 | Len | validation | func (h *ResponseHeader) Len() int {
n := 0
h.VisitAll(func(k, v []byte) { n++ })
return n
} | go | {
"resource": ""
} |
q167798 | Reset | validation | func (h *ResponseHeader) Reset() {
h.disableNormalizing = false
h.noDefaultContentType = false
h.resetSkipNormalize()
} | go | {
"resource": ""
} |
q167799 | SetCookie | validation | func (h *ResponseHeader) SetCookie(cookie *Cookie) {
h.cookies = setArgBytes(h.cookies, cookie.Key(), cookie.Cookie(), argsHasValue)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.