id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c16400 | c.Command("setvol %d", volume).OK()
} | |
c16401 | c.Command("playlistinfo %d", start)
case start < 0 && end >= 0:
return nil, errors.New("negative start index")
default:
panic("unreachable")
}
return cmd.AttrsList("file")
} | |
c16402 | return c.Command("prio %d %d:%d", priority, start, end).OK()
case start >= 0 && end < 0:
// Update the prio for a single playlist item at this position.
return c.Command("prio %d %d", priority, start).OK()
case start < 0 && end >= 0:
return errors.New("negative start index")
default:
panic("unreachable")
... | |
c16403 | c.Command("prioid %d %d", priority, id).OK()
} | |
c16404 | index")
}
if end < 0 {
return c.Command("delete %d", start).OK()
}
return c.Command("delete %d:%d", start, end).OK()
} | |
c16405 | index")
}
if end < 0 {
return c.Command("move %d %d", start, position).OK()
}
return c.Command("move %d:%d %d", start, end, position).OK()
} | |
c16406 | c.Command("moveid %d %d", songid, position).OK()
} | |
c16407 | " + quoteArgs(args)).AttrsList("file")
} | |
c16408 | c.Command("enableoutput %d", id).OK()
} | |
c16409 | c.Command("disableoutput %d", id).OK()
} | |
c16410 | c.Command("listplaylistinfo %s", name).AttrsList("file")
} | |
c16411 | c.Command("load %s", name).OK()
}
return c.Command("load %s %d:%d", name, start, end).OK()
} | |
c16412 | c.Command("playlistadd %s %s", name, uri).OK()
} | |
c16413 | c.Command("playlistclear %s", name).OK()
} | |
c16414 | c.Command("playlistmove %s %d %d", name, id, pos).OK()
} | |
c16415 | c.Command("rename %s %s", name, newName).OK()
} | |
c16416 | return c.Command("rm %s", name).OK()
} | |
c16417 | c.Command("save %s", name).OK()
} | |
c16418 | attr["sticker"]; !ok {
return nil, nil, textproto.ProtocolError("sticker attribute not found")
}
files[i] = attr["file"]
stk, err := parseSticker(attr["sticker"])
if err != nil {
return nil, nil, err
}
stks[i] = *stk
}
return files, stks, nil
} | |
c16419 | {
return nil, textproto.ProtocolError("sticker not found")
}
stk, err := parseSticker(attr)
if stk == nil {
return nil, err
}
return stk, nil
} | |
c16420 | !ok {
return nil, textproto.ProtocolError("sticker attribute not found")
}
stk, err := parseSticker(s)
if err != nil {
return nil, err
}
stks[i] = *stk
}
return stks, nil
} | |
c16421 | return c.Command("sticker set song %s %s %s", uri, name, value).OK()
} | |
c16422 | {
return nil, errors.New("value has not been computed yet")
}
return pa.attrs, nil
} | |
c16423 |
return -1, errors.New("value has not been computed yet")
}
return (int)(*pi), nil
} | |
c16424 |
cl.cmdQ.PushBack(&command{"currentsong", pa, cmdAttrReturn})
return pa
} | |
c16425 | nil, cmdNoReturn})
} else {
cl.cmdQ.PushBack(&command{fmt.Sprintf("playid %d", id), nil, cmdNoReturn})
}
} | |
c16426 | setvol %d", volume), nil, cmdNoReturn})
} | |
c16427 | cl.cmdQ.PushBack(&command{fmt.Sprintf("prio %d %d", priority, start), nil, cmdNoReturn})
} else {
cl.cmdQ.PushBack(&command{fmt.Sprintf("prio %d %d:%d", priority, start, end), nil, cmdNoReturn})
}
return nil
} | |
c16428 | f("prioid %d %d", priority, id), nil, cmdNoReturn})
} | |
c16429 | %d %d", songid, position), nil, cmdNoReturn})
} | |
c16430 | cl.cmdQ.PushBack(&command{fmt.Sprintf("load %s %d:%d", quote(name), start, end), nil, cmdNoReturn})
}
} | |
c16431 | err
}
case cmdAttrReturn:
a, aErr := cl.client.readAttrs("list_OK")
if aErr != nil {
return aErr
}
pa := e.Value.(*command).promise.(*PromisedAttrs)
pa.attrs = a
pa.computed = true
case cmdIDReturn:
a, aErr := cl.client.readAttrs("list_OK")
if aErr != nil {
return aErr
}
... | |
c16432 |
}
}
return &Command{
client: c,
cmd: fmt.Sprintf(format, args...),
}
} | |
c16433 | defer cmd.client.text.EndResponse(id)
return cmd.client.readOKLine("OK")
} | |
c16434 |
cmd.client.text.StartResponse(id)
defer cmd.client.text.EndResponse(id)
return cmd.client.readAttrs("OK")
} | |
c16435 |
}
cmd.client.text.StartResponse(id)
defer cmd.client.text.EndResponse(id)
return cmd.client.readAttrsList(startKey)
} | |
c16436 | err != nil {
return nil, err
}
cmd.client.text.StartResponse(id)
defer cmd.client.text.EndResponse(id)
return cmd.client.readList(key)
} | |
c16437 | '%s' as enabled? %v\n", name, enabled)
} | |
c16438 | *configOption) {
o.refreshInterval = refreshInterval
}
} | |
c16439 | *configOption) {
o.metricsInterval = metricsInterval
}
} | |
c16440 | *configOption) {
o.httpClient = client
}
} | |
c16441 | *configOption) {
o.customHeaders = headers
}
} | |
c16442 | *featureOption) {
opts.ctx = &ctx
}
} | |
c16443 | defaultClient.IsEnabled(feature, options...)
} | |
c16444 | false
}
for _, s := range f.Strategies {
foundStrategy := uc.getStrategy(s.Name)
if foundStrategy == nil {
// TODO: warnOnce missingStrategy
continue
}
if foundStrategy.IsEnabled(s.Parameters, opts.ctx) {
return true
}
}
return false
} | |
c16445 |
uc.closed <- true
return nil
} | |
c16446 | {
r, n := utf8.DecodeLastRune(maxb)
if r != utf8.RuneError {
if r < utf8.MaxRune {
r++
if r > 0x7f {
b := make([]byte, 4)
nn := utf8.EncodeRune(b, r)
maxb = append(maxb[:len(maxb)-n], b[:nn]...)
} else {
maxb = append(maxb[:len(maxb)-n], byte(r))
}
}
}
}
return string(... | |
c16447 | str[i] == '?' {
return true
}
}
return false
} | |
c16448 | OpAlias
}{
Where: where,
OpAlias: (OpAlias)(o),
})
default:
return json.Marshal(&struct {
OpAlias
}{
OpAlias: (OpAlias)(o),
})
}
} | |
c16449 | val)
innerMap = append(innerMap, mapSeg)
}
ovsMap = append(ovsMap, innerMap)
return json.Marshal(ovsMap)
} | |
c16450 | err == nil && len(oMap) > 1 {
innerSlice := oMap[1].([]interface{})
for _, val := range innerSlice {
f := val.([]interface{})
o.GoMap[f[0]] = f[1]
}
}
return err
} | |
c16451 | _, key := range keys {
genMap[key.Interface()] = v.MapIndex(key).Interface()
}
return &OvsMap{genMap}, nil
} | |
c16452 | i < v.Len(); i++ {
ovsSet = append(ovsSet, v.Index(i).Interface())
}
return &OvsSet{ovsSet}, nil
} | |
c16453 |
oSet = append(oSet, "set")
oSet = append(oSet, o.GoSet)
return json.Marshal(oSet)
} | |
c16454 | goVal, err := ovsSliceToGoNotation(val)
if err == nil {
o.GoSet = append(o.GoSet, goVal)
}
}
}
return err
} | |
c16455 | ovsSliceToGoNotation(val)
if err != nil {
return err
}
r.Fields[key] = val
}
return err
} | |
c16456 | range schema.Tables {
fmt.Fprintf(w, "\t %s\n", table)
for column, columnSchema := range tableSchema.Columns {
fmt.Fprintf(w, "\t\t %s => %v\n", column, columnSchema)
}
}
} | |
c16457 | return false
}
}
for _, row := range op.Rows {
for column := range row {
if _, ok := table.Columns[column]; !ok {
return false
}
}
}
for _, column := range op.Columns {
if _, ok := table.Columns[column]; !ok {
return false
}
}
} else {
return false
}
}... | |
c16458 | for i, d := range operations {
opsSlice[i] = d
}
ops := append(dbSlice, opsSlice...)
return ops
} | |
c16459 | return []interface{}{database, value, requests}
} | |
c16460 | == nil {
uuidSlice = []string{"uuid", u.GoUUID}
} else {
uuidSlice = []string{"named-uuid", u.GoUUID}
}
return json.Marshal(uuidSlice)
} | |
c16461 | json.Unmarshal(b, &ovsUUID); err == nil {
u.GoUUID = ovsUUID[1]
}
return err
} | |
c16462 | Async Notifications
dbs, err := ovs.ListDbs()
if err == nil {
for _, db := range dbs {
schema, err := ovs.GetSchema(db)
if err == nil {
ovs.Schema[db] = *schema
} else {
return nil, err
}
}
}
return ovs, nil
} | |
c16463 | target := fmt.Sprintf("%s:%d", ipAddr, port)
return ConnectUsingProtocol("tcp", target)
} | |
c16464 | os.IsNotExist(err) {
return nil, errors.New("Invalid socket file")
}
return ConnectUsingProtocol("unix", socketFile)
} | |
c16465 | ovs.handlersMutex.Unlock()
ovs.handlers = append(ovs.handlers, handler)
} | |
c16466 |
for i, h := range handlers {
if reflect.DeepEqual(h, handler) {
return i, nil
}
}
return -1, errors.New("Handler not found")
} | |
c16467 | != nil {
return err
}
ovs.handlers = append(ovs.handlers[:i], ovs.handlers[i+1:]...)
return nil
} | |
c16468 | }
}
escfn, ok := e.Escapers[ct]
if !ok {
// TODO: Communicate error, no escaper for the specified content type.
return val
}
return stick.NewSafeValue(escfn(stick.CoerceString(val)), ct)
}
return nil
} | |
c16469 | "js": escape.JS,
"css": escape.CSS,
"url": escape.URLQueryParam,
},
}
} | |
c16470 | = append(v.stack, name)
} | |
c16471 | v.stack[0 : len(v.stack)-1]
} | |
c16472 | 0),
macros: make(map[string]*parse.MacroNode),
env: env,
scope: &scopeStack{[]map[string]Value{ctx}},
}
} | |
c16473 | make(map[string]Value))
} | |
c16474 |
s.scopes = s.scopes[0 : len(s.scopes)-1]
} | |
c16475 | for k, v := range scope {
res[k] = v
}
}
return res
} | |
c16476 | := blocks[name]; ok {
return block
}
}
return nil
} | |
c16477 | nil {
return err
}
}
case *parse.UseNode:
return s.walkUseNode(node)
}
return nil
} | |
c16478 | return "", nil, err
}
}
if !node.Only {
ctx = s.scope.All()
}
if with != nil {
if with, ok := with.(map[string]Value); ok {
for k, v := range with {
ctx[k] = v
}
}
}
return tpl, ctx, err
} | |
c16479 |
}
s.blocks = append(s.blocks, tree.Blocks())
err = s.walk(tree.Root())
if err != nil {
return err
}
return nil
} | |
c16480 | = append(tree.Visitors, env.Visitors...)
err = tree.Parse()
if err != nil {
return nil, err
}
return tree, nil
} | |
c16481 | } else if c == 39 {
// '
out.WriteString("'")
} else if c == 60 {
// <
out.WriteString("<")
} else if c == 62 {
// >
out.WriteString(">")
} else {
// UTF-8
out.WriteRune(c)
}
}
return out.String()
} | |
c16482 | // <
out.WriteString("<")
} else if c == 62 {
// >
out.WriteString(">")
} else if c <= 31 && c != 9 && c != 10 && c != 13 {
// Non-whitespace
out.WriteString("�")
} else {
// UTF-8
fmt.Fprintf(out, "&#%d;", c)
}
}
return out.String()
} | |
c16483 | == 95 {
// a-zA-Z0-9,._
out.WriteRune(c)
} else {
// UTF-8
fmt.Fprintf(out, "\\u%04X", c)
}
}
return out.String()
} | |
c16484 | // a-zA-Z0-9-._~
out.WriteByte(c)
} else {
// UTF-8
fmt.Fprintf(out, "%%%02X", c)
}
}
return out.String()
} | |
c16485 | return parseDo(t, name.Pos)
case "filter":
return parseFilter(t, name.Pos)
case "macro":
return parseMacro(t, name.Pos)
case "import":
return parseImport(t, name.Pos)
case "from":
return parseFrom(t, name.Pos)
default:
return nil, newUnexpectedTokenError(name)
}
} | |
c16486 | return nil, err
}
_, err = t.expect(tokenTagClose)
if err != nil {
return nil, err
}
return n, nil
} | |
c16487 | {
return n, nil
}
t.backup3()
o, err := t.parse()
if err != nil {
return n, err
}
n.Append(o)
default:
o, err := t.parse()
if err != nil {
return n, err
}
n.Append(o)
}
}
} | |
c16488 | return nil, err
}
return NewIncludeNode(expr, with, only, start), nil
} | |
c16489 | n, err := parseBlock(t, start)
if err != nil {
return nil, err
}
if _, ok := n.(*BlockNode); !ok {
return nil, newUnexpectedTokenError(tok)
}
} else {
return nil, newUnexpectedValueError(tok, "endembed or block")
}
}
}
blockRefs := t.popBlockStack()
return NewEmbedNode(expr, wi... | |
c16490 |
macros: make(map[string]*MacroNode),
unread: make([]token, 0),
read: make([]token, 0),
Name: name,
Visitors: make([]NodeVisitor, 0),
}
} | |
c16491 | {
return t.blocks[len(t.blocks)-1]
} | |
c16492 |
t.backup()
return tok
} | |
c16493 | next = t.next()
if next.tokenType != tokenWhitespace {
t.backup()
return next
}
}
} | |
c16494 | t.read[len(t.read)-1], t.read[:len(t.read)-1]
t.unread = append(t.unread, tok)
} | |
c16495 | t.unread[:len(t.unread)-1]
} else {
tok = t.lex.nextToken()
}
t.read = append(t.read, tok)
return tok
} | |
c16496 | t.next()
if next.tokenType != tokenWhitespace || next.tokenType == tokenEOF {
return next
}
}
} | |
c16497 | typ := range typs {
if tok.tokenType == typ {
return tok, nil
}
}
return tok, newUnexpectedTokenError(tok, typs...)
} | |
c16498 | val {
return tok, newUnexpectedValueError(tok, val)
}
return tok, nil
} | |
c16499 | t.Visitors {
v.Enter(n)
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.