_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q33100 | List | train | func (z *ZipArchive) List(prefixes ...string) []string {
isHasPrefix := len(prefixes) > 0
names := make([]string, 0, z.NumFiles)
for _, f := range z.files {
if isHasPrefix && !cae.HasPrefix(f.Name, prefixes) {
continue
}
names = append(names, f.Name)
}
return names
} | go | {
"resource": ""
} |
q33101 | AddEmptyDir | train | func (z *ZipArchive) AddEmptyDir(dirPath string) bool {
if !strings.HasSuffix(dirPath, "/") {
dirPath += "/"
}
for _, f := range z.files {
if dirPath == f.Name {
return false
}
}
dirPath = strings.TrimSuffix(dirPath, "/")
if strings.Contains(dirPath, "/") {
// Auto add all upper level directories.
... | go | {
"resource": ""
} |
q33102 | AddFile | train | func (z *ZipArchive) AddFile(fileName, absPath string) error {
if cae.IsFilter(absPath) {
return nil
}
f, err := os.Open(absPath)
if err != nil {
return err
}
defer f.Close()
fi, err := f.Stat()
if err != nil {
return err
}
file := new(File)
file.FileHeader, err = zip.FileInfoHeader(fi)
if err != n... | go | {
"resource": ""
} |
q33103 | NewContext | train | func NewContext(app *App, set *flag.FlagSet, globalSet *flag.FlagSet) *Context {
return &Context{App: app, flagSet: set, globalSet: globalSet}
} | go | {
"resource": ""
} |
q33104 | GlobalInt | train | func (c *Context) GlobalInt(name string) int {
return lookupInt(name, c.globalSet)
} | go | {
"resource": ""
} |
q33105 | GlobalDuration | train | func (c *Context) GlobalDuration(name string) time.Duration {
return lookupDuration(name, c.globalSet)
} | go | {
"resource": ""
} |
q33106 | GlobalBool | train | func (c *Context) GlobalBool(name string) bool {
return lookupBool(name, c.globalSet)
} | go | {
"resource": ""
} |
q33107 | GlobalString | train | func (c *Context) GlobalString(name string) string {
return lookupString(name, c.globalSet)
} | go | {
"resource": ""
} |
q33108 | GlobalStringSlice | train | func (c *Context) GlobalStringSlice(name string) []string {
return lookupStringSlice(name, c.globalSet)
} | go | {
"resource": ""
} |
q33109 | GlobalIntSlice | train | func (c *Context) GlobalIntSlice(name string) []int {
return lookupIntSlice(name, c.globalSet)
} | go | {
"resource": ""
} |
q33110 | IsSet | train | func (c *Context) IsSet(name string) bool {
if c.setFlags == nil {
c.setFlags = make(map[string]bool)
c.flagSet.Visit(func(f *flag.Flag) {
c.setFlags[f.Name] = true
})
}
return c.setFlags[name] == true
} | go | {
"resource": ""
} |
q33111 | downloadPackage | train | func downloadPackage(ctx *cli.Context, n *doc.Node) (*doc.Node, []string, error) {
// fmt.Println(n.VerString())
log.Info("Downloading package: %s", n.VerString())
downloadCache.Set(n.VerString())
vendor := base.GetTempDir()
defer os.RemoveAll(vendor)
var (
err error
imports []string
srcPath string
... | go | {
"resource": ""
} |
q33112 | SaveConfigFile | train | func SaveConfigFile(c *ConfigFile, filename string) (err error) {
// Write configuration file by filename.
var f *os.File
if f, err = os.Create(filename); err != nil {
return err
}
equalSign := "="
if PrettyFormat {
equalSign = " = "
}
buf := bytes.NewBuffer(nil)
for _, section := range c.sectionList {
... | go | {
"resource": ""
} |
q33113 | LoadGopmfile | train | func LoadGopmfile(fileName string) (*goconfig.ConfigFile, error) {
if !base.IsFile(fileName) {
return goconfig.LoadFromData([]byte(""))
}
gf, err := goconfig.LoadConfigFile(fileName)
if err != nil {
return nil, fmt.Errorf("Fail to load gopmfile: %v", err)
}
return gf, nil
} | go | {
"resource": ""
} |
q33114 | SaveGopmfile | train | func SaveGopmfile(gf *goconfig.ConfigFile, fileName string) error {
if err := goconfig.SaveConfigFile(gf, fileName); err != nil {
return fmt.Errorf("Fail to save gopmfile: %v", err)
}
return nil
} | go | {
"resource": ""
} |
q33115 | LoadConfig | train | func LoadConfig() (err error) {
if !base.IsExist(ConfigFile) {
os.MkdirAll(path.Dir(ConfigFile), os.ModePerm)
if _, err = os.Create(ConfigFile); err != nil {
return fmt.Errorf("fail to create config file: %v", err)
}
}
Cfg, err = goconfig.LoadConfigFile(ConfigFile)
if err != nil {
return fmt.Errorf("fai... | go | {
"resource": ""
} |
q33116 | SetConfigValue | train | func SetConfigValue(section, key, val string) error {
Cfg.SetValue(section, key, val)
if err := goconfig.SaveConfigFile(Cfg, ConfigFile); err != nil {
return fmt.Errorf("fail to set config value(%s:%s=%s): %v", section, key, val, err)
}
return nil
} | go | {
"resource": ""
} |
q33117 | DeleteConfigOption | train | func DeleteConfigOption(section, key string) error {
Cfg.DeleteKey(section, key)
if err := goconfig.SaveConfigFile(Cfg, ConfigFile); err != nil {
return fmt.Errorf("fail to delete config key(%s:%s): %v", section, key, err)
}
return nil
} | go | {
"resource": ""
} |
q33118 | LoadPkgNameList | train | func LoadPkgNameList() error {
if !base.IsFile(PkgNameListFile) {
return nil
}
data, err := ioutil.ReadFile(PkgNameListFile)
if err != nil {
return fmt.Errorf("fail to load package name list: %v", err)
}
pkgs := strings.Split(string(data), "\n")
for i, line := range pkgs {
infos := strings.Split(line, "=... | go | {
"resource": ""
} |
q33119 | GetPkgFullPath | train | func GetPkgFullPath(short string) (string, error) {
name, ok := PackageNameList[short]
if !ok {
return "", fmt.Errorf("no match package import path with given short name: %s", short)
}
return name, nil
} | go | {
"resource": ""
} |
q33120 | validPkgInfo | train | func validPkgInfo(info string) (doc.RevisionType, string, error) {
if len(info) == 0 {
return doc.BRANCH, "", nil
}
infos := strings.Split(info, ":")
if len(infos) == 2 {
tp := doc.RevisionType(infos[0])
val := infos[1]
switch tp {
case doc.BRANCH, doc.COMMIT, doc.TAG:
default:
return "", "", fmt.E... | go | {
"resource": ""
} |
q33121 | NewApp | train | func NewApp() *App {
return &App{
Name: os.Args[0],
Usage: "A new cli application",
Version: "0.0.0",
BashComplete: DefaultAppComplete,
Action: helpCommand.Action,
Compiled: compileTime(),
}
} | go | {
"resource": ""
} |
q33122 | RunAndExitOnError | train | func (a *App) RunAndExitOnError() {
if err := a.Run(os.Args); err != nil {
os.Stderr.WriteString(fmt.Sprintln(err))
os.Exit(1)
}
} | go | {
"resource": ""
} |
q33123 | setup | train | func setup(ctx *cli.Context) (err error) {
setting.Debug = ctx.GlobalBool("debug")
log.NonColor = ctx.GlobalBool("noterm")
log.Verbose = ctx.Bool("verbose")
log.Info("App Version: %s", ctx.App.Version)
setting.HomeDir, err = base.HomeDir()
if err != nil {
return fmt.Errorf("Fail to get home directory: %v", er... | go | {
"resource": ""
} |
q33124 | isSubpackage | train | func isSubpackage(rootPath, target string) bool {
return strings.HasSuffix(setting.WorkDir, rootPath) ||
strings.HasPrefix(rootPath, target)
} | go | {
"resource": ""
} |
q33125 | LoadConfigFile | train | func LoadConfigFile(fileName string, moreFiles ...string) (c *ConfigFile, err error) {
// Append files' name together.
fileNames := make([]string, 1, len(moreFiles)+1)
fileNames[0] = fileName
if len(moreFiles) > 0 {
fileNames = append(fileNames, moreFiles...)
}
c = newConfigFile(fileNames)
for _, name := ran... | go | {
"resource": ""
} |
q33126 | Reload | train | func (c *ConfigFile) Reload() (err error) {
var cfg *ConfigFile
if len(c.fileNames) == 1 {
cfg, err = LoadConfigFile(c.fileNames[0])
} else {
cfg, err = LoadConfigFile(c.fileNames[0], c.fileNames[1:]...)
}
if err == nil {
*c = *cfg
}
return err
} | go | {
"resource": ""
} |
q33127 | AppendFiles | train | func (c *ConfigFile) AppendFiles(files ...string) error {
c.fileNames = append(c.fileNames, files...)
return c.Reload()
} | go | {
"resource": ""
} |
q33128 | extractFile | train | func (z *ZipArchive) extractFile(f *File) error {
if !z.isHasWriter {
for _, zf := range z.ReadCloser.File {
if f.Name == zf.Name {
return extractFile(zf, path.Dir(f.tmpPath))
}
}
}
return cae.Copy(f.tmpPath, f.absPath)
} | go | {
"resource": ""
} |
q33129 | packDir | train | func packDir(srcPath string, recPath string, zw *zip.Writer, fn cae.HookFunc) error {
dir, err := os.Open(srcPath)
if err != nil {
return err
}
defer dir.Close()
fis, err := dir.Readdir(0)
if err != nil {
return err
}
for _, fi := range fis {
if cae.IsFilter(fi.Name()) {
continue
}
curPath := srcP... | go | {
"resource": ""
} |
q33130 | packToWriter | train | func packToWriter(srcPath string, w io.Writer, fn func(fullName string, fi os.FileInfo) error, includeDir bool) error {
zw := zip.NewWriter(w)
defer zw.Close()
f, err := os.Open(srcPath)
if err != nil {
return err
}
defer f.Close()
fi, err := f.Stat()
if err != nil {
return err
}
basePath := path.Base(... | go | {
"resource": ""
} |
q33131 | packTo | train | func packTo(srcPath, destPath string, fn cae.HookFunc, includeDir bool) error {
fw, err := os.Create(destPath)
if err != nil {
return err
}
defer fw.Close()
return packToWriter(srcPath, fw, fn, includeDir)
} | go | {
"resource": ""
} |
q33132 | maybeExpandNamedQueryAndExec | train | func maybeExpandNamedQueryAndExec(e SqlExecutor, query string, args ...interface{}) (sql.Result, error) {
dbMap := extractDbMap(e)
if len(args) == 1 {
query, args = maybeExpandNamedQuery(dbMap, query, args)
}
return exec(e, query, args...)
} | go | {
"resource": ""
} |
q33133 | SetTransient | train | func (c *ColumnMap) SetTransient(b bool) *ColumnMap {
c.Transient = b
return c
} | go | {
"resource": ""
} |
q33134 | SetUnique | train | func (c *ColumnMap) SetUnique(b bool) *ColumnMap {
c.Unique = b
return c
} | go | {
"resource": ""
} |
q33135 | SetNotNull | train | func (c *ColumnMap) SetNotNull(nn bool) *ColumnMap {
c.isNotNull = nn
return c
} | go | {
"resource": ""
} |
q33136 | IdxMap | train | func (t *TableMap) IdxMap(field string) *IndexMap {
for _, idx := range t.indexes {
if idx.IndexName == field {
return idx
}
}
return nil
} | go | {
"resource": ""
} |
q33137 | SqlForCreate | train | func (t *TableMap) SqlForCreate(ifNotExists bool) string {
s := bytes.Buffer{}
dialect := t.dbmap.Dialect
if strings.TrimSpace(t.SchemaName) != "" {
schemaCreate := "create schema"
if ifNotExists {
s.WriteString(dialect.IfSchemaNotExists(schemaCreate, t.SchemaName))
} else {
s.WriteString(schemaCreate)
... | go | {
"resource": ""
} |
q33138 | CreateTableSuffix | train | func (d MySQLDialect) CreateTableSuffix() string {
if d.Engine == "" || d.Encoding == "" {
msg := "gorp - undefined"
if d.Engine == "" {
msg += " MySQLDialect.Engine"
}
if d.Engine == "" && d.Encoding == "" {
msg += ","
}
if d.Encoding == "" {
msg += " MySQLDialect.Encoding"
}
msg += ". Check... | go | {
"resource": ""
} |
q33139 | AddTableWithName | train | func (m *DbMap) AddTableWithName(i interface{}, name string) *TableMap {
return m.AddTableWithNameAndSchema(i, "", name)
} | go | {
"resource": ""
} |
q33140 | AddTableWithNameAndSchema | train | func (m *DbMap) AddTableWithNameAndSchema(i interface{}, schema string, name string) *TableMap {
t := reflect.TypeOf(i)
if name == "" {
name = t.Name()
}
// check if we have a table for this type already
// if so, update the name and return the existing pointer
for i := range m.tables {
table := m.tables[i]
... | go | {
"resource": ""
} |
q33141 | AddTableDynamic | train | func (m *DbMap) AddTableDynamic(inp DynamicTable, schema string) *TableMap {
val := reflect.ValueOf(inp)
elm := val.Elem()
t := elm.Type()
name := inp.TableName()
if name == "" {
panic("Missing table name in DynamicTable instance")
}
// Check if there is another dynamic table with the same name
if _, found ... | go | {
"resource": ""
} |
q33142 | DropTable | train | func (m *DbMap) DropTable(table interface{}) error {
t := reflect.TypeOf(table)
tableName := ""
if dyn, ok := table.(DynamicTable); ok {
tableName = dyn.TableName()
}
return m.dropTable(t, tableName, false)
} | go | {
"resource": ""
} |
q33143 | DropTableIfExists | train | func (m *DbMap) DropTableIfExists(table interface{}) error {
t := reflect.TypeOf(table)
tableName := ""
if dyn, ok := table.(DynamicTable); ok {
tableName = dyn.TableName()
}
return m.dropTable(t, tableName, true)
} | go | {
"resource": ""
} |
q33144 | dropTables | train | func (m *DbMap) dropTables(addIfExists bool) (err error) {
for _, table := range m.tables {
err = m.dropTableImpl(table, addIfExists)
if err != nil {
return err
}
}
for _, table := range m.dynamicTableMap() {
err = m.dropTableImpl(table, addIfExists)
if err != nil {
return err
}
}
return err
} | go | {
"resource": ""
} |
q33145 | dropTable | train | func (m *DbMap) dropTable(t reflect.Type, name string, addIfExists bool) error {
table := tableOrNil(m, t, name)
if table == nil {
return fmt.Errorf("table %s was not registered", table.TableName)
}
return m.dropTableImpl(table, addIfExists)
} | go | {
"resource": ""
} |
q33146 | SelectInt | train | func (m *DbMap) SelectInt(query string, args ...interface{}) (int64, error) {
if m.ExpandSliceArgs {
expandSliceArgs(&query, args...)
}
return SelectInt(m, query, args...)
} | go | {
"resource": ""
} |
q33147 | SelectNullInt | train | func (m *DbMap) SelectNullInt(query string, args ...interface{}) (sql.NullInt64, error) {
if m.ExpandSliceArgs {
expandSliceArgs(&query, args...)
}
return SelectNullInt(m, query, args...)
} | go | {
"resource": ""
} |
q33148 | SelectFloat | train | func (m *DbMap) SelectFloat(query string, args ...interface{}) (float64, error) {
if m.ExpandSliceArgs {
expandSliceArgs(&query, args...)
}
return SelectFloat(m, query, args...)
} | go | {
"resource": ""
} |
q33149 | SelectNullFloat | train | func (m *DbMap) SelectNullFloat(query string, args ...interface{}) (sql.NullFloat64, error) {
if m.ExpandSliceArgs {
expandSliceArgs(&query, args...)
}
return SelectNullFloat(m, query, args...)
} | go | {
"resource": ""
} |
q33150 | SelectStr | train | func (m *DbMap) SelectStr(query string, args ...interface{}) (string, error) {
if m.ExpandSliceArgs {
expandSliceArgs(&query, args...)
}
return SelectStr(m, query, args...)
} | go | {
"resource": ""
} |
q33151 | SelectNullStr | train | func (m *DbMap) SelectNullStr(query string, args ...interface{}) (sql.NullString, error) {
if m.ExpandSliceArgs {
expandSliceArgs(&query, args...)
}
return SelectNullStr(m, query, args...)
} | go | {
"resource": ""
} |
q33152 | SelectOne | train | func (m *DbMap) SelectOne(holder interface{}, query string, args ...interface{}) error {
if m.ExpandSliceArgs {
expandSliceArgs(&query, args...)
}
return SelectOne(m, m, holder, query, args...)
} | go | {
"resource": ""
} |
q33153 | Begin | train | func (m *DbMap) Begin() (*Transaction, error) {
if m.logger != nil {
now := time.Now()
defer m.trace(now, "begin;")
}
tx, err := begin(m)
if err != nil {
return nil, err
}
return &Transaction{
dbmap: m,
tx: tx,
closed: false,
}, nil
} | go | {
"resource": ""
} |
q33154 | SetUnique | train | func (idx *IndexMap) SetUnique(b bool) *IndexMap {
idx.Unique = b
return idx
} | go | {
"resource": ""
} |
q33155 | SetIndexType | train | func (idx *IndexMap) SetIndexType(indtype string) *IndexMap {
idx.IndexType = indtype
return idx
} | go | {
"resource": ""
} |
q33156 | QuotedTableForQuery | train | func (d SqliteDialect) QuotedTableForQuery(schema string, table string) string {
return d.QuoteField(table)
} | go | {
"resource": ""
} |
q33157 | InsertQueryToTarget | train | func (d OracleDialect) InsertQueryToTarget(exec SqlExecutor, insertSql, idSql string, target interface{}, params ...interface{}) error {
_, err := exec.Exec(insertSql, params...)
if err != nil {
return err
}
id, err := exec.SelectInt(idSql)
if err != nil {
return err
}
switch target.(type) {
case *int64:
... | go | {
"resource": ""
} |
q33158 | SelectInt | train | func (t *Transaction) SelectInt(query string, args ...interface{}) (int64, error) {
if t.dbmap.ExpandSliceArgs {
expandSliceArgs(&query, args...)
}
return SelectInt(t, query, args...)
} | go | {
"resource": ""
} |
q33159 | SelectNullInt | train | func (t *Transaction) SelectNullInt(query string, args ...interface{}) (sql.NullInt64, error) {
if t.dbmap.ExpandSliceArgs {
expandSliceArgs(&query, args...)
}
return SelectNullInt(t, query, args...)
} | go | {
"resource": ""
} |
q33160 | SelectFloat | train | func (t *Transaction) SelectFloat(query string, args ...interface{}) (float64, error) {
if t.dbmap.ExpandSliceArgs {
expandSliceArgs(&query, args...)
}
return SelectFloat(t, query, args...)
} | go | {
"resource": ""
} |
q33161 | SelectNullFloat | train | func (t *Transaction) SelectNullFloat(query string, args ...interface{}) (sql.NullFloat64, error) {
if t.dbmap.ExpandSliceArgs {
expandSliceArgs(&query, args...)
}
return SelectNullFloat(t, query, args...)
} | go | {
"resource": ""
} |
q33162 | SelectStr | train | func (t *Transaction) SelectStr(query string, args ...interface{}) (string, error) {
if t.dbmap.ExpandSliceArgs {
expandSliceArgs(&query, args...)
}
return SelectStr(t, query, args...)
} | go | {
"resource": ""
} |
q33163 | SelectNullStr | train | func (t *Transaction) SelectNullStr(query string, args ...interface{}) (sql.NullString, error) {
if t.dbmap.ExpandSliceArgs {
expandSliceArgs(&query, args...)
}
return SelectNullStr(t, query, args...)
} | go | {
"resource": ""
} |
q33164 | SelectOne | train | func (t *Transaction) SelectOne(holder interface{}, query string, args ...interface{}) error {
if t.dbmap.ExpandSliceArgs {
expandSliceArgs(&query, args...)
}
return SelectOne(t.dbmap, t, holder, query, args...)
} | go | {
"resource": ""
} |
q33165 | Savepoint | train | func (t *Transaction) Savepoint(name string) error {
query := "savepoint " + t.dbmap.Dialect.QuoteField(name)
if t.dbmap.logger != nil {
now := time.Now()
defer t.dbmap.trace(now, query, nil)
}
_, err := exec(t, query)
return err
} | go | {
"resource": ""
} |
q33166 | Error | train | func (e OptimisticLockError) Error() string {
if e.RowExists {
return fmt.Sprintf("gorp: OptimisticLockError table=%s keys=%v out of date version=%d", e.TableName, e.Keys, e.LocalVersion)
}
return fmt.Sprintf("gorp: OptimisticLockError no row found for table=%s keys=%v", e.TableName, e.Keys)
} | go | {
"resource": ""
} |
q33167 | SelectInt | train | func SelectInt(e SqlExecutor, query string, args ...interface{}) (int64, error) {
var h int64
err := selectVal(e, &h, query, args...)
if err != nil && err != sql.ErrNoRows {
return 0, err
}
return h, nil
} | go | {
"resource": ""
} |
q33168 | NewConstraint | train | func NewConstraint(v string) (Constraints, error) {
vs := strings.Split(v, ",")
result := make([]*Constraint, len(vs))
for i, single := range vs {
c, err := parseSingle(single)
if err != nil {
return nil, err
}
result[i] = c
}
return Constraints(result), nil
} | go | {
"resource": ""
} |
q33169 | Check | train | func (cs Constraints) Check(v *Version) bool {
for _, c := range cs {
if !c.Check(v) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q33170 | String | train | func (cs Constraints) String() string {
csStr := make([]string, len(cs))
for i, c := range cs {
csStr[i] = c.String()
}
return strings.Join(csStr, ",")
} | go | {
"resource": ""
} |
q33171 | Check | train | func (c *Constraint) Check(v *Version) bool {
return c.f(v, c.check)
} | go | {
"resource": ""
} |
q33172 | Compare | train | func (v *Version) Compare(other *Version) int {
// A quick, efficient equality check
if v.String() == other.String() {
return 0
}
segmentsSelf := v.Segments64()
segmentsOther := other.Segments64()
// If the segments are the same, we must compare on prerelease info
if reflect.DeepEqual(segmentsSelf, segmentsO... | go | {
"resource": ""
} |
q33173 | Segments | train | func (v *Version) Segments() []int {
segmentSlice := make([]int, len(v.segments))
for i, v := range v.segments {
segmentSlice[i] = int(v)
}
return segmentSlice
} | go | {
"resource": ""
} |
q33174 | Segments64 | train | func (v *Version) Segments64() []int64 {
result := make([]int64, len(v.segments))
copy(result, v.segments)
return result
} | go | {
"resource": ""
} |
q33175 | elapsedTime | train | func elapsedTime(p *process.Process) (string, error) {
crtTime, err := p.CreateTime()
if err != nil {
return "", err
}
etime := time.Since(time.Unix(int64(crtTime/1000), 0))
return fmtEtimeDuration(etime), nil
} | go | {
"resource": ""
} |
q33176 | displayProcessTree | train | func displayProcessTree() {
ps := goprocess.FindAll()
pstree = make(map[int][]goprocess.P)
for _, p := range ps {
pstree[p.PPID] = append(pstree[p.PPID], p)
}
tree := treeprint.New()
tree.SetValue("...")
seen := map[int]bool{}
for _, p := range ps {
constructProcessTree(p.PPID, p, seen, tree)
}
fmt.Printl... | go | {
"resource": ""
} |
q33177 | constructProcessTree | train | func constructProcessTree(ppid int, process goprocess.P, seen map[int]bool, tree treeprint.Tree) {
if seen[ppid] {
return
}
seen[ppid] = true
if ppid != process.PPID {
output := strconv.Itoa(ppid) + " (" + process.Exec + ")" + " {" + process.BuildVersion + "}"
if process.Agent {
tree = tree.AddMetaBranch("... | go | {
"resource": ""
} |
q33178 | FindAll | train | func FindAll() []P {
pss, err := ps.Processes()
if err != nil {
return nil
}
var wg sync.WaitGroup
wg.Add(len(pss))
found := make(chan P)
for _, pr := range pss {
pr := pr
go func() {
defer wg.Done()
path, version, agent, ok, err := isGo(pr)
if err != nil {
// TODO(jbd): Return a list of er... | go | {
"resource": ""
} |
q33179 | Find | train | func Find(pid int) (p P, ok bool, err error) {
pr, err := ps.FindProcess(pid)
if err != nil {
return P{}, false, err
}
path, version, agent, ok, err := isGo(pr)
if !ok {
return P{}, false, nil
}
return P{
PID: pr.Pid(),
PPID: pr.PPid(),
Exec: pr.Executable(),
Path: pa... | go | {
"resource": ""
} |
q33180 | isGo | train | func isGo(pr ps.Process) (path, version string, agent, ok bool, err error) {
if pr.Pid() == 0 {
// ignore system process
return
}
path, err = pr.Path()
if err != nil {
return
}
var versionInfo goversion.Version
versionInfo, err = goversion.ReadExe(path)
if err != nil {
return
}
ok = true
version = ve... | go | {
"resource": ""
} |
q33181 | Close | train | func Close() {
mu.Lock()
defer mu.Unlock()
if portfile != "" {
os.Remove(portfile)
portfile = ""
}
if listener != nil {
listener.Close()
}
} | go | {
"resource": ""
} |
q33182 | GoMainDirs | train | func GoMainDirs(packages []string, GoCmd string) ([]string, error) {
args := make([]string, 0, len(packages)+3)
args = append(args, "list", "-f", "{{.Name}}|{{.ImportPath}}")
args = append(args, packages...)
output, err := execGo(GoCmd, nil, "", args...)
if err != nil {
return nil, err
}
results := make([]st... | go | {
"resource": ""
} |
q33183 | GoRoot | train | func GoRoot() (string, error) {
output, err := execGo("go", nil, "", "env", "GOROOT")
if err != nil {
return "", err
}
return strings.TrimSpace(output), nil
} | go | {
"resource": ""
} |
q33184 | mainBuildToolchain | train | func mainBuildToolchain(parallel int, platformFlag PlatformFlag, verbose bool) int {
if _, err := exec.LookPath("go"); err != nil {
fmt.Fprintf(os.Stderr, "You must have Go already built for your native platform\n")
fmt.Fprintf(os.Stderr, "and the `go` binary on the PATH to build toolchains.\n")
return 1
}
//... | go | {
"resource": ""
} |
q33185 | SupportedPlatforms | train | func SupportedPlatforms(v string) []Platform {
// Use latest if we get an unexpected version string
if !strings.HasPrefix(v, "go") {
return PlatformsLatest
}
// go-version only cares about version numbers
v = v[2:]
current, err := version.NewVersion(v)
if err != nil {
log.Printf("Unable to parse current go ... | go | {
"resource": ""
} |
q33186 | encode | train | func (q *QRCode) encode(numTerminatorBits int) {
q.addTerminatorBits(numTerminatorBits)
q.addPadding()
encoded := q.encodeBlocks()
const numMasks int = 8
penalty := 0
for mask := 0; mask < numMasks; mask++ {
var s *symbol
var err error
s, err = buildRegularSymbol(q.version, mask, encoded)
if err != n... | go | {
"resource": ""
} |
q33187 | addPadding | train | func (q *QRCode) addPadding() {
numDataBits := q.version.numDataBits()
if q.data.Len() == numDataBits {
return
}
// Pad to the nearest codeword boundary.
q.data.AppendNumBools(q.version.numBitsToPadToCodeword(q.data.Len()), false)
// Pad codewords 0b11101100 and 0b00010001.
padding := [2]*bitset.Bitset{
b... | go | {
"resource": ""
} |
q33188 | ToString | train | func (q *QRCode) ToString(inverseColor bool) string {
bits := q.Bitmap()
var buf bytes.Buffer
for y := range bits {
for x := range bits[y] {
if bits[y][x] != inverseColor {
buf.WriteString(" ")
} else {
buf.WriteString("██")
}
}
buf.WriteString("\n")
}
return buf.String()
} | go | {
"resource": ""
} |
q33189 | ToSmallString | train | func (q *QRCode) ToSmallString(inverseColor bool) string {
bits := q.Bitmap()
var buf bytes.Buffer
// if there is an odd number of rows, the last one needs special treatment
for y := 0; y < len(bits)-1; y += 2 {
for x := range bits[y] {
if bits[y][x] == bits[y+1][x] {
if bits[y][x] != inverseColor {
b... | go | {
"resource": ""
} |
q33190 | New | train | func New(v ...bool) *Bitset {
b := &Bitset{numBits: 0, bits: make([]byte, 0)}
b.AppendBools(v...)
return b
} | go | {
"resource": ""
} |
q33191 | Clone | train | func Clone(from *Bitset) *Bitset {
return &Bitset{numBits: from.numBits, bits: from.bits[:]}
} | go | {
"resource": ""
} |
q33192 | Substr | train | func (b *Bitset) Substr(start int, end int) *Bitset {
if start > end || end > b.numBits {
log.Panicf("Out of range start=%d end=%d numBits=%d", start, end, b.numBits)
}
result := New()
result.ensureCapacity(end - start)
for i := start; i < end; i++ {
if b.At(i) {
result.bits[result.numBits/8] |= 0x80 >> u... | go | {
"resource": ""
} |
q33193 | AppendBytes | train | func (b *Bitset) AppendBytes(data []byte) {
for _, d := range data {
b.AppendByte(d, 8)
}
} | go | {
"resource": ""
} |
q33194 | AppendByte | train | func (b *Bitset) AppendByte(value byte, numBits int) {
b.ensureCapacity(numBits)
if numBits > 8 {
log.Panicf("numBits %d out of range 0-8", numBits)
}
for i := numBits - 1; i >= 0; i-- {
if value&(1<<uint(i)) != 0 {
b.bits[b.numBits/8] |= 0x80 >> uint(b.numBits%8)
}
b.numBits++
}
} | go | {
"resource": ""
} |
q33195 | AppendUint32 | train | func (b *Bitset) AppendUint32(value uint32, numBits int) {
b.ensureCapacity(numBits)
if numBits > 32 {
log.Panicf("numBits %d out of range 0-32", numBits)
}
for i := numBits - 1; i >= 0; i-- {
if value&(1<<uint(i)) != 0 {
b.bits[b.numBits/8] |= 0x80 >> uint(b.numBits%8)
}
b.numBits++
}
} | go | {
"resource": ""
} |
q33196 | ensureCapacity | train | func (b *Bitset) ensureCapacity(numBits int) {
numBits += b.numBits
newNumBytes := numBits / 8
if numBits%8 != 0 {
newNumBytes++
}
if len(b.bits) >= newNumBytes {
return
}
b.bits = append(b.bits, make([]byte, newNumBytes+2*len(b.bits))...)
} | go | {
"resource": ""
} |
q33197 | AppendBools | train | func (b *Bitset) AppendBools(bits ...bool) {
b.ensureCapacity(len(bits))
for _, v := range bits {
if v {
b.bits[b.numBits/8] |= 0x80 >> uint(b.numBits%8)
}
b.numBits++
}
} | go | {
"resource": ""
} |
q33198 | AppendNumBools | train | func (b *Bitset) AppendNumBools(num int, value bool) {
for i := 0; i < num; i++ {
b.AppendBools(value)
}
} | go | {
"resource": ""
} |
q33199 | String | train | func (b *Bitset) String() string {
var bitString string
for i := 0; i < b.numBits; i++ {
if (i % 8) == 0 {
bitString += " "
}
if (b.bits[i/8] & (0x80 >> byte(i%8))) != 0 {
bitString += "1"
} else {
bitString += "0"
}
}
return fmt.Sprintf("numBits=%d, bits=%s", b.numBits, bitString)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.