_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q12800 | kern_procargs | train | func kern_procargs(pid int,
exe func(string),
argv func(string),
env func(string, string)) error {
mib := []C.int{C.CTL_KERN, C.KERN_PROCARGS2, C.int(pid)}
argmax := uintptr(C.ARG_MAX)
buf := make([]byte, argmax)
err := sysctl(mib, &buf[0], &argmax, nil, 0)
if err != nil {
return nil
}
bbuf := bytes.NewBuffer(buf)
bbuf.Truncate(int(argmax))
var argc int32
binary.Read(bbuf, binary.LittleEndian, &argc)
path, err := bbuf.ReadBytes(0)
if exe != nil {
exe(string(chop(path)))
}
// skip trailing \0's
for {
c, _ := bbuf.ReadByte()
if c != 0 {
bbuf.UnreadByte()
break // start of argv[0]
}
}
for i := 0; i < int(argc); i++ {
arg, err := bbuf.ReadBytes(0)
if err == io.EOF {
break
}
if argv != nil {
argv(string(chop(arg)))
}
}
if env == nil {
return nil
}
delim := []byte{61} // "="
for {
line, err := bbuf.ReadBytes(0)
if err == io.EOF || line[0] == 0 {
break
}
pair := bytes.SplitN(chop(line), delim, 2)
env(string(pair[0]), string(pair[1]))
}
return nil
} | go | {
"resource": ""
} |
q12801 | sysctl | train | func sysctl(mib []C.int, old *byte, oldlen *uintptr,
new *byte, newlen uintptr) (err error) {
var p0 unsafe.Pointer
p0 = unsafe.Pointer(&mib[0])
_, _, e1 := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(p0),
uintptr(len(mib)),
uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)),
uintptr(unsafe.Pointer(new)), uintptr(newlen))
if e1 != 0 {
err = e1
}
return
} | go | {
"resource": ""
} |
q12802 | createListener | train | func createListener() (eventListener, error) {
listener := &netlinkListener{}
err := listener.bind()
return listener, err
} | go | {
"resource": ""
} |
q12803 | readEvents | train | func (w *Watcher) readEvents() {
buf := make([]byte, syscall.Getpagesize())
listener, _ := w.listener.(*netlinkListener)
for {
if w.isDone() {
return
}
nr, _, err := syscall.Recvfrom(listener.sock, buf, 0)
if err != nil {
w.Error <- err
continue
}
if nr < syscall.NLMSG_HDRLEN {
w.Error <- syscall.EINVAL
continue
}
msgs, _ := syscall.ParseNetlinkMessage(buf[:nr])
for _, m := range msgs {
if m.Header.Type == syscall.NLMSG_DONE {
w.handleEvent(m.Data)
}
}
}
} | go | {
"resource": ""
} |
q12804 | isWatching | train | func (w *Watcher) isWatching(pid int, event uint32) bool {
w.watchesMutex.Lock()
defer w.watchesMutex.Unlock()
if watch, ok := w.watches[pid]; ok {
return (watch.flags & event) == event
}
return false
} | go | {
"resource": ""
} |
q12805 | bind | train | func (listener *netlinkListener) bind() error {
sock, err := syscall.Socket(
syscall.AF_NETLINK,
syscall.SOCK_DGRAM,
syscall.NETLINK_CONNECTOR)
if err != nil {
return err
}
listener.sock = sock
listener.addr = &syscall.SockaddrNetlink{
Family: syscall.AF_NETLINK,
Groups: _CN_IDX_PROC,
}
err = syscall.Bind(listener.sock, listener.addr)
if err != nil {
return err
}
return listener.send(_PROC_CN_MCAST_LISTEN)
} | go | {
"resource": ""
} |
q12806 | close | train | func (listener *netlinkListener) close() error {
err := listener.send(_PROC_CN_MCAST_IGNORE)
syscall.Close(listener.sock)
return err
} | go | {
"resource": ""
} |
q12807 | FormatSize | train | func FormatSize(size uint64) string {
ord := []string{"K", "M", "G", "T", "P", "E"}
o := 0
buf := new(bytes.Buffer)
w := bufio.NewWriter(buf)
if size < 973 {
fmt.Fprintf(w, "%3d ", size)
w.Flush()
return buf.String()
}
for {
remain := size & 1023
size >>= 10
if size >= 973 {
o++
continue
}
if size < 9 || (size == 9 && remain < 973) {
remain = ((remain * 5) + 256) / 512
if remain >= 10 {
size++
remain = 0
}
fmt.Fprintf(w, "%d.%d%s", size, remain, ord[o])
break
}
if remain >= 512 {
size++
}
fmt.Fprintf(w, "%3d%s", size, ord[o])
break
}
w.Flush()
return buf.String()
} | go | {
"resource": ""
} |
q12808 | SymbolsByRune | train | func SymbolsByRune(def Definition) map[rune]string {
out := map[rune]string{}
for s, r := range def.Symbols() {
out[r] = s
}
return out
} | go | {
"resource": ""
} |
q12809 | NameOfReader | train | func NameOfReader(r interface{}) string {
if nr, ok := r.(interface{ Name() string }); ok {
return nr.Name()
}
return ""
} | go | {
"resource": ""
} |
q12810 | ConsumeAll | train | func ConsumeAll(lexer Lexer) ([]Token, error) {
tokens := []Token{}
for {
token, err := lexer.Next()
if err != nil {
return nil, err
}
tokens = append(tokens, token)
if token.Type == EOF {
return tokens, nil
}
}
} | go | {
"resource": ""
} |
q12811 | RuneToken | train | func RuneToken(r rune) Token {
return Token{Type: r, Value: string(r)}
} | go | {
"resource": ""
} |
q12812 | MakeSymbolTable | train | func MakeSymbolTable(def Definition, types ...string) (map[rune]bool, error) {
symbols := def.Symbols()
table := map[rune]bool{}
for _, symbol := range types {
rn, ok := symbols[symbol]
if !ok {
return nil, fmt.Errorf("lexer does not support symbol %q", symbol)
}
table[rn] = true
}
return table, nil
} | go | {
"resource": ""
} |
q12813 | Upgrade | train | func Upgrade(lexer Lexer) PeekingLexer {
if peeking, ok := lexer.(PeekingLexer); ok {
return peeking
}
return &lookaheadLexer{Lexer: lexer}
} | go | {
"resource": ""
} |
q12814 | Defer | train | func (p *parseContext) Defer(pos lexer.Position, strct reflect.Value, field structLexerField, fieldValue []reflect.Value) {
p.apply = append(p.apply, &contextFieldSet{pos, strct, field, fieldValue})
} | go | {
"resource": ""
} |
q12815 | Apply | train | func (p *parseContext) Apply() error {
for _, apply := range p.apply {
if err := setField(apply.pos, apply.strct, apply.field, apply.fieldValue); err != nil {
return err
}
}
p.apply = nil
return nil
} | go | {
"resource": ""
} |
q12816 | Accept | train | func (p *parseContext) Accept(branch *parseContext) {
p.apply = append(p.apply, branch.apply...)
p.rewinder = branch.rewinder
} | go | {
"resource": ""
} |
q12817 | Branch | train | func (p *parseContext) Branch() *parseContext {
branch := &parseContext{}
*branch = *p
branch.apply = nil
branch.rewinder = p.rewinder.Lookahead()
return branch
} | go | {
"resource": ""
} |
q12818 | Stop | train | func (p *parseContext) Stop(branch *parseContext) bool {
if branch.cursor > p.cursor+p.lookahead {
p.Accept(branch)
return true
}
return false
} | go | {
"resource": ""
} |
q12819 | Lookahead | train | func (r *rewinder) Lookahead() *rewinder {
clone := &rewinder{}
*clone = *r
clone.limit = clone.cursor
return clone
} | go | {
"resource": ""
} |
q12820 | LexWithScanner | train | func LexWithScanner(r io.Reader, scan *scanner.Scanner) Lexer {
return lexWithScanner(r, scan)
} | go | {
"resource": ""
} |
q12821 | Map | train | func Map(mapper Mapper, symbols ...string) Option {
return func(p *Parser) error {
p.mappers = append(p.mappers, mapperByToken{
mapper: mapper,
symbols: symbols,
})
return nil
}
} | go | {
"resource": ""
} |
q12822 | Upper | train | func Upper(types ...string) Option {
return Map(func(token lexer.Token) (lexer.Token, error) {
token.Value = strings.ToUpper(token.Value)
return token, nil
}, types...)
} | go | {
"resource": ""
} |
q12823 | Elide | train | func Elide(types ...string) Option {
return Map(func(token lexer.Token) (lexer.Token, error) {
return lexer.Token{}, DropToken
}, types...)
} | go | {
"resource": ""
} |
q12824 | parseTerm | train | func (p *parser) parseTerm() (x Expression) {
pos := p.pos
switch p.tok {
case scanner.Ident:
x = p.parseIdentifier()
case scanner.String:
x = p.parseRange()
case '(':
p.next()
x = &Group{pos, p.parseExpression()}
p.expect(')')
case '[':
p.next()
x = &Option{pos, p.parseExpression()}
p.expect(']')
case '{':
p.next()
x = &Repetition{pos, p.parseExpression()}
p.expect('}')
}
return x
} | go | {
"resource": ""
} |
q12825 | Parse | train | func Parse(filename string, src io.Reader) (Grammar, error) {
var p parser
grammar := p.parse(filename, src)
return grammar, p.errors.Err()
} | go | {
"resource": ""
} |
q12826 | optimize | train | func (e *ebnfLexerDefinition) optimize(expr internal.Expression) internal.Expression {
switch n := expr.(type) {
case internal.Alternative:
// Convert alternate characters into a character set (eg. "a" | "b" | "c" | "true" becomes
// set("abc") | "true").
out := make(internal.Alternative, 0, len(n))
set := ""
for _, expr := range n {
if t, ok := expr.(*internal.Token); ok && utf8.RuneCountInString(t.String) == 1 {
set += t.String
continue
}
// Hit a node that is not a single-character Token. Flush set?
if set != "" {
out = append(out, &characterSet{pos: n.Pos(), Set: set})
set = ""
}
out = append(out, e.optimize(expr))
}
if set != "" {
out = append(out, &characterSet{pos: n.Pos(), Set: set})
}
return out
case internal.Sequence:
for i, expr := range n {
n[i] = e.optimize(expr)
}
case *internal.Group:
n.Body = e.optimize(n.Body)
case *internal.Option:
n.Body = e.optimize(n.Body)
case *internal.Repetition:
n.Body = e.optimize(n.Body)
case *internal.Range:
// Convert range into a set.
begin, end := beginEnd(n)
set := &rangeSet{
pos: n.Pos(),
include: [2]rune{begin, end},
}
for next := n.Exclude; next != nil; {
switch n := next.(type) {
case *internal.Range:
begin, end := beginEnd(n)
set.exclude = append(set.exclude, [2]rune{begin, end})
next = n.Exclude
case *internal.Token:
rn, _ := utf8.DecodeRuneInString(n.String)
set.exclude = append(set.exclude, [2]rune{rn, rn})
next = nil
default:
panic(fmt.Sprintf("should not have encountered %T", n))
}
}
// Use an asciiSet if the characters are in ASCII range.
return makeSet(n.Pos(), set)
case *internal.Token:
return &ebnfToken{pos: n.Pos(), runes: []rune(n.String)}
}
return expr
} | go | {
"resource": ""
} |
q12827 | validate | train | func validate(grammar internal.Grammar, expr internal.Expression) error { // nolint: gocyclo
switch n := expr.(type) {
case *internal.Production:
return validate(grammar, n.Expr)
case internal.Alternative:
for _, e := range n {
if err := validate(grammar, e); err != nil {
return err
}
}
return nil
case *internal.Group:
return validate(grammar, n.Body)
case *internal.Name:
if grammar.Index[n.String] == nil {
return lexer.Errorf(lexer.Position(n.Pos()), "unknown production %q", n.String)
}
return nil
case *internal.Option:
return validate(grammar, n.Body)
case *internal.Range:
if utf8.RuneCountInString(n.Begin.String) != 1 {
return lexer.Errorf(lexer.Position(n.Pos()), "start of range must be a single rune")
}
if utf8.RuneCountInString(n.End.String) != 1 {
return lexer.Errorf(lexer.Position(n.Pos()), "end of range must be a single rune")
}
return nil
case *internal.Repetition:
return validate(grammar, n.Body)
case internal.Sequence:
for _, e := range n {
if err := validate(grammar, e); err != nil {
return err
}
}
return nil
case *internal.Token:
return nil
case nil:
return nil
}
return lexer.Errorf(lexer.Position(expr.Pos()), "unknown EBNF expression %T", expr)
} | go | {
"resource": ""
} |
q12828 | Lex | train | func (p *Parser) Lex(r io.Reader) ([]lexer.Token, error) {
lex, err := p.lex.Lex(r)
if err != nil {
return nil, err
}
return lexer.ConsumeAll(lex)
} | go | {
"resource": ""
} |
q12829 | Lexer | train | func Lexer(def lexer.Definition) Option {
return func(p *Parser) error {
p.lex = def
return nil
}
} | go | {
"resource": ""
} |
q12830 | UseLookahead | train | func UseLookahead(n int) Option {
return func(p *Parser) error {
p.useLookahead = n
return nil
}
} | go | {
"resource": ""
} |
q12831 | CaseInsensitive | train | func CaseInsensitive(tokens ...string) Option {
return func(p *Parser) error {
for _, token := range tokens {
p.caseInsensitive[token] = true
}
return nil
}
} | go | {
"resource": ""
} |
q12832 | collectFieldIndexes | train | func collectFieldIndexes(s reflect.Type) (out [][]int, err error) {
if s.Kind() != reflect.Struct {
return nil, fmt.Errorf("expected a struct but got %q", s)
}
defer decorate(&err, s.String)
for i := 0; i < s.NumField(); i++ {
f := s.Field(i)
if f.Anonymous {
children, err := collectFieldIndexes(f.Type)
if err != nil {
return nil, err
}
for _, idx := range children {
out = append(out, append(f.Index, idx...))
}
} else if fieldLexerTag(f) != "" {
out = append(out, f.Index)
}
}
return
} | go | {
"resource": ""
} |
q12833 | parseType | train | func (g *generatorContext) parseType(t reflect.Type) (_ node, returnedError error) {
rt := t
t = indirectType(t)
if n, ok := g.typeNodes[t]; ok {
return n, nil
}
if rt.Implements(parseableType) {
return &parseable{rt.Elem()}, nil
}
if reflect.PtrTo(rt).Implements(parseableType) {
return &parseable{rt}, nil
}
switch t.Kind() {
case reflect.Slice, reflect.Ptr:
t = indirectType(t.Elem())
if t.Kind() != reflect.Struct {
return nil, fmt.Errorf("expected a struct but got %T", t)
}
fallthrough
case reflect.Struct:
slexer, err := lexStruct(t)
if err != nil {
return nil, err
}
out := &strct{typ: t}
g.typeNodes[t] = out // Ensure we avoid infinite recursion.
if slexer.NumField() == 0 {
return nil, fmt.Errorf("can not parse into empty struct %s", t)
}
defer decorate(&returnedError, func() string { return slexer.Field().Name })
e, err := g.parseDisjunction(slexer)
if err != nil {
return nil, err
}
if e == nil {
return nil, fmt.Errorf("no grammar found in %s", t)
}
if token, _ := slexer.Peek(); !token.EOF() {
return nil, fmt.Errorf("unexpected input %q", token.Value)
}
out.expr = e
return out, nil
}
return nil, fmt.Errorf("%s should be a struct or should implement the Parseable interface", t)
} | go | {
"resource": ""
} |
q12834 | parseLiteral | train | func (g *generatorContext) parseLiteral(lex *structLexer) (node, error) { // nolint: interfacer
token, err := lex.Next()
if err != nil {
return nil, err
}
if token.Type != scanner.String && token.Type != scanner.RawString && token.Type != scanner.Char {
return nil, fmt.Errorf("expected quoted string but got %q", token)
}
s := token.Value
t := rune(-1)
token, err = lex.Peek()
if err != nil {
return nil, err
}
if token.Value == ":" && (token.Type == scanner.Char || token.Type == ':') {
_, _ = lex.Next()
token, err = lex.Next()
if err != nil {
return nil, err
}
if token.Type != scanner.Ident {
return nil, fmt.Errorf("expected identifier for literal type constraint but got %q", token)
}
var ok bool
t, ok = g.Symbols()[token.Value]
if !ok {
return nil, fmt.Errorf("unknown token type %q in literal type constraint", token)
}
}
return &literal{s: s, t: t, tt: g.symbolsToIDs[t]}, nil
} | go | {
"resource": ""
} |
q12835 | Begin | train | func (r *tokenReader) Begin() {
r.runes = r.runes[r.cursor:]
r.cursor = 0
r.oldPos = r.pos
} | go | {
"resource": ""
} |
q12836 | buffer | train | func (r *tokenReader) buffer() (rune, error) {
rn, _, err := r.r.ReadRune()
if err != nil {
return 0, err
}
r.runes = append(r.runes, rn)
return rn, nil
} | go | {
"resource": ""
} |
q12837 | Parse | train | func Parse(r io.Reader) (*Program, error) {
program := &Program{}
err := basicParser.Parse(r, program)
if err != nil {
return nil, err
}
program.init()
return program, nil
} | go | {
"resource": ""
} |
q12838 | Parse | train | func (r *repetition) Parse(ctx *parseContext, parent reflect.Value) (out []reflect.Value, err error) {
i := 0
for ; i < MaxIterations; i++ {
branch := ctx.Branch()
v, err := r.node.Parse(branch, parent)
out = append(out, v...)
if err != nil {
// Optional part failed to match.
if ctx.Stop(branch) {
return out, err
}
break
} else {
ctx.Accept(branch)
}
if v == nil {
break
}
}
if i >= MaxIterations {
t, _ := ctx.Peek(0)
panic(lexer.Errorf(t.Pos, "too many iterations of %s (> %d)", r, MaxIterations))
}
if out == nil {
out = []reflect.Value{}
}
return out, nil
} | go | {
"resource": ""
} |
q12839 | conform | train | func conform(t reflect.Type, values []reflect.Value) (out []reflect.Value, err error) {
for _, v := range values {
for t != v.Type() && t.Kind() == reflect.Ptr && v.Kind() != reflect.Ptr {
// This can occur during partial failure.
if !v.CanAddr() {
return
}
v = v.Addr()
}
// Already of the right kind, don't bother converting.
if v.Kind() == t.Kind() {
out = append(out, v)
continue
}
kind := t.Kind()
switch kind {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
n, err := strconv.ParseInt(v.String(), 0, sizeOfKind(kind))
if err != nil {
return nil, fmt.Errorf("invalid integer %q: %s", v.String(), err)
}
v = reflect.New(t).Elem()
v.SetInt(n)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
n, err := strconv.ParseUint(v.String(), 0, sizeOfKind(kind))
if err != nil {
return nil, fmt.Errorf("invalid integer %q: %s", v.String(), err)
}
v = reflect.New(t).Elem()
v.SetUint(n)
case reflect.Bool:
v = reflect.ValueOf(true)
case reflect.Float32, reflect.Float64:
n, err := strconv.ParseFloat(v.String(), sizeOfKind(kind))
if err != nil {
return nil, fmt.Errorf("invalid integer %q: %s", v.String(), err)
}
v = reflect.New(t).Elem()
v.SetFloat(n)
}
out = append(out, v)
}
return out, nil
} | go | {
"resource": ""
} |
q12840 | Errorf | train | func Errorf(pos Position, format string, args ...interface{}) *Error {
return &Error{
Message: fmt.Sprintf(format, args...),
Pos: pos,
}
} | go | {
"resource": ""
} |
q12841 | Error | train | func (e *Error) Error() string {
filename := e.Pos.Filename
if filename == "" {
filename = "<source>"
}
return fmt.Sprintf("%s:%d:%d: %s", filename, e.Pos.Line, e.Pos.Column, e.Message)
} | go | {
"resource": ""
} |
q12842 | Wrap | train | func Wrap(value interface{}) *Future {
pr := NewPromise()
if e, ok := value.(error); !ok {
pr.Resolve(value)
} else {
pr.Reject(e)
}
return pr.Future
} | go | {
"resource": ""
} |
q12843 | WhenAll | train | func WhenAll(acts ...interface{}) (fu *Future) {
pr := NewPromise()
fu = pr.Future
if len(acts) == 0 {
pr.Resolve([]interface{}{})
return
}
fs := make([]*Future, len(acts))
for i, act := range acts {
fs[i] = Start(act)
}
fu = whenAllFuture(fs...)
return
} | go | {
"resource": ""
} |
q12844 | whenAllFuture | train | func whenAllFuture(fs ...*Future) *Future {
wf := NewPromise()
rs := make([]interface{}, len(fs))
if len(fs) == 0 {
wf.Resolve([]interface{}{})
} else {
n := int32(len(fs))
cancelOthers := func(j int) {
for k, f1 := range fs {
if k != j {
f1.Cancel()
}
}
}
go func() {
isCancelled := int32(0)
for i, f := range fs {
j := i
f.OnSuccess(func(v interface{}) {
rs[j] = v
if atomic.AddInt32(&n, -1) == 0 {
wf.Resolve(rs)
}
}).OnFailure(func(v interface{}) {
if atomic.CompareAndSwapInt32(&isCancelled, 0, 1) {
//try to cancel all futures
cancelOthers(j)
//errs := make([]error, 0, 1)
//errs = append(errs, v.(error))
e := newAggregateError1("Error appears in WhenAll:", v)
wf.Reject(e)
}
}).OnCancel(func() {
if atomic.CompareAndSwapInt32(&isCancelled, 0, 1) {
//try to cancel all futures
cancelOthers(j)
wf.Cancel()
}
})
}
}()
}
return wf.Future
} | go | {
"resource": ""
} |
q12845 | getPipe | train | func (this *pipe) getPipe(isResolved bool) (func(v interface{}) *Future, *Promise) {
if isResolved {
return this.pipeDoneTask, this.pipePromise
} else {
return this.pipeFailTask, this.pipePromise
}
} | go | {
"resource": ""
} |
q12846 | IsCancelled | train | func (this *Future) IsCancelled() bool {
val := this.loadVal()
if val != nil && val.r != nil && val.r.Typ == RESULT_CANCELLED {
return true
} else {
return false
}
} | go | {
"resource": ""
} |
q12847 | SetTimeout | train | func (this *Future) SetTimeout(mm int) *Future {
if mm == 0 {
mm = 10
} else {
mm = mm * 1000 * 1000
}
go func() {
<-time.After((time.Duration)(mm) * time.Nanosecond)
this.Cancel()
}()
return this
} | go | {
"resource": ""
} |
q12848 | GetChan | train | func (this *Future) GetChan() <-chan *PromiseResult {
c := make(chan *PromiseResult, 1)
this.OnComplete(func(v interface{}) {
c <- this.loadResult()
}).OnCancel(func() {
c <- this.loadResult()
})
return c
} | go | {
"resource": ""
} |
q12849 | loadVal | train | func (this *Future) loadVal() *futureVal {
r := atomic.LoadPointer(&this.val)
return (*futureVal)(r)
} | go | {
"resource": ""
} |
q12850 | setResult | train | func (this *Future) setResult(r *PromiseResult) (e error) { //r *PromiseResult) {
defer func() {
if err := getError(recover()); err != nil {
e = err
fmt.Println("\nerror in setResult():", err)
}
}()
e = errors.New("Cannot resolve/reject/cancel more than once")
for {
v := this.loadVal()
if v.r != nil {
return
}
newVal := *v
newVal.r = r
//Use CAS operation to ensure that the state of Promise isn't changed.
//If the state is changed, must get latest state and try to call CAS again.
//No ABA issue in this case because address of all objects are different.
if atomic.CompareAndSwapPointer(&this.val, unsafe.Pointer(v), unsafe.Pointer(&newVal)) {
//Close chEnd then all Get() and GetOrTimeout() will be unblocked
close(this.final)
//call callback functions and start the Promise pipeline
if len(v.dones) > 0 || len(v.fails) > 0 || len(v.always) > 0 || len(v.cancels) > 0 {
go func() {
execCallback(r, v.dones, v.fails, v.always, v.cancels)
}()
}
//start the pipeline
if len(v.pipes) > 0 {
go func() {
for _, pipe := range v.pipes {
pipeTask, pipePromise := pipe.getPipe(r.Typ == RESULT_SUCCESS)
startPipe(r, pipeTask, pipePromise)
}
}()
}
e = nil
break
}
}
return
} | go | {
"resource": ""
} |
q12851 | addCallback | train | func (this *Future) addCallback(callback interface{}, t callbackType) {
if callback == nil {
return
}
if (t == CALLBACK_DONE) ||
(t == CALLBACK_FAIL) ||
(t == CALLBACK_ALWAYS) {
if _, ok := callback.(func(v interface{})); !ok {
panic(errors.New("Callback function spec must be func(v interface{})"))
}
} else if t == CALLBACK_CANCEL {
if _, ok := callback.(func()); !ok {
panic(errors.New("Callback function spec must be func()"))
}
}
for {
v := this.loadVal()
r := v.r
if r == nil {
newVal := *v
switch t {
case CALLBACK_DONE:
newVal.dones = append(newVal.dones, callback.(func(v interface{})))
case CALLBACK_FAIL:
newVal.fails = append(newVal.fails, callback.(func(v interface{})))
case CALLBACK_ALWAYS:
newVal.always = append(newVal.always, callback.(func(v interface{})))
case CALLBACK_CANCEL:
newVal.cancels = append(newVal.cancels, callback.(func()))
}
//use CAS to ensure that the state of Future is not changed,
//if the state is changed, will retry CAS operation.
if atomic.CompareAndSwapPointer(&this.val, unsafe.Pointer(v), unsafe.Pointer(&newVal)) {
break
}
} else {
if (t == CALLBACK_DONE && r.Typ == RESULT_SUCCESS) ||
(t == CALLBACK_FAIL && r.Typ == RESULT_FAILURE) ||
(t == CALLBACK_ALWAYS && r.Typ != RESULT_CANCELLED) {
callbackFunc := callback.(func(v interface{}))
callbackFunc(r.Result)
} else if t == CALLBACK_CANCEL && r.Typ == RESULT_CANCELLED {
callbackFunc := callback.(func())
callbackFunc()
}
break
}
}
} | go | {
"resource": ""
} |
q12852 | NewPromise | train | func NewPromise() *Promise {
val := &futureVal{
make([]func(v interface{}), 0, 8),
make([]func(v interface{}), 0, 8),
make([]func(v interface{}), 0, 4),
make([]func(), 0, 2),
make([]*pipe, 0, 4), nil,
}
f := &Promise{
&Future{
rand.Int(),
make(chan struct{}),
unsafe.Pointer(val),
},
}
return f
} | go | {
"resource": ""
} |
q12853 | Handle | train | func (r Rule) Handle(h events.Handler) Rule {
return Rules{r, Handle(h)}.Eval
} | go | {
"resource": ""
} |
q12854 | HandleF | train | func (r Rule) HandleF(h events.HandlerFunc) Rule {
return r.Handle(events.Handler(h))
} | go | {
"resource": ""
} |
q12855 | HandleEvent | train | func (r Rule) HandleEvent(ctx context.Context, e *executor.Event) (err error) {
if r == nil {
return nil
}
_, _, err = r(ctx, e, nil, ChainIdentity)
return
} | go | {
"resource": ""
} |
q12856 | HandleEvent | train | func (rs Rules) HandleEvent(ctx context.Context, e *executor.Event) error {
return Rule(rs.Eval).HandleEvent(ctx, e)
} | go | {
"resource": ""
} |
q12857 | Error | train | func (es ErrorList) Error() string {
switch len(es) {
case 0:
return msgNoErrors
case 1:
return es[0].Error()
default:
return fmt.Sprintf("%s (and %d more errors)", es[0], len(es)-1)
}
} | go | {
"resource": ""
} |
q12858 | Error2 | train | func Error2(a, b error) error {
if a == nil {
if b == nil {
return nil
}
if list, ok := b.(ErrorList); ok {
return flatten(list).Err()
}
return b
}
if b == nil {
if list, ok := a.(ErrorList); ok {
return flatten(list).Err()
}
return a
}
return Error(a, b)
} | go | {
"resource": ""
} |
q12859 | IsErrorList | train | func IsErrorList(err error) bool {
if err != nil {
_, ok := err.(ErrorList)
return ok
}
return false
} | go | {
"resource": ""
} |
q12860 | MinCyclePeriod | train | func MinCyclePeriod(d time.Duration) detector.Option {
return func(di interface{}) detector.Option {
md := di.(*MasterDetector)
old := md.minDetectorCyclePeriod
md.minDetectorCyclePeriod = d
return MinCyclePeriod(old)
}
} | go | {
"resource": ""
} |
q12861 | NewMasterDetector | train | func NewMasterDetector(zkurls string, options ...detector.Option) (*MasterDetector, error) {
zkHosts, zkPath, err := parseZk(zkurls)
if err != nil {
log.Fatalln("Failed to parse url", err)
return nil, err
}
detector := &MasterDetector{
minDetectorCyclePeriod: defaultMinDetectorCyclePeriod,
done: make(chan struct{}),
cancel: func() {},
}
detector.bootstrapFunc = func(client ZKInterface, _ <-chan struct{}) (ZKInterface, error) {
if client == nil {
return connect2(zkHosts, zkPath)
}
return client, nil
}
// apply options last so that they can override default behavior
for _, opt := range options {
opt(detector)
}
log.V(2).Infoln("Created new detector to watch", zkHosts, zkPath)
return detector, nil
} | go | {
"resource": ""
} |
q12862 | logPanic | train | func logPanic(f func()) {
defer func() {
if r := recover(); r != nil {
log.Errorf("recovered from client panic: %v", r)
}
}()
f()
} | go | {
"resource": ""
} |
q12863 | Detect | train | func (md *MasterDetector) Detect(f detector.MasterChanged) (err error) {
// kickstart zk client connectivity
if err := md.callBootstrap(); err != nil {
log.V(3).Infoln("failed to execute bootstrap function", err.Error())
return err
}
if f == nil {
// only ever install, at most, one ignoreChanged listener. multiple instances of it
// just consume resources and generate misleading log messages.
if !atomic.CompareAndSwapInt32(&md.ignoreInstalled, 0, 1) {
log.V(3).Infoln("ignoreChanged listener already installed")
return
}
f = ignoreChanged
}
log.V(3).Infoln("spawning detect()")
go md.detect(f)
return nil
} | go | {
"resource": ""
} |
q12864 | buildEventHandler | train | func buildEventHandler(state *internalState, fidStore store.Singleton) events.Handler {
// disable brief logs when verbose logs are enabled (there's no sense logging twice!)
logger := controller.LogEvents(nil).Unless(state.config.verbose)
return eventrules.New(
logAllEvents().If(state.config.verbose),
eventMetrics(state.metricsAPI, time.Now, state.config.summaryMetrics),
controller.LiftErrors().DropOnError(),
).Handle(events.Handlers{
scheduler.Event_FAILURE: logger.HandleF(failure),
scheduler.Event_OFFERS: trackOffersReceived(state).HandleF(resourceOffers(state)),
scheduler.Event_UPDATE: controller.AckStatusUpdates(state.cli).AndThen().HandleF(statusUpdate(state)),
scheduler.Event_SUBSCRIBED: eventrules.New(
logger,
controller.TrackSubscription(fidStore, state.config.failoverTimeout),
),
}.Otherwise(logger.HandleEvent))
} | go | {
"resource": ""
} |
q12865 | logAllEvents | train | func logAllEvents() eventrules.Rule {
return func(ctx context.Context, e *scheduler.Event, err error, ch eventrules.Chain) (context.Context, *scheduler.Event, error) {
log.Printf("%+v\n", *e)
return ch(ctx, e, err)
}
} | go | {
"resource": ""
} |
q12866 | eventMetrics | train | func eventMetrics(metricsAPI *metricsAPI, clock func() time.Time, timingMetrics bool) eventrules.Rule {
timed := metricsAPI.eventReceivedLatency
if !timingMetrics {
timed = nil
}
harness := xmetrics.NewHarness(metricsAPI.eventReceivedCount, metricsAPI.eventErrorCount, timed, clock)
return eventrules.Metrics(harness, nil)
} | go | {
"resource": ""
} |
q12867 | callMetrics | train | func callMetrics(metricsAPI *metricsAPI, clock func() time.Time, timingMetrics bool) callrules.Rule {
timed := metricsAPI.callLatency
if !timingMetrics {
timed = nil
}
harness := xmetrics.NewHarness(metricsAPI.callCount, metricsAPI.callErrorCount, timed, clock)
return callrules.Metrics(harness, nil)
} | go | {
"resource": ""
} |
q12868 | logCalls | train | func logCalls(messages map[scheduler.Call_Type]string) callrules.Rule {
return func(ctx context.Context, c *scheduler.Call, r mesos.Response, err error, ch callrules.Chain) (context.Context, *scheduler.Call, mesos.Response, error) {
if message, ok := messages[c.GetType()]; ok {
log.Println(message)
}
return ch(ctx, c, r, err)
}
} | go | {
"resource": ""
} |
q12869 | makeAuthenticatee | train | func makeAuthenticatee(handler callback.Handler, factory transportFactory) (auth.Authenticatee, error) {
ip := callback.NewInterprocess()
if err := handler.Handle(ip); err != nil {
return nil, err
}
config := &authenticateeConfig{
client: ip.Client(),
handler: handler,
transport: factory.makeTransport(),
}
return auth.AuthenticateeFunc(func(ctx context.Context, handler callback.Handler) error {
ctx, auth := newAuthenticatee(ctx, config)
auth.authenticate(ctx, ip.Server())
select {
case <-ctx.Done():
return auth.discard(ctx)
case <-auth.done:
return auth.err
}
}), nil
} | go | {
"resource": ""
} |
q12870 | installHandlers | train | func (self *authenticateeProcess) installHandlers(ctx context.Context) error {
type handlerFn func(ctx context.Context, from *upid.UPID, pbMsg proto.Message)
withContext := func(f handlerFn) messenger.MessageHandler {
return func(from *upid.UPID, m proto.Message) {
status := (&self.status).get()
if self.from != nil && !self.from.Equal(from) {
self.terminate(status, statusError, UnexpectedAuthenticatorPid)
} else {
f(withStatus(ctx, status), from, m)
}
}
}
// Anticipate mechanisms and steps from the server
handlers := []struct {
f handlerFn
m proto.Message
}{
{self.mechanisms, &mesos.AuthenticationMechanismsMessage{}},
{self.step, &mesos.AuthenticationStepMessage{}},
{self.completed, &mesos.AuthenticationCompletedMessage{}},
{self.failed, &mesos.AuthenticationFailedMessage{}},
{self.errored, &mesos.AuthenticationErrorMessage{}},
}
for _, h := range handlers {
if err := self.transport.Install(withContext(h.f), h.m); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q12871 | UPIDBindingAddress | train | func UPIDBindingAddress(hostname string, bindingAddress net.IP) (string, error) {
upidHost := ""
if bindingAddress != nil && "0.0.0.0" != bindingAddress.String() {
upidHost = bindingAddress.String()
} else {
if hostname == "" || hostname == "0.0.0.0" {
return "", fmt.Errorf("invalid hostname (%q) specified with binding address %v", hostname, bindingAddress)
}
ip := net.ParseIP(hostname)
if ip != nil {
ip = ip.To4()
}
if ip == nil {
ips, err := net.LookupIP(hostname)
if err != nil {
return "", err
}
// try to find an ipv4 and use that
for _, addr := range ips {
if ip = addr.To4(); ip != nil {
break
}
}
if ip == nil {
// no ipv4? best guess, just take the first addr
if len(ips) > 0 {
ip = ips[0]
log.Warningf("failed to find an IPv4 address for '%v', best guess is '%v'", hostname, ip)
} else {
return "", fmt.Errorf("failed to determine IP address for host '%v'", hostname)
}
}
}
upidHost = ip.String()
}
return upidHost, nil
} | go | {
"resource": ""
} |
q12872 | NewHttp | train | func NewHttp(upid upid.UPID, opts ...httpOpt) *MesosMessenger {
return NewHttpWithBindingAddress(upid, nil, opts...)
} | go | {
"resource": ""
} |
q12873 | Send | train | func (m *MesosMessenger) Send(ctx context.Context, upid *upid.UPID, msg proto.Message) error {
if upid == nil {
panic("cannot sent a message to a nil pid")
} else if *upid == m.upid {
return fmt.Errorf("Send the message to self")
}
b, err := proto.Marshal(msg)
if err != nil {
return err
}
name := getMessageName(msg)
log.V(2).Infof("Sending message %v to %v\n", name, upid)
wrapped := &Message{upid, name, msg, b}
d := dispatchFunc(func(rf errorHandlerFunc) {
err := m.tr.Send(ctx, wrapped)
err = rf(ctx, wrapped, err)
if err != nil {
m.reportError("send", wrapped, err)
}
})
select {
case <-ctx.Done():
return ctx.Err()
case m.sendingQueue <- d:
return nil
}
} | go | {
"resource": ""
} |
q12874 | Start | train | func (m *MesosMessenger) Start() error {
m.stop = make(chan struct{})
pid, errChan := m.tr.Start()
if pid == (upid.UPID{}) {
err := <-errChan
return fmt.Errorf("failed to start messenger: %v", err)
}
// the pid that we're actually bound as
m.upid = pid
go m.sendLoop()
go m.decodeLoop()
// wait for a listener error or a stop signal; either way stop the messenger
// TODO(jdef) a better implementation would attempt to re-listen; need to coordinate
// access to m.upid in that case. probably better off with a state machine instead of
// what we have now.
go func() {
select {
case err := <-errChan:
if err != nil {
//TODO(jdef) should the driver abort in this case? probably
//since this messenger will never attempt to re-establish the
//transport
log.Errorln("transport stopped unexpectedly:", err.Error())
}
err = m.Stop()
if err != nil && err != errTerminal {
log.Errorln("failed to stop messenger cleanly: ", err.Error())
}
case <-m.stop:
}
}()
return nil
} | go | {
"resource": ""
} |
q12875 | Stop | train | func (m *MesosMessenger) Stop() (err error) {
m.stopOnce.Do(func() {
select {
case <-m.stop:
default:
defer close(m.stop)
}
log.Infof("stopping messenger %v..", m.upid)
//TODO(jdef) don't hardcode the graceful flag here
if err2 := m.tr.Stop(true); err2 != nil && err2 != errTerminal {
log.Warningf("failed to stop the transporter: %v\n", err2)
err = err2
}
})
return
} | go | {
"resource": ""
} |
q12876 | getMessageName | train | func getMessageName(msg proto.Message) string {
var msgName string
switch msg := msg.(type) {
case *scheduler.Call:
msgName = "scheduler"
default:
msgName = fmt.Sprintf("%v.%v", "mesos.internal", reflect.TypeOf(msg).Elem().Name())
}
return msgName
} | go | {
"resource": ""
} |
q12877 | NewRanges | train | func NewRanges(ns ...uint64) Ranges {
xs := append(uint64s{}, ns...)
sort.Sort(xs)
rs := make(Ranges, len(xs))
for i := range xs {
rs[i].Begin, rs[i].End = xs[i], xs[i]
}
return rs.Squash()
} | go | {
"resource": ""
} |
q12878 | Size | train | func (rs Ranges) Size() uint64 {
var sz uint64
for i := range rs {
sz += 1 + (rs[i].End - rs[i].Begin)
}
return sz
} | go | {
"resource": ""
} |
q12879 | Squash | train | func (rs Ranges) Squash() Ranges {
if len(rs) < 2 {
return rs
}
squashed := Ranges{rs[0]}
for i := 1; i < len(rs); i++ {
switch max := squashed[len(squashed)-1].End; {
case 1+max < rs[i].Begin: // no overlap nor continuity: push
squashed = append(squashed, rs[i])
case max <= rs[i].End: // overlap or continuity: squash
squashed[len(squashed)-1].End = rs[i].End
}
}
return squashed
} | go | {
"resource": ""
} |
q12880 | Search | train | func (rs Ranges) Search(n uint64) int {
for lo, hi := 0, len(rs)-1; lo <= hi; {
switch m := lo + (hi-lo)/2; {
case n < rs[m].Begin:
hi = m - 1
case n > rs[m].End:
lo = m + 1
default:
return m
}
}
return -1
} | go | {
"resource": ""
} |
q12881 | Partition | train | func (rs Ranges) Partition(n uint64) (Ranges, bool) {
i := rs.Search(n)
if i < 0 {
return rs, false
}
pn := make(Ranges, 0, len(rs)+1)
switch pn = append(pn, rs[:i]...); {
case rs[i].Begin == rs[i].End: // delete
case rs[i].Begin == n: // increment lower bound
pn = append(pn, Value_Range{rs[i].Begin + 1, rs[i].End})
case rs[i].End == n: // decrement upper bound
pn = append(pn, Value_Range{rs[i].Begin, rs[i].End - 1})
default: // split
pn = append(pn, Value_Range{rs[i].Begin, n - 1}, Value_Range{n + 1, rs[i].End})
}
return append(pn, rs[i+1:]...), true
} | go | {
"resource": ""
} |
q12882 | Remove | train | func (rs Ranges) Remove(removal Value_Range) Ranges {
ranges := make([]Value_Range, 0, len(rs))
for _, r := range rs {
// skip if the entire range is subsumed by removal
if r.Begin >= removal.Begin && r.End <= removal.End {
continue
}
// divide if the range subsumes the removal
if r.Begin < removal.Begin && r.End > removal.End {
ranges = append(ranges,
Value_Range{r.Begin, removal.Begin - 1},
Value_Range{removal.End + 1, r.End},
)
continue
}
// add the full range if there's no intersection
if r.End < removal.Begin || r.Begin > removal.End {
ranges = append(ranges, r)
continue
}
// trim if the range does intersect
if r.End > removal.End {
ranges = append(ranges, Value_Range{removal.End + 1, r.End})
} else {
if r.Begin >= removal.Begin {
// should never happen
panic("r.Begin >= removal.Begin")
}
ranges = append(ranges, Value_Range{r.Begin, removal.Begin - 1})
}
}
return Ranges(ranges).Squash()
} | go | {
"resource": ""
} |
q12883 | Compare | train | func (rs Ranges) Compare(right Ranges) int {
x, y, result := rs.equiv(right)
if result {
return 0
}
for _, a := range x {
// make sure that this range is a subset of a range in y
matched := false
for _, b := range y {
if a.Begin >= b.Begin && a.End <= b.End {
matched = true
break
}
}
if !matched {
return 1
}
}
return -1
} | go | {
"resource": ""
} |
q12884 | getAuthenticateeProvider | train | func getAuthenticateeProvider(name string) (provider Authenticatee, ok bool) {
providerLock.Lock()
defer providerLock.Unlock()
provider, ok = authenticateeProviders[name]
return
} | go | {
"resource": ""
} |
q12885 | New | train | func New(opts ...Opt) *Client {
c := &Client{
codec: DefaultCodec,
do: With(DefaultConfigOpt...),
header: cloneHeaders(DefaultHeaders),
errorMapper: DefaultErrorMapper,
}
c.buildRequestFunc = c.buildRequest
c.handleResponse = c.HandleResponse
c.With(opts...)
return c
} | go | {
"resource": ""
} |
q12886 | Apply | train | func (opts RequestOpts) Apply(req *http.Request) {
// apply per-request options
for _, o := range opts {
if o != nil {
o(req)
}
}
} | go | {
"resource": ""
} |
q12887 | With | train | func (c *Client) With(opts ...Opt) Opt {
return Opts(opts).Merged().Apply(c)
} | go | {
"resource": ""
} |
q12888 | Mesos | train | func (c *Client) Mesos(opts ...RequestOpt) mesos.Client {
return mesos.ClientFunc(func(m encoding.Marshaler) (mesos.Response, error) {
return c.Do(m, opts...)
})
} | go | {
"resource": ""
} |
q12889 | buildRequest | train | func (c *Client) buildRequest(cr client.Request, rc client.ResponseClass, opt ...RequestOpt) (*http.Request, error) {
if crs, ok := cr.(client.RequestStreaming); ok {
return c.buildRequestStream(crs.Marshaler, rc, opt...)
}
accept, err := prepareForResponse(rc, c.codec)
if err != nil {
return nil, err
}
//TODO(jdef): use a pool to allocate these (and reduce garbage)?
// .. or else, use a pipe (like streaming does) to avoid the intermediate buffer?
var body bytes.Buffer
if err := c.codec.NewEncoder(encoding.SinkWriter(&body)).Encode(cr.Marshaler()); err != nil {
return nil, err
}
req, err := http.NewRequest("POST", c.url, &body)
if err != nil {
return nil, err
}
helper := HTTPRequestHelper{req}
return helper.
withOptions(c.requestOpts, opt).
withHeaders(c.header).
withHeader("Content-Type", c.codec.Type.ContentType()).
withHeader("Accept", c.codec.Type.ContentType()).
withOptions(accept).
Request, nil
} | go | {
"resource": ""
} |
q12890 | HandleResponse | train | func (c *Client) HandleResponse(res *http.Response, rc client.ResponseClass, err error) (mesos.Response, error) {
if err != nil {
if res != nil && res.Body != nil {
res.Body.Close()
}
return nil, err
}
result := &Response{
Closer: res.Body,
Header: res.Header,
}
if err = c.errorMapper(res); err != nil {
return result, err
}
err = validateSuccessfulResponse(c.codec, res, rc)
if err != nil {
res.Body.Close()
return nil, err
}
switch res.StatusCode {
case http.StatusOK:
debug.Log("request OK, decoding response")
sf := newSourceFactory(rc, res.ContentLength > -1)
if sf == nil {
if rc != client.ResponseClassNoData {
panic("nil Source for response that expected data")
}
// we don't expect any data. drain the response body and close it (compliant with golang's expectations
// for http/1.1 keepalive support.
defer res.Body.Close()
_, err = io.Copy(ioutil.Discard, res.Body)
return nil, err
}
result.Decoder = c.codec.NewDecoder(sf.NewSource(res.Body))
case http.StatusAccepted:
debug.Log("request Accepted")
// noop; no decoder for these types of calls
defer res.Body.Close()
_, err = io.Copy(ioutil.Discard, res.Body)
return nil, err
default:
debug.Log("unexpected HTTP status", res.StatusCode)
defer res.Body.Close()
io.Copy(ioutil.Discard, res.Body) // intentionally discard any error here
return nil, ProtocolError(fmt.Sprintf("unexpected mesos HTTP response code: %d", res.StatusCode))
}
return result, nil
} | go | {
"resource": ""
} |
q12891 | Do | train | func (c *Client) Do(m encoding.Marshaler, opt ...RequestOpt) (res mesos.Response, err error) {
return c.Send(client.RequestSingleton(m), client.ResponseClassAuto, opt...)
} | go | {
"resource": ""
} |
q12892 | ErrorMapper | train | func ErrorMapper(em ErrorMapperFunc) Opt {
return func(c *Client) Opt {
old := c.errorMapper
c.errorMapper = em
return ErrorMapper(old)
}
} | go | {
"resource": ""
} |
q12893 | Endpoint | train | func Endpoint(rawurl string) Opt {
return func(c *Client) Opt {
old := c.url
c.url = rawurl
return Endpoint(old)
}
} | go | {
"resource": ""
} |
q12894 | WrapDoer | train | func WrapDoer(f func(DoFunc) DoFunc) Opt {
return func(c *Client) Opt {
old := c.do
c.do = f(c.do)
return Do(old)
}
} | go | {
"resource": ""
} |
q12895 | Do | train | func Do(do DoFunc) Opt {
return func(c *Client) Opt {
old := c.do
c.do = do
return Do(old)
}
} | go | {
"resource": ""
} |
q12896 | Codec | train | func Codec(codec encoding.Codec) Opt {
return func(c *Client) Opt {
old := c.codec
c.codec = codec
return Codec(old)
}
} | go | {
"resource": ""
} |
q12897 | DefaultHeader | train | func DefaultHeader(k, v string) Opt {
return func(c *Client) Opt {
old, found := c.header[k]
old = append([]string{}, old...) // clone
c.header.Add(k, v)
return func(c *Client) Opt {
if found {
c.header[k] = old
} else {
c.header.Del(k)
}
return DefaultHeader(k, v)
}
}
} | go | {
"resource": ""
} |
q12898 | HandleResponse | train | func HandleResponse(f ResponseHandler) Opt {
return func(c *Client) Opt {
old := c.handleResponse
c.handleResponse = f
return HandleResponse(old)
}
} | go | {
"resource": ""
} |
q12899 | RequestOptions | train | func RequestOptions(opts ...RequestOpt) Opt {
if len(opts) == 0 {
return nil
}
return func(c *Client) Opt {
old := append([]RequestOpt{}, c.requestOpts...)
c.requestOpts = opts
return RequestOptions(old...)
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.