_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q171800 | DropLast | validation | func DropLast(n int) Filter {
return FilterFunc(func(arg Arg) error {
r := newRing(n)
for s := range arg.In {
if r.full() {
arg.Out <- r.popFront()
}
r.pushBack(s)
}
return nil
})
} | go | {
"resource": ""
} |
q171801 | Text | validation | func (s *SortFilter) Text(n int) *SortFilter {
s.add(func(a, b string) int {
a1, a2 := column(a, n)
b1, b2 := column(b, n)
switch {
case a1 < b1:
return -1
case a1 > b1:
return +1
case a2 < b2:
return -1
case a2 > b2:
return +1
}
return 0
})
return s
} | go | {
"resource": ""
} |
q171802 | TextDecreasing | validation | func (s *SortFilter) TextDecreasing(n int) *SortFilter {
return s.Text(n).flipLast()
} | go | {
"resource": ""
} |
q171803 | Num | validation | func (s *SortFilter) Num(n int) *SortFilter {
s.add(func(a, b string) int {
a1, a2 := column(a, n)
b1, b2 := column(b, n)
switch {
case a1 < b1:
return -1
case a1 > b1:
return +1
}
// Convert columns from strings to numbers.
a3, a4 := strconv.ParseFloat(a2, 64)
b3, b4 := strconv.ParseFloat(b2,... | go | {
"resource": ""
} |
q171804 | NumDecreasing | validation | func (s *SortFilter) NumDecreasing(n int) *SortFilter {
return s.Num(n).flipLast()
} | go | {
"resource": ""
} |
q171805 | By | validation | func (s *SortFilter) By(less func(a, b string) bool) *SortFilter {
s.add(func(a, b string) int {
if less(a, b) {
return -1
}
if less(b, a) {
return +1
}
return 0
})
return s
} | go | {
"resource": ""
} |
q171806 | flipLast | validation | func (s *SortFilter) flipLast() *SortFilter {
last := s.cmp[len(s.cmp)-1]
s.cmp[len(s.cmp)-1] = func(a, b string) int { return last(b, a) }
return s
} | go | {
"resource": ""
} |
q171807 | RunFilter | validation | func (s *SortFilter) RunFilter(arg Arg) error {
state := sortState{s.cmp, nil}
for item := range arg.In {
state.data = append(state.data, item)
}
sort.Sort(state)
for _, item := range state.data {
arg.Out <- item
}
return nil
} | go | {
"resource": ""
} |
q171808 | RunFilter | validation | func (f *FindFilter) RunFilter(arg Arg) error {
return filepath.Walk(f.dir, func(n string, s os.FileInfo, e error) error {
if e != nil {
return e
}
if s.Mode().IsDir() && f.skipdirif(n) {
return filepath.SkipDir
}
if f.ifmode(s.Mode()) {
arg.Out <- n
}
return nil
})
} | go | {
"resource": ""
} |
q171809 | Grep | validation | func Grep(r string) Filter {
re, err := regexp.Compile(r)
if err != nil {
return FilterFunc(func(Arg) error { return err })
}
return If(re.MatchString)
} | go | {
"resource": ""
} |
q171810 | GrepNot | validation | func GrepNot(r string) Filter {
re, err := regexp.Compile(r)
if err != nil {
return FilterFunc(func(Arg) error { return err })
}
return If(func(s string) bool { return !re.MatchString(s) })
} | go | {
"resource": ""
} |
q171811 | LimitArgs | validation | func (x *XargsFilter) LimitArgs(n int) *XargsFilter {
x.limitArgs = n
return x
} | go | {
"resource": ""
} |
q171812 | Cat | validation | func Cat(filenames ...string) Filter {
return FilterFunc(func(arg Arg) error {
if len(filenames) == 0 {
for s := range arg.In {
arg.Out <- s
}
return nil
}
for _, f := range filenames {
file, err := os.Open(f)
if err == nil {
err = splitIntoLines(file, arg)
file.Close()
}
if err ... | go | {
"resource": ""
} |
q171813 | ReadLines | validation | func ReadLines(reader io.Reader) Filter {
return FilterFunc(func(arg Arg) error {
return splitIntoLines(reader, arg)
})
} | go | {
"resource": ""
} |
q171814 | IsComment | validation | func (l HostsLine) IsComment() bool {
trimLine := strings.TrimSpace(l.Raw)
isComment := strings.HasPrefix(trimLine, commentChar)
return isComment
} | go | {
"resource": ""
} |
q171815 | NewHostsLine | validation | func NewHostsLine(raw string) HostsLine {
fields := strings.Fields(raw)
if len(fields) == 0 {
return HostsLine{Raw: raw}
}
output := HostsLine{Raw: raw}
if !output.IsComment() {
rawIP := fields[0]
if net.ParseIP(rawIP) == nil {
output.Err = errors.New(fmt.Sprintf("Bad hosts line: %q", raw))
}
output... | go | {
"resource": ""
} |
q171816 | IsWritable | validation | func (h *Hosts) IsWritable() bool {
_, err := os.OpenFile(h.Path, os.O_WRONLY, 0660)
if err != nil {
return false
}
return true
} | go | {
"resource": ""
} |
q171817 | Flush | validation | func (h Hosts) Flush() error {
file, err := os.Create(h.Path)
if err != nil {
return err
}
w := bufio.NewWriter(file)
for _, line := range h.Lines {
fmt.Fprintf(w, "%s%s", line.Raw, eol)
}
err = w.Flush()
if err != nil {
return err
}
return h.Load()
} | go | {
"resource": ""
} |
q171818 | Add | validation | func (h *Hosts) Add(ip string, hosts ...string) error {
if net.ParseIP(ip) == nil {
return errors.New(fmt.Sprintf("%q is an invalid IP address.", ip))
}
position := h.getIpPosition(ip)
if position == -1 {
endLine := NewHostsLine(buildRawLine(ip, hosts))
// Ip line is not in file, so we just append our new li... | go | {
"resource": ""
} |
q171819 | Remove | validation | func (h *Hosts) Remove(ip string, hosts ...string) error {
var outputLines []HostsLine
if net.ParseIP(ip) == nil {
return errors.New(fmt.Sprintf("%q is an invalid IP address.", ip))
}
for _, line := range h.Lines {
// Bad lines or comments just get readded.
if line.Err != nil || line.IsComment() || line.IP... | go | {
"resource": ""
} |
q171820 | NewHosts | validation | func NewHosts() (Hosts, error) {
osHostsFilePath := ""
if os.Getenv("HOSTS_PATH") == "" {
osHostsFilePath = os.ExpandEnv(filepath.FromSlash(hostsFilePath))
} else {
osHostsFilePath = os.Getenv("HOSTS_PATH")
}
hosts := Hosts{Path: osHostsFilePath}
err := hosts.Load()
if err != nil {
return hosts, err
}
... | go | {
"resource": ""
} |
q171821 | NewOpenAPISchemaFor | validation | func NewOpenAPISchemaFor(delegate discovery.OpenAPISchemaInterface, gvk schema.GroupVersionKind) (*OpenAPISchema, error) {
log.Debugf("Fetching schema for %v", gvk)
doc, err := delegate.OpenAPISchema()
if err != nil {
return nil, err
}
res, err := openapi.NewOpenAPIData(doc)
if err != nil {
return nil, err
}... | go | {
"resource": ""
} |
q171822 | Validate | validation | func (s *OpenAPISchema) Validate(obj *unstructured.Unstructured) []error {
gvk := obj.GroupVersionKind()
log.Infof("validate object %q", gvk)
return validation.ValidateModel(obj.UnstructuredContent(), s.schema, fmt.Sprintf("%s.%s", gvk.Version, gvk.Kind))
} | go | {
"resource": ""
} |
q171823 | FlattenToV1 | validation | func FlattenToV1(objs []runtime.Object) []*unstructured.Unstructured {
ret := make([]*unstructured.Unstructured, 0, len(objs))
for _, obj := range objs {
switch o := obj.(type) {
case *unstructured.UnstructuredList:
for i := range o.Items {
ret = append(ret, &o.Items[i])
}
case *unstructured.Unstructu... | go | {
"resource": ""
} |
q171824 | ParseVersion | validation | func ParseVersion(v *version.Info) (ServerVersion, error) {
var ret ServerVersion
var err error
ret.Major, err = strconv.Atoi(v.Major)
if err != nil {
// Try to parse using GitVersion
return parseGitVersion(v.GitVersion)
}
// trim "+" in minor version (happened on GKE)
v.Minor = strings.TrimSuffix(v.Minor, ... | go | {
"resource": ""
} |
q171825 | FetchVersion | validation | func FetchVersion(v discovery.ServerVersionInterface) (ret ServerVersion, err error) {
version, err := v.ServerVersion()
if err != nil {
return ServerVersion{}, err
}
return ParseVersion(version)
} | go | {
"resource": ""
} |
q171826 | SetMetaDataAnnotation | validation | func SetMetaDataAnnotation(obj metav1.Object, key, value string) {
a := obj.GetAnnotations()
if a == nil {
a = make(map[string]string)
}
a[key] = value
obj.SetAnnotations(a)
} | go | {
"resource": ""
} |
q171827 | SetMetaDataLabel | validation | func SetMetaDataLabel(obj metav1.Object, key, value string) {
l := obj.GetLabels()
if l == nil {
l = make(map[string]string)
}
l[key] = value
obj.SetLabels(l)
} | go | {
"resource": ""
} |
q171828 | ResourceNameFor | validation | func ResourceNameFor(mapper meta.RESTMapper, o runtime.Object) string {
gvk := o.GetObjectKind().GroupVersionKind()
mapping, err := mapper.RESTMapping(gvk.GroupKind(), gvk.Version)
if err != nil {
log.Debugf("RESTMapper failed for %s: %s, falling back to kind", gvk, err)
return strings.ToLower(gvk.Kind)
}
ret... | go | {
"resource": ""
} |
q171829 | FqName | validation | func FqName(o metav1.Object) string {
if o.GetNamespace() == "" {
return o.GetName()
}
return fmt.Sprintf("%s.%s", o.GetNamespace(), o.GetName())
} | go | {
"resource": ""
} |
q171830 | String | validation | func (n ImageName) String() string {
buf := bytes.Buffer{}
if n.Registry != "" {
buf.WriteString(n.Registry)
buf.WriteString("/")
}
if n.Repository != "" {
buf.WriteString(n.Repository)
buf.WriteString("/")
}
buf.WriteString(n.Name)
if n.Digest != "" {
buf.WriteString("@")
buf.WriteString(n.Digest)
... | go | {
"resource": ""
} |
q171831 | RegistryRepoName | validation | func (n ImageName) RegistryRepoName() string {
repo := n.Repository
if repo == "" {
repo = "library"
}
return fmt.Sprintf("%s/%s", repo, n.Name)
} | go | {
"resource": ""
} |
q171832 | RegistryURL | validation | func (n ImageName) RegistryURL() string {
reg := n.Registry
if reg == "" {
reg = defaultRegistry
}
return fmt.Sprintf("https://%s", reg)
} | go | {
"resource": ""
} |
q171833 | ParseImageName | validation | func ParseImageName(image string) (ImageName, error) {
ret := ImageName{}
img, err := registry.ParseImage(image)
if err != nil {
return ret, err
}
ret.Registry = img.Domain
ret.Name = img.Path
ret.Digest = img.Digest.String()
ret.Tag = img.Tag
return ret, nil
} | go | {
"resource": ""
} |
q171834 | NewRegistryResolver | validation | func NewRegistryResolver(opt registry.Opt) Resolver {
return ®istryResolver{
opt: opt,
cache: make(map[string]string),
}
} | go | {
"resource": ""
} |
q171835 | NewLogFormatter | validation | func NewLogFormatter(out io.Writer) log.Formatter {
var ret = logFormatter{}
if f, ok := out.(*os.File); ok {
ret.colorise = terminal.IsTerminal(int(f.Fd()))
ret.escapes = terminal.NewTerminal(f, "").Escape
}
return &ret
} | go | {
"resource": ""
} |
q171836 | NewMemcachedDiscoveryClient | validation | func NewMemcachedDiscoveryClient(cl discovery.DiscoveryInterface) discovery.CachedDiscoveryInterface {
c := &memcachedDiscoveryClient{cl: cl}
c.Invalidate()
return c
} | go | {
"resource": ""
} |
q171837 | ClientForResource | validation | func ClientForResource(client dynamic.Interface, mapper meta.RESTMapper, obj runtime.Object, defNs string) (dynamic.ResourceInterface, error) {
gvk := obj.GetObjectKind().GroupVersionKind()
mapping, err := mapper.RESTMapping(gvk.GroupKind(), gvk.Version)
if err != nil {
return nil, err
}
rc := client.Resource(... | go | {
"resource": ""
} |
q171838 | formatDiff | validation | func (c DiffCmd) formatDiff(diffs []diffmatchpatch.Diff, color bool) string {
var buff bytes.Buffer
for _, diff := range diffs {
text := diff.Text
switch diff.Type {
case diffmatchpatch.DiffInsert:
if color {
_, _ = buff.WriteString("\x1b[32m")
}
_, _ = buff.WriteString(DiffLineStart.ReplaceAllSt... | go | {
"resource": ""
} |
q171839 | isEmptyValue | validation | func isEmptyValue(i interface{}) bool {
switch v := i.(type) {
case []interface{}:
return len(v) == 0
case []string:
return len(v) == 0
case map[string]interface{}:
return len(v) == 0
case bool:
return !v
case float64:
return v == 0
case int64:
return v == 0
case string:
return v == ""
case nil:
... | go | {
"resource": ""
} |
q171840 | depTier | validation | func depTier(disco discovery.OpenAPISchemaInterface, mapper meta.RESTMapper, o schema.ObjectKind) (int, error) {
gvk := o.GroupVersionKind()
if gk := gvk.GroupKind(); gk == gkTpr || gk == gkCrd {
// Special case: these create other types
return 10, nil
}
mapping, err := mapper.RESTMapping(gvk.GroupKind(), gvk.... | go | {
"resource": ""
} |
q171841 | New | validation | func New(input string) *Lexer {
l := &Lexer{input: input, curLine: 1}
l.readChar()
return l
} | go | {
"resource": ""
} |
q171842 | NextToken | validation | func (l *Lexer) NextToken() token.Token {
if l.inside {
return l.nextInsideToken()
}
var tok token.Token
// l.skipWhitespace()
if l.ch == 0 {
tok.Literal = ""
tok.Type = token.EOF
tok.LineNumber = l.curLine
return tok
}
if l.ch == '<' && l.peekChar() == '%' {
l.inside = true
return l.nextInsideTo... | go | {
"resource": ""
} |
q171843 | InnerText | validation | func (bs *BlockStatement) InnerText() string {
var out bytes.Buffer
for _, s := range bs.Statements {
out.WriteString(s.String())
}
return out.String()
} | go | {
"resource": ""
} |
q171844 | MarkdownHelper | validation | func MarkdownHelper(body string, help HelperContext) (template.HTML, error) {
var err error
if help.HasBlock() {
body, err = help.Block()
if err != nil {
return "", err
}
}
b := github_flavored_markdown.Markdown([]byte(body))
return template.HTML(b), err
} | go | {
"resource": ""
} |
q171845 | Parse | validation | func Parse(s string) (*ast.Program, error) {
p := newParser(lexer.New(s))
prog := p.parseProgram()
if len(p.errors) > 0 {
return prog, p.errors
}
return prog, nil
} | go | {
"resource": ""
} |
q171846 | NewHelperMap | validation | func NewHelperMap() (HelperMap, error) {
hm := HelperMap{
helpers: map[string]interface{}{},
moot: &sync.Mutex{},
}
err := hm.AddMany(Helpers.Helpers())
if err != nil {
return hm, err
}
return hm, nil
} | go | {
"resource": ""
} |
q171847 | AddMany | validation | func (h *HelperMap) AddMany(helpers map[string]interface{}) error {
for k, v := range helpers {
err := h.Add(k, v)
if err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q171848 | BuffaloRenderer | validation | func BuffaloRenderer(input string, data map[string]interface{}, helpers map[string]interface{}) (string, error) {
t, err := Parse(input)
if err != nil {
return "", err
}
if helpers != nil {
for k, v := range helpers {
data[k] = v
}
}
return t.Exec(NewContextWith(data))
} | go | {
"resource": ""
} |
q171849 | Render | validation | func Render(input string, ctx hctx.Context) (string, error) {
t, err := Parse(input)
if err != nil {
return "", err
}
return t.Exec(ctx)
} | go | {
"resource": ""
} |
q171850 | RunScript | validation | func RunScript(input string, ctx hctx.Context) error {
input = "<% " + input + "%>"
ctx = ctx.New()
ctx.Set("print", func(i interface{}) {
fmt.Print(i)
})
ctx.Set("println", func(i interface{}) {
fmt.Println(i)
})
_, err := Render(input, ctx)
return err
} | go | {
"resource": ""
} |
q171851 | NewTemplate | validation | func NewTemplate(input string) (*Template, error) {
t := &Template{
Input: input,
}
err := t.Parse()
if err != nil {
return t, err
}
return t, nil
} | go | {
"resource": ""
} |
q171852 | Parse | validation | func (t *Template) Parse() error {
if t.program != nil {
return nil
}
program, err := parser.Parse(t.Input)
if err != nil {
return err
}
t.program = program
return nil
} | go | {
"resource": ""
} |
q171853 | Exec | validation | func (t *Template) Exec(ctx hctx.Context) (string, error) {
err := t.Parse()
if err != nil {
return "", err
}
ev := compiler{
ctx: ctx,
program: t.program,
}
s, err := ev.compile()
return s, err
} | go | {
"resource": ""
} |
q171854 | Clone | validation | func (t *Template) Clone() *Template {
t2 := &Template{
Input: t.Input,
program: t.program,
}
return t2
} | go | {
"resource": ""
} |
q171855 | Render | validation | func (h HelperContext) Render(s string) (string, error) {
return Render(s, h.Context)
} | go | {
"resource": ""
} |
q171856 | BlockWith | validation | func (h HelperContext) BlockWith(hc hctx.Context) (string, error) {
ctx, ok := hc.(*Context)
if !ok {
return "", fmt.Errorf("expected *Context, got %T", hc)
}
octx := h.compiler.ctx
defer func() { h.compiler.ctx = octx }()
h.compiler.ctx = ctx
if h.block == nil {
return "", errors.New("no block defined")
}... | go | {
"resource": ""
} |
q171857 | Has | validation | func (c *Context) Has(key string) bool {
return c.Value(key) != nil
} | go | {
"resource": ""
} |
q171858 | export | validation | func (c *Context) export() map[string]interface{} {
m := map[string]interface{}{}
if c.outer != nil {
for k, v := range c.outer.export() {
m[k] = v
}
}
for k, v := range c.data {
m[k] = v
}
return m
} | go | {
"resource": ""
} |
q171859 | NewContextWith | validation | func NewContextWith(data map[string]interface{}) *Context {
c := &Context{
Context: context.Background(),
data: data,
outer: nil,
moot: &sync.Mutex{},
}
for k, v := range Helpers.helpers {
if !c.Has(k) {
c.Set(k, v)
}
}
return c
} | go | {
"resource": ""
} |
q171860 | NewContextWithContext | validation | func NewContextWithContext(ctx context.Context) *Context {
c := NewContext()
c.Context = ctx
return c
} | go | {
"resource": ""
} |
q171861 | Aggregate | validation | func Aggregate(goroutines []*Goroutine, similar Similarity) []*Bucket {
type count struct {
ids []int
first bool
}
b := map[*Signature]*count{}
// O(n²). Fix eventually.
for _, routine := range goroutines {
found := false
for key, c := range b {
// When a match is found, this effectively drops the oth... | go | {
"resource": ""
} |
q171862 | less | validation | func (b *Bucket) less(r *Bucket) bool {
if b.First || r.First {
return b.First
}
return b.Signature.less(&r.Signature)
} | go | {
"resource": ""
} |
q171863 | parseDump | validation | func parseDump(r io.Reader, out io.Writer) ([]*Goroutine, error) {
scanner := bufio.NewScanner(r)
scanner.Split(scanLines)
s := scanningState{}
for scanner.Scan() {
line, err := s.scan(scanner.Text())
if line != "" {
_, _ = io.WriteString(out, line)
}
if err != nil {
return s.goroutines, err
}
}
r... | go | {
"resource": ""
} |
q171864 | hasPathPrefix | validation | func hasPathPrefix(p string, s map[string]string) bool {
for prefix := range s {
if strings.HasPrefix(p, prefix+"/") {
return true
}
}
return false
} | go | {
"resource": ""
} |
q171865 | getFiles | validation | func getFiles(goroutines []*Goroutine) []string {
files := map[string]struct{}{}
for _, g := range goroutines {
for _, c := range g.Stack.Calls {
files[c.SrcPath] = struct{}{}
}
}
out := make([]string, 0, len(files))
for f := range files {
out = append(out, f)
}
sort.Strings(out)
return out
} | go | {
"resource": ""
} |
q171866 | splitPath | validation | func splitPath(p string) []string {
if p == "" {
return nil
}
var out []string
s := ""
for _, c := range p {
if c != '/' || (len(out) == 0 && strings.Count(s, "/") == len(s)) {
s += string(c)
} else if s != "" {
out = append(out, s)
s = ""
}
}
if s != "" {
out = append(out, s)
}
return out
} | go | {
"resource": ""
} |
q171867 | isFile | validation | func isFile(p string) bool {
// TODO(maruel): Is it faster to open the file or to stat it? Worth a perf
// test on Windows.
i, err := os.Stat(p)
return err == nil && !i.IsDir()
} | go | {
"resource": ""
} |
q171868 | rootedIn | validation | func rootedIn(root string, parts []string) string {
//log.Printf("rootIn(%s, %v)", root, parts)
for i := 1; i < len(parts); i++ {
suffix := filepath.Join(parts[i:]...)
if isFile(filepath.Join(root, suffix)) {
return filepath.Join(parts[:i]...)
}
}
return ""
} | go | {
"resource": ""
} |
q171869 | findRoots | validation | func (c *Context) findRoots() {
c.GOPATHs = map[string]string{}
for _, f := range getFiles(c.Goroutines) {
// TODO(maruel): Could a stack dump have mixed cases? I think it's
// possible, need to confirm and handle.
//log.Printf(" Analyzing %s", f)
if c.GOROOT != "" && strings.HasPrefix(f, c.GOROOT+"/") {
... | go | {
"resource": ""
} |
q171870 | String | validation | func (f *Func) String() string {
s, _ := url.QueryUnescape(f.Raw)
return s
} | go | {
"resource": ""
} |
q171871 | Name | validation | func (f *Func) Name() string {
parts := strings.SplitN(filepath.Base(f.Raw), ".", 2)
if len(parts) == 1 {
return parts[0]
}
return parts[1]
} | go | {
"resource": ""
} |
q171872 | PkgName | validation | func (f *Func) PkgName() string {
parts := strings.SplitN(filepath.Base(f.Raw), ".", 2)
if len(parts) == 1 {
return ""
}
s, _ := url.QueryUnescape(parts[0])
return s
} | go | {
"resource": ""
} |
q171873 | IsExported | validation | func (f *Func) IsExported() bool {
name := f.Name()
parts := strings.Split(name, ".")
r, _ := utf8.DecodeRuneInString(parts[len(parts)-1])
if unicode.ToUpper(r) == r {
return true
}
return f.PkgName() == "main" && name == "main"
} | go | {
"resource": ""
} |
q171874 | IsPtr | validation | func (a *Arg) IsPtr() bool {
// Assumes all pointers are above 16Mb and positive.
return a.Value > 16*1024*1024 && a.Value < math.MaxInt64
} | go | {
"resource": ""
} |
q171875 | equal | validation | func (a *Args) equal(r *Args) bool {
if a.Elided != r.Elided || len(a.Values) != len(r.Values) {
return false
}
for i, l := range a.Values {
if l != r.Values[i] {
return false
}
}
return true
} | go | {
"resource": ""
} |
q171876 | similar | validation | func (a *Args) similar(r *Args, similar Similarity) bool {
if a.Elided != r.Elided || len(a.Values) != len(r.Values) {
return false
}
if similar == AnyValue {
return true
}
for i, l := range a.Values {
switch similar {
case ExactFlags, ExactLines:
if l != r.Values[i] {
return false
}
default:
... | go | {
"resource": ""
} |
q171877 | merge | validation | func (a *Args) merge(r *Args) Args {
out := Args{
Values: make([]Arg, len(a.Values)),
Elided: a.Elided,
}
for i, l := range a.Values {
if l != r.Values[i] {
out.Values[i].Name = "*"
out.Values[i].Value = l.Value
} else {
out.Values[i] = l
}
}
return out
} | go | {
"resource": ""
} |
q171878 | equal | validation | func (c *Call) equal(r *Call) bool {
return c.SrcPath == r.SrcPath && c.Line == r.Line && c.Func == r.Func && c.Args.equal(&r.Args)
} | go | {
"resource": ""
} |
q171879 | similar | validation | func (c *Call) similar(r *Call, similar Similarity) bool {
return c.SrcPath == r.SrcPath && c.Line == r.Line && c.Func == r.Func && c.Args.similar(&r.Args, similar)
} | go | {
"resource": ""
} |
q171880 | merge | validation | func (c *Call) merge(r *Call) Call {
return Call{
SrcPath: c.SrcPath,
Line: c.Line,
Func: c.Func,
Args: c.Args.merge(&r.Args),
LocalSrcPath: c.LocalSrcPath,
IsStdlib: c.IsStdlib,
}
} | go | {
"resource": ""
} |
q171881 | PkgSrc | validation | func (c *Call) PkgSrc() string {
return filepath.Join(filepath.Base(filepath.Dir(c.SrcPath)), c.SrcName())
} | go | {
"resource": ""
} |
q171882 | updateLocations | validation | func (c *Call) updateLocations(goroot, localgoroot string, gopaths map[string]string) {
if c.SrcPath != "" {
// Always check GOROOT first, then GOPATH.
if strings.HasPrefix(c.SrcPath, goroot) {
// Replace remote GOROOT with local GOROOT.
c.LocalSrcPath = filepath.Join(localgoroot, c.SrcPath[len(goroot):])
... | go | {
"resource": ""
} |
q171883 | equal | validation | func (s *Stack) equal(r *Stack) bool {
if len(s.Calls) != len(r.Calls) || s.Elided != r.Elided {
return false
}
for i := range s.Calls {
if !s.Calls[i].equal(&r.Calls[i]) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q171884 | similar | validation | func (s *Stack) similar(r *Stack, similar Similarity) bool {
if len(s.Calls) != len(r.Calls) || s.Elided != r.Elided {
return false
}
for i := range s.Calls {
if !s.Calls[i].similar(&r.Calls[i], similar) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q171885 | merge | validation | func (s *Stack) merge(r *Stack) *Stack {
// Assumes similar stacks have the same length.
out := &Stack{
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
} | go | {
"resource": ""
} |
q171886 | less | validation | func (s *Stack) less(r *Stack) bool {
lStdlib := 0
lPrivate := 0
for _, c := range s.Calls {
if c.IsStdlib {
lStdlib++
} else {
lPrivate++
}
}
rStdlib := 0
rPrivate := 0
for _, s := range r.Calls {
if s.IsStdlib {
rStdlib++
} else {
rPrivate++
}
}
if lPrivate > rPrivate {
return true
... | go | {
"resource": ""
} |
q171887 | equal | validation | func (s *Signature) equal(r *Signature) bool {
if s.State != r.State || !s.CreatedBy.equal(&r.CreatedBy) || s.Locked != r.Locked || s.SleepMin != r.SleepMin || s.SleepMax != r.SleepMax {
return false
}
return s.Stack.equal(&r.Stack)
} | go | {
"resource": ""
} |
q171888 | similar | validation | func (s *Signature) similar(r *Signature, similar Similarity) bool {
if s.State != r.State || !s.CreatedBy.similar(&r.CreatedBy, similar) {
return false
}
if similar == ExactFlags && s.Locked != r.Locked {
return false
}
return s.Stack.similar(&r.Stack, similar)
} | go | {
"resource": ""
} |
q171889 | merge | validation | func (s *Signature) merge(r *Signature) *Signature {
min := s.SleepMin
if r.SleepMin < min {
min = r.SleepMin
}
max := s.SleepMax
if r.SleepMax > max {
max = r.SleepMax
}
return &Signature{
State: s.State, // Drop right side.
CreatedBy: s.CreatedBy, // Drop right side.
SleepMin: min,
SleepMa... | go | {
"resource": ""
} |
q171890 | less | validation | func (s *Signature) less(r *Signature) bool {
if s.Stack.less(&r.Stack) {
return true
}
if r.Stack.less(&s.Stack) {
return false
}
if s.Locked && !r.Locked {
return true
}
if r.Locked && !s.Locked {
return false
}
if s.State < r.State {
return true
}
if s.State > r.State {
return false
}
return... | go | {
"resource": ""
} |
q171891 | CreatedByString | validation | func (s *Signature) CreatedByString(fullPath bool) string {
created := s.CreatedBy.Func.PkgDotName()
if created == "" {
return ""
}
created += " @ "
if fullPath {
created += s.CreatedBy.FullSrcLine()
} else {
created += s.CreatedBy.SrcLine()
}
return created
} | go | {
"resource": ""
} |
q171892 | nameArguments | validation | func nameArguments(goroutines []*Goroutine) {
// Set a name for any pointer occurring more than once.
type object struct {
args []*Arg
inPrimary bool
id int
}
objects := map[uint64]object{}
// Enumerate all the arguments.
for i := range goroutines {
for j := range goroutines[i].Stack.Calls {
... | go | {
"resource": ""
} |
q171893 | CalcLengths | validation | func CalcLengths(buckets []*stack.Bucket, fullPath bool) (int, int) {
srcLen := 0
pkgLen := 0
for _, bucket := range buckets {
for _, line := range bucket.Signature.Stack.Calls {
l := 0
if fullPath {
l = len(line.FullSrcLine())
} else {
l = len(line.SrcLine())
}
if l > srcLen {
srcLen = ... | go | {
"resource": ""
} |
q171894 | functionColor | validation | func (p *Palette) functionColor(line *stack.Call) string {
if line.IsStdlib {
if line.Func.IsExported() {
return p.FuncStdLibExported
}
return p.FuncStdLib
} else if line.IsPkgMain() {
return p.FuncMain
} else if line.Func.IsExported() {
return p.FuncOtherExported
}
return p.FuncOther
} | go | {
"resource": ""
} |
q171895 | routineColor | validation | func (p *Palette) routineColor(bucket *stack.Bucket, multipleBuckets bool) string {
if bucket.First && multipleBuckets {
return p.RoutineFirst
}
return p.Routine
} | go | {
"resource": ""
} |
q171896 | BucketHeader | validation | func (p *Palette) BucketHeader(bucket *stack.Bucket, fullPath, multipleBuckets bool) string {
extra := ""
if s := bucket.SleepString(); s != "" {
extra += " [" + s + "]"
}
if bucket.Locked {
extra += " [locked]"
}
if c := bucket.CreatedByString(fullPath); c != "" {
extra += p.CreatedBy + " [Created by " + c... | go | {
"resource": ""
} |
q171897 | callLine | validation | func (p *Palette) callLine(line *stack.Call, srcLen, pkgLen int, fullPath bool) string {
src := ""
if fullPath {
src = line.FullSrcLine()
} else {
src = line.SrcLine()
}
return fmt.Sprintf(
" %s%-*s %s%-*s %s%s%s(%s)%s",
p.Package, pkgLen, line.Func.PkgName(),
p.SrcFile, srcLen, src,
p.functionColor... | go | {
"resource": ""
} |
q171898 | StackLines | validation | func (p *Palette) StackLines(signature *stack.Signature, srcLen, pkgLen int, fullPath bool) string {
out := make([]string, len(signature.Stack.Calls))
for i := range signature.Stack.Calls {
out[i] = p.callLine(&signature.Stack.Calls[i], srcLen, pkgLen, fullPath)
}
if signature.Stack.Elided {
out = append(out, "... | go | {
"resource": ""
} |
q171899 | augmentGoroutine | validation | func (c *cache) augmentGoroutine(goroutine *Goroutine) {
if c.files == nil {
c.files = map[string][]byte{}
}
if c.parsed == nil {
c.parsed = map[string]*parsedFile{}
}
// For each call site, look at the next call and populate it. Then we can
// walk back and reformat things.
for i := range goroutine.Stack.Ca... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.