id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c14200 | lf,
initializedLEDs: map[string]LED{},
}
} | |
c14201 | sep += i
if sep == 0 || s[sep-1] != '\\' {
return sep
}
}
} | |
c14202 |
opt.f(&e)
}
return process(out, in, e.runCommand)
} | |
c14203 |
return Option{func(e *embedder) { e.baseDir = path }}
} | |
c14204 |
return Option{func(e *embedder) { e.Fetcher = c }}
} | |
c14205 |
return err
}
return e.encodeHeader(typ)
} | |
c14206 | h := range header {
m[h] = i
}
return &Decoder{
r: r,
header: header,
hmap: m,
unused: make([]int, 0, len(header)),
}, nil
} | |
c14207 | make([]string, len(d.header))
copy(header, d.header)
return header
} | |
c14208 | nil
}
indices := make([]int, len(d.unused))
copy(indices, d.unused)
return indices
} | |
c14209 | {
close(l.done)
<-l.rmvd
})
return nil
} | |
c14210 | in the future.
if dur := time.Until(t); dur > 0 {
if closed {
d.cancel = make(chan struct{})
}
d.timer = time.AfterFunc(dur, func() {
close(d.cancel)
})
return
}
// Time in the past, so close immediately.
if !closed {
close(d.cancel)
}
} | |
c14211 | defer d.mu.Unlock()
return d.cancel
} | |
c14212 | wrTx: cb2, wrRx: cn2,
localDone: done1, remoteDone: done2,
readDeadline: makePipeDeadline(),
writeDeadline: makePipeDeadline(),
}
p2 := &pipe{
rdRx: cb2, rdTx: cn2,
wrTx: cb1, wrRx: cn1,
localDone: done2, remoteDone: done1,
readDeadline: makePipeDeadline(),
writeDeadline: makePipeDeadline(),
}
r... | |
c14213 | c.buf.configMu.RUnlock()
return c.buf.max
}
return 0
} | |
c14214 | {
c.buf.configMu.RLock()
defer c.buf.configMu.RUnlock()
return c.buf.closeTimeout
}
return 0
} | |
c14215 | {
c.buf.configMu.Lock()
defer c.buf.configMu.Unlock()
c.buf.closeTimeout = d
}
} | |
c14216 | defer c.buf.dataMu.Unlock()
for len(c.buf.dataN) > 0 {
c.buf.dataMu.Unlock()
c.buf.dataMu.Lock()
}
close(writesDone)
}()
// Wait to close the connection.
select {
case <-writesDone:
case <-timeoutDone:
}
}
close(c.pipe.localDone)
})
return nil
} | |
c14217 |
// concurrent access to the buffer.
c.buf.dataMu.Lock()
// Get the number of bytes to read.
n := c.buf.dataN[0]
c.buf.dataN = c.buf.dataN[1:]
// Read the bytes from the buffer into a temporary buffer.
b := make([]byte, n)
if nr, err := c.buf.data.Read(b); err != nil {
go func() { c.buf.errs <- err... | |
c14218 |
CacheSizeMax: 100 * 1024 * 1024, // 100MB
}),
}
} | |
c14219 |
return req.Method + " " + req.URL.String()
}
} | |
c14220 | := c.Get(cacheKey(req))
if !ok {
return
}
b := bytes.NewBuffer(cachedVal)
return http.ReadResponse(bufio.NewReader(b), req)
} | |
c14221 |
c.items[key] = resp
c.mu.Unlock()
} | |
c14222 | delete(c.items, key)
c.mu.Unlock()
} | |
c14223 | if header != "" && req.Header.Get(header) != cachedResp.Header.Get("X-Varied-"+header) {
return false
}
}
return true
} | |
c14224 | = ErrNoDateHeader
return
}
return time.Parse(time.RFC1123, dateHeader)
} | |
c14225 | err != nil {
return nil, err
}
return cache, nil
} | |
c14226 |
if c == 0x07 || c == '\n' {
break
}
title = append(title, c)
}
if len(title) > 0 {
title8, err := syscall.UTF16PtrFromString(string(title))
if err == nil {
procSetConsoleTitle.Call(uintptr(unsafe.Pointer(title8)))
}
}
return nil
} | |
c14227 | nil {
switch r := r.(type) {
case error:
err = r
case string:
err = errors.New(r)
default:
err = fmt.Errorf("%v", r)
}
}
}()
node = parseNode(lb, 0, nil)
return
} | |
c14228 | err = Parse(fin)
if err != nil {
return nil, err
}
return f, nil
} | |
c14229 | Parse(buf)
if err != nil {
panic(err)
}
return f
} | |
c14230 | err != nil {
panic(err)
}
return f
} | |
c14231 | spec,
Spec: spec,
Token: "$",
Expected: "yaml.Scalar",
Node: node,
}
}
return scalar.String(), nil
} | |
c14232 | spec,
Spec: spec,
Token: "$",
Expected: "yaml.List",
Node: node,
}
}
return lst.Len(), nil
} | |
c14233 | err := f.Get(spec)
if err != nil {
panic(err)
}
return str
} | |
c14234 | return node[idx]
}
return nil
} | |
c14235 |
node.write(buf, 0, 0)
return buf.String()
} | |
c14236 | have you tried turning it off and on again?", 404)
} | |
c14237 | DefaultMux.Insert(middleware, before)
} | |
c14238 | web.HandlerType) {
DefaultMux.Handle(pattern, handler)
} | |
c14239 | web.HandlerType) {
DefaultMux.Connect(pattern, handler)
} | |
c14240 | web.HandlerType) {
DefaultMux.Delete(pattern, handler)
} | |
c14241 | web.HandlerType) {
DefaultMux.Get(pattern, handler)
} | |
c14242 | web.HandlerType) {
DefaultMux.Head(pattern, handler)
} | |
c14243 | web.HandlerType) {
DefaultMux.Options(pattern, handler)
} | |
c14244 | web.HandlerType) {
DefaultMux.Patch(pattern, handler)
} | |
c14245 | web.HandlerType) {
DefaultMux.Post(pattern, handler)
} | |
c14246 | web.HandlerType) {
DefaultMux.Put(pattern, handler)
} | |
c14247 | web.HandlerType) {
DefaultMux.Trace(pattern, handler)
} | |
c14248 |
}
if reqID, ok := v.(string); ok {
return reqID
}
return ""
} | |
c14249 | *http.Request) {
if r.Method == "OPTIONS" {
w = &autoOptionsProxy{c: c, w: w}
}
h.ServeHTTP(w, r)
}
return http.HandlerFunc(fn)
} | |
c14250 | w http.ResponseWriter, r *http.Request) {
h(c, w, r)
} | |
c14251 | c.Env[URLQueryKey] = r.URL.Query()
h.ServeHTTP(w, r)
}
return http.HandlerFunc(fn)
} | |
c14252 |
return envInit{c, h}
} | |
c14253 | err := base64.StdEncoding.DecodeString(auth[6:])
if err != nil || string(password) != Password {
pleaseAuth(w)
return
}
h.ServeHTTP(w, r)
}
return http.HandlerFunc(fn)
} | |
c14254 |
return "einhorn@0"
} else if usingSystemd() {
return "fd@3"
} else if port := os.Getenv("PORT"); port != "" {
return ":" + port
}
return ""
} | |
c14255 | err != nil {
log.Fatal(err)
}
return l
} | |
c14256 | _, rf := w.(io.ReaderFrom)
bw := basicWriter{ResponseWriter: w}
if cn && fl && hj && rf {
return &fancyWriter{bw}
}
if fl {
return &flushWriter{bw}
}
return &bw
} | |
c14257 |
shard := &t.shards[int(connID)%len(t.shards)]
wc := &conn{
Conn: c,
shard: shard,
mode: t.mode,
}
if err = wc.init(); err != nil {
return nil, err
}
return wc, nil
} | |
c14258 | false)
}
// Not sure if returning errors is actually useful here :/
return nil
} | |
c14259 | true)
}
for i := range t.shards {
t.shards[i].wait()
}
return nil
} | |
c14260 | return cn.disown()
}
return errNotManaged
} | |
c14261 | c.(*conn); ok {
cn.markIdle()
return nil
}
return errNotManaged
} | |
c14262 | c.(*conn); ok {
cn.markInUse()
return nil
}
return errNotManaged
} | |
c14263 | "accept" consistently. It's platform independent.
// See https://github.com/golang/go/commit/b0f4ee533a875c258ac1030ee382f0ffe2de304b
case "AcceptEx":
fallthrough
case "accept":
if oe.Err.Error() == errClosing {
return nil
}
}
}
return err
} | |
c14264 | g.User,
g.Time.Format(time.UnixDate))
} | |
c14265 | (@%s)\n%s\n", u.Name, handle, u.Bio)
} | |
c14266 | notFound: parseHandler(http.NotFound),
},
}
mux.ms.router = &mux.rt
return &mux
} | |
c14267 | m.ms.alloc()
stack.ServeHTTPC(c, w, r)
m.ms.release(stack)
} | |
c14268 | HandlerType) {
m.rt.handleUntyped(pattern, mCONNECT, handler)
} | |
c14269 | HandlerType) {
m.rt.handleUntyped(pattern, mDELETE, handler)
} | |
c14270 | HandlerType) {
m.rt.handleUntyped(pattern, mHEAD, handler)
} | |
c14271 | HandlerType) {
m.rt.handleUntyped(pattern, mOPTIONS, handler)
} | |
c14272 | HandlerType) {
m.rt.handleUntyped(pattern, mPATCH, handler)
} | |
c14273 | HandlerType) {
m.rt.handleUntyped(pattern, mPOST, handler)
} | |
c14274 | HandlerType) {
m.rt.handleUntyped(pattern, mPUT, handler)
} | |
c14275 | HandlerType) {
m.rt.handleUntyped(pattern, mTRACE, handler)
} | |
c14276 | {
flag.Parse()
}
ServeListener(tls.NewListener(bind.Default(), config))
} | |
c14277 | stopping") })
graceful.PostHook(func() { log.Printf("Goji stopped") })
err := graceful.Serve(listener, http.DefaultServeMux)
if err != nil {
log.Fatal(err)
}
graceful.Wait()
} | |
c14278 | }
fmt.Fprintf(buf, "\n%s:%d", file, line)
}
return buf.String()
} | |
c14279 | prefix,
router: router,
handlers: handlers,
}
} | |
c14280 | return rg.add("DELETE", path, handlers)
} | |
c14281 | len(h1)+len(h2))
copy(hh, h1)
copy(hh[len(h1):], h2)
return hh
} | |
c14282 | return
}
headers := c.Request.Header.Get(headerRequestHeaders)
opts.setPreflightHeaders(origin, method, headers, c.Response.Header())
c.Abort()
return
}
opts.setActualHeaders(origin, c.Response.Header())
return
}
} | |
c14283 | return r
}
if r.tags == nil {
r.tags = []interface{}{}
}
r.tags = append(r.tags, value)
return r
} | |
c14284 | r.group.add("GET", r.path, handlers)
} | |
c14285 | r.group.add("POST", r.path, handlers)
} | |
c14286 | r.group.add("PUT", r.path, handlers)
} | |
c14287 | r.group.add("PATCH", r.path, handlers)
} | |
c14288 | r.group.add("DELETE", r.path, handlers)
} | |
c14289 | r.group.add("CONNECT", r.path, handlers)
} | |
c14290 | r.group.add("HEAD", r.path, handlers)
} | |
c14291 | r.group.add("OPTIONS", r.path, handlers)
} | |
c14292 | r.group.add("TRACE", r.path, handlers)
} | |
c14293 | url.QueryEscape(fmt.Sprint(pairs[i+1]))
}
s = strings.Replace(s, name, value, -1)
}
return
} | |
c14294 |
return r.method + " " + r.group.prefix + r.path
} | |
c14295 | c := &Context{handlers: handlers}
c.init(res, req)
return c
} | |
c14296 | name {
return c.pvalues[i]
}
}
return ""
} | |
c14297 |
c.pnames = append(c.pnames, name)
c.pvalues = append(c.pvalues, value)
} | |
c14298 | make(map[string]interface{})
}
c.data[name] = value
} | |
c14299 | }
if len(defaultValue) > 0 {
return defaultValue[0]
}
return ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.