id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c171800 | arg.Out <- r.popFront()
}
r.pushBack(s)
}
return nil
})
} | |
c171801 | case a1 > b1:
return +1
case a2 < b2:
return -1
case a2 > b2:
return +1
}
return 0
})
return s
} | |
c171802 | return s.Text(n).flipLast()
} | |
c171803 | nil { // a had a parse error, b did not
return +1
}
// b had a parse error, a did not
return -1
}
switch {
case a3 < b3:
return -1
case a3 > b3:
return +1
}
return 0
})
return s
} | |
c171804 | return s.Num(n).flipLast()
} | |
c171805 |
if less(b, a) {
return +1
}
return 0
})
return s
} | |
c171806 | b string) int { return last(b, a) }
return s
} | |
c171807 | }
sort.Sort(state)
for _, item := range state.data {
arg.Out <- item
}
return nil
} | |
c171808 | if s.Mode().IsDir() && f.skipdirif(n) {
return filepath.SkipDir
}
if f.ifmode(s.Mode()) {
arg.Out <- n
}
return nil
})
} | |
c171809 | != nil {
return FilterFunc(func(Arg) error { return err })
}
return If(re.MatchString)
} | |
c171810 |
}
return If(func(s string) bool { return !re.MatchString(s) })
} | |
c171811 | x.limitArgs = n
return x
} | |
c171812 | {
err = splitIntoLines(file, arg)
file.Close()
}
if err != nil {
return err
}
}
return nil
})
} | |
c171813 | return splitIntoLines(reader, arg)
})
} | |
c171814 |
isComment := strings.HasPrefix(trimLine, commentChar)
return isComment
} | |
c171815 | output.Err = errors.New(fmt.Sprintf("Bad hosts line: %q", raw))
}
output.IP = rawIP
output.Hosts = fields[1:]
}
return output
} | |
c171816 | err != nil {
return false
}
return true
} | |
c171817 |
fmt.Fprintf(w, "%s%s", line.Raw, eol)
}
err = w.Flush()
if err != nil {
return err
}
return h.Load()
} | |
c171818 |
for _, addHost := range hosts {
if itemInSlice(addHost, newHosts) {
continue
}
newHosts = append(newHosts, addHost)
}
endLine := NewHostsLine(buildRawLine(ip, newHosts))
h.Lines[position] = endLine
}
return nil
} | |
c171819 | append(newHosts, checkHost)
}
}
// If hosts is empty, skip the line completely.
if len(newHosts) > 0 {
newLineRaw := line.IP
for _, host := range newHosts {
newLineRaw = fmt.Sprintf("%s %s", newLineRaw, host)
}
newLine := NewHostsLine(newLineRaw)
outputLines = append(outputLines, newLine)
}
}
h.Lines = outputLines
return nil
} | |
c171820 | } else {
osHostsFilePath = os.Getenv("HOSTS_PATH")
}
hosts := Hosts{Path: osHostsFilePath}
err := hosts.Load()
if err != nil {
return hosts, err
}
return hosts, nil
} | |
c171821 | figure out a meaningful group+resource for schemas.
Group: "schema",
Resource: "schema",
}
return nil, errors.NewNotFound(gvr, fmt.Sprintf("%s", gvk))
}
return &OpenAPISchema{schema: sc}, nil
} | |
c171822 |
log.Infof("validate object %q", gvk)
return validation.ValidateModel(obj.UnstructuredContent(), s.schema, fmt.Sprintf("%s.%s", gvk.Version, gvk.Kind))
} | |
c171823 | ret = append(ret, &o.Items[i])
}
case *unstructured.Unstructured:
ret = append(ret, o)
default:
panic("Unexpected unstructured object type")
}
}
return ret
} | |
c171824 | = strings.TrimSuffix(v.Minor, "+")
ret.Minor, err = strconv.Atoi(v.Minor)
if err != nil {
// Try to parse using GitVersion
return parseGitVersion(v.GitVersion)
}
return ret, err
} | |
c171825 | != nil {
return ServerVersion{}, err
}
return ParseVersion(version)
} | |
c171826 | a = make(map[string]string)
}
a[key] = value
obj.SetAnnotations(a)
} | |
c171827 | l = make(map[string]string)
}
l[key] = value
obj.SetLabels(l)
} | |
c171828 | log.Debugf("RESTMapper failed for %s: %s, falling back to kind", gvk, err)
return strings.ToLower(gvk.Kind)
}
return mapping.Resource.Resource
} | |
c171829 | return fmt.Sprintf("%s.%s", o.GetNamespace(), o.GetName())
} | |
c171830 | buf.WriteString("@")
buf.WriteString(n.Digest)
} else {
buf.WriteString(":")
buf.WriteString(n.Tag)
}
return buf.String()
} | |
c171831 | = "library"
}
return fmt.Sprintf("%s/%s", repo, n.Name)
} | |
c171832 | = defaultRegistry
}
return fmt.Sprintf("https://%s", reg)
} | |
c171833 |
ret.Name = img.Path
ret.Digest = img.Digest.String()
ret.Tag = img.Tag
return ret, nil
} | |
c171834 |
return ®istryResolver{
opt: opt,
cache: make(map[string]string),
}
} | |
c171835 | ok {
ret.colorise = terminal.IsTerminal(int(f.Fd()))
ret.escapes = terminal.NewTerminal(f, "").Escape
}
return &ret
} | |
c171836 | &memcachedDiscoveryClient{cl: cl}
c.Invalidate()
return c
} | |
c171837 | return nil, err
}
namespace := meta.GetNamespace()
if namespace == "" {
namespace = defNs
}
return rc.Namespace(namespace), nil
default:
return nil, fmt.Errorf("unexpected resource scope %q", mapping.Scope)
}
} | |
c171838 | = buff.WriteString("\x1b[31m")
}
_, _ = buff.WriteString(DiffLineStart.ReplaceAllString(text, "$1- $2"))
if color {
_, _ = buff.WriteString("\x1b[0m")
}
case diffmatchpatch.DiffEqual:
_, _ = buff.WriteString(DiffLineStart.ReplaceAllString(text, "$1 $2"))
}
}
return buff.String()
} | |
c171839 | return v == ""
case nil:
return true
default:
panic(fmt.Sprintf("Found unexpected type %T in json unmarshal (value=%v)", i, i))
}
} | |
c171840 | if err != nil {
log.Debugf("unable to fetch resource for %s (%v), continuing", gvk, err)
return 50, nil
}
if mapping.Scope.Name() == meta.RESTScopeNameRoot {
// Place global before namespaced
return 20, nil
} else if containsPodSpec(disco, gvk) {
// (Potentially) starts a pod, so place last
return 100, nil
} else {
// Everything else
return 50, nil
}
} | |
c171841 | 1}
l.readChar()
return l
} | |
c171842 | tok.Type = token.EOF
tok.LineNumber = l.curLine
return tok
}
if l.ch == '<' && l.peekChar() == '%' {
l.inside = true
return l.nextInsideToken()
}
tok.Type = token.HTML
tok.Literal = l.readHTML()
tok.LineNumber = l.curLine
return tok
} | |
c171843 | out.WriteString(s.String())
}
return out.String()
} | |
c171844 | "", err
}
}
b := github_flavored_markdown.Markdown([]byte(body))
return template.HTML(b), err
} | |
c171845 |
prog := p.parseProgram()
if len(p.errors) > 0 {
return prog, p.errors
}
return prog, nil
} | |
c171846 |
err := hm.AddMany(Helpers.Helpers())
if err != nil {
return hm, err
}
return hm, nil
} | |
c171847 | err := h.Add(k, v)
if err != nil {
return err
}
}
return nil
} | |
c171848 | if helpers != nil {
for k, v := range helpers {
data[k] = v
}
}
return t.Exec(NewContextWith(data))
} | |
c171849 | != nil {
return "", err
}
return t.Exec(ctx)
} | |
c171850 | ctx.Set("println", func(i interface{}) {
fmt.Println(i)
})
_, err := Render(input, ctx)
return err
} | |
c171851 | t.Parse()
if err != nil {
return t, err
}
return t, nil
} | |
c171852 | nil {
return err
}
t.program = program
return nil
} | |
c171853 | ctx,
program: t.program,
}
s, err := ev.compile()
return s, err
} | |
c171854 | program: t.program,
}
return t2
} | |
c171855 | return Render(s, h.Context)
} | |
c171856 | return "", errors.New("no block defined")
}
i, err := h.compiler.evalBlockStatement(h.block)
if err != nil {
return "", err
}
bb := &bytes.Buffer{}
h.compiler.write(bb, i)
return bb.String(), nil
} | |
c171857 | c.Value(key) != nil
} | |
c171858 | != nil {
for k, v := range c.outer.export() {
m[k] = v
}
}
for k, v := range c.data {
m[k] = v
}
return m
} | |
c171859 | &sync.Mutex{},
}
for k, v := range Helpers.helpers {
if !c.Has(k) {
c.Set(k, v)
}
}
return c
} | |
c171860 | := NewContext()
c.Context = ctx
return c
} | |
c171861 | }
}
if !found {
// Create a copy of the Signature, since it will be mutated.
key := &Signature{}
*key = routine.Signature
b[key] = &count{ids: []int{routine.ID}, first: routine.First}
}
}
out := make(buckets, 0, len(b))
for signature, c := range b {
sort.Ints(c.ids)
out = append(out, &Bucket{Signature: *signature, IDs: c.ids, First: c.first})
}
sort.Sort(out)
return out
} | |
c171862 |
return b.Signature.less(&r.Signature)
} | |
c171863 | _, _ = io.WriteString(out, line)
}
if err != nil {
return s.goroutines, err
}
}
return s.goroutines, scanner.Err()
} | |
c171864 | := range s {
if strings.HasPrefix(p, prefix+"/") {
return true
}
}
return false
} | |
c171865 | make([]string, 0, len(files))
for f := range files {
out = append(out, f)
}
sort.Strings(out)
return out
} | |
c171866 | } else if s != "" {
out = append(out, s)
s = ""
}
}
if s != "" {
out = append(out, s)
}
return out
} | |
c171867 | test on Windows.
i, err := os.Stat(p)
return err == nil && !i.IsDir()
} | |
c171868 | filepath.Join(parts[i:]...)
if isFile(filepath.Join(root, suffix)) {
return filepath.Join(parts[:i]...)
}
}
return ""
} | |
c171869 | if r := rootedIn(l, parts); r != "" {
//log.Printf("Found GOPATH=%s", r)
c.GOPATHs[r] = l
found = true
break
}
}
if !found {
// If the source is not found, just too bad.
//log.Printf("Failed to find locally: %s / %s", f, goroot)
}
}
} | |
c171870 | url.QueryUnescape(f.Raw)
return s
} | |
c171871 | len(parts) == 1 {
return parts[0]
}
return parts[1]
} | |
c171872 | return ""
}
s, _ := url.QueryUnescape(parts[0])
return s
} | |
c171873 | == r {
return true
}
return f.PkgName() == "main" && name == "main"
} | |
c171874 | above 16Mb and positive.
return a.Value > 16*1024*1024 && a.Value < math.MaxInt64
} | |
c171875 | i, l := range a.Values {
if l != r.Values[i] {
return false
}
}
return true
} | |
c171876 | }
default:
if l.IsPtr() != r.Values[i].IsPtr() || (!l.IsPtr() && l != r.Values[i]) {
return false
}
}
}
return true
} | |
c171877 | out.Values[i].Name = "*"
out.Values[i].Value = l.Value
} else {
out.Values[i] = l
}
}
return out
} | |
c171878 | == r.SrcPath && c.Line == r.Line && c.Func == r.Func && c.Args.equal(&r.Args)
} | |
c171879 | c.SrcPath == r.SrcPath && c.Line == r.Line && c.Func == r.Func && c.Args.similar(&r.Args, similar)
} | |
c171880 | c.Args.merge(&r.Args),
LocalSrcPath: c.LocalSrcPath,
IsStdlib: c.IsStdlib,
}
} | |
c171881 | path.Join(filepath.Base(filepath.Dir(c.SrcPath)), c.SrcName())
} | |
c171882 |
if strings.HasPrefix(c.SrcPath, prefix) {
c.LocalSrcPath = filepath.Join(dest, c.SrcPath[len(prefix):])
break
}
}
}
}
// Consider _test/_testmain.go as stdlib since it's injected by "go test".
c.IsStdlib = (goroot != "" && strings.HasPrefix(c.SrcPath, goroot)) || c.PkgSrc() == testMainSrc
} | |
c171883 | !s.Calls[i].equal(&r.Calls[i]) {
return false
}
}
return true
} | |
c171884 | if !s.Calls[i].similar(&r.Calls[i], similar) {
return false
}
}
return true
} | |
c171885 | Calls: make([]Call, len(s.Calls)),
Elided: s.Elided,
}
for i := range s.Calls {
out.Calls[i] = s.Calls[i].merge(&r.Calls[i])
}
return out
} | |
c171886 | {
return false
}
if lStdlib < rStdlib {
return true
}
// Stack lengths are the same.
for x := range s.Calls {
if s.Calls[x].Func.Raw < r.Calls[x].Func.Raw {
return true
}
if s.Calls[x].Func.Raw > r.Calls[x].Func.Raw {
return true
}
if s.Calls[x].PkgSrc() < r.Calls[x].PkgSrc() {
return true
}
if s.Calls[x].PkgSrc() > r.Calls[x].PkgSrc() {
return true
}
if s.Calls[x].Line < r.Calls[x].Line {
return true
}
if s.Calls[x].Line > r.Calls[x].Line {
return true
}
}
return false
} | |
c171887 | s.SleepMax != r.SleepMax {
return false
}
return s.Stack.equal(&r.Stack)
} | |
c171888 | if similar == ExactFlags && s.Locked != r.Locked {
return false
}
return s.Stack.similar(&r.Stack, similar)
} | |
c171889 |
return &Signature{
State: s.State, // Drop right side.
CreatedBy: s.CreatedBy, // Drop right side.
SleepMin: min,
SleepMax: max,
Stack: *s.Stack.merge(&r.Stack),
Locked: s.Locked || r.Locked, // TODO(maruel): This is weirdo.
}
} | |
c171890 | !s.Locked {
return false
}
if s.State < r.State {
return true
}
if s.State > r.State {
return false
}
return false
} | |
c171891 | {
created += s.CreatedBy.FullSrcLine()
} else {
created += s.CreatedBy.SrcLine()
}
return created
} | |
c171892 |
for _, k := range order {
for _, arg := range objects[k].args {
arg.Name = fmt.Sprintf("#%d", nextID)
}
nextID++
}
// Now do the rest. This is done so the output is deterministic.
order = make(uint64Slice, 0, len(objects))
for k := range objects {
order = append(order, k)
}
sort.Sort(order)
for _, k := range order {
// Process the remaining pointers, they were not referenced by primary
// thread so will have higher IDs.
if objects[k].inPrimary {
continue
}
for _, arg := range objects[k].args {
arg.Name = fmt.Sprintf("#%d", nextID)
}
nextID++
}
} | |
c171893 | }
if l > srcLen {
srcLen = l
}
l = len(line.Func.PkgName())
if l > pkgLen {
pkgLen = l
}
}
}
return srcLen, pkgLen
} | |
c171894 | }
return p.FuncStdLib
} else if line.IsPkgMain() {
return p.FuncMain
} else if line.Func.IsExported() {
return p.FuncOtherExported
}
return p.FuncOther
} | |
c171895 | bool) string {
if bucket.First && multipleBuckets {
return p.RoutineFirst
}
return p.Routine
} | |
c171896 | extra += " [locked]"
}
if c := bucket.CreatedByString(fullPath); c != "" {
extra += p.CreatedBy + " [Created by " + c + "]"
}
return fmt.Sprintf(
"%s%d: %s%s%s\n",
p.routineColor(bucket, multipleBuckets), len(bucket.IDs),
bucket.State, extra,
p.EOLReset)
} | |
c171897 | p.Package, pkgLen, line.Func.PkgName(),
p.SrcFile, srcLen, src,
p.functionColor(line), line.Func.Name(),
p.Arguments, &line.Args,
p.EOLReset)
} | |
c171898 | out[i] = p.callLine(&signature.Stack.Calls[i], srcLen, pkgLen, fullPath)
}
if signature.Stack.Elided {
out = append(out, " (...)")
}
return strings.Join(out, "\n") + "\n"
} | |
c171899 | for i := range goroutine.Stack.Calls {
c.load(goroutine.Stack.Calls[i].LocalSrcPath)
}
// Once all loaded, we can look at the next call when available.
for i := 0; i < len(goroutine.Stack.Calls)-1; i++ {
// Get the AST from the previous call and process the call line with it.
if f := c.getFuncAST(&goroutine.Stack.Calls[i]); f != nil {
processCall(&goroutine.Stack.Calls[i], f)
}
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.