_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q14200 | NewLEDDriver | train | func NewLEDDriver(ledMap LEDMap, lf ledFactory) LEDDriver {
return &ledDriver{
ledMap: ledMap,
lf: lf,
initializedLEDs: map[string]LED{},
}
} | go | {
"resource": ""
} |
q14201 | nextSlash | train | func nextSlash(s string) int {
for sep := 0; ; sep++ {
i := strings.IndexByte(s[sep:], '/')
if i < 0 {
return -1
}
sep += i
if sep == 0 || s[sep-1] != '\\' {
return sep
}
}
} | go | {
"resource": ""
} |
q14202 | Process | train | func Process(out io.Writer, in io.Reader, opts ...Option) error {
e := embedder{Fetcher: fetcher{}}
for _, opt := range opts {
opt.f(&e)
}
return process(out, in, e.runCommand)
} | go | {
"resource": ""
} |
q14203 | WithBaseDir | train | func WithBaseDir(path string) Option {
return Option{func(e *embedder) { e.baseDir = path }}
} | go | {
"resource": ""
} |
q14204 | WithFetcher | train | func WithFetcher(c Fetcher) Option {
return Option{func(e *embedder) { e.Fetcher = c }}
} | go | {
"resource": ""
} |
q14205 | EncodeHeader | train | func (e *Encoder) EncodeHeader(v interface{}) error {
typ, err := valueType(v)
if err != nil {
return err
}
return e.encodeHeader(typ)
} | go | {
"resource": ""
} |
q14206 | NewDecoder | train | func NewDecoder(r Reader, header ...string) (dec *Decoder, err error) {
if len(header) == 0 {
header, err = r.Read()
if err != nil {
return nil, err
}
}
h := make([]string, len(header))
copy(h, header)
header = h
m := make(map[string]int, len(header))
for i, h := range header {
m[h] = i
}
return &Decoder{
r: r,
header: header,
hmap: m,
unused: make([]int, 0, len(header)),
}, nil
} | go | {
"resource": ""
} |
q14207 | Header | train | func (d *Decoder) Header() []string {
header := make([]string, len(d.header))
copy(header, d.header)
return header
} | go | {
"resource": ""
} |
q14208 | Unused | train | func (d *Decoder) Unused() []int {
if len(d.unused) == 0 {
return nil
}
indices := make([]int, len(d.unused))
copy(indices, d.unused)
return indices
} | go | {
"resource": ""
} |
q14209 | Close | train | func (l *Listener) Close() error {
l.once.Do(func() {
close(l.done)
<-l.rmvd
})
return nil
} | go | {
"resource": ""
} |
q14210 | set | train | func (d *pipeDeadline) set(t time.Time) {
d.mu.Lock()
defer d.mu.Unlock()
if d.timer != nil && !d.timer.Stop() {
<-d.cancel // Wait for the timer callback to finish and close cancel
}
d.timer = nil
// Time is zero, then there is no deadline.
closed := isClosedChan(d.cancel)
if t.IsZero() {
if closed {
d.cancel = make(chan struct{})
}
return
}
// Time in the future, setup a timer to cancel 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)
}
} | go | {
"resource": ""
} |
q14211 | wait | train | func (d *pipeDeadline) wait() chan struct{} {
d.mu.Lock()
defer d.mu.Unlock()
return d.cancel
} | go | {
"resource": ""
} |
q14212 | Pipe | train | func Pipe() (net.Conn, net.Conn) {
cb1 := make(chan []byte)
cb2 := make(chan []byte)
cn1 := make(chan int)
cn2 := make(chan int)
done1 := make(chan struct{})
done2 := make(chan struct{})
p1 := &pipe{
rdRx: cb1, rdTx: cn1,
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(),
}
return p1, p2
} | go | {
"resource": ""
} |
q14213 | BufferSize | train | func (c *Conn) BufferSize() int {
if c.laddr.Buffered() {
c.buf.configMu.RLock()
defer c.buf.configMu.RUnlock()
return c.buf.max
}
return 0
} | go | {
"resource": ""
} |
q14214 | CloseTimeout | train | func (c *Conn) CloseTimeout() time.Duration {
if c.laddr.Buffered() {
c.buf.configMu.RLock()
defer c.buf.configMu.RUnlock()
return c.buf.closeTimeout
}
return 0
} | go | {
"resource": ""
} |
q14215 | SetCloseTimeout | train | func (c *Conn) SetCloseTimeout(d time.Duration) {
if c.laddr.Buffered() {
c.buf.configMu.Lock()
defer c.buf.configMu.Unlock()
c.buf.closeTimeout = d
}
} | go | {
"resource": ""
} |
q14216 | Close | train | func (c *Conn) Close() error {
c.pipe.once.Do(func() {
// Buffered connections will attempt to wait until all
// pending Writes are completed or until the specified
// timeout value has elapsed.
if c.laddr.Buffered() {
// Set up a channel that is closed when the specified
// timer elapses.
timeout := c.CloseTimeout()
timeoutDone := make(chan struct{})
if timeout == 0 {
close(timeoutDone)
} else {
time.AfterFunc(timeout, func() { close(timeoutDone) })
}
// Set up a channel that is closed when there is
// no more buffered data.
writesDone := make(chan struct{})
go func() {
c.buf.dataMu.Lock()
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
} | go | {
"resource": ""
} |
q14217 | writeAsync | train | func (c *Conn) writeAsync(b []byte) (int, error) {
// Prevent concurrent writes.
c.buf.writeMu.Lock()
defer c.buf.writeMu.Unlock()
// Get the max buffer size to determine if the buffer's capacity
// should be grown.
c.buf.configMu.RLock()
max := c.buf.max
c.buf.configMu.RUnlock()
// If the provided data is too large for the buffer then force
// a synchrnous write.
if max > 0 && len(b) > max {
return c.writeSync(b)
}
// Lock access to the buffer. This prevents concurrent writes to
// the buffer. Occasionally the lock is released temporarily to
// check if the buffer's length allows this write operation to
// proceed.
c.buf.dataMu.Lock()
// If the max buffer size is non-zero and larger than the
// capacity of the buffer, then grow the buffer capacity.
if max > 0 && max > c.buf.data.Cap() {
c.buf.data.Grow(max)
}
// Wait until there is room in the buffer to proceed.
for max > 0 && c.buf.data.Len()+len(b) > c.buf.data.Cap() {
c.buf.dataMu.Unlock()
c.buf.dataMu.Lock()
}
defer c.buf.dataMu.Unlock()
// Write the data to the buffer.
n, err := c.buf.data.Write(b)
if err != nil {
return n, err
} else if n < len(b) {
return n, fmt.Errorf("trunc write: exp=%d act=%d", len(b), n)
}
// Record the number of bytes written in a FIFO list.
c.buf.dataN = append(c.buf.dataN, n)
// Start a goroutine that reads n bytes from the buffer where n
// is the first element in the FIFO list from above. The read
// below may not actually correspond to the write from above;
// that's okay. The important thing is the order of the reads,
// and that's achieved using the circular buffer and FIFO list
// of bytes written.
go func() {
// The read operation must also obtain a lock, preventing
// 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 }()
c.buf.dataMu.Unlock()
return
} else if nr < n {
go func() {
c.buf.errs <- fmt.Errorf("trunc read: exp=%d act=%d", n, nr)
}()
c.buf.dataMu.Unlock()
return
}
// Ensure access to the buffer is restored.
defer c.buf.dataMu.Unlock()
// Write the temporary buffer into the underlying connection.
if nw, err := c.writeSync(b); err != nil {
go func() { c.buf.errs <- err }()
return
} else if nw < n {
go func() {
c.buf.errs <- fmt.Errorf("trunc write: exp=%d act=%d", n, nw)
}()
return
}
}()
return n, nil
} | go | {
"resource": ""
} |
q14218 | New | train | func New(basePath string) *Cache {
return &Cache{
d: diskv.New(diskv.Options{
BasePath: basePath,
CacheSizeMax: 100 * 1024 * 1024, // 100MB
}),
}
} | go | {
"resource": ""
} |
q14219 | cacheKey | train | func cacheKey(req *http.Request) string {
if req.Method == http.MethodGet {
return req.URL.String()
} else {
return req.Method + " " + req.URL.String()
}
} | go | {
"resource": ""
} |
q14220 | CachedResponse | train | func CachedResponse(c Cache, req *http.Request) (resp *http.Response, err error) {
cachedVal, ok := c.Get(cacheKey(req))
if !ok {
return
}
b := bytes.NewBuffer(cachedVal)
return http.ReadResponse(bufio.NewReader(b), req)
} | go | {
"resource": ""
} |
q14221 | Set | train | func (c *MemoryCache) Set(key string, resp []byte) {
c.mu.Lock()
c.items[key] = resp
c.mu.Unlock()
} | go | {
"resource": ""
} |
q14222 | Delete | train | func (c *MemoryCache) Delete(key string) {
c.mu.Lock()
delete(c.items, key)
c.mu.Unlock()
} | go | {
"resource": ""
} |
q14223 | varyMatches | train | func varyMatches(cachedResp *http.Response, req *http.Request) bool {
for _, header := range headerAllCommaSepValues(cachedResp.Header, "vary") {
header = http.CanonicalHeaderKey(header)
if header != "" && req.Header.Get(header) != cachedResp.Header.Get("X-Varied-"+header) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q14224 | Date | train | func Date(respHeaders http.Header) (date time.Time, err error) {
dateHeader := respHeaders.Get("date")
if dateHeader == "" {
err = ErrNoDateHeader
return
}
return time.Parse(time.RFC1123, dateHeader)
} | go | {
"resource": ""
} |
q14225 | New | train | func New(path string) (*Cache, error) {
cache := &Cache{}
var err error
cache.db, err = leveldb.OpenFile(path, nil)
if err != nil {
return nil, err
}
return cache, nil
} | go | {
"resource": ""
} |
q14226 | doTitleSequence | train | func doTitleSequence(er *bytes.Reader) error {
var c byte
var err error
c, err = er.ReadByte()
if err != nil {
return err
}
if c != '0' && c != '2' {
return nil
}
c, err = er.ReadByte()
if err != nil {
return err
}
if c != ';' {
return nil
}
title := make([]byte, 0, 80)
for {
c, err = er.ReadByte()
if err != nil {
return err
}
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
} | go | {
"resource": ""
} |
q14227 | Parse | train | func Parse(r io.Reader) (node Node, err error) {
lb := &lineBuffer{
Reader: bufio.NewReader(r),
}
defer func() {
if r := recover(); r != 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
} | go | {
"resource": ""
} |
q14228 | ReadFile | train | func ReadFile(filename string) (*File, error) {
fin, err := os.Open(filename)
if err != nil {
return nil, err
}
defer fin.Close()
f := new(File)
f.Root, err = Parse(fin)
if err != nil {
return nil, err
}
return f, nil
} | go | {
"resource": ""
} |
q14229 | Config | train | func Config(yamlconf string) *File {
var err error
buf := bytes.NewBufferString(yamlconf)
f := new(File)
f.Root, err = Parse(buf)
if err != nil {
panic(err)
}
return f
} | go | {
"resource": ""
} |
q14230 | ConfigFile | train | func ConfigFile(filename string) *File {
f, err := ReadFile(filename)
if err != nil {
panic(err)
}
return f
} | go | {
"resource": ""
} |
q14231 | Get | train | func (f *File) Get(spec string) (string, error) {
node, err := Child(f.Root, spec)
if err != nil {
return "", err
}
if node == nil {
return "", &NodeNotFound{
Full: spec,
Spec: spec,
}
}
scalar, ok := node.(Scalar)
if !ok {
return "", &NodeTypeMismatch{
Full: spec,
Spec: spec,
Token: "$",
Expected: "yaml.Scalar",
Node: node,
}
}
return scalar.String(), nil
} | go | {
"resource": ""
} |
q14232 | Count | train | func (f *File) Count(spec string) (int, error) {
node, err := Child(f.Root, spec)
if err != nil {
return -1, err
}
if node == nil {
return -1, &NodeNotFound{
Full: spec,
Spec: spec,
}
}
lst, ok := node.(List)
if !ok {
return -1, &NodeTypeMismatch{
Full: spec,
Spec: spec,
Token: "$",
Expected: "yaml.List",
Node: node,
}
}
return lst.Len(), nil
} | go | {
"resource": ""
} |
q14233 | Require | train | func (f *File) Require(spec string) string {
str, err := f.Get(spec)
if err != nil {
panic(err)
}
return str
} | go | {
"resource": ""
} |
q14234 | Item | train | func (node List) Item(idx int) Node {
if idx >= 0 && idx < len(node) {
return node[idx]
}
return nil
} | go | {
"resource": ""
} |
q14235 | Render | train | func Render(node Node) string {
buf := bytes.NewBuffer(nil)
node.write(buf, 0, 0)
return buf.String()
} | go | {
"resource": ""
} |
q14236 | NotFound | train | func NotFound(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Umm... have you tried turning it off and on again?", 404)
} | go | {
"resource": ""
} |
q14237 | Insert | train | func Insert(middleware, before web.MiddlewareType) error {
return DefaultMux.Insert(middleware, before)
} | go | {
"resource": ""
} |
q14238 | Handle | train | func Handle(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Handle(pattern, handler)
} | go | {
"resource": ""
} |
q14239 | Connect | train | func Connect(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Connect(pattern, handler)
} | go | {
"resource": ""
} |
q14240 | Delete | train | func Delete(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Delete(pattern, handler)
} | go | {
"resource": ""
} |
q14241 | Get | train | func Get(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Get(pattern, handler)
} | go | {
"resource": ""
} |
q14242 | Head | train | func Head(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Head(pattern, handler)
} | go | {
"resource": ""
} |
q14243 | Options | train | func Options(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Options(pattern, handler)
} | go | {
"resource": ""
} |
q14244 | Patch | train | func Patch(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Patch(pattern, handler)
} | go | {
"resource": ""
} |
q14245 | Post | train | func Post(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Post(pattern, handler)
} | go | {
"resource": ""
} |
q14246 | Put | train | func Put(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Put(pattern, handler)
} | go | {
"resource": ""
} |
q14247 | Trace | train | func Trace(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Trace(pattern, handler)
} | go | {
"resource": ""
} |
q14248 | GetReqID | train | func GetReqID(c web.C) string {
if c.Env == nil {
return ""
}
v, ok := c.Env[RequestIDKey]
if !ok {
return ""
}
if reqID, ok := v.(string); ok {
return reqID
}
return ""
} | go | {
"resource": ""
} |
q14249 | AutomaticOptions | train | func AutomaticOptions(c *web.C, h http.Handler) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
if r.Method == "OPTIONS" {
w = &autoOptionsProxy{c: c, w: w}
}
h.ServeHTTP(w, r)
}
return http.HandlerFunc(fn)
} | go | {
"resource": ""
} |
q14250 | ServeHTTPC | train | func (h HandlerFunc) ServeHTTPC(c C, w http.ResponseWriter, r *http.Request) {
h(c, w, r)
} | go | {
"resource": ""
} |
q14251 | URLQuery | train | func URLQuery(c *web.C, h http.Handler) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
if c.Env == nil {
c.Env = make(map[interface{}]interface{})
}
c.Env[URLQueryKey] = r.URL.Query()
h.ServeHTTP(w, r)
}
return http.HandlerFunc(fn)
} | go | {
"resource": ""
} |
q14252 | EnvInit | train | func EnvInit(c *web.C, h http.Handler) http.Handler {
return envInit{c, h}
} | go | {
"resource": ""
} |
q14253 | SuperSecure | train | func SuperSecure(c *web.C, h http.Handler) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
auth := r.Header.Get("Authorization")
if !strings.HasPrefix(auth, "Basic ") {
pleaseAuth(w)
return
}
password, err := base64.StdEncoding.DecodeString(auth[6:])
if err != nil || string(password) != Password {
pleaseAuth(w)
return
}
h.ServeHTTP(w, r)
}
return http.HandlerFunc(fn)
} | go | {
"resource": ""
} |
q14254 | Sniff | train | func Sniff() string {
if bind := os.Getenv("GOJI_BIND"); bind != "" {
return bind
} else if usingEinhorn() {
return "einhorn@0"
} else if usingSystemd() {
return "fd@3"
} else if port := os.Getenv("PORT"); port != "" {
return ":" + port
}
return ""
} | go | {
"resource": ""
} |
q14255 | Socket | train | func Socket(bind string) net.Listener {
l, err := listenTo(bind)
if err != nil {
log.Fatal(err)
}
return l
} | go | {
"resource": ""
} |
q14256 | WrapWriter | train | func WrapWriter(w http.ResponseWriter) WriterProxy {
_, cn := w.(http.CloseNotifier)
_, fl := w.(http.Flusher)
_, hj := w.(http.Hijacker)
_, rf := w.(io.ReaderFrom)
bw := basicWriter{ResponseWriter: w}
if cn && fl && hj && rf {
return &fancyWriter{bw}
}
if fl {
return &flushWriter{bw}
}
return &bw
} | go | {
"resource": ""
} |
q14257 | Accept | train | func (t *T) Accept() (net.Conn, error) {
c, err := t.l.Accept()
if err != nil {
return nil, err
}
connID := atomic.AddUint64(&t.connCount, 1)
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
} | go | {
"resource": ""
} |
q14258 | CloseIdle | train | func (t *T) CloseIdle() error {
for i := range t.shards {
t.shards[i].closeConns(false, false)
}
// Not sure if returning errors is actually useful here :/
return nil
} | go | {
"resource": ""
} |
q14259 | Drain | train | func (t *T) Drain() error {
for i := range t.shards {
t.shards[i].closeConns(false, true)
}
for i := range t.shards {
t.shards[i].wait()
}
return nil
} | go | {
"resource": ""
} |
q14260 | Disown | train | func Disown(c net.Conn) error {
if cn, ok := c.(*conn); ok {
return cn.disown()
}
return errNotManaged
} | go | {
"resource": ""
} |
q14261 | MarkIdle | train | func MarkIdle(c net.Conn) error {
if cn, ok := c.(*conn); ok {
cn.markIdle()
return nil
}
return errNotManaged
} | go | {
"resource": ""
} |
q14262 | MarkInUse | train | func MarkInUse(c net.Conn) error {
if cn, ok := c.(*conn); ok {
cn.markInUse()
return nil
}
return errNotManaged
} | go | {
"resource": ""
} |
q14263 | peacefulError | train | func peacefulError(err error) error {
if atomic.LoadInt32(&closing) == 0 {
return err
}
// Unfortunately Go doesn't really give us a better way to select errors
// than this, so *shrug*.
if oe, ok := err.(*net.OpError); ok {
switch oe.Op {
// backward compatibility: older golang returns AcceptEx on Windows.
// Current golang returns "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
} | go | {
"resource": ""
} |
q14264 | Write | train | func (g Greet) Write(w io.Writer) {
fmt.Fprintf(w, "%s\n@%s at %s\n---\n", g.Message, g.User,
g.Time.Format(time.UnixDate))
} | go | {
"resource": ""
} |
q14265 | Write | train | func (u User) Write(w io.Writer, handle string) {
fmt.Fprintf(w, "%s (@%s)\n%s\n", u.Name, handle, u.Bio)
} | go | {
"resource": ""
} |
q14266 | New | train | func New() *Mux {
mux := Mux{
ms: mStack{
stack: make([]mLayer, 0),
pool: makeCPool(),
},
rt: router{
routes: make([]route, 0),
notFound: parseHandler(http.NotFound),
},
}
mux.ms.router = &mux.rt
return &mux
} | go | {
"resource": ""
} |
q14267 | ServeHTTPC | train | func (m *Mux) ServeHTTPC(c C, w http.ResponseWriter, r *http.Request) {
stack := m.ms.alloc()
stack.ServeHTTPC(c, w, r)
m.ms.release(stack)
} | go | {
"resource": ""
} |
q14268 | Connect | train | func (m *Mux) Connect(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mCONNECT, handler)
} | go | {
"resource": ""
} |
q14269 | Delete | train | func (m *Mux) Delete(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mDELETE, handler)
} | go | {
"resource": ""
} |
q14270 | Head | train | func (m *Mux) Head(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mHEAD, handler)
} | go | {
"resource": ""
} |
q14271 | Options | train | func (m *Mux) Options(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mOPTIONS, handler)
} | go | {
"resource": ""
} |
q14272 | Patch | train | func (m *Mux) Patch(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mPATCH, handler)
} | go | {
"resource": ""
} |
q14273 | Post | train | func (m *Mux) Post(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mPOST, handler)
} | go | {
"resource": ""
} |
q14274 | Put | train | func (m *Mux) Put(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mPUT, handler)
} | go | {
"resource": ""
} |
q14275 | Trace | train | func (m *Mux) Trace(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mTRACE, handler)
} | go | {
"resource": ""
} |
q14276 | ServeTLS | train | func ServeTLS(config *tls.Config) {
if !flag.Parsed() {
flag.Parse()
}
ServeListener(tls.NewListener(bind.Default(), config))
} | go | {
"resource": ""
} |
q14277 | ServeListener | train | func ServeListener(listener net.Listener) {
DefaultMux.Compile()
// Install our handler at the root of the standard net/http default mux.
// This allows packages like expvar to continue working as expected.
http.Handle("/", DefaultMux)
log.Println("Starting Goji on", listener.Addr())
graceful.HandleSignals()
bind.Ready()
graceful.PreHook(func() { log.Printf("Goji received signal, gracefully stopping") })
graceful.PostHook(func() { log.Printf("Goji stopped") })
err := graceful.Serve(listener, http.DefaultServeMux)
if err != nil {
log.Fatal(err)
}
graceful.Wait()
} | go | {
"resource": ""
} |
q14278 | getCallStack | train | func getCallStack(skip int) string {
buf := new(bytes.Buffer)
for i := skip; ; i++ {
_, file, line, ok := runtime.Caller(i)
if !ok {
break
}
fmt.Fprintf(buf, "\n%s:%d", file, line)
}
return buf.String()
} | go | {
"resource": ""
} |
q14279 | newRouteGroup | train | func newRouteGroup(prefix string, router *Router, handlers []Handler) *RouteGroup {
return &RouteGroup{
prefix: prefix,
router: router,
handlers: handlers,
}
} | go | {
"resource": ""
} |
q14280 | Delete | train | func (rg *RouteGroup) Delete(path string, handlers ...Handler) *Route {
return rg.add("DELETE", path, handlers)
} | go | {
"resource": ""
} |
q14281 | combineHandlers | train | func combineHandlers(h1 []Handler, h2 []Handler) []Handler {
hh := make([]Handler, len(h1)+len(h2))
copy(hh, h1)
copy(hh[len(h1):], h2)
return hh
} | go | {
"resource": ""
} |
q14282 | Handler | train | func Handler(opts Options) routing.Handler {
opts.init()
return func(c *routing.Context) (err error) {
origin := c.Request.Header.Get(headerOrigin)
if origin == "" {
// the request is outside the scope of CORS
return
}
if c.Request.Method == "OPTIONS" {
// a preflight request
method := c.Request.Header.Get(headerRequestMethod)
if method == "" {
// the request is outside the scope of CORS
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
}
} | go | {
"resource": ""
} |
q14283 | Tag | train | func (r *Route) Tag(value interface{}) *Route {
if len(r.routes) > 0 {
// this route is a composite one (a path with multiple methods)
for _, route := range r.routes {
route.Tag(value)
}
return r
}
if r.tags == nil {
r.tags = []interface{}{}
}
r.tags = append(r.tags, value)
return r
} | go | {
"resource": ""
} |
q14284 | Get | train | func (r *Route) Get(handlers ...Handler) *Route {
return r.group.add("GET", r.path, handlers)
} | go | {
"resource": ""
} |
q14285 | Post | train | func (r *Route) Post(handlers ...Handler) *Route {
return r.group.add("POST", r.path, handlers)
} | go | {
"resource": ""
} |
q14286 | Put | train | func (r *Route) Put(handlers ...Handler) *Route {
return r.group.add("PUT", r.path, handlers)
} | go | {
"resource": ""
} |
q14287 | Patch | train | func (r *Route) Patch(handlers ...Handler) *Route {
return r.group.add("PATCH", r.path, handlers)
} | go | {
"resource": ""
} |
q14288 | Delete | train | func (r *Route) Delete(handlers ...Handler) *Route {
return r.group.add("DELETE", r.path, handlers)
} | go | {
"resource": ""
} |
q14289 | Connect | train | func (r *Route) Connect(handlers ...Handler) *Route {
return r.group.add("CONNECT", r.path, handlers)
} | go | {
"resource": ""
} |
q14290 | Head | train | func (r *Route) Head(handlers ...Handler) *Route {
return r.group.add("HEAD", r.path, handlers)
} | go | {
"resource": ""
} |
q14291 | Options | train | func (r *Route) Options(handlers ...Handler) *Route {
return r.group.add("OPTIONS", r.path, handlers)
} | go | {
"resource": ""
} |
q14292 | Trace | train | func (r *Route) Trace(handlers ...Handler) *Route {
return r.group.add("TRACE", r.path, handlers)
} | go | {
"resource": ""
} |
q14293 | URL | train | func (r *Route) URL(pairs ...interface{}) (s string) {
s = r.template
for i := 0; i < len(pairs); i++ {
name := fmt.Sprintf("<%v>", pairs[i])
value := ""
if i < len(pairs)-1 {
value = url.QueryEscape(fmt.Sprint(pairs[i+1]))
}
s = strings.Replace(s, name, value, -1)
}
return
} | go | {
"resource": ""
} |
q14294 | String | train | func (r *Route) String() string {
return r.method + " " + r.group.prefix + r.path
} | go | {
"resource": ""
} |
q14295 | NewContext | train | func NewContext(res http.ResponseWriter, req *http.Request, handlers ...Handler) *Context {
c := &Context{handlers: handlers}
c.init(res, req)
return c
} | go | {
"resource": ""
} |
q14296 | Param | train | func (c *Context) Param(name string) string {
for i, n := range c.pnames {
if n == name {
return c.pvalues[i]
}
}
return ""
} | go | {
"resource": ""
} |
q14297 | SetParam | train | func (c *Context) SetParam(name, value string) {
for i, n := range c.pnames {
if n == name {
c.pvalues[i] = value
return
}
}
c.pnames = append(c.pnames, name)
c.pvalues = append(c.pvalues, value)
} | go | {
"resource": ""
} |
q14298 | Set | train | func (c *Context) Set(name string, value interface{}) {
if c.data == nil {
c.data = make(map[string]interface{})
}
c.data[name] = value
} | go | {
"resource": ""
} |
q14299 | Query | train | func (c *Context) Query(name string, defaultValue ...string) string {
if vs, _ := c.Request.URL.Query()[name]; len(vs) > 0 {
return vs[0]
}
if len(defaultValue) > 0 {
return defaultValue[0]
}
return ""
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.