id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c19700 | strings.ToLower(f.name[0:1]) == f.name[0:1]
} | |
c19701 | fieldType,
typeStr: func() string {
return typesMap.TypeString(fieldType)
},
}
if n.Fields[i].Private() {
if external {
n.Reflect = true
}
}
}
return n
} | |
c19702 | { return deriveCompare_(list[i], list[j]) < 0 })
return list
} | |
c19703 | {
continue
}
res := sig.Results()
if res.Len() != 1 {
continue
}
b, ok := res.At(0).Type().(*types.Basic)
if !ok {
continue
}
if b.Kind() != types.String {
continue
}
return true
}
return false
} | |
c19704 | return `""`
case types.Bool:
return "false"
default:
return "0"
}
}
return "nil"
} | |
c19705 |
var err error
for i, elem := range list {
out[i], err = f(elem)
if err != nil {
return nil, err
}
}
return out, nil
} | |
c19706 | && that.StringPtr == nil) || (this.StringPtr != nil && that.StringPtr != nil && *(this.StringPtr) == *(that.StringPtr)))
} | |
c19707 |
printer: p,
fmap: deps["fmap"],
join: deps["join"],
}
} | |
c19708 | {
in := input{param0, param1}
if o, ok := m[in]; ok {
return o.Res0, o.Res1
}
res0, res1 := f(param0, param1)
m[in] = output{res0, res1}
return res0, res1
}
} | |
c19709 | ps,
autoname: autoname,
dedup: dedup,
}
} | |
c19710 |
keys = append(keys, key)
}
return keys
} | |
c19711 | if deriveCompare(v, m) < 0 {
m = list[i]
}
}
return m
} | |
c19712 |
reflectPkg: p.NewImport("reflect", "reflect"),
unsafePkg: p.NewImport("unsafe", "unsafe"),
}
} | |
c19713 | err error
for i := 0; i < 2; i++ {
errc := <-errChan
if errc != nil {
if err == nil {
err = errc
}
}
}
return v0, v1, err
} | |
c19714 | indexes := table[hash]
for _, index := range indexes {
if deriveEqual(list[index], list[i]) {
contains = true
break
}
}
if contains {
continue
}
if i != u {
list[u] = list[i]
}
table[hash] = append(table[hash], u)
u++
}
return list[:u]
} | |
c19715 |
h = 31*h + uint64(c)
}
return h
} | |
c19716 | v_1_0, err0 := f0(v_0_0)
if err0 != nil {
return nil, err0
}
v_2_0, err1 := f1(v_1_0)
if err1 != nil {
return nil, err1
}
v_3_0, err2 := f2(v_2_0)
if err2 != nil {
return nil, err2
}
v_4_0, err3 := f3(v_3_0)
if err3 != nil {
return nil, err3
}
v_5_0, err4 := f4(v_4_0)
if err4 != n... | |
c19717 | := range call.Args {
typs[i] = pkgInfo.TypeOf(a)
}
return typs
} | |
c19718 | }
}
if strings.Index(c.Args[i].String(), "invalid type") >= 0 {
return true
}
}
return false
} | |
c19719 |
bytesPkg: p.NewImport("bytes", "bytes"),
fmtPkg: p.NewImport("fmt", "fmt"),
}
} | |
c19720 | this.Int64 == that.Int64 &&
((this.StringPtr == nil && that.StringPtr == nil) || (this.StringPtr != nil && that.StringPtr != nil && *(this.StringPtr) == *(that.StringPtr)))
} | |
c19721 | {
return func(vers string) (int, int, error) {
out0, out1, success := f(vers)
if success {
return out0, out1, nil
}
return out0, out1, err
}
} | |
c19722 |
return 0, err0
}
v_2_0, err1 := f1(v_1_0, v_1_1)
if err1 != nil {
return 0, err1
}
return v_2_0, nil
}
} | |
c19723 | len(list))
for _, v := range list {
set[v] = struct{}{}
}
return set
} | |
c19724 | h = 31*h + uint64(c)
}
return h
} | |
c19725 |
}
h := uint64(17)
for i := 0; i < len(object); i++ {
h = 31*h + uint64(object[i])
}
return h
} | |
c19726 | this = append(this, that[i])
}
}
return this
} | |
c19727 |
return &gen{
TypesMap: typesMap,
printer: p,
mathPkg: p.NewImport("math", "math"),
keys: deps["keys"],
sort: deps["sort"],
}
} | |
c19728 |
if deriveContains(that, v) {
intersect = append(intersect, this[i])
}
}
return intersect
} | |
c19729 | fmt.Fprintf(buf, "this.StringPtr = func (v string) *string { return &v }(%#v)\n", *this.StringPtr)
}
fmt.Fprintf(buf, "return this\n")
}
fmt.Fprintf(buf, "}()\n")
return buf.String()
} | |
c19730 | <-chan int {
b := f(a)
return deriveJoin(deriveFmap(g, b))
}
} | |
c19731 | range in {
wait.Add(1)
res := c
go func() {
for r := range res {
out <- r
}
wait.Done()
}()
}
wait.Wait()
close(out)
}()
return out
} | |
c19732 | make(chan (<-chan int), cap(in))
go func() {
for a := range in {
b := f(a)
out <- b
}
close(out)
}()
return out
} | |
c19733 |
return m.register(method, path, handler)
} | |
c19734 | m.register("GET", path, handler)
} | |
c19735 |
m.register(mt, path, handler)
}
} | |
c19736 | m.register("OPTIONS", path, handler)
} | |
c19737 |
m.Routes[method] = append(m.Routes[method], r)
return r
}
m.Routes[static] = append(m.Routes[static], r)
return r
} | |
c19738 |
m.Routes[mt] = append(m.Routes[mt], r)
}
return r
}
return nil
} | |
c19739 | == nil {
r.Compile = make(map[int]*regexp.Regexp)
r.Tag = make(map[int]string)
}
tmp := strings.Split(s, "^")
r.Tag[i] = tmp[0][1:]
r.Compile[i] = regexp.MustCompile("^" + tmp[1][:len(tmp[1])-1])
r.Atts |= REGEX
case "*":
r.wildPos = i
r.Atts |= WC
default:
r.Token.raw =... | |
c19740 | _ := r.matchAndParse(req)
return ok
} | |
c19741 | vars[v], _ = url.QueryUnescape(ss[k])
}
if r.Atts®EX != 0 {
for k, v := range r.Compile {
if !v.MatchString(ss[k]) {
return false, nil
}
vars[r.Tag[k]], _ = url.QueryUnescape(ss[k])
}
}
return true, vars
}
}
return false, nil
} | |
c19742 | adapters {
adap(m)
}
if m.Serve == nil {
m.Serve = m.DefaultServe
}
return m
} | |
c19743 | m.Validators == nil {
m.Validators = make(map[string]Validator)
}
m.Validators[name] = newValidatorFunc(validator)
} | |
c19744 | m.Validators == nil {
m.Validators = make(map[string]Validator)
}
m.Validators[name] = validator
} | |
c19745 | strings.TrimSuffix(p, "/")
return m
} | |
c19746 | if !m.validate(rw, req) {
// Check if same route exists for another HTTP method
if !m.otherMethods(rw, req) {
m.HandleNotFound(rw, req)
}
}
}
}
} | |
c19747 | strings.ToLower(req.URL.Path)
}
m.Serve(rw, req)
} | |
c19748 | if req.URL.Path[:s.Size] == s.Path {
s.Handler.ServeHTTP(rw, req)
return true
}
}
}
return false
} | |
c19749 | m.notFound.ServeHTTP(rw, req)
} else {
http.NotFound(rw, req)
}
} | |
c19750 | {
*url = (*url)[:ulen-1]
cleanURL(url)
}
}
} | |
c19751 | }
}
for _, s := range m.Routes[static] {
if len(req.URL.Path) >= s.Size {
if req.URL.Path[:s.Size] == s.Path {
return s.Path
}
}
}
return "NotFound"
} | |
c19752 | return nil, err
}
return hosts, nil
} | |
c19753 | nil, err
}
i := C.Pa_HostApiTypeIdToHostApiIndex(C.PaHostApiTypeId(apiType))
if i < 0 {
return nil, newError(C.PaError(i))
}
return hosts[i], nil
} | |
c19754 |
return nil, err
}
i := C.Pa_GetDefaultHostApi()
if i < 0 {
return nil, newError(C.PaError(i))
}
return hosts[i], nil
} | |
c19755 | return nil, err
}
return devs, nil
} | |
c19756 | return nil, err
}
i := C.Pa_GetDefaultInputDevice()
if i < 0 {
return nil, newError(C.PaError(i))
}
return devs[i], nil
} | |
c19757 |
return nil, err
}
i := C.Pa_GetDefaultOutputDevice()
if i < 0 {
return nil, newError(C.PaError(i))
}
return devs[i], nil
} | |
c19758 | args...)
if err != nil {
return err
}
return newError(C.Pa_IsFormatSupported(s.inParams, s.outParams, C.double(p.SampleRate)))
} | |
c19759 | = byte(i32 >> 8)
i24[1] = byte(i32 >> 16)
i24[0] = byte(i32 >> 24)
}
} | |
c19760 |
paErr := C.Pa_OpenStream(&s.paStream, s.inParams, s.outParams, C.double(p.SampleRate), C.ulong(p.FramesPerBuffer), C.PaStreamFlags(p.Flags), cb, unsafe.Pointer(s.id))
if paErr != C.paNoError {
delStream(s)
return nil, newError(paErr)
}
return s, nil
} | |
c19761 | newError(C.Pa_CloseStream(s.paStream))
delStream(s)
return err
}
return nil
} | |
c19762 | return &StreamInfo{duration(i.inputLatency), duration(i.outputLatency), float64(i.sampleRate)}
} | |
c19763 | {
return duration(C.Pa_GetStreamTime(s.paStream))
} | |
c19764 | 0, newError(C.PaError(n))
}
return int(n), nil
} | |
c19765 | 0, newError(C.PaError(n))
}
return int(n), nil
} | |
c19766 | s.inParams)
if err != nil {
return err
}
return newError(C.Pa_ReadStream(s.paStream, buf, C.ulong(frames)))
} | |
c19767 | s.outParams)
if err != nil {
return err
}
return newError(C.Pa_WriteStream(s.paStream, buf, C.ulong(frames)))
} | |
c19768 | spec.Templating = &swarm.Driver{
Name: info.Template.Name,
Options: info.Template.Options,
}
}
_, err = cli.ConfigCreate(ctx, spec)
return
})
} | |
c19769 | //spec.Name = info.Name
//spec.Data = []byte(info.Data)
spec.Labels = info.Labels.ToMap()
return cli.ConfigUpdate(ctx, info.ID, version(info.Version), spec)
})
} | |
c19770 | cli, err = mgr.Client(); err == nil {
cfg, raw, err = cli.ConfigInspectWithRaw(ctx, id)
}
return
} | |
c19771 | cli.ConfigRemove(ctx, id); err != nil {
return
}
}
return
})
} | |
c19772 |
InitPost: homeInitPost,
Error403: homeError403,
Error404: homeError404,
}
} | |
c19773 |
return nil, errors.Wrapf(err, "service %s", service.Name)
}
serviceSpec, err := Service(client.ClientVersion(), namespace, service, networks, volumes, secrets, configs)
if err != nil {
return nil, errors.Wrapf(err, "service %s", service.Name)
}
result[service.Name] = serviceSpec
}
return result, ni... | |
c19774 | ok := user.(*model.AuthUser); ok {
return au.IsAllowed(h.Name())
}
return false
} | |
c19775 | := biz.Perm.Check(ctx.User(), array[0], array[1], ctx.P(array[2]))
if err != nil {
return err
}
}
return next(ctx)
}
} | |
c19776 | 0600, nil)
if err != nil {
return nil, errors.Wrap(err, "failed to open bolt database")
}
d := &Dao{
logger: log.Get("bolt"),
db: db,
}
return d, nil
} | |
c19777 | secretNew,
Create: secretCreate,
Edit: secretEdit,
Update: secretUpdate,
}
} | |
c19778 | i + 1
}
} else if page <= 4 {
p.Pages = []int{1, 2, 3, 4, 5, 6, 0, p.MaxPage}
} else if page > (p.MaxPage - 4) {
p.Pages = []int{1, 0}
for i := p.MaxPage - 5; i <= p.MaxPage; i++ {
p.Pages = append(p.Pages, i)
}
} else {
p.Pages = []int{1, 0, page - 2, page - 1, page, page + 1, page + 2, 0, p.MaxPage... | |
c19779 | return nodes[i].Description.Hostname < nodes[j].Description.Hostname
})
infos = make([]*model.NodeListInfo, len(nodes))
for i, n := range nodes {
infos[i] = model.NewNodeListInfo(n)
}
}
return
})
return
} | |
c19780 | nodes, err = cli.NodeList(ctx, types.NodeListOptions{})
if err == nil {
count = len(nodes)
}
return
})
return
} | |
c19781 | cli *client.Client) (err error) {
return cli.NodeRemove(ctx, id, types.NodeRemoveOptions{})
})
} | |
c19782 | cli, err = mgr.Client(); err == nil {
return cli.NodeInspectWithRaw(ctx, id)
}
return
} | |
c19783 | Availability: info.Availability,
}
spec.Name = info.Name
spec.Labels = info.Labels.ToMap()
return cli.NodeUpdate(ctx, id, version(info.Version), spec)
})
} | |
c19784 | Update: serviceUpdate,
Scale: serviceScale,
Rollback: serviceRollback,
Restart: serviceRestart,
PermEdit: servicePermEdit,
PermUpdate: permUpdate("service", "name"),
Stats: serviceStats,
}
} | |
c19785 | error) {
do(func(d dao.Interface) {
setting, err = d.SettingGet()
})
return
} | |
c19786 | Disconnect: networkDisconnect,
Detail: networkDetail,
Raw: networkRaw,
}
} | |
c19787 | sort.Slice(resp.Volumes, func(i, j int) bool {
return resp.Volumes[i].Name < resp.Volumes[j].Name
})
totalCount = len(resp.Volumes)
start, end := misc.Page(totalCount, pageIndex, pageSize)
volumes = resp.Volumes[start:end]
return
} | |
c19788 | info.Name,
DriverOpts: info.Options.ToMap(),
Labels: info.Labels.ToMap(),
}
if info.Driver == "other" {
options.Driver = info.CustomDriver
} else {
options.Driver = info.Driver
}
_, err = cli.VolumeCreate(ctx, options)
return
})
} | |
c19789 | filters.NewArgs()
report, err = cli.VolumesPrune(ctx, f)
return
})
return
} | |
c19790 | err = cli.VolumeInspectWithRaw(ctx, name)
return err
})
return
} | |
c19791 | = len(summaries)
start, end := misc.Page(totalCount, pageIndex, pageSize)
summaries = summaries[start:end]
if length := len(summaries); length > 0 {
images = make([]*model.ImageListInfo, length)
for i, summary := range summaries {
images[i] = model.NewImageListInfo(summary)
}
}
return
} | |
c19792 | cli, err = mgr.Client(); err == nil {
return cli.ImageInspectWithRaw(ctx, id)
}
return
} | |
c19793 | (err error) {
opts := types.ImageRemoveOptions{}
_, err = cli.ImageRemove(ctx, id, opts)
return
})
} | |
c19794 | New: templateNew,
Create: templateCreate,
Edit: templateEdit,
Update: templateUpdate,
Delete: templateDelete,
}
} | |
c19795 | nodeRaw,
Delete: nodeDelete,
Edit: nodeEdit,
Update: nodeUpdate,
}
} | |
c19796 | Delete: roleDelete,
Detail: roleDetail,
Edit: roleEdit,
Update: roleUpdate,
}
} | |
c19797 | registryCreate,
Delete: registryDelete,
Update: registryUpdate,
}
} | |
c19798 | Password: profilePassword,
ModifyPassword: profileModifyPassword,
}
} | |
c19799 | return secrets[i].Spec.Name < secrets[j].Spec.Name
})
totalCount = len(secrets)
start, end := misc.Page(totalCount, pageIndex, pageSize)
secrets = secrets[start:end]
}
return
})
return
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.