id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
14,200 | kidoman/embd | leddriver.go | NewLEDDriver | func NewLEDDriver(ledMap LEDMap, lf ledFactory) LEDDriver {
return &ledDriver{
ledMap: ledMap,
lf: lf,
initializedLEDs: map[string]LED{},
}
} | go | func NewLEDDriver(ledMap LEDMap, lf ledFactory) LEDDriver {
return &ledDriver{
ledMap: ledMap,
lf: lf,
initializedLEDs: map[string]LED{},
}
} | [
"func",
"NewLEDDriver",
"(",
"ledMap",
"LEDMap",
",",
"lf",
"ledFactory",
")",
"LEDDriver",
"{",
"return",
"&",
"ledDriver",
"{",
"ledMap",
":",
"ledMap",
",",
"lf",
":",
"lf",
",",
"initializedLEDs",
":",
"map",
"[",
"string",
"]",
"LED",
"{",
"}",
",... | // NewLEDDriver returns a LEDDriver interface which allows control
// over the LED subsystem. | [
"NewLEDDriver",
"returns",
"a",
"LEDDriver",
"interface",
"which",
"allows",
"control",
"over",
"the",
"LED",
"subsystem",
"."
] | d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62 | https://github.com/kidoman/embd/blob/d3d8c0c5c68dc6caccebb7d720f36e64bafd0a62/leddriver.go#L26-L33 |
14,201 | campoy/embedmd | embedmd/command.go | nextSlash | 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 | 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
}
}
} | [
"func",
"nextSlash",
"(",
"s",
"string",
")",
"int",
"{",
"for",
"sep",
":=",
"0",
";",
";",
"sep",
"++",
"{",
"i",
":=",
"strings",
".",
"IndexByte",
"(",
"s",
"[",
"sep",
":",
"]",
",",
"'/'",
")",
"\n",
"if",
"i",
"<",
"0",
"{",
"return",
... | // nextSlash will find the index of the next unescaped slash in a string. | [
"nextSlash",
"will",
"find",
"the",
"index",
"of",
"the",
"next",
"unescaped",
"slash",
"in",
"a",
"string",
"."
] | 97c13d6e41602fc6e397eb51c45f38069371a969 | https://github.com/campoy/embedmd/blob/97c13d6e41602fc6e397eb51c45f38069371a969/embedmd/command.go#L90-L101 |
14,202 | campoy/embedmd | embedmd/embedmd.go | Process | 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 | 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)
} | [
"func",
"Process",
"(",
"out",
"io",
".",
"Writer",
",",
"in",
"io",
".",
"Reader",
",",
"opts",
"...",
"Option",
")",
"error",
"{",
"e",
":=",
"embedder",
"{",
"Fetcher",
":",
"fetcher",
"{",
"}",
"}",
"\n",
"for",
"_",
",",
"opt",
":=",
"range"... | // Process reads markdown from the given io.Reader searching for an embedmd
// command. When a command is found, it is executed and the output is written
// into the given io.Writer with the rest of standard markdown. | [
"Process",
"reads",
"markdown",
"from",
"the",
"given",
"io",
".",
"Reader",
"searching",
"for",
"an",
"embedmd",
"command",
".",
"When",
"a",
"command",
"is",
"found",
"it",
"is",
"executed",
"and",
"the",
"output",
"is",
"written",
"into",
"the",
"given"... | 97c13d6e41602fc6e397eb51c45f38069371a969 | https://github.com/campoy/embedmd/blob/97c13d6e41602fc6e397eb51c45f38069371a969/embedmd/embedmd.go#L64-L70 |
14,203 | campoy/embedmd | embedmd/embedmd.go | WithBaseDir | func WithBaseDir(path string) Option {
return Option{func(e *embedder) { e.baseDir = path }}
} | go | func WithBaseDir(path string) Option {
return Option{func(e *embedder) { e.baseDir = path }}
} | [
"func",
"WithBaseDir",
"(",
"path",
"string",
")",
"Option",
"{",
"return",
"Option",
"{",
"func",
"(",
"e",
"*",
"embedder",
")",
"{",
"e",
".",
"baseDir",
"=",
"path",
"}",
"}",
"\n",
"}"
] | // WithBaseDir indicates that the given path should be used to resolve relative
// paths. | [
"WithBaseDir",
"indicates",
"that",
"the",
"given",
"path",
"should",
"be",
"used",
"to",
"resolve",
"relative",
"paths",
"."
] | 97c13d6e41602fc6e397eb51c45f38069371a969 | https://github.com/campoy/embedmd/blob/97c13d6e41602fc6e397eb51c45f38069371a969/embedmd/embedmd.go#L77-L79 |
14,204 | campoy/embedmd | embedmd/embedmd.go | WithFetcher | func WithFetcher(c Fetcher) Option {
return Option{func(e *embedder) { e.Fetcher = c }}
} | go | func WithFetcher(c Fetcher) Option {
return Option{func(e *embedder) { e.Fetcher = c }}
} | [
"func",
"WithFetcher",
"(",
"c",
"Fetcher",
")",
"Option",
"{",
"return",
"Option",
"{",
"func",
"(",
"e",
"*",
"embedder",
")",
"{",
"e",
".",
"Fetcher",
"=",
"c",
"}",
"}",
"\n",
"}"
] | // WithFetcher provides a custom Fetcher to be used whenever a path or url needs
// to be fetched. | [
"WithFetcher",
"provides",
"a",
"custom",
"Fetcher",
"to",
"be",
"used",
"whenever",
"a",
"path",
"or",
"url",
"needs",
"to",
"be",
"fetched",
"."
] | 97c13d6e41602fc6e397eb51c45f38069371a969 | https://github.com/campoy/embedmd/blob/97c13d6e41602fc6e397eb51c45f38069371a969/embedmd/embedmd.go#L83-L85 |
14,205 | jszwec/csvutil | encoder.go | EncodeHeader | func (e *Encoder) EncodeHeader(v interface{}) error {
typ, err := valueType(v)
if err != nil {
return err
}
return e.encodeHeader(typ)
} | go | func (e *Encoder) EncodeHeader(v interface{}) error {
typ, err := valueType(v)
if err != nil {
return err
}
return e.encodeHeader(typ)
} | [
"func",
"(",
"e",
"*",
"Encoder",
")",
"EncodeHeader",
"(",
"v",
"interface",
"{",
"}",
")",
"error",
"{",
"typ",
",",
"err",
":=",
"valueType",
"(",
"v",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"e",
... | // EncodeHeader writes the CSV header of the provided struct value to the output
// stream. The provided argument v must be a struct value.
//
// The first Encode method call will not write header if EncodeHeader was called
// before it. This method can be called in cases when a data set could be
// empty, but header is desired.
//
// EncodeHeader is like Header function, but it works with the Encoder and writes
// directly to the output stream. Look at Header documentation for the exact
// header encoding rules. | [
"EncodeHeader",
"writes",
"the",
"CSV",
"header",
"of",
"the",
"provided",
"struct",
"value",
"to",
"the",
"output",
"stream",
".",
"The",
"provided",
"argument",
"v",
"must",
"be",
"a",
"struct",
"value",
".",
"The",
"first",
"Encode",
"method",
"call",
"... | 0115205d1ccaac20f9c7e4cdc987adf657c9fbf2 | https://github.com/jszwec/csvutil/blob/0115205d1ccaac20f9c7e4cdc987adf657c9fbf2/encoder.go#L139-L145 |
14,206 | jszwec/csvutil | decoder.go | NewDecoder | 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 | 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
} | [
"func",
"NewDecoder",
"(",
"r",
"Reader",
",",
"header",
"...",
"string",
")",
"(",
"dec",
"*",
"Decoder",
",",
"err",
"error",
")",
"{",
"if",
"len",
"(",
"header",
")",
"==",
"0",
"{",
"header",
",",
"err",
"=",
"r",
".",
"Read",
"(",
")",
"\... | // NewDecoder returns a new decoder that reads from r.
//
// Decoder will match struct fields according to the given header.
//
// If header is empty NewDecoder will read one line and treat it as a header.
//
// Records coming from r must be of the same length as the header.
//
// NewDecoder may return io.EOF if there is no data in r and no header was
// provided by the caller. | [
"NewDecoder",
"returns",
"a",
"new",
"decoder",
"that",
"reads",
"from",
"r",
".",
"Decoder",
"will",
"match",
"struct",
"fields",
"according",
"to",
"the",
"given",
"header",
".",
"If",
"header",
"is",
"empty",
"NewDecoder",
"will",
"read",
"one",
"line",
... | 0115205d1ccaac20f9c7e4cdc987adf657c9fbf2 | https://github.com/jszwec/csvutil/blob/0115205d1ccaac20f9c7e4cdc987adf657c9fbf2/decoder.go#L61-L84 |
14,207 | jszwec/csvutil | decoder.go | Header | func (d *Decoder) Header() []string {
header := make([]string, len(d.header))
copy(header, d.header)
return header
} | go | func (d *Decoder) Header() []string {
header := make([]string, len(d.header))
copy(header, d.header)
return header
} | [
"func",
"(",
"d",
"*",
"Decoder",
")",
"Header",
"(",
")",
"[",
"]",
"string",
"{",
"header",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"d",
".",
"header",
")",
")",
"\n",
"copy",
"(",
"header",
",",
"d",
".",
"header",
")",
"\n... | // Header returns the first line that came from the reader, or returns the
// defined header by the caller. | [
"Header",
"returns",
"the",
"first",
"line",
"that",
"came",
"from",
"the",
"reader",
"or",
"returns",
"the",
"defined",
"header",
"by",
"the",
"caller",
"."
] | 0115205d1ccaac20f9c7e4cdc987adf657c9fbf2 | https://github.com/jszwec/csvutil/blob/0115205d1ccaac20f9c7e4cdc987adf657c9fbf2/decoder.go#L155-L159 |
14,208 | jszwec/csvutil | decoder.go | Unused | 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 | func (d *Decoder) Unused() []int {
if len(d.unused) == 0 {
return nil
}
indices := make([]int, len(d.unused))
copy(indices, d.unused)
return indices
} | [
"func",
"(",
"d",
"*",
"Decoder",
")",
"Unused",
"(",
")",
"[",
"]",
"int",
"{",
"if",
"len",
"(",
"d",
".",
"unused",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"indices",
":=",
"make",
"(",
"[",
"]",
"int",
",",
"len",
"(",
... | // Unused returns a list of column indexes that were not used during decoding
// due to lack of matching struct field. | [
"Unused",
"returns",
"a",
"list",
"of",
"column",
"indexes",
"that",
"were",
"not",
"used",
"during",
"decoding",
"due",
"to",
"lack",
"of",
"matching",
"struct",
"field",
"."
] | 0115205d1ccaac20f9c7e4cdc987adf657c9fbf2 | https://github.com/jszwec/csvutil/blob/0115205d1ccaac20f9c7e4cdc987adf657c9fbf2/decoder.go#L163-L171 |
14,209 | akutz/memconn | memconn_listener.go | Close | func (l *Listener) Close() error {
l.once.Do(func() {
close(l.done)
<-l.rmvd
})
return nil
} | go | func (l *Listener) Close() error {
l.once.Do(func() {
close(l.done)
<-l.rmvd
})
return nil
} | [
"func",
"(",
"l",
"*",
"Listener",
")",
"Close",
"(",
")",
"error",
"{",
"l",
".",
"once",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"close",
"(",
"l",
".",
"done",
")",
"\n",
"<-",
"l",
".",
"rmvd",
"\n",
"}",
")",
"\n",
"return",
"nil",
"\n"... | // Close implements the net.Listener Close method. | [
"Close",
"implements",
"the",
"net",
".",
"Listener",
"Close",
"method",
"."
] | e0a19f53d865bbc181e3ed1204978510b315f7e2 | https://github.com/akutz/memconn/blob/e0a19f53d865bbc181e3ed1204978510b315f7e2/memconn_listener.go#L94-L100 |
14,210 | akutz/memconn | memconn_pipe.go | set | 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 | 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)
}
} | [
"func",
"(",
"d",
"*",
"pipeDeadline",
")",
"set",
"(",
"t",
"time",
".",
"Time",
")",
"{",
"d",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"d",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"d",
".",
"timer",
"!=",
"nil",
"&&",
"... | // set sets the point in time when the deadline will time out.
// A timeout event is signaled by closing the channel returned by waiter.
// Once a timeout has occurred, the deadline can be refreshed by specifying a
// t value in the future.
//
// A zero value for t prevents timeout. | [
"set",
"sets",
"the",
"point",
"in",
"time",
"when",
"the",
"deadline",
"will",
"time",
"out",
".",
"A",
"timeout",
"event",
"is",
"signaled",
"by",
"closing",
"the",
"channel",
"returned",
"by",
"waiter",
".",
"Once",
"a",
"timeout",
"has",
"occurred",
... | e0a19f53d865bbc181e3ed1204978510b315f7e2 | https://github.com/akutz/memconn/blob/e0a19f53d865bbc181e3ed1204978510b315f7e2/memconn_pipe.go#L52-L85 |
14,211 | akutz/memconn | memconn_pipe.go | wait | func (d *pipeDeadline) wait() chan struct{} {
d.mu.Lock()
defer d.mu.Unlock()
return d.cancel
} | go | func (d *pipeDeadline) wait() chan struct{} {
d.mu.Lock()
defer d.mu.Unlock()
return d.cancel
} | [
"func",
"(",
"d",
"*",
"pipeDeadline",
")",
"wait",
"(",
")",
"chan",
"struct",
"{",
"}",
"{",
"d",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"d",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"d",
".",
"cancel",
"\n",
"}"
] | // wait returns a channel that is closed when the deadline is exceeded. | [
"wait",
"returns",
"a",
"channel",
"that",
"is",
"closed",
"when",
"the",
"deadline",
"is",
"exceeded",
"."
] | e0a19f53d865bbc181e3ed1204978510b315f7e2 | https://github.com/akutz/memconn/blob/e0a19f53d865bbc181e3ed1204978510b315f7e2/memconn_pipe.go#L88-L92 |
14,212 | akutz/memconn | memconn_pipe.go | Pipe | 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 | 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
} | [
"func",
"Pipe",
"(",
")",
"(",
"net",
".",
"Conn",
",",
"net",
".",
"Conn",
")",
"{",
"cb1",
":=",
"make",
"(",
"chan",
"[",
"]",
"byte",
")",
"\n",
"cb2",
":=",
"make",
"(",
"chan",
"[",
"]",
"byte",
")",
"\n",
"cn1",
":=",
"make",
"(",
"c... | // Pipe creates a synchronous, in-memory, full duplex
// network connection; both ends implement the Conn interface.
// Reads on one end are matched with writes on the other,
// copying data directly between the two; there is no internal
// buffering. | [
"Pipe",
"creates",
"a",
"synchronous",
"in",
"-",
"memory",
"full",
"duplex",
"network",
"connection",
";",
"both",
"ends",
"implement",
"the",
"Conn",
"interface",
".",
"Reads",
"on",
"one",
"end",
"are",
"matched",
"with",
"writes",
"on",
"the",
"other",
... | e0a19f53d865bbc181e3ed1204978510b315f7e2 | https://github.com/akutz/memconn/blob/e0a19f53d865bbc181e3ed1204978510b315f7e2/memconn_pipe.go#L140-L163 |
14,213 | akutz/memconn | memconn_conn.go | BufferSize | 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 | func (c *Conn) BufferSize() int {
if c.laddr.Buffered() {
c.buf.configMu.RLock()
defer c.buf.configMu.RUnlock()
return c.buf.max
}
return 0
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"BufferSize",
"(",
")",
"int",
"{",
"if",
"c",
".",
"laddr",
".",
"Buffered",
"(",
")",
"{",
"c",
".",
"buf",
".",
"configMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"buf",
".",
"configMu",
".",
"... | // BufferSize gets the number of bytes allowed to be queued for
// asynchrnous Write operations.
//
// Please note that this function will always return zero for unbuffered
// connections.
//
// Please see the function SetBufferSize for more information. | [
"BufferSize",
"gets",
"the",
"number",
"of",
"bytes",
"allowed",
"to",
"be",
"queued",
"for",
"asynchrnous",
"Write",
"operations",
".",
"Please",
"note",
"that",
"this",
"function",
"will",
"always",
"return",
"zero",
"for",
"unbuffered",
"connections",
".",
... | e0a19f53d865bbc181e3ed1204978510b315f7e2 | https://github.com/akutz/memconn/blob/e0a19f53d865bbc181e3ed1204978510b315f7e2/memconn_conn.go#L136-L143 |
14,214 | akutz/memconn | memconn_conn.go | CloseTimeout | 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 | 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
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"CloseTimeout",
"(",
")",
"time",
".",
"Duration",
"{",
"if",
"c",
".",
"laddr",
".",
"Buffered",
"(",
")",
"{",
"c",
".",
"buf",
".",
"configMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"buf",
".",
... | // CloseTimeout gets the time.Duration value used when closing buffered
// connections.
//
// Please note that this function will always return zero for
// unbuffered connections.
//
// Please see the function SetCloseTimeout for more information. | [
"CloseTimeout",
"gets",
"the",
"time",
".",
"Duration",
"value",
"used",
"when",
"closing",
"buffered",
"connections",
".",
"Please",
"note",
"that",
"this",
"function",
"will",
"always",
"return",
"zero",
"for",
"unbuffered",
"connections",
".",
"Please",
"see"... | e0a19f53d865bbc181e3ed1204978510b315f7e2 | https://github.com/akutz/memconn/blob/e0a19f53d865bbc181e3ed1204978510b315f7e2/memconn_conn.go#L172-L179 |
14,215 | akutz/memconn | memconn_conn.go | SetCloseTimeout | 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 | func (c *Conn) SetCloseTimeout(d time.Duration) {
if c.laddr.Buffered() {
c.buf.configMu.Lock()
defer c.buf.configMu.Unlock()
c.buf.closeTimeout = d
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"SetCloseTimeout",
"(",
"d",
"time",
".",
"Duration",
")",
"{",
"if",
"c",
".",
"laddr",
".",
"Buffered",
"(",
")",
"{",
"c",
".",
"buf",
".",
"configMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"buf"... | // SetCloseTimeout sets a time.Duration value used by the Close function
// to determine the amount of time to wait for pending, buffered Writes
// to complete before closing the connection.
//
// The default timeout value is 10 seconds. A zero value does not
// mean there is no timeout, rather it means the timeout is immediate.
//
// Please note that setting this value has no effect on unbuffered
// connections. | [
"SetCloseTimeout",
"sets",
"a",
"time",
".",
"Duration",
"value",
"used",
"by",
"the",
"Close",
"function",
"to",
"determine",
"the",
"amount",
"of",
"time",
"to",
"wait",
"for",
"pending",
"buffered",
"Writes",
"to",
"complete",
"before",
"closing",
"the",
... | e0a19f53d865bbc181e3ed1204978510b315f7e2 | https://github.com/akutz/memconn/blob/e0a19f53d865bbc181e3ed1204978510b315f7e2/memconn_conn.go#L190-L196 |
14,216 | akutz/memconn | memconn_conn.go | Close | 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 | 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
} | [
"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... | // Close implements the net.Conn Close method. | [
"Close",
"implements",
"the",
"net",
".",
"Conn",
"Close",
"method",
"."
] | e0a19f53d865bbc181e3ed1204978510b315f7e2 | https://github.com/akutz/memconn/blob/e0a19f53d865bbc181e3ed1204978510b315f7e2/memconn_conn.go#L209-L250 |
14,217 | akutz/memconn | memconn_conn.go | writeAsync | 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 | 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
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"writeAsync",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"// Prevent concurrent writes.",
"c",
".",
"buf",
".",
"writeMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"buf",
".",
"... | // writeAsync performs the Write operation in a goroutine. This
// behavior means the Write operation is not blocking, but also means
// that when Write operations fail the associated error is not returned
// from this function. | [
"writeAsync",
"performs",
"the",
"Write",
"operation",
"in",
"a",
"goroutine",
".",
"This",
"behavior",
"means",
"the",
"Write",
"operation",
"is",
"not",
"blocking",
"but",
"also",
"means",
"that",
"when",
"Write",
"operations",
"fail",
"the",
"associated",
"... | e0a19f53d865bbc181e3ed1204978510b315f7e2 | https://github.com/akutz/memconn/blob/e0a19f53d865bbc181e3ed1204978510b315f7e2/memconn_conn.go#L317-L409 |
14,218 | gregjones/httpcache | diskcache/diskcache.go | New | func New(basePath string) *Cache {
return &Cache{
d: diskv.New(diskv.Options{
BasePath: basePath,
CacheSizeMax: 100 * 1024 * 1024, // 100MB
}),
}
} | go | func New(basePath string) *Cache {
return &Cache{
d: diskv.New(diskv.Options{
BasePath: basePath,
CacheSizeMax: 100 * 1024 * 1024, // 100MB
}),
}
} | [
"func",
"New",
"(",
"basePath",
"string",
")",
"*",
"Cache",
"{",
"return",
"&",
"Cache",
"{",
"d",
":",
"diskv",
".",
"New",
"(",
"diskv",
".",
"Options",
"{",
"BasePath",
":",
"basePath",
",",
"CacheSizeMax",
":",
"100",
"*",
"1024",
"*",
"1024",
... | // New returns a new Cache that will store files in basePath | [
"New",
"returns",
"a",
"new",
"Cache",
"that",
"will",
"store",
"files",
"in",
"basePath"
] | 3befbb6ad0cc97d4c25d851e9528915809e1a22f | https://github.com/gregjones/httpcache/blob/3befbb6ad0cc97d4c25d851e9528915809e1a22f/diskcache/diskcache.go#L48-L55 |
14,219 | gregjones/httpcache | httpcache.go | cacheKey | func cacheKey(req *http.Request) string {
if req.Method == http.MethodGet {
return req.URL.String()
} else {
return req.Method + " " + req.URL.String()
}
} | go | func cacheKey(req *http.Request) string {
if req.Method == http.MethodGet {
return req.URL.String()
} else {
return req.Method + " " + req.URL.String()
}
} | [
"func",
"cacheKey",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"string",
"{",
"if",
"req",
".",
"Method",
"==",
"http",
".",
"MethodGet",
"{",
"return",
"req",
".",
"URL",
".",
"String",
"(",
")",
"\n",
"}",
"else",
"{",
"return",
"req",
".",
... | // cacheKey returns the cache key for req. | [
"cacheKey",
"returns",
"the",
"cache",
"key",
"for",
"req",
"."
] | 3befbb6ad0cc97d4c25d851e9528915809e1a22f | https://github.com/gregjones/httpcache/blob/3befbb6ad0cc97d4c25d851e9528915809e1a22f/httpcache.go#L42-L48 |
14,220 | gregjones/httpcache | httpcache.go | CachedResponse | 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 | 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)
} | [
"func",
"CachedResponse",
"(",
"c",
"Cache",
",",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"resp",
"*",
"http",
".",
"Response",
",",
"err",
"error",
")",
"{",
"cachedVal",
",",
"ok",
":=",
"c",
".",
"Get",
"(",
"cacheKey",
"(",
"req",
")",
... | // CachedResponse returns the cached http.Response for req if present, and nil
// otherwise. | [
"CachedResponse",
"returns",
"the",
"cached",
"http",
".",
"Response",
"for",
"req",
"if",
"present",
"and",
"nil",
"otherwise",
"."
] | 3befbb6ad0cc97d4c25d851e9528915809e1a22f | https://github.com/gregjones/httpcache/blob/3befbb6ad0cc97d4c25d851e9528915809e1a22f/httpcache.go#L52-L60 |
14,221 | gregjones/httpcache | httpcache.go | Set | func (c *MemoryCache) Set(key string, resp []byte) {
c.mu.Lock()
c.items[key] = resp
c.mu.Unlock()
} | go | func (c *MemoryCache) Set(key string, resp []byte) {
c.mu.Lock()
c.items[key] = resp
c.mu.Unlock()
} | [
"func",
"(",
"c",
"*",
"MemoryCache",
")",
"Set",
"(",
"key",
"string",
",",
"resp",
"[",
"]",
"byte",
")",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"c",
".",
"items",
"[",
"key",
"]",
"=",
"resp",
"\n",
"c",
".",
"mu",
".",
"Unloc... | // Set saves response resp to the cache with key | [
"Set",
"saves",
"response",
"resp",
"to",
"the",
"cache",
"with",
"key"
] | 3befbb6ad0cc97d4c25d851e9528915809e1a22f | https://github.com/gregjones/httpcache/blob/3befbb6ad0cc97d4c25d851e9528915809e1a22f/httpcache.go#L77-L81 |
14,222 | gregjones/httpcache | httpcache.go | Delete | func (c *MemoryCache) Delete(key string) {
c.mu.Lock()
delete(c.items, key)
c.mu.Unlock()
} | go | func (c *MemoryCache) Delete(key string) {
c.mu.Lock()
delete(c.items, key)
c.mu.Unlock()
} | [
"func",
"(",
"c",
"*",
"MemoryCache",
")",
"Delete",
"(",
"key",
"string",
")",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"delete",
"(",
"c",
".",
"items",
",",
"key",
")",
"\n",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // Delete removes key from the cache | [
"Delete",
"removes",
"key",
"from",
"the",
"cache"
] | 3befbb6ad0cc97d4c25d851e9528915809e1a22f | https://github.com/gregjones/httpcache/blob/3befbb6ad0cc97d4c25d851e9528915809e1a22f/httpcache.go#L84-L88 |
14,223 | gregjones/httpcache | httpcache.go | varyMatches | 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 | 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
} | [
"func",
"varyMatches",
"(",
"cachedResp",
"*",
"http",
".",
"Response",
",",
"req",
"*",
"http",
".",
"Request",
")",
"bool",
"{",
"for",
"_",
",",
"header",
":=",
"range",
"headerAllCommaSepValues",
"(",
"cachedResp",
".",
"Header",
",",
"\"",
"\"",
")"... | // varyMatches will return false unless all of the cached values for the headers listed in Vary
// match the new request | [
"varyMatches",
"will",
"return",
"false",
"unless",
"all",
"of",
"the",
"cached",
"values",
"for",
"the",
"headers",
"listed",
"in",
"Vary",
"match",
"the",
"new",
"request"
] | 3befbb6ad0cc97d4c25d851e9528915809e1a22f | https://github.com/gregjones/httpcache/blob/3befbb6ad0cc97d4c25d851e9528915809e1a22f/httpcache.go#L121-L129 |
14,224 | gregjones/httpcache | httpcache.go | Date | 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 | 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)
} | [
"func",
"Date",
"(",
"respHeaders",
"http",
".",
"Header",
")",
"(",
"date",
"time",
".",
"Time",
",",
"err",
"error",
")",
"{",
"dateHeader",
":=",
"respHeaders",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"if",
"dateHeader",
"==",
"\"",
"\"",
"{",
"... | // Date parses and returns the value of the Date header. | [
"Date",
"parses",
"and",
"returns",
"the",
"value",
"of",
"the",
"Date",
"header",
"."
] | 3befbb6ad0cc97d4c25d851e9528915809e1a22f | https://github.com/gregjones/httpcache/blob/3befbb6ad0cc97d4c25d851e9528915809e1a22f/httpcache.go#L260-L268 |
14,225 | gregjones/httpcache | leveldbcache/leveldbcache.go | New | 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 | 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
} | [
"func",
"New",
"(",
"path",
"string",
")",
"(",
"*",
"Cache",
",",
"error",
")",
"{",
"cache",
":=",
"&",
"Cache",
"{",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"cache",
".",
"db",
",",
"err",
"=",
"leveldb",
".",
"OpenFile",
"(",
"path",
",",
... | // New returns a new Cache that will store leveldb in path | [
"New",
"returns",
"a",
"new",
"Cache",
"that",
"will",
"store",
"leveldb",
"in",
"path"
] | 3befbb6ad0cc97d4c25d851e9528915809e1a22f | https://github.com/gregjones/httpcache/blob/3befbb6ad0cc97d4c25d851e9528915809e1a22f/leveldbcache/leveldbcache.go#L35-L45 |
14,226 | mattn/go-colorable | colorable_windows.go | doTitleSequence | 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 | 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
} | [
"func",
"doTitleSequence",
"(",
"er",
"*",
"bytes",
".",
"Reader",
")",
"error",
"{",
"var",
"c",
"byte",
"\n",
"var",
"err",
"error",
"\n\n",
"c",
",",
"err",
"=",
"er",
".",
"ReadByte",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"... | // `\033]0;TITLESTR\007` | [
"\\",
"033",
"]",
"0",
";",
"TITLESTR",
"\\",
"007"
] | 3a70a971f94a22f2fa562ffcc7a0eb45f5daf045 | https://github.com/mattn/go-colorable/blob/3a70a971f94a22f2fa562ffcc7a0eb45f5daf045/colorable_windows.go#L379-L415 |
14,227 | kylelemons/go-gypsy | yaml/parser.go | Parse | 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 | 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
} | [
"func",
"Parse",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"node",
"Node",
",",
"err",
"error",
")",
"{",
"lb",
":=",
"&",
"lineBuffer",
"{",
"Reader",
":",
"bufio",
".",
"NewReader",
"(",
"r",
")",
",",
"}",
"\n\n",
"defer",
"func",
"(",
")",
"... | // Parse returns a root-level Node parsed from the lines read from r. In
// general, this will be done for you by one of the File constructors. | [
"Parse",
"returns",
"a",
"root",
"-",
"level",
"Node",
"parsed",
"from",
"the",
"lines",
"read",
"from",
"r",
".",
"In",
"general",
"this",
"will",
"be",
"done",
"for",
"you",
"by",
"one",
"of",
"the",
"File",
"constructors",
"."
] | 08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8 | https://github.com/kylelemons/go-gypsy/blob/08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8/yaml/parser.go#L28-L48 |
14,228 | kylelemons/go-gypsy | yaml/config.go | ReadFile | 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 | 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
} | [
"func",
"ReadFile",
"(",
"filename",
"string",
")",
"(",
"*",
"File",
",",
"error",
")",
"{",
"fin",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"filename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"... | // ReadFile reads a YAML configuration file from the given filename. | [
"ReadFile",
"reads",
"a",
"YAML",
"configuration",
"file",
"from",
"the",
"given",
"filename",
"."
] | 08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8 | https://github.com/kylelemons/go-gypsy/blob/08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8/yaml/config.go#L34-L48 |
14,229 | kylelemons/go-gypsy | yaml/config.go | Config | 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 | 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
} | [
"func",
"Config",
"(",
"yamlconf",
"string",
")",
"*",
"File",
"{",
"var",
"err",
"error",
"\n",
"buf",
":=",
"bytes",
".",
"NewBufferString",
"(",
"yamlconf",
")",
"\n\n",
"f",
":=",
"new",
"(",
"File",
")",
"\n",
"f",
".",
"Root",
",",
"err",
"="... | // Config reads a YAML configuration from a static string. If an error is
// found, it will panic. This is a utility function and is intended for use in
// initializers. | [
"Config",
"reads",
"a",
"YAML",
"configuration",
"from",
"a",
"static",
"string",
".",
"If",
"an",
"error",
"is",
"found",
"it",
"will",
"panic",
".",
"This",
"is",
"a",
"utility",
"function",
"and",
"is",
"intended",
"for",
"use",
"in",
"initializers",
... | 08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8 | https://github.com/kylelemons/go-gypsy/blob/08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8/yaml/config.go#L53-L64 |
14,230 | kylelemons/go-gypsy | yaml/config.go | ConfigFile | func ConfigFile(filename string) *File {
f, err := ReadFile(filename)
if err != nil {
panic(err)
}
return f
} | go | func ConfigFile(filename string) *File {
f, err := ReadFile(filename)
if err != nil {
panic(err)
}
return f
} | [
"func",
"ConfigFile",
"(",
"filename",
"string",
")",
"*",
"File",
"{",
"f",
",",
"err",
":=",
"ReadFile",
"(",
"filename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"f",
"\n",
"}"
] | // ConfigFile reads a YAML configuration file from the given filename and
// panics if an error is found. This is a utility function and is intended for
// use in initializers. | [
"ConfigFile",
"reads",
"a",
"YAML",
"configuration",
"file",
"from",
"the",
"given",
"filename",
"and",
"panics",
"if",
"an",
"error",
"is",
"found",
".",
"This",
"is",
"a",
"utility",
"function",
"and",
"is",
"intended",
"for",
"use",
"in",
"initializers",
... | 08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8 | https://github.com/kylelemons/go-gypsy/blob/08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8/yaml/config.go#L69-L75 |
14,231 | kylelemons/go-gypsy | yaml/config.go | Get | 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 | 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
} | [
"func",
"(",
"f",
"*",
"File",
")",
"Get",
"(",
"spec",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"node",
",",
"err",
":=",
"Child",
"(",
"f",
".",
"Root",
",",
"spec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"... | // Get retrieves a scalar from the file specified by a string of the same
// format as that expected by Child. If the final node is not a Scalar, Get
// will return an error. | [
"Get",
"retrieves",
"a",
"scalar",
"from",
"the",
"file",
"specified",
"by",
"a",
"string",
"of",
"the",
"same",
"format",
"as",
"that",
"expected",
"by",
"Child",
".",
"If",
"the",
"final",
"node",
"is",
"not",
"a",
"Scalar",
"Get",
"will",
"return",
... | 08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8 | https://github.com/kylelemons/go-gypsy/blob/08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8/yaml/config.go#L80-L104 |
14,232 | kylelemons/go-gypsy | yaml/config.go | Count | 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 | 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
} | [
"func",
"(",
"f",
"*",
"File",
")",
"Count",
"(",
"spec",
"string",
")",
"(",
"int",
",",
"error",
")",
"{",
"node",
",",
"err",
":=",
"Child",
"(",
"f",
".",
"Root",
",",
"spec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
... | // Count retrieves a the number of elements in the specified list from the file
// using the same format as that expected by Child. If the final node is not a
// List, Count will return an error. | [
"Count",
"retrieves",
"a",
"the",
"number",
"of",
"elements",
"in",
"the",
"specified",
"list",
"from",
"the",
"file",
"using",
"the",
"same",
"format",
"as",
"that",
"expected",
"by",
"Child",
".",
"If",
"the",
"final",
"node",
"is",
"not",
"a",
"List",... | 08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8 | https://github.com/kylelemons/go-gypsy/blob/08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8/yaml/config.go#L137-L161 |
14,233 | kylelemons/go-gypsy | yaml/config.go | Require | func (f *File) Require(spec string) string {
str, err := f.Get(spec)
if err != nil {
panic(err)
}
return str
} | go | func (f *File) Require(spec string) string {
str, err := f.Get(spec)
if err != nil {
panic(err)
}
return str
} | [
"func",
"(",
"f",
"*",
"File",
")",
"Require",
"(",
"spec",
"string",
")",
"string",
"{",
"str",
",",
"err",
":=",
"f",
".",
"Get",
"(",
"spec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"s... | // Require retrieves a scalar from the file specified by a string of the same
// format as that expected by Child. If the final node is not a Scalar, String
// will panic. This is a convenience function for use in initializers. | [
"Require",
"retrieves",
"a",
"scalar",
"from",
"the",
"file",
"specified",
"by",
"a",
"string",
"of",
"the",
"same",
"format",
"as",
"that",
"expected",
"by",
"Child",
".",
"If",
"the",
"final",
"node",
"is",
"not",
"a",
"Scalar",
"String",
"will",
"pani... | 08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8 | https://github.com/kylelemons/go-gypsy/blob/08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8/yaml/config.go#L166-L172 |
14,234 | kylelemons/go-gypsy | yaml/types.go | Item | func (node List) Item(idx int) Node {
if idx >= 0 && idx < len(node) {
return node[idx]
}
return nil
} | go | func (node List) Item(idx int) Node {
if idx >= 0 && idx < len(node) {
return node[idx]
}
return nil
} | [
"func",
"(",
"node",
"List",
")",
"Item",
"(",
"idx",
"int",
")",
"Node",
"{",
"if",
"idx",
">=",
"0",
"&&",
"idx",
"<",
"len",
"(",
"node",
")",
"{",
"return",
"node",
"[",
"idx",
"]",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Get the idx'th item from the List. | [
"Get",
"the",
"idx",
"th",
"item",
"from",
"the",
"List",
"."
] | 08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8 | https://github.com/kylelemons/go-gypsy/blob/08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8/yaml/types.go#L85-L90 |
14,235 | kylelemons/go-gypsy | yaml/types.go | Render | func Render(node Node) string {
buf := bytes.NewBuffer(nil)
node.write(buf, 0, 0)
return buf.String()
} | go | func Render(node Node) string {
buf := bytes.NewBuffer(nil)
node.write(buf, 0, 0)
return buf.String()
} | [
"func",
"Render",
"(",
"node",
"Node",
")",
"string",
"{",
"buf",
":=",
"bytes",
".",
"NewBuffer",
"(",
"nil",
")",
"\n",
"node",
".",
"write",
"(",
"buf",
",",
"0",
",",
"0",
")",
"\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
] | // Render returns a string of the node as a YAML document. Note that
// Scalars will have a newline appended if they are rendered directly. | [
"Render",
"returns",
"a",
"string",
"of",
"the",
"node",
"as",
"a",
"YAML",
"document",
".",
"Note",
"that",
"Scalars",
"will",
"have",
"a",
"newline",
"appended",
"if",
"they",
"are",
"rendered",
"directly",
"."
] | 08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8 | https://github.com/kylelemons/go-gypsy/blob/08cad365cd28a7fba23bb1e57aa43c5e18ad8bb8/yaml/types.go#L116-L120 |
14,236 | zenazn/goji | example/main.go | NotFound | func NotFound(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Umm... have you tried turning it off and on again?", 404)
} | go | func NotFound(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Umm... have you tried turning it off and on again?", 404)
} | [
"func",
"NotFound",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"http",
".",
"Error",
"(",
"w",
",",
"\"",
"\"",
",",
"404",
")",
"\n",
"}"
] | // NotFound is a 404 handler. | [
"NotFound",
"is",
"a",
"404",
"handler",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/example/main.go#L175-L177 |
14,237 | zenazn/goji | default.go | Insert | func Insert(middleware, before web.MiddlewareType) error {
return DefaultMux.Insert(middleware, before)
} | go | func Insert(middleware, before web.MiddlewareType) error {
return DefaultMux.Insert(middleware, before)
} | [
"func",
"Insert",
"(",
"middleware",
",",
"before",
"web",
".",
"MiddlewareType",
")",
"error",
"{",
"return",
"DefaultMux",
".",
"Insert",
"(",
"middleware",
",",
"before",
")",
"\n",
"}"
] | // Insert the given middleware into the default Mux's middleware stack. See the
// documentation for web.Mux.Insert for more information. | [
"Insert",
"the",
"given",
"middleware",
"into",
"the",
"default",
"Mux",
"s",
"middleware",
"stack",
".",
"See",
"the",
"documentation",
"for",
"web",
".",
"Mux",
".",
"Insert",
"for",
"more",
"information",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/default.go#L28-L30 |
14,238 | zenazn/goji | default.go | Handle | func Handle(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Handle(pattern, handler)
} | go | func Handle(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Handle(pattern, handler)
} | [
"func",
"Handle",
"(",
"pattern",
"web",
".",
"PatternType",
",",
"handler",
"web",
".",
"HandlerType",
")",
"{",
"DefaultMux",
".",
"Handle",
"(",
"pattern",
",",
"handler",
")",
"\n",
"}"
] | // Handle adds a route to the default Mux. See the documentation for web.Mux for
// more information about what types this function accepts. | [
"Handle",
"adds",
"a",
"route",
"to",
"the",
"default",
"Mux",
".",
"See",
"the",
"documentation",
"for",
"web",
".",
"Mux",
"for",
"more",
"information",
"about",
"what",
"types",
"this",
"function",
"accepts",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/default.go#L40-L42 |
14,239 | zenazn/goji | default.go | Connect | func Connect(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Connect(pattern, handler)
} | go | func Connect(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Connect(pattern, handler)
} | [
"func",
"Connect",
"(",
"pattern",
"web",
".",
"PatternType",
",",
"handler",
"web",
".",
"HandlerType",
")",
"{",
"DefaultMux",
".",
"Connect",
"(",
"pattern",
",",
"handler",
")",
"\n",
"}"
] | // Connect adds a CONNECT route to the default Mux. See the documentation for
// web.Mux for more information about what types this function accepts. | [
"Connect",
"adds",
"a",
"CONNECT",
"route",
"to",
"the",
"default",
"Mux",
".",
"See",
"the",
"documentation",
"for",
"web",
".",
"Mux",
"for",
"more",
"information",
"about",
"what",
"types",
"this",
"function",
"accepts",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/default.go#L46-L48 |
14,240 | zenazn/goji | default.go | Delete | func Delete(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Delete(pattern, handler)
} | go | func Delete(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Delete(pattern, handler)
} | [
"func",
"Delete",
"(",
"pattern",
"web",
".",
"PatternType",
",",
"handler",
"web",
".",
"HandlerType",
")",
"{",
"DefaultMux",
".",
"Delete",
"(",
"pattern",
",",
"handler",
")",
"\n",
"}"
] | // Delete adds a DELETE route to the default Mux. See the documentation for
// web.Mux for more information about what types this function accepts. | [
"Delete",
"adds",
"a",
"DELETE",
"route",
"to",
"the",
"default",
"Mux",
".",
"See",
"the",
"documentation",
"for",
"web",
".",
"Mux",
"for",
"more",
"information",
"about",
"what",
"types",
"this",
"function",
"accepts",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/default.go#L52-L54 |
14,241 | zenazn/goji | default.go | Get | func Get(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Get(pattern, handler)
} | go | func Get(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Get(pattern, handler)
} | [
"func",
"Get",
"(",
"pattern",
"web",
".",
"PatternType",
",",
"handler",
"web",
".",
"HandlerType",
")",
"{",
"DefaultMux",
".",
"Get",
"(",
"pattern",
",",
"handler",
")",
"\n",
"}"
] | // Get adds a GET route to the default Mux. See the documentation for web.Mux for
// more information about what types this function accepts. | [
"Get",
"adds",
"a",
"GET",
"route",
"to",
"the",
"default",
"Mux",
".",
"See",
"the",
"documentation",
"for",
"web",
".",
"Mux",
"for",
"more",
"information",
"about",
"what",
"types",
"this",
"function",
"accepts",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/default.go#L58-L60 |
14,242 | zenazn/goji | default.go | Head | func Head(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Head(pattern, handler)
} | go | func Head(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Head(pattern, handler)
} | [
"func",
"Head",
"(",
"pattern",
"web",
".",
"PatternType",
",",
"handler",
"web",
".",
"HandlerType",
")",
"{",
"DefaultMux",
".",
"Head",
"(",
"pattern",
",",
"handler",
")",
"\n",
"}"
] | // Head adds a HEAD route to the default Mux. See the documentation for web.Mux
// for more information about what types this function accepts. | [
"Head",
"adds",
"a",
"HEAD",
"route",
"to",
"the",
"default",
"Mux",
".",
"See",
"the",
"documentation",
"for",
"web",
".",
"Mux",
"for",
"more",
"information",
"about",
"what",
"types",
"this",
"function",
"accepts",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/default.go#L64-L66 |
14,243 | zenazn/goji | default.go | Options | func Options(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Options(pattern, handler)
} | go | func Options(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Options(pattern, handler)
} | [
"func",
"Options",
"(",
"pattern",
"web",
".",
"PatternType",
",",
"handler",
"web",
".",
"HandlerType",
")",
"{",
"DefaultMux",
".",
"Options",
"(",
"pattern",
",",
"handler",
")",
"\n",
"}"
] | // Options adds a OPTIONS route to the default Mux. See the documentation for
// web.Mux for more information about what types this function accepts. | [
"Options",
"adds",
"a",
"OPTIONS",
"route",
"to",
"the",
"default",
"Mux",
".",
"See",
"the",
"documentation",
"for",
"web",
".",
"Mux",
"for",
"more",
"information",
"about",
"what",
"types",
"this",
"function",
"accepts",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/default.go#L70-L72 |
14,244 | zenazn/goji | default.go | Patch | func Patch(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Patch(pattern, handler)
} | go | func Patch(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Patch(pattern, handler)
} | [
"func",
"Patch",
"(",
"pattern",
"web",
".",
"PatternType",
",",
"handler",
"web",
".",
"HandlerType",
")",
"{",
"DefaultMux",
".",
"Patch",
"(",
"pattern",
",",
"handler",
")",
"\n",
"}"
] | // Patch adds a PATCH route to the default Mux. See the documentation for web.Mux
// for more information about what types this function accepts. | [
"Patch",
"adds",
"a",
"PATCH",
"route",
"to",
"the",
"default",
"Mux",
".",
"See",
"the",
"documentation",
"for",
"web",
".",
"Mux",
"for",
"more",
"information",
"about",
"what",
"types",
"this",
"function",
"accepts",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/default.go#L76-L78 |
14,245 | zenazn/goji | default.go | Post | func Post(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Post(pattern, handler)
} | go | func Post(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Post(pattern, handler)
} | [
"func",
"Post",
"(",
"pattern",
"web",
".",
"PatternType",
",",
"handler",
"web",
".",
"HandlerType",
")",
"{",
"DefaultMux",
".",
"Post",
"(",
"pattern",
",",
"handler",
")",
"\n",
"}"
] | // Post adds a POST route to the default Mux. See the documentation for web.Mux
// for more information about what types this function accepts. | [
"Post",
"adds",
"a",
"POST",
"route",
"to",
"the",
"default",
"Mux",
".",
"See",
"the",
"documentation",
"for",
"web",
".",
"Mux",
"for",
"more",
"information",
"about",
"what",
"types",
"this",
"function",
"accepts",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/default.go#L82-L84 |
14,246 | zenazn/goji | default.go | Put | func Put(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Put(pattern, handler)
} | go | func Put(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Put(pattern, handler)
} | [
"func",
"Put",
"(",
"pattern",
"web",
".",
"PatternType",
",",
"handler",
"web",
".",
"HandlerType",
")",
"{",
"DefaultMux",
".",
"Put",
"(",
"pattern",
",",
"handler",
")",
"\n",
"}"
] | // Put adds a PUT route to the default Mux. See the documentation for web.Mux for
// more information about what types this function accepts. | [
"Put",
"adds",
"a",
"PUT",
"route",
"to",
"the",
"default",
"Mux",
".",
"See",
"the",
"documentation",
"for",
"web",
".",
"Mux",
"for",
"more",
"information",
"about",
"what",
"types",
"this",
"function",
"accepts",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/default.go#L88-L90 |
14,247 | zenazn/goji | default.go | Trace | func Trace(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Trace(pattern, handler)
} | go | func Trace(pattern web.PatternType, handler web.HandlerType) {
DefaultMux.Trace(pattern, handler)
} | [
"func",
"Trace",
"(",
"pattern",
"web",
".",
"PatternType",
",",
"handler",
"web",
".",
"HandlerType",
")",
"{",
"DefaultMux",
".",
"Trace",
"(",
"pattern",
",",
"handler",
")",
"\n",
"}"
] | // Trace adds a TRACE route to the default Mux. See the documentation for
// web.Mux for more information about what types this function accepts. | [
"Trace",
"adds",
"a",
"TRACE",
"route",
"to",
"the",
"default",
"Mux",
".",
"See",
"the",
"documentation",
"for",
"web",
".",
"Mux",
"for",
"more",
"information",
"about",
"what",
"types",
"this",
"function",
"accepts",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/default.go#L94-L96 |
14,248 | zenazn/goji | web/middleware/request_id.go | GetReqID | 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 | 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 ""
} | [
"func",
"GetReqID",
"(",
"c",
"web",
".",
"C",
")",
"string",
"{",
"if",
"c",
".",
"Env",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"v",
",",
"ok",
":=",
"c",
".",
"Env",
"[",
"RequestIDKey",
"]",
"\n",
"if",
"!",
"ok",
"{",
... | // GetReqID returns a request ID from the given context if one is present.
// Returns the empty string if a request ID cannot be found. | [
"GetReqID",
"returns",
"a",
"request",
"ID",
"from",
"the",
"given",
"context",
"if",
"one",
"is",
"present",
".",
"Returns",
"the",
"empty",
"string",
"if",
"a",
"request",
"ID",
"cannot",
"be",
"found",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/web/middleware/request_id.go#L76-L88 |
14,249 | zenazn/goji | web/middleware/options.go | AutomaticOptions | 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 | 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)
} | [
"func",
"AutomaticOptions",
"(",
"c",
"*",
"web",
".",
"C",
",",
"h",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"fn",
":=",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"r... | // AutomaticOptions automatically return an appropriate "Allow" header when the
// request method is OPTIONS and the request would have otherwise been 404'd. | [
"AutomaticOptions",
"automatically",
"return",
"an",
"appropriate",
"Allow",
"header",
"when",
"the",
"request",
"method",
"is",
"OPTIONS",
"and",
"the",
"request",
"would",
"have",
"otherwise",
"been",
"404",
"d",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/web/middleware/options.go#L64-L74 |
14,250 | zenazn/goji | web/web.go | ServeHTTPC | func (h HandlerFunc) ServeHTTPC(c C, w http.ResponseWriter, r *http.Request) {
h(c, w, r)
} | go | func (h HandlerFunc) ServeHTTPC(c C, w http.ResponseWriter, r *http.Request) {
h(c, w, r)
} | [
"func",
"(",
"h",
"HandlerFunc",
")",
"ServeHTTPC",
"(",
"c",
"C",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"h",
"(",
"c",
",",
"w",
",",
"r",
")",
"\n",
"}"
] | // ServeHTTPC implements Handler. | [
"ServeHTTPC",
"implements",
"Handler",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/web/web.go#L53-L55 |
14,251 | zenazn/goji | web/middleware/urlquery.go | URLQuery | 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 | 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)
} | [
"func",
"URLQuery",
"(",
"c",
"*",
"web",
".",
"C",
",",
"h",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"fn",
":=",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"c",
"."... | // URLQuery is a middleware to parse the URL Query parameters just once,
// and store the resulting url.Values in the context. | [
"URLQuery",
"is",
"a",
"middleware",
"to",
"parse",
"the",
"URL",
"Query",
"parameters",
"just",
"once",
"and",
"store",
"the",
"resulting",
"url",
".",
"Values",
"in",
"the",
"context",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/web/middleware/urlquery.go#L13-L24 |
14,252 | zenazn/goji | web/middleware/envinit.go | EnvInit | func EnvInit(c *web.C, h http.Handler) http.Handler {
return envInit{c, h}
} | go | func EnvInit(c *web.C, h http.Handler) http.Handler {
return envInit{c, h}
} | [
"func",
"EnvInit",
"(",
"c",
"*",
"web",
".",
"C",
",",
"h",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"return",
"envInit",
"{",
"c",
",",
"h",
"}",
"\n",
"}"
] | // EnvInit is a middleware that allocates an environment map if it is nil. While
// it's impossible in general to ensure that Env is never nil in a middleware
// stack, in most common cases placing this middleware at the top of the stack
// will eliminate the need for repetative nil checks. | [
"EnvInit",
"is",
"a",
"middleware",
"that",
"allocates",
"an",
"environment",
"map",
"if",
"it",
"is",
"nil",
".",
"While",
"it",
"s",
"impossible",
"in",
"general",
"to",
"ensure",
"that",
"Env",
"is",
"never",
"nil",
"in",
"a",
"middleware",
"stack",
"... | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/web/middleware/envinit.go#L25-L27 |
14,253 | zenazn/goji | example/middleware.go | SuperSecure | 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 | 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)
} | [
"func",
"SuperSecure",
"(",
"c",
"*",
"web",
".",
"C",
",",
"h",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"fn",
":=",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"auth",
":=",... | // SuperSecure is HTTP Basic Auth middleware for super-secret admin page. Shhhh! | [
"SuperSecure",
"is",
"HTTP",
"Basic",
"Auth",
"middleware",
"for",
"super",
"-",
"secret",
"admin",
"page",
".",
"Shhhh!"
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/example/middleware.go#L24-L41 |
14,254 | zenazn/goji | bind/bind.go | Sniff | 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 | 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 ""
} | [
"func",
"Sniff",
"(",
")",
"string",
"{",
"if",
"bind",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
";",
"bind",
"!=",
"\"",
"\"",
"{",
"return",
"bind",
"\n",
"}",
"else",
"if",
"usingEinhorn",
"(",
")",
"{",
"return",
"\"",
"\"",
"\n",
"... | // Sniff attempts to select a sensible default bind string by examining its
// environment. It examines the GOJI_BIND environment variable, Einhorn,
// systemd, and the PORT environment variable, in that order, selecting the
// first plausible option. It returns the empty string if no sensible default
// could be extracted from the environment. | [
"Sniff",
"attempts",
"to",
"select",
"a",
"sensible",
"default",
"bind",
"string",
"by",
"examining",
"its",
"environment",
".",
"It",
"examines",
"the",
"GOJI_BIND",
"environment",
"variable",
"Einhorn",
"systemd",
"and",
"the",
"PORT",
"environment",
"variable",... | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/bind/bind.go#L86-L97 |
14,255 | zenazn/goji | bind/bind.go | Socket | func Socket(bind string) net.Listener {
l, err := listenTo(bind)
if err != nil {
log.Fatal(err)
}
return l
} | go | func Socket(bind string) net.Listener {
l, err := listenTo(bind)
if err != nil {
log.Fatal(err)
}
return l
} | [
"func",
"Socket",
"(",
"bind",
"string",
")",
"net",
".",
"Listener",
"{",
"l",
",",
"err",
":=",
"listenTo",
"(",
"bind",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"l",
"\n",
"}"... | // Socket parses and binds to the specified address. If Socket encounters an
// error while parsing or binding to the given socket it will exit by calling
// log.Fatal. | [
"Socket",
"parses",
"and",
"binds",
"to",
"the",
"specified",
"address",
".",
"If",
"Socket",
"encounters",
"an",
"error",
"while",
"parsing",
"or",
"binding",
"to",
"the",
"given",
"socket",
"it",
"will",
"exit",
"by",
"calling",
"log",
".",
"Fatal",
"."
... | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/bind/bind.go#L128-L134 |
14,256 | zenazn/goji | web/mutil/writer_proxy.go | WrapWriter | 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 | 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
} | [
"func",
"WrapWriter",
"(",
"w",
"http",
".",
"ResponseWriter",
")",
"WriterProxy",
"{",
"_",
",",
"cn",
":=",
"w",
".",
"(",
"http",
".",
"CloseNotifier",
")",
"\n",
"_",
",",
"fl",
":=",
"w",
".",
"(",
"http",
".",
"Flusher",
")",
"\n",
"_",
","... | // WrapWriter wraps an http.ResponseWriter, returning a proxy that allows you to
// hook into various parts of the response process. | [
"WrapWriter",
"wraps",
"an",
"http",
".",
"ResponseWriter",
"returning",
"a",
"proxy",
"that",
"allows",
"you",
"to",
"hook",
"into",
"various",
"parts",
"of",
"the",
"response",
"process",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/web/mutil/writer_proxy.go#L32-L46 |
14,257 | zenazn/goji | graceful/listener/listener.go | Accept | 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 | 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
} | [
"func",
"(",
"t",
"*",
"T",
")",
"Accept",
"(",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"c",
",",
"err",
":=",
"t",
".",
"l",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"... | // Accept waits for and returns the next connection to the listener. The
// returned net.Conn's idleness is tracked, and idle connections can be closed
// from the associated T. | [
"Accept",
"waits",
"for",
"and",
"returns",
"the",
"next",
"connection",
"to",
"the",
"listener",
".",
"The",
"returned",
"net",
".",
"Conn",
"s",
"idleness",
"is",
"tracked",
"and",
"idle",
"connections",
"can",
"be",
"closed",
"from",
"the",
"associated",
... | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/graceful/listener/listener.go#L74-L92 |
14,258 | zenazn/goji | graceful/listener/listener.go | CloseIdle | 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 | 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
} | [
"func",
"(",
"t",
"*",
"T",
")",
"CloseIdle",
"(",
")",
"error",
"{",
"for",
"i",
":=",
"range",
"t",
".",
"shards",
"{",
"t",
".",
"shards",
"[",
"i",
"]",
".",
"closeConns",
"(",
"false",
",",
"false",
")",
"\n",
"}",
"\n",
"// Not sure if retu... | // CloseIdle closes all connections that are currently marked as being idle. It,
// however, makes no attempt to wait for in-use connections to die, or to close
// connections which become idle in the future. Call this function if you're
// interested in shedding useless connections, but otherwise wish to continue
// serving requests. | [
"CloseIdle",
"closes",
"all",
"connections",
"that",
"are",
"currently",
"marked",
"as",
"being",
"idle",
".",
"It",
"however",
"makes",
"no",
"attempt",
"to",
"wait",
"for",
"in",
"-",
"use",
"connections",
"to",
"die",
"or",
"to",
"close",
"connections",
... | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/graceful/listener/listener.go#L109-L115 |
14,259 | zenazn/goji | graceful/listener/listener.go | Drain | 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 | 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
} | [
"func",
"(",
"t",
"*",
"T",
")",
"Drain",
"(",
")",
"error",
"{",
"for",
"i",
":=",
"range",
"t",
".",
"shards",
"{",
"t",
".",
"shards",
"[",
"i",
"]",
".",
"closeConns",
"(",
"false",
",",
"true",
")",
"\n",
"}",
"\n",
"for",
"i",
":=",
"... | // Drain immediately closes all idle connections, prevents new connections from
// being accepted, and waits for all outstanding connections to finish.
//
// Once a listener has been drained, there is no way to re-enable it. You
// probably want to Close the listener before draining it, otherwise new
// connections will be accepted and immediately closed. | [
"Drain",
"immediately",
"closes",
"all",
"idle",
"connections",
"prevents",
"new",
"connections",
"from",
"being",
"accepted",
"and",
"waits",
"for",
"all",
"outstanding",
"connections",
"to",
"finish",
".",
"Once",
"a",
"listener",
"has",
"been",
"drained",
"th... | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/graceful/listener/listener.go#L123-L131 |
14,260 | zenazn/goji | graceful/listener/listener.go | Disown | func Disown(c net.Conn) error {
if cn, ok := c.(*conn); ok {
return cn.disown()
}
return errNotManaged
} | go | func Disown(c net.Conn) error {
if cn, ok := c.(*conn); ok {
return cn.disown()
}
return errNotManaged
} | [
"func",
"Disown",
"(",
"c",
"net",
".",
"Conn",
")",
"error",
"{",
"if",
"cn",
",",
"ok",
":=",
"c",
".",
"(",
"*",
"conn",
")",
";",
"ok",
"{",
"return",
"cn",
".",
"disown",
"(",
")",
"\n",
"}",
"\n",
"return",
"errNotManaged",
"\n",
"}"
] | // Disown causes a connection to no longer be tracked by the listener. The
// passed connection must have been returned by a call to Accept from this
// listener. | [
"Disown",
"causes",
"a",
"connection",
"to",
"no",
"longer",
"be",
"tracked",
"by",
"the",
"listener",
".",
"The",
"passed",
"connection",
"must",
"have",
"been",
"returned",
"by",
"a",
"call",
"to",
"Accept",
"from",
"this",
"listener",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/graceful/listener/listener.go#L151-L156 |
14,261 | zenazn/goji | graceful/listener/listener.go | MarkIdle | func MarkIdle(c net.Conn) error {
if cn, ok := c.(*conn); ok {
cn.markIdle()
return nil
}
return errNotManaged
} | go | func MarkIdle(c net.Conn) error {
if cn, ok := c.(*conn); ok {
cn.markIdle()
return nil
}
return errNotManaged
} | [
"func",
"MarkIdle",
"(",
"c",
"net",
".",
"Conn",
")",
"error",
"{",
"if",
"cn",
",",
"ok",
":=",
"c",
".",
"(",
"*",
"conn",
")",
";",
"ok",
"{",
"cn",
".",
"markIdle",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"errNotManaged... | // MarkIdle marks the given connection as being idle, and therefore eligible for
// closing at any time. The passed connection must have been returned by a call
// to Accept from this listener. | [
"MarkIdle",
"marks",
"the",
"given",
"connection",
"as",
"being",
"idle",
"and",
"therefore",
"eligible",
"for",
"closing",
"at",
"any",
"time",
".",
"The",
"passed",
"connection",
"must",
"have",
"been",
"returned",
"by",
"a",
"call",
"to",
"Accept",
"from"... | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/graceful/listener/listener.go#L161-L167 |
14,262 | zenazn/goji | graceful/listener/listener.go | MarkInUse | func MarkInUse(c net.Conn) error {
if cn, ok := c.(*conn); ok {
cn.markInUse()
return nil
}
return errNotManaged
} | go | func MarkInUse(c net.Conn) error {
if cn, ok := c.(*conn); ok {
cn.markInUse()
return nil
}
return errNotManaged
} | [
"func",
"MarkInUse",
"(",
"c",
"net",
".",
"Conn",
")",
"error",
"{",
"if",
"cn",
",",
"ok",
":=",
"c",
".",
"(",
"*",
"conn",
")",
";",
"ok",
"{",
"cn",
".",
"markInUse",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"errNotManag... | // MarkInUse marks this connection as being in use, removing it from the set of
// connections which are eligible for closing. The passed connection must have
// been returned by a call to Accept from this listener. | [
"MarkInUse",
"marks",
"this",
"connection",
"as",
"being",
"in",
"use",
"removing",
"it",
"from",
"the",
"set",
"of",
"connections",
"which",
"are",
"eligible",
"for",
"closing",
".",
"The",
"passed",
"connection",
"must",
"have",
"been",
"returned",
"by",
"... | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/graceful/listener/listener.go#L172-L178 |
14,263 | zenazn/goji | graceful/graceful.go | peacefulError | 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 | 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
} | [
"func",
"peacefulError",
"(",
"err",
"error",
")",
"error",
"{",
"if",
"atomic",
".",
"LoadInt32",
"(",
"&",
"closing",
")",
"==",
"0",
"{",
"return",
"err",
"\n",
"}",
"\n",
"// Unfortunately Go doesn't really give us a better way to select errors",
"// than this, ... | // During graceful shutdown, calls to Accept will start returning errors. This
// is inconvenient, since we know these sorts of errors are peaceful, so we
// silently swallow them. | [
"During",
"graceful",
"shutdown",
"calls",
"to",
"Accept",
"will",
"start",
"returning",
"errors",
".",
"This",
"is",
"inconvenient",
"since",
"we",
"know",
"these",
"sorts",
"of",
"errors",
"are",
"peaceful",
"so",
"we",
"silently",
"swallow",
"them",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/graceful/graceful.go#L45-L65 |
14,264 | zenazn/goji | example/models.go | Write | 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 | 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))
} | [
"func",
"(",
"g",
"Greet",
")",
"Write",
"(",
"w",
"io",
".",
"Writer",
")",
"{",
"fmt",
".",
"Fprintf",
"(",
"w",
",",
"\"",
"\\n",
"\\n",
"\\n",
"\"",
",",
"g",
".",
"Message",
",",
"g",
".",
"User",
",",
"g",
".",
"Time",
".",
"Format",
... | // Write out a representation of the greet | [
"Write",
"out",
"a",
"representation",
"of",
"the",
"greet"
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/example/models.go#L28-L31 |
14,265 | zenazn/goji | example/models.go | Write | func (u User) Write(w io.Writer, handle string) {
fmt.Fprintf(w, "%s (@%s)\n%s\n", u.Name, handle, u.Bio)
} | go | func (u User) Write(w io.Writer, handle string) {
fmt.Fprintf(w, "%s (@%s)\n%s\n", u.Name, handle, u.Bio)
} | [
"func",
"(",
"u",
"User",
")",
"Write",
"(",
"w",
"io",
".",
"Writer",
",",
"handle",
"string",
")",
"{",
"fmt",
".",
"Fprintf",
"(",
"w",
",",
"\"",
"\\n",
"\\n",
"\"",
",",
"u",
".",
"Name",
",",
"handle",
",",
"u",
".",
"Bio",
")",
"\n",
... | // Write out the user | [
"Write",
"out",
"the",
"user"
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/example/models.go#L47-L49 |
14,266 | zenazn/goji | web/mux.go | New | 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 | 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
} | [
"func",
"New",
"(",
")",
"*",
"Mux",
"{",
"mux",
":=",
"Mux",
"{",
"ms",
":",
"mStack",
"{",
"stack",
":",
"make",
"(",
"[",
"]",
"mLayer",
",",
"0",
")",
",",
"pool",
":",
"makeCPool",
"(",
")",
",",
"}",
",",
"rt",
":",
"router",
"{",
"ro... | // New creates a new Mux without any routes or middleware. | [
"New",
"creates",
"a",
"new",
"Mux",
"without",
"any",
"routes",
"or",
"middleware",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/web/mux.go#L27-L40 |
14,267 | zenazn/goji | web/mux.go | ServeHTTPC | 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 | 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)
} | [
"func",
"(",
"m",
"*",
"Mux",
")",
"ServeHTTPC",
"(",
"c",
"C",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"stack",
":=",
"m",
".",
"ms",
".",
"alloc",
"(",
")",
"\n",
"stack",
".",
"ServeHTTPC",
"... | // ServeHTTPC creates a context dependent request with the given Mux. Satisfies
// the Handler interface. | [
"ServeHTTPC",
"creates",
"a",
"context",
"dependent",
"request",
"with",
"the",
"given",
"Mux",
".",
"Satisfies",
"the",
"Handler",
"interface",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/web/mux.go#L51-L55 |
14,268 | zenazn/goji | web/mux.go | Connect | func (m *Mux) Connect(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mCONNECT, handler)
} | go | func (m *Mux) Connect(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mCONNECT, handler)
} | [
"func",
"(",
"m",
"*",
"Mux",
")",
"Connect",
"(",
"pattern",
"PatternType",
",",
"handler",
"HandlerType",
")",
"{",
"m",
".",
"rt",
".",
"handleUntyped",
"(",
"pattern",
",",
"mCONNECT",
",",
"handler",
")",
"\n",
"}"
] | // Connect dispatches to the given handler when the pattern matches and the HTTP
// method is CONNECT. | [
"Connect",
"dispatches",
"to",
"the",
"given",
"handler",
"when",
"the",
"pattern",
"matches",
"and",
"the",
"HTTP",
"method",
"is",
"CONNECT",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/web/mux.go#L140-L142 |
14,269 | zenazn/goji | web/mux.go | Delete | func (m *Mux) Delete(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mDELETE, handler)
} | go | func (m *Mux) Delete(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mDELETE, handler)
} | [
"func",
"(",
"m",
"*",
"Mux",
")",
"Delete",
"(",
"pattern",
"PatternType",
",",
"handler",
"HandlerType",
")",
"{",
"m",
".",
"rt",
".",
"handleUntyped",
"(",
"pattern",
",",
"mDELETE",
",",
"handler",
")",
"\n",
"}"
] | // Delete dispatches to the given handler when the pattern matches and the HTTP
// method is DELETE. | [
"Delete",
"dispatches",
"to",
"the",
"given",
"handler",
"when",
"the",
"pattern",
"matches",
"and",
"the",
"HTTP",
"method",
"is",
"DELETE",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/web/mux.go#L146-L148 |
14,270 | zenazn/goji | web/mux.go | Head | func (m *Mux) Head(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mHEAD, handler)
} | go | func (m *Mux) Head(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mHEAD, handler)
} | [
"func",
"(",
"m",
"*",
"Mux",
")",
"Head",
"(",
"pattern",
"PatternType",
",",
"handler",
"HandlerType",
")",
"{",
"m",
".",
"rt",
".",
"handleUntyped",
"(",
"pattern",
",",
"mHEAD",
",",
"handler",
")",
"\n",
"}"
] | // Head dispatches to the given handler when the pattern matches and the HTTP
// method is HEAD. | [
"Head",
"dispatches",
"to",
"the",
"given",
"handler",
"when",
"the",
"pattern",
"matches",
"and",
"the",
"HTTP",
"method",
"is",
"HEAD",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/web/mux.go#L163-L165 |
14,271 | zenazn/goji | web/mux.go | Options | func (m *Mux) Options(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mOPTIONS, handler)
} | go | func (m *Mux) Options(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mOPTIONS, handler)
} | [
"func",
"(",
"m",
"*",
"Mux",
")",
"Options",
"(",
"pattern",
"PatternType",
",",
"handler",
"HandlerType",
")",
"{",
"m",
".",
"rt",
".",
"handleUntyped",
"(",
"pattern",
",",
"mOPTIONS",
",",
"handler",
")",
"\n",
"}"
] | // Options dispatches to the given handler when the pattern matches and the HTTP
// method is OPTIONS. | [
"Options",
"dispatches",
"to",
"the",
"given",
"handler",
"when",
"the",
"pattern",
"matches",
"and",
"the",
"HTTP",
"method",
"is",
"OPTIONS",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/web/mux.go#L169-L171 |
14,272 | zenazn/goji | web/mux.go | Patch | func (m *Mux) Patch(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mPATCH, handler)
} | go | func (m *Mux) Patch(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mPATCH, handler)
} | [
"func",
"(",
"m",
"*",
"Mux",
")",
"Patch",
"(",
"pattern",
"PatternType",
",",
"handler",
"HandlerType",
")",
"{",
"m",
".",
"rt",
".",
"handleUntyped",
"(",
"pattern",
",",
"mPATCH",
",",
"handler",
")",
"\n",
"}"
] | // Patch dispatches to the given handler when the pattern matches and the HTTP
// method is PATCH. | [
"Patch",
"dispatches",
"to",
"the",
"given",
"handler",
"when",
"the",
"pattern",
"matches",
"and",
"the",
"HTTP",
"method",
"is",
"PATCH",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/web/mux.go#L175-L177 |
14,273 | zenazn/goji | web/mux.go | Post | func (m *Mux) Post(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mPOST, handler)
} | go | func (m *Mux) Post(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mPOST, handler)
} | [
"func",
"(",
"m",
"*",
"Mux",
")",
"Post",
"(",
"pattern",
"PatternType",
",",
"handler",
"HandlerType",
")",
"{",
"m",
".",
"rt",
".",
"handleUntyped",
"(",
"pattern",
",",
"mPOST",
",",
"handler",
")",
"\n",
"}"
] | // Post dispatches to the given handler when the pattern matches and the HTTP
// method is POST. | [
"Post",
"dispatches",
"to",
"the",
"given",
"handler",
"when",
"the",
"pattern",
"matches",
"and",
"the",
"HTTP",
"method",
"is",
"POST",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/web/mux.go#L181-L183 |
14,274 | zenazn/goji | web/mux.go | Put | func (m *Mux) Put(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mPUT, handler)
} | go | func (m *Mux) Put(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mPUT, handler)
} | [
"func",
"(",
"m",
"*",
"Mux",
")",
"Put",
"(",
"pattern",
"PatternType",
",",
"handler",
"HandlerType",
")",
"{",
"m",
".",
"rt",
".",
"handleUntyped",
"(",
"pattern",
",",
"mPUT",
",",
"handler",
")",
"\n",
"}"
] | // Put dispatches to the given handler when the pattern matches and the HTTP
// method is PUT. | [
"Put",
"dispatches",
"to",
"the",
"given",
"handler",
"when",
"the",
"pattern",
"matches",
"and",
"the",
"HTTP",
"method",
"is",
"PUT",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/web/mux.go#L187-L189 |
14,275 | zenazn/goji | web/mux.go | Trace | func (m *Mux) Trace(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mTRACE, handler)
} | go | func (m *Mux) Trace(pattern PatternType, handler HandlerType) {
m.rt.handleUntyped(pattern, mTRACE, handler)
} | [
"func",
"(",
"m",
"*",
"Mux",
")",
"Trace",
"(",
"pattern",
"PatternType",
",",
"handler",
"HandlerType",
")",
"{",
"m",
".",
"rt",
".",
"handleUntyped",
"(",
"pattern",
",",
"mTRACE",
",",
"handler",
")",
"\n",
"}"
] | // Trace dispatches to the given handler when the pattern matches and the HTTP
// method is TRACE. | [
"Trace",
"dispatches",
"to",
"the",
"given",
"handler",
"when",
"the",
"pattern",
"matches",
"and",
"the",
"HTTP",
"method",
"is",
"TRACE",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/web/mux.go#L193-L195 |
14,276 | zenazn/goji | serve.go | ServeTLS | func ServeTLS(config *tls.Config) {
if !flag.Parsed() {
flag.Parse()
}
ServeListener(tls.NewListener(bind.Default(), config))
} | go | func ServeTLS(config *tls.Config) {
if !flag.Parsed() {
flag.Parse()
}
ServeListener(tls.NewListener(bind.Default(), config))
} | [
"func",
"ServeTLS",
"(",
"config",
"*",
"tls",
".",
"Config",
")",
"{",
"if",
"!",
"flag",
".",
"Parsed",
"(",
")",
"{",
"flag",
".",
"Parse",
"(",
")",
"\n",
"}",
"\n\n",
"ServeListener",
"(",
"tls",
".",
"NewListener",
"(",
"bind",
".",
"Default"... | // Like Serve, but enables TLS using the given config. | [
"Like",
"Serve",
"but",
"enables",
"TLS",
"using",
"the",
"given",
"config",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/serve.go#L35-L41 |
14,277 | zenazn/goji | serve.go | ServeListener | 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 | 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()
} | [
"func",
"ServeListener",
"(",
"listener",
"net",
".",
"Listener",
")",
"{",
"DefaultMux",
".",
"Compile",
"(",
")",
"\n",
"// Install our handler at the root of the standard net/http default mux.",
"// This allows packages like expvar to continue working as expected.",
"http",
".... | // Like Serve, but runs Goji on top of an arbitrary net.Listener. | [
"Like",
"Serve",
"but",
"runs",
"Goji",
"on",
"top",
"of",
"an",
"arbitrary",
"net",
".",
"Listener",
"."
] | 84fcf9f2a841e8e9124cfadbdf0f45132a9b821e | https://github.com/zenazn/goji/blob/84fcf9f2a841e8e9124cfadbdf0f45132a9b821e/serve.go#L44-L64 |
14,278 | go-ozzo/ozzo-routing | fault/panic.go | getCallStack | 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 | 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()
} | [
"func",
"getCallStack",
"(",
"skip",
"int",
")",
"string",
"{",
"buf",
":=",
"new",
"(",
"bytes",
".",
"Buffer",
")",
"\n",
"for",
"i",
":=",
"skip",
";",
";",
"i",
"++",
"{",
"_",
",",
"file",
",",
"line",
",",
"ok",
":=",
"runtime",
".",
"Cal... | // getCallStack returns the current call stack information as a string.
// The skip parameter specifies how many top frames should be skipped. | [
"getCallStack",
"returns",
"the",
"current",
"call",
"stack",
"information",
"as",
"a",
"string",
".",
"The",
"skip",
"parameter",
"specifies",
"how",
"many",
"top",
"frames",
"should",
"be",
"skipped",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/fault/panic.go#L46-L56 |
14,279 | go-ozzo/ozzo-routing | group.go | newRouteGroup | func newRouteGroup(prefix string, router *Router, handlers []Handler) *RouteGroup {
return &RouteGroup{
prefix: prefix,
router: router,
handlers: handlers,
}
} | go | func newRouteGroup(prefix string, router *Router, handlers []Handler) *RouteGroup {
return &RouteGroup{
prefix: prefix,
router: router,
handlers: handlers,
}
} | [
"func",
"newRouteGroup",
"(",
"prefix",
"string",
",",
"router",
"*",
"Router",
",",
"handlers",
"[",
"]",
"Handler",
")",
"*",
"RouteGroup",
"{",
"return",
"&",
"RouteGroup",
"{",
"prefix",
":",
"prefix",
",",
"router",
":",
"router",
",",
"handlers",
"... | // newRouteGroup creates a new RouteGroup with the given path prefix, router, and handlers. | [
"newRouteGroup",
"creates",
"a",
"new",
"RouteGroup",
"with",
"the",
"given",
"path",
"prefix",
"router",
"and",
"handlers",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/group.go#L17-L23 |
14,280 | go-ozzo/ozzo-routing | group.go | Delete | func (rg *RouteGroup) Delete(path string, handlers ...Handler) *Route {
return rg.add("DELETE", path, handlers)
} | go | func (rg *RouteGroup) Delete(path string, handlers ...Handler) *Route {
return rg.add("DELETE", path, handlers)
} | [
"func",
"(",
"rg",
"*",
"RouteGroup",
")",
"Delete",
"(",
"path",
"string",
",",
"handlers",
"...",
"Handler",
")",
"*",
"Route",
"{",
"return",
"rg",
".",
"add",
"(",
"\"",
"\"",
",",
"path",
",",
"handlers",
")",
"\n",
"}"
] | // Delete adds a DELETE route to the router with the given route path and handlers. | [
"Delete",
"adds",
"a",
"DELETE",
"route",
"to",
"the",
"router",
"with",
"the",
"given",
"route",
"path",
"and",
"handlers",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/group.go#L46-L48 |
14,281 | go-ozzo/ozzo-routing | group.go | combineHandlers | 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 | func combineHandlers(h1 []Handler, h2 []Handler) []Handler {
hh := make([]Handler, len(h1)+len(h2))
copy(hh, h1)
copy(hh[len(h1):], h2)
return hh
} | [
"func",
"combineHandlers",
"(",
"h1",
"[",
"]",
"Handler",
",",
"h2",
"[",
"]",
"Handler",
")",
"[",
"]",
"Handler",
"{",
"hh",
":=",
"make",
"(",
"[",
"]",
"Handler",
",",
"len",
"(",
"h1",
")",
"+",
"len",
"(",
"h2",
")",
")",
"\n",
"copy",
... | // combineHandlers merges two lists of handlers into a new list. | [
"combineHandlers",
"merges",
"two",
"lists",
"of",
"handlers",
"into",
"a",
"new",
"list",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/group.go#L125-L130 |
14,282 | go-ozzo/ozzo-routing | cors/handler.go | Handler | 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 | 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
}
} | [
"func",
"Handler",
"(",
"opts",
"Options",
")",
"routing",
".",
"Handler",
"{",
"opts",
".",
"init",
"(",
")",
"\n\n",
"return",
"func",
"(",
"c",
"*",
"routing",
".",
"Context",
")",
"(",
"err",
"error",
")",
"{",
"origin",
":=",
"c",
".",
"Reques... | // Handler creates a routing handler that adds appropriate CORS headers according to the specified options and the request. | [
"Handler",
"creates",
"a",
"routing",
"handler",
"that",
"adds",
"appropriate",
"CORS",
"headers",
"according",
"to",
"the",
"specified",
"options",
"and",
"the",
"request",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/cors/handler.go#L59-L84 |
14,283 | go-ozzo/ozzo-routing | route.go | Tag | 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 | 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
} | [
"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",
... | // Tag associates some custom data with the route. | [
"Tag",
"associates",
"some",
"custom",
"data",
"with",
"the",
"route",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/route.go#L31-L44 |
14,284 | go-ozzo/ozzo-routing | route.go | Get | func (r *Route) Get(handlers ...Handler) *Route {
return r.group.add("GET", r.path, handlers)
} | go | func (r *Route) Get(handlers ...Handler) *Route {
return r.group.add("GET", r.path, handlers)
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"Get",
"(",
"handlers",
"...",
"Handler",
")",
"*",
"Route",
"{",
"return",
"r",
".",
"group",
".",
"add",
"(",
"\"",
"\"",
",",
"r",
".",
"path",
",",
"handlers",
")",
"\n",
"}"
] | // Get adds the route to the router using the GET HTTP method. | [
"Get",
"adds",
"the",
"route",
"to",
"the",
"router",
"using",
"the",
"GET",
"HTTP",
"method",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/route.go#L62-L64 |
14,285 | go-ozzo/ozzo-routing | route.go | Post | func (r *Route) Post(handlers ...Handler) *Route {
return r.group.add("POST", r.path, handlers)
} | go | func (r *Route) Post(handlers ...Handler) *Route {
return r.group.add("POST", r.path, handlers)
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"Post",
"(",
"handlers",
"...",
"Handler",
")",
"*",
"Route",
"{",
"return",
"r",
".",
"group",
".",
"add",
"(",
"\"",
"\"",
",",
"r",
".",
"path",
",",
"handlers",
")",
"\n",
"}"
] | // Post adds the route to the router using the POST HTTP method. | [
"Post",
"adds",
"the",
"route",
"to",
"the",
"router",
"using",
"the",
"POST",
"HTTP",
"method",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/route.go#L67-L69 |
14,286 | go-ozzo/ozzo-routing | route.go | Put | func (r *Route) Put(handlers ...Handler) *Route {
return r.group.add("PUT", r.path, handlers)
} | go | func (r *Route) Put(handlers ...Handler) *Route {
return r.group.add("PUT", r.path, handlers)
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"Put",
"(",
"handlers",
"...",
"Handler",
")",
"*",
"Route",
"{",
"return",
"r",
".",
"group",
".",
"add",
"(",
"\"",
"\"",
",",
"r",
".",
"path",
",",
"handlers",
")",
"\n",
"}"
] | // Put adds the route to the router using the PUT HTTP method. | [
"Put",
"adds",
"the",
"route",
"to",
"the",
"router",
"using",
"the",
"PUT",
"HTTP",
"method",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/route.go#L72-L74 |
14,287 | go-ozzo/ozzo-routing | route.go | Patch | func (r *Route) Patch(handlers ...Handler) *Route {
return r.group.add("PATCH", r.path, handlers)
} | go | func (r *Route) Patch(handlers ...Handler) *Route {
return r.group.add("PATCH", r.path, handlers)
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"Patch",
"(",
"handlers",
"...",
"Handler",
")",
"*",
"Route",
"{",
"return",
"r",
".",
"group",
".",
"add",
"(",
"\"",
"\"",
",",
"r",
".",
"path",
",",
"handlers",
")",
"\n",
"}"
] | // Patch adds the route to the router using the PATCH HTTP method. | [
"Patch",
"adds",
"the",
"route",
"to",
"the",
"router",
"using",
"the",
"PATCH",
"HTTP",
"method",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/route.go#L77-L79 |
14,288 | go-ozzo/ozzo-routing | route.go | Delete | func (r *Route) Delete(handlers ...Handler) *Route {
return r.group.add("DELETE", r.path, handlers)
} | go | func (r *Route) Delete(handlers ...Handler) *Route {
return r.group.add("DELETE", r.path, handlers)
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"Delete",
"(",
"handlers",
"...",
"Handler",
")",
"*",
"Route",
"{",
"return",
"r",
".",
"group",
".",
"add",
"(",
"\"",
"\"",
",",
"r",
".",
"path",
",",
"handlers",
")",
"\n",
"}"
] | // Delete adds the route to the router using the DELETE HTTP method. | [
"Delete",
"adds",
"the",
"route",
"to",
"the",
"router",
"using",
"the",
"DELETE",
"HTTP",
"method",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/route.go#L82-L84 |
14,289 | go-ozzo/ozzo-routing | route.go | Connect | func (r *Route) Connect(handlers ...Handler) *Route {
return r.group.add("CONNECT", r.path, handlers)
} | go | func (r *Route) Connect(handlers ...Handler) *Route {
return r.group.add("CONNECT", r.path, handlers)
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"Connect",
"(",
"handlers",
"...",
"Handler",
")",
"*",
"Route",
"{",
"return",
"r",
".",
"group",
".",
"add",
"(",
"\"",
"\"",
",",
"r",
".",
"path",
",",
"handlers",
")",
"\n",
"}"
] | // Connect adds the route to the router using the CONNECT HTTP method. | [
"Connect",
"adds",
"the",
"route",
"to",
"the",
"router",
"using",
"the",
"CONNECT",
"HTTP",
"method",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/route.go#L87-L89 |
14,290 | go-ozzo/ozzo-routing | route.go | Head | func (r *Route) Head(handlers ...Handler) *Route {
return r.group.add("HEAD", r.path, handlers)
} | go | func (r *Route) Head(handlers ...Handler) *Route {
return r.group.add("HEAD", r.path, handlers)
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"Head",
"(",
"handlers",
"...",
"Handler",
")",
"*",
"Route",
"{",
"return",
"r",
".",
"group",
".",
"add",
"(",
"\"",
"\"",
",",
"r",
".",
"path",
",",
"handlers",
")",
"\n",
"}"
] | // Head adds the route to the router using the HEAD HTTP method. | [
"Head",
"adds",
"the",
"route",
"to",
"the",
"router",
"using",
"the",
"HEAD",
"HTTP",
"method",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/route.go#L92-L94 |
14,291 | go-ozzo/ozzo-routing | route.go | Options | func (r *Route) Options(handlers ...Handler) *Route {
return r.group.add("OPTIONS", r.path, handlers)
} | go | func (r *Route) Options(handlers ...Handler) *Route {
return r.group.add("OPTIONS", r.path, handlers)
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"Options",
"(",
"handlers",
"...",
"Handler",
")",
"*",
"Route",
"{",
"return",
"r",
".",
"group",
".",
"add",
"(",
"\"",
"\"",
",",
"r",
".",
"path",
",",
"handlers",
")",
"\n",
"}"
] | // Options adds the route to the router using the OPTIONS HTTP method. | [
"Options",
"adds",
"the",
"route",
"to",
"the",
"router",
"using",
"the",
"OPTIONS",
"HTTP",
"method",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/route.go#L97-L99 |
14,292 | go-ozzo/ozzo-routing | route.go | Trace | func (r *Route) Trace(handlers ...Handler) *Route {
return r.group.add("TRACE", r.path, handlers)
} | go | func (r *Route) Trace(handlers ...Handler) *Route {
return r.group.add("TRACE", r.path, handlers)
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"Trace",
"(",
"handlers",
"...",
"Handler",
")",
"*",
"Route",
"{",
"return",
"r",
".",
"group",
".",
"add",
"(",
"\"",
"\"",
",",
"r",
".",
"path",
",",
"handlers",
")",
"\n",
"}"
] | // Trace adds the route to the router using the TRACE HTTP method. | [
"Trace",
"adds",
"the",
"route",
"to",
"the",
"router",
"using",
"the",
"TRACE",
"HTTP",
"method",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/route.go#L102-L104 |
14,293 | go-ozzo/ozzo-routing | route.go | URL | 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 | 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
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"URL",
"(",
"pairs",
"...",
"interface",
"{",
"}",
")",
"(",
"s",
"string",
")",
"{",
"s",
"=",
"r",
".",
"template",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"pairs",
")",
";",
"i",
"++",... | // URL creates a URL using the current route and the given parameters.
// The parameters should be given in the sequence of name1, value1, name2, value2, and so on.
// If a parameter in the route is not provided a value, the parameter token will remain in the resulting URL.
// The method will perform URL encoding for all given parameter values. | [
"URL",
"creates",
"a",
"URL",
"using",
"the",
"current",
"route",
"and",
"the",
"given",
"parameters",
".",
"The",
"parameters",
"should",
"be",
"given",
"in",
"the",
"sequence",
"of",
"name1",
"value1",
"name2",
"value2",
"and",
"so",
"on",
".",
"If",
"... | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/route.go#L116-L127 |
14,294 | go-ozzo/ozzo-routing | route.go | String | func (r *Route) String() string {
return r.method + " " + r.group.prefix + r.path
} | go | func (r *Route) String() string {
return r.method + " " + r.group.prefix + r.path
} | [
"func",
"(",
"r",
"*",
"Route",
")",
"String",
"(",
")",
"string",
"{",
"return",
"r",
".",
"method",
"+",
"\"",
"\"",
"+",
"r",
".",
"group",
".",
"prefix",
"+",
"r",
".",
"path",
"\n",
"}"
] | // String returns the string representation of the route. | [
"String",
"returns",
"the",
"string",
"representation",
"of",
"the",
"route",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/route.go#L130-L132 |
14,295 | go-ozzo/ozzo-routing | context.go | NewContext | func NewContext(res http.ResponseWriter, req *http.Request, handlers ...Handler) *Context {
c := &Context{handlers: handlers}
c.init(res, req)
return c
} | go | func NewContext(res http.ResponseWriter, req *http.Request, handlers ...Handler) *Context {
c := &Context{handlers: handlers}
c.init(res, req)
return c
} | [
"func",
"NewContext",
"(",
"res",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
",",
"handlers",
"...",
"Handler",
")",
"*",
"Context",
"{",
"c",
":=",
"&",
"Context",
"{",
"handlers",
":",
"handlers",
"}",
"\n",
"c",
".",
"... | // NewContext creates a new Context object with the given response, request, and the handlers.
// This method is primarily provided for writing unit tests for handlers. | [
"NewContext",
"creates",
"a",
"new",
"Context",
"object",
"with",
"the",
"given",
"response",
"request",
"and",
"the",
"handlers",
".",
"This",
"method",
"is",
"primarily",
"provided",
"for",
"writing",
"unit",
"tests",
"for",
"handlers",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/context.go#L26-L30 |
14,296 | go-ozzo/ozzo-routing | context.go | Param | func (c *Context) Param(name string) string {
for i, n := range c.pnames {
if n == name {
return c.pvalues[i]
}
}
return ""
} | go | func (c *Context) Param(name string) string {
for i, n := range c.pnames {
if n == name {
return c.pvalues[i]
}
}
return ""
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"Param",
"(",
"name",
"string",
")",
"string",
"{",
"for",
"i",
",",
"n",
":=",
"range",
"c",
".",
"pnames",
"{",
"if",
"n",
"==",
"name",
"{",
"return",
"c",
".",
"pvalues",
"[",
"i",
"]",
"\n",
"}",
"\... | // Param returns the named parameter value that is found in the URL path matching the current route.
// If the named parameter cannot be found, an empty string will be returned. | [
"Param",
"returns",
"the",
"named",
"parameter",
"value",
"that",
"is",
"found",
"in",
"the",
"URL",
"path",
"matching",
"the",
"current",
"route",
".",
"If",
"the",
"named",
"parameter",
"cannot",
"be",
"found",
"an",
"empty",
"string",
"will",
"be",
"ret... | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/context.go#L39-L46 |
14,297 | go-ozzo/ozzo-routing | context.go | SetParam | 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 | 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)
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"SetParam",
"(",
"name",
",",
"value",
"string",
")",
"{",
"for",
"i",
",",
"n",
":=",
"range",
"c",
".",
"pnames",
"{",
"if",
"n",
"==",
"name",
"{",
"c",
".",
"pvalues",
"[",
"i",
"]",
"=",
"value",
"\... | // SetParam sets the named parameter value.
// This method is primarily provided for writing unit tests. | [
"SetParam",
"sets",
"the",
"named",
"parameter",
"value",
".",
"This",
"method",
"is",
"primarily",
"provided",
"for",
"writing",
"unit",
"tests",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/context.go#L50-L59 |
14,298 | go-ozzo/ozzo-routing | context.go | Set | func (c *Context) Set(name string, value interface{}) {
if c.data == nil {
c.data = make(map[string]interface{})
}
c.data[name] = value
} | go | func (c *Context) Set(name string, value interface{}) {
if c.data == nil {
c.data = make(map[string]interface{})
}
c.data[name] = value
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"Set",
"(",
"name",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"{",
"if",
"c",
".",
"data",
"==",
"nil",
"{",
"c",
".",
"data",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
... | // Set stores the named data item in the context so that it can be retrieved later. | [
"Set",
"stores",
"the",
"named",
"data",
"item",
"in",
"the",
"context",
"so",
"that",
"it",
"can",
"be",
"retrieved",
"later",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/context.go#L68-L73 |
14,299 | go-ozzo/ozzo-routing | context.go | Query | 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 | 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 ""
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"Query",
"(",
"name",
"string",
",",
"defaultValue",
"...",
"string",
")",
"string",
"{",
"if",
"vs",
",",
"_",
":=",
"c",
".",
"Request",
".",
"URL",
".",
"Query",
"(",
")",
"[",
"name",
"]",
";",
"len",
... | // Query returns the first value for the named component of the URL query parameters.
// If key is not present, it returns the specified default value or an empty string. | [
"Query",
"returns",
"the",
"first",
"value",
"for",
"the",
"named",
"component",
"of",
"the",
"URL",
"query",
"parameters",
".",
"If",
"key",
"is",
"not",
"present",
"it",
"returns",
"the",
"specified",
"default",
"value",
"or",
"an",
"empty",
"string",
".... | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/context.go#L77-L85 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.