_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q36700 | Receive | train | func (ln *Listener) Receive() (channel string, payload string, err error) {
return ln.ReceiveTimeout(0)
} | go | {
"resource": ""
} |
q36701 | ReceiveTimeout | train | func (ln *Listener) ReceiveTimeout(timeout time.Duration) (channel, payload string, err error) {
cn, err := ln.conn()
if err != nil {
return "", "", err
}
err = cn.WithReader(timeout, func(rd *internal.BufReader) error {
channel, payload, err = readNotification(rd)
return err
})
if err != nil {
ln.releas... | go | {
"resource": ""
} |
q36702 | writeBindExecuteMsg | train | func writeBindExecuteMsg(buf *pool.WriteBuffer, name string, params ...interface{}) error {
buf.StartMessage(bindMsg)
buf.WriteString("")
buf.WriteString(name)
buf.WriteInt16(0)
buf.WriteInt16(int16(len(params)))
for _, param := range params {
buf.StartParam()
bytes := types.Append(buf.Bytes, param, 0)
if b... | go | {
"resource": ""
} |
q36703 | Exec | train | func (stmt *Stmt) Exec(params ...interface{}) (Result, error) {
return stmt.exec(context.TODO(), params...)
} | go | {
"resource": ""
} |
q36704 | ExecContext | train | func (stmt *Stmt) ExecContext(c context.Context, params ...interface{}) (Result, error) {
return stmt.exec(c, params...)
} | go | {
"resource": ""
} |
q36705 | Query | train | func (stmt *Stmt) Query(model interface{}, params ...interface{}) (Result, error) {
return stmt.query(context.TODO(), model, params...)
} | go | {
"resource": ""
} |
q36706 | Exec | train | func (db *baseDB) Exec(query interface{}, params ...interface{}) (res Result, err error) {
return db.exec(context.TODO(), query, params...)
} | go | {
"resource": ""
} |
q36707 | Query | train | func (db *baseDB) Query(model, query interface{}, params ...interface{}) (res Result, err error) {
return db.query(context.TODO(), model, query, params...)
} | go | {
"resource": ""
} |
q36708 | Model | train | func (db *baseDB) Model(model ...interface{}) *orm.Query {
return orm.NewQuery(db.db, model...)
} | go | {
"resource": ""
} |
q36709 | Select | train | func (db *baseDB) Select(model interface{}) error {
return orm.Select(db.db, model)
} | go | {
"resource": ""
} |
q36710 | Insert | train | func (db *baseDB) Insert(model ...interface{}) error {
return orm.Insert(db.db, model...)
} | go | {
"resource": ""
} |
q36711 | Update | train | func (db *baseDB) Update(model interface{}) error {
return orm.Update(db.db, model)
} | go | {
"resource": ""
} |
q36712 | Delete | train | func (db *baseDB) Delete(model interface{}) error {
return orm.Delete(db.db, model)
} | go | {
"resource": ""
} |
q36713 | DropTable | train | func (db *baseDB) DropTable(model interface{}, opt *orm.DropTableOptions) error {
return orm.DropTable(db.db, model, opt)
} | go | {
"resource": ""
} |
q36714 | ModelContext | train | func ModelContext(c context.Context, model ...interface{}) *orm.Query {
return orm.NewQueryContext(c, nil, model...)
} | go | {
"resource": ""
} |
q36715 | Q | train | func Q(query string, params ...interface{}) types.ValueAppender {
return orm.Q(query, params...)
} | go | {
"resource": ""
} |
q36716 | Init | train | func (strings *Strings) Init() error {
if s := *strings; len(s) > 0 {
*strings = s[:0]
}
return nil
} | go | {
"resource": ""
} |
q36717 | ScanColumn | train | func (strings *Strings) ScanColumn(colIdx int, _ string, rd types.Reader, n int) error {
b := make([]byte, n)
_, err := io.ReadFull(rd, b)
if err != nil {
return err
}
*strings = append(*strings, internal.BytesToString(b))
return nil
} | go | {
"resource": ""
} |
q36718 | AppendValue | train | func (strings Strings) AppendValue(dst []byte, quote int) []byte {
if len(strings) == 0 {
return dst
}
for _, s := range strings {
dst = types.AppendString(dst, s, 1)
dst = append(dst, ',')
}
dst = dst[:len(dst)-1]
return dst
} | go | {
"resource": ""
} |
q36719 | Init | train | func (ints *Ints) Init() error {
if s := *ints; len(s) > 0 {
*ints = s[:0]
}
return nil
} | go | {
"resource": ""
} |
q36720 | ScanColumn | train | func (ints *Ints) ScanColumn(colIdx int, colName string, rd types.Reader, n int) error {
num, err := types.ScanInt64(rd, n)
if err != nil {
return err
}
*ints = append(*ints, num)
return nil
} | go | {
"resource": ""
} |
q36721 | AppendValue | train | func (ints Ints) AppendValue(dst []byte, quote int) []byte {
if len(ints) == 0 {
return dst
}
for _, v := range ints {
dst = strconv.AppendInt(dst, v, 10)
dst = append(dst, ',')
}
dst = dst[:len(dst)-1]
return dst
} | go | {
"resource": ""
} |
q36722 | Init | train | func (set *IntSet) Init() error {
if len(*set) > 0 {
*set = make(map[int64]struct{})
}
return nil
} | go | {
"resource": ""
} |
q36723 | ScanColumn | train | func (set *IntSet) ScanColumn(colIdx int, colName string, rd types.Reader, n int) error {
num, err := types.ScanInt64(rd, n)
if err != nil {
return err
}
setVal := *set
if setVal == nil {
*set = make(IntSet)
setVal = *set
}
setVal[num] = struct{}{}
return nil
} | go | {
"resource": ""
} |
q36724 | Buffered | train | func (b *BufReader) Buffered() int {
d := b.w - b.r
if b.available != -1 && d > b.available {
return b.available
}
return d
} | go | {
"resource": ""
} |
q36725 | New | train | func (q *Query) New() *Query {
cp := &Query{
ctx: q.ctx,
db: q.db,
model: q.model,
implicitModel: true,
deleted: q.deleted,
}
return cp
} | go | {
"resource": ""
} |
q36726 | Copy | train | func (q *Query) Copy() *Query {
var modelValues map[string]*queryParamsAppender
if len(q.modelValues) > 0 {
modelValues = make(map[string]*queryParamsAppender, len(q.modelValues))
for k, v := range q.modelValues {
modelValues[k] = v
}
}
copy := &Query{
ctx: q.ctx,
db: q.db,
stickyErr: q... | go | {
"resource": ""
} |
q36727 | Deleted | train | func (q *Query) Deleted() *Query {
if q.model != nil {
if err := q.model.Table().mustSoftDelete(); err != nil {
return q.err(err)
}
}
q.deleted = true
return q
} | go | {
"resource": ""
} |
q36728 | With | train | func (q *Query) With(name string, subq *Query) *Query {
return q._with(name, newSelectQuery(subq))
} | go | {
"resource": ""
} |
q36729 | WrapWith | train | func (q *Query) WrapWith(name string) *Query {
wrapper := q.New()
wrapper.with = q.with
q.with = nil
wrapper = wrapper.With(name, q)
return wrapper
} | go | {
"resource": ""
} |
q36730 | ColumnExpr | train | func (q *Query) ColumnExpr(expr string, params ...interface{}) *Query {
q.columns = append(q.columns, &queryParamsAppender{expr, params})
return q
} | go | {
"resource": ""
} |
q36731 | ExcludeColumn | train | func (q *Query) ExcludeColumn(columns ...string) *Query {
if q.columns == nil {
for _, f := range q.model.Table().Fields {
q.columns = append(q.columns, fieldAppender{f.SQLName})
}
}
for _, col := range columns {
if !q.excludeColumn(col) {
return q.err(fmt.Errorf("pg: can't find column=%q", col))
}
}... | go | {
"resource": ""
} |
q36732 | Value | train | func (q *Query) Value(column string, value string, params ...interface{}) *Query {
if !q.hasModel() {
q.err(errModelNil)
return q
}
table := q.model.Table()
if _, ok := table.FieldsMap[column]; !ok {
q.err(fmt.Errorf("%s does not have column=%q", table, column))
return q
}
if q.modelValues == nil {
q.... | go | {
"resource": ""
} |
q36733 | JoinOn | train | func (q *Query) JoinOn(condition string, params ...interface{}) *Query {
if q.joinAppendOn == nil {
q.err(errors.New("pg: no joins to apply JoinOn"))
return q
}
q.joinAppendOn(&condAppender{
sep: " AND ",
cond: condition,
params: params,
})
return q
} | go | {
"resource": ""
} |
q36734 | Order | train | func (q *Query) Order(orders ...string) *Query {
loop:
for _, order := range orders {
if order == "" {
continue
}
ind := strings.Index(order, " ")
if ind != -1 {
field := order[:ind]
sort := order[ind+1:]
switch internal.UpperString(sort) {
case "ASC", "DESC", "ASC NULLS FIRST", "DESC NULLS FIRS... | go | {
"resource": ""
} |
q36735 | OrderExpr | train | func (q *Query) OrderExpr(order string, params ...interface{}) *Query {
if order != "" {
q.order = append(q.order, &queryParamsAppender{order, params})
}
return q
} | go | {
"resource": ""
} |
q36736 | Apply | train | func (q *Query) Apply(fn func(*Query) (*Query, error)) *Query {
qq, err := fn(q)
if err != nil {
q.err(err)
return q
}
return qq
} | go | {
"resource": ""
} |
q36737 | Count | train | func (q *Query) Count() (int, error) {
if q.stickyErr != nil {
return 0, q.stickyErr
}
var count int
_, err := q.db.QueryOneContext(
q.ctx, Scan(&count), q.countSelectQuery("count(*)"), q.model)
return count, err
} | go | {
"resource": ""
} |
q36738 | Select | train | func (q *Query) Select(values ...interface{}) error {
if q.stickyErr != nil {
return q.stickyErr
}
model, err := q.newModel(values...)
if err != nil {
return err
}
q, err = model.BeforeSelectQuery(q.ctx, q.db, q)
if err != nil {
return err
}
res, err := q.query(model, newSelectQuery(q))
if err != nil... | go | {
"resource": ""
} |
q36739 | SelectAndCount | train | func (q *Query) SelectAndCount(values ...interface{}) (count int, firstErr error) {
if q.stickyErr != nil {
return 0, q.stickyErr
}
var wg sync.WaitGroup
var mu sync.Mutex
if q.limit >= 0 {
wg.Add(1)
go func() {
defer wg.Done()
err := q.Select(values...)
if err != nil {
mu.Lock()
if firstE... | go | {
"resource": ""
} |
q36740 | ForEach | train | func (q *Query) ForEach(fn interface{}) error {
m := newFuncModel(fn)
return q.Select(m)
} | go | {
"resource": ""
} |
q36741 | Insert | train | func (q *Query) Insert(values ...interface{}) (Result, error) {
if q.stickyErr != nil {
return nil, q.stickyErr
}
model, err := q.newModel(values...)
if err != nil {
return nil, err
}
if q.model != nil && q.model.Table().HasFlag(BeforeInsertHookFlag) {
err = q.model.BeforeInsert(q.ctx, q.db)
if err != n... | go | {
"resource": ""
} |
q36742 | SelectOrInsert | train | func (q *Query) SelectOrInsert(values ...interface{}) (inserted bool, _ error) {
if q.stickyErr != nil {
return false, q.stickyErr
}
var insertq *Query
var insertErr error
for i := 0; i < 5; i++ {
if i >= 2 {
time.Sleep(internal.RetryBackoff(i-2, 250*time.Millisecond, 5*time.Second))
}
err := q.Select... | go | {
"resource": ""
} |
q36743 | Update | train | func (q *Query) Update(scan ...interface{}) (Result, error) {
return q.update(scan, false)
} | go | {
"resource": ""
} |
q36744 | UpdateNotNull | train | func (q *Query) UpdateNotNull(scan ...interface{}) (Result, error) {
return q.update(scan, true)
} | go | {
"resource": ""
} |
q36745 | Delete | train | func (q *Query) Delete(values ...interface{}) (Result, error) {
if q.hasModel() {
table := q.model.Table()
if table.SoftDeleteField != nil {
q.model.setSoftDeleteField()
columns := q.columns
q.columns = nil
res, err := q.Column(table.SoftDeleteField.SQLName).Update(values...)
q.columns = columns
... | go | {
"resource": ""
} |
q36746 | CopyFrom | train | func (q *Query) CopyFrom(r io.Reader, query interface{}, params ...interface{}) (Result, error) {
params = append(params, q.model)
return q.db.CopyFrom(r, query, params...)
} | go | {
"resource": ""
} |
q36747 | CopyTo | train | func (q *Query) CopyTo(w io.Writer, query interface{}, params ...interface{}) (Result, error) {
params = append(params, q.model)
return q.db.CopyTo(w, query, params...)
} | go | {
"resource": ""
} |
q36748 | Exists | train | func (q *Query) Exists() (bool, error) {
cp := q.Copy() // copy to not change original query
cp.columns = []QueryAppender{Q("1")}
cp.order = nil
cp.limit = 1
res, err := q.db.ExecContext(q.ctx, newSelectQuery(cp))
if err != nil {
return false, err
}
return res.RowsAffected() > 0, nil
} | go | {
"resource": ""
} |
q36749 | Connect | train | func Connect(opt *Options) *DB {
opt.init()
return newDB(
context.TODO(),
&baseDB{
opt: opt,
pool: newConnPool(opt),
},
)
} | go | {
"resource": ""
} |
q36750 | Listen | train | func (db *DB) Listen(channels ...string) *Listener {
ln := &Listener{
db: db,
}
ln.init()
_ = ln.Listen(channels...)
return ln
} | go | {
"resource": ""
} |
q36751 | Conn | train | func (db *DB) Conn() *Conn {
return newConn(db.ctx, db.baseDB.withPool(pool.NewSingleConnPool(db.pool)))
} | go | {
"resource": ""
} |
q36752 | helloEmail | train | func helloEmail() []byte {
address := "test@example.com"
name := "Example User"
from := mail.NewEmail(name, address)
subject := "Hello World from the SendGrid Go Library"
address = "test@example.com"
name = "Example User"
to := mail.NewEmail(name, address)
content := mail.NewContent("text/plain", "some text her... | go | {
"resource": ""
} |
q36753 | GetRequestSubuser | train | func GetRequestSubuser(key, endpoint, host, subuser string) rest.Request {
return requestNew(options{key, endpoint, host, subuser})
} | go | {
"resource": ""
} |
q36754 | requestNew | train | func requestNew(options options) rest.Request {
if options.Host == "" {
options.Host = "https://api.sendgrid.com"
}
requestHeaders := map[string]string{
"Authorization": "Bearer " + options.Key,
"User-Agent": "sendgrid/" + Version + ";go",
"Accept": "application/json",
}
if len(options.Subuser)... | go | {
"resource": ""
} |
q36755 | Send | train | func (cl *Client) Send(email *mail.SGMailV3) (*rest.Response, error) {
cl.Body = mail.GetRequestBody(email)
return MakeRequest(cl.Request)
} | go | {
"resource": ""
} |
q36756 | NewSendClient | train | func NewSendClient(key string) *Client {
request := GetRequest(key, "/v3/mail/send", "")
request.Method = "POST"
return &Client{request}
} | go | {
"resource": ""
} |
q36757 | NewSendClientSubuser | train | func NewSendClientSubuser(key, subuser string) *Client {
request := GetRequestSubuser(key, "/v3/mail/send", "", subuser)
request.Method = "POST"
return &Client{request}
} | go | {
"resource": ""
} |
q36758 | MakeRequest | train | func MakeRequest(request rest.Request) (*rest.Response, error) {
return DefaultClient.Send(request)
} | go | {
"resource": ""
} |
q36759 | MakeRequestRetry | train | func MakeRequestRetry(request rest.Request) (*rest.Response, error) {
retry := 0
var response *rest.Response
var err error
for {
response, err = MakeRequest(request)
if err != nil {
return nil, err
}
if response.StatusCode != http.StatusTooManyRequests {
return response, nil
}
if retry > rateLi... | go | {
"resource": ""
} |
q36760 | isRoot | train | func isRoot(path string) bool {
_, err := os.Stat(filepath.Join(path, "content", "welcome.article"))
if err == nil {
_, err = os.Stat(filepath.Join(path, "template", "index.tmpl"))
}
return err == nil
} | go | {
"resource": ""
} |
q36761 | registerStatic | train | func registerStatic(root string) {
// Keep these static file handlers in sync with app.yaml.
http.Handle("/favicon.ico", http.FileServer(http.Dir(filepath.Join(root, "static", "img"))))
static := http.FileServer(http.Dir(root))
http.Handle("/content/img/", static)
http.Handle("/static/", static)
} | go | {
"resource": ""
} |
q36762 | rootHandler | train | func rootHandler(w http.ResponseWriter, r *http.Request) {
if err := renderUI(w); err != nil {
log.Println(err)
}
} | go | {
"resource": ""
} |
q36763 | lessonHandler | train | func lessonHandler(w http.ResponseWriter, r *http.Request) {
lesson := strings.TrimPrefix(r.URL.Path, "/lesson/")
if err := writeLesson(lesson, w); err != nil {
if err == lessonNotFound {
http.NotFound(w, r)
} else {
log.Println(err)
}
}
} | go | {
"resource": ""
} |
q36764 | waitServer | train | func waitServer(url string) bool {
tries := 20
for tries > 0 {
resp, err := http.Get(url)
if err == nil {
resp.Body.Close()
return true
}
time.Sleep(100 * time.Millisecond)
tries--
}
return false
} | go | {
"resource": ""
} |
q36765 | startBrowser | train | func startBrowser(url string) bool {
// try to start the browser
var args []string
switch runtime.GOOS {
case "darwin":
args = []string{"open"}
case "windows":
args = []string{"cmd", "/c", "start"}
default:
args = []string{"xdg-open"}
}
cmd := exec.Command(args[0], append(args[1:], url)...)
return cmd.St... | go | {
"resource": ""
} |
q36766 | hstsHandler | train | func hstsHandler(fn http.HandlerFunc) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Strict-Transport-Security", "max-age=31536000; preload")
fn(w, r)
})
} | go | {
"resource": ""
} |
q36767 | New | train | func New(k int) *Tree {
var t *Tree
for _, v := range rand.Perm(10) {
t = insert(t, (1+v)*k)
}
return t
} | go | {
"resource": ""
} |
q36768 | fibonacci | train | func fibonacci() func() int {
f, g := 1, 0
return func() int {
f, g = g, f+g
return f
}
} | go | {
"resource": ""
} |
q36769 | Walk | train | func Walk(t *tree.Tree, ch, quit chan int) {
walkImpl(t, ch, quit)
close(ch)
} | go | {
"resource": ""
} |
q36770 | Same | train | func Same(t1, t2 *tree.Tree) bool {
w1, w2 := make(chan int), make(chan int)
quit := make(chan int)
defer close(quit)
go Walk(t1, w1, quit)
go Walk(t2, w2, quit)
for {
v1, ok1 := <-w1
v2, ok2 := <-w2
if !ok1 || !ok2 {
return ok1 == ok2
}
if v1 != v2 {
return false
}
}
} | go | {
"resource": ""
} |
q36771 | Inc | train | func (c *SafeCounter) Inc(key string) {
c.mux.Lock()
// Lock so only one goroutine at a time can access the map c.v.
c.v[key]++
c.mux.Unlock()
} | go | {
"resource": ""
} |
q36772 | Value | train | func (c *SafeCounter) Value(key string) int {
c.mux.Lock()
// Lock so only one goroutine at a time can access the map c.v.
defer c.mux.Unlock()
return c.v[key]
} | go | {
"resource": ""
} |
q36773 | initTour | train | func initTour(root, transport string) error {
// Make sure playground is enabled before rendering.
present.PlayEnabled = true
// Set up templates.
action := filepath.Join(root, "template", "action.tmpl")
tmpl, err := present.Template().ParseFiles(action)
if err != nil {
return fmt.Errorf("parse templates: %v",... | go | {
"resource": ""
} |
q36774 | initLessons | train | func initLessons(tmpl *template.Template, content string) error {
dir, err := os.Open(content)
if err != nil {
return err
}
files, err := dir.Readdirnames(0)
if err != nil {
return err
}
for _, f := range files {
if filepath.Ext(f) != ".article" {
continue
}
content, err := parseLesson(tmpl, filepat... | go | {
"resource": ""
} |
q36775 | parseLesson | train | func parseLesson(tmpl *template.Template, path string) ([]byte, error) {
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
doc, err := present.Parse(prepContent(f), path, 0)
if err != nil {
return nil, err
}
lesson := Lesson{
doc.Title,
doc.Subtitle,
make([]Page, len(doc.Secti... | go | {
"resource": ""
} |
q36776 | findPlayCode | train | func findPlayCode(e present.Elem) []*present.Code {
var r []*present.Code
switch v := e.(type) {
case present.Code:
if v.Play {
r = append(r, &v)
}
case present.Section:
for _, s := range v.Elem {
r = append(r, findPlayCode(s)...)
}
}
return r
} | go | {
"resource": ""
} |
q36777 | writeLesson | train | func writeLesson(name string, w io.Writer) error {
if uiContent == nil {
panic("writeLesson called before successful initTour")
}
if len(name) == 0 {
return writeAllLessons(w)
}
l, ok := lessons[name]
if !ok {
return lessonNotFound
}
_, err := w.Write(l)
return err
} | go | {
"resource": ""
} |
q36778 | renderUI | train | func renderUI(w io.Writer) error {
if uiContent == nil {
panic("renderUI called before successful initTour")
}
_, err := w.Write(uiContent)
return err
} | go | {
"resource": ""
} |
q36779 | nocode | train | func nocode(s present.Section) bool {
for _, e := range s.Elem {
if c, ok := e.(present.Code); ok && c.Play {
return false
}
}
return true
} | go | {
"resource": ""
} |
q36780 | GetFullName | train | func (fs *Goofys) GetFullName(id fuseops.InodeID) *string {
fs.mu.Lock()
inode := fs.inodes[id]
fs.mu.Unlock()
if inode == nil {
return nil
}
return inode.FullName()
} | go | {
"resource": ""
} |
q36781 | filterCategory | train | func filterCategory(flags []cli.Flag, category string) (ret []cli.Flag) {
for _, f := range flags {
if flagCategories[f.GetName()] == category {
ret = append(ret, f)
}
}
return
} | go | {
"resource": ""
} |
q36782 | mount | train | func mount(
ctx context.Context,
bucketName string,
flags *FlagStorage) (fs *Goofys, mfs *fuse.MountedFileSystem, err error) {
// XXX really silly copy here! in goofys.Mount we will copy it
// back to FlagStorage. But I don't see a easier way to expose
// Config in the api package
var config goofys.Config
copi... | go | {
"resource": ""
} |
q36783 | MyUserAndGroup | train | func MyUserAndGroup() (uid int, gid int) {
// Ask for the current user.
user, err := user.Current()
if err != nil {
panic(err)
}
// Parse UID.
uid64, err := strconv.ParseInt(user.Uid, 10, 32)
if err != nil {
log.Fatalf("Parsing UID (%s): %v", user.Uid, err)
return
}
// Parse GID.
gid64, err := strconv... | go | {
"resource": ""
} |
q36784 | Seek | train | func (mb *MBuf) Seek(offset int64, whence int) (int64, error) {
switch whence {
case 0: // relative to beginning
if offset == 0 {
mb.rbuf = 0
mb.rp = 0
return 0, nil
}
case 1: // relative to current position
if offset == 0 {
for i := 0; i < mb.rbuf; i++ {
offset += int64(len(mb.buffers[i]))
... | go | {
"resource": ""
} |
q36785 | UnmarshalJSON | train | func (d *Duration) UnmarshalJSON(buf []byte) error {
var str string
err := json.Unmarshal(buf, &str)
if err != nil {
return err
}
dur, err := time.ParseDuration(str)
if err != nil {
return err
}
d.Duration = dur
return nil
} | go | {
"resource": ""
} |
q36786 | writeTable | train | func writeTable(data [][]string, cols ...string) {
table := tablewriter.NewWriter(os.Stdout)
table.SetHeader(cols)
table.SetBorder(false)
table.AppendBulk(data)
table.Render()
} | go | {
"resource": ""
} |
q36787 | checkFlags | train | func checkFlags(c *cli.Context, flags ...string) error {
for _, flag := range flags {
if c.String(flag) == "" {
cli.ShowSubcommandHelp(c)
err := errors.Errorf("error: the required flag %q was empty or not provided", flag)
fmt.Fprintln(os.Stderr, err)
return err
}
}
return nil
} | go | {
"resource": ""
} |
q36788 | _getIps | train | func _getIps(ipType string, showMsgType bool) {
ips, _ := cloudflare.IPs()
switch ipType {
case "ipv4":
if showMsgType != true {
fmt.Println("IPv4 ranges:")
}
for _, r := range ips.IPv4CIDRs {
fmt.Println(" ", r)
}
case "ipv6":
if showMsgType != true {
fmt.Println("IPv6 ranges:")
}
for _, r ... | go | {
"resource": ""
} |
q36789 | String | train | func (a AuditLogFilter) String() string {
params := "?"
if a.ID != "" {
params += "&id=" + a.ID
}
if a.ActorIP != "" {
params += "&actor.ip=" + a.ActorIP
}
if a.ActorEmail != "" {
params += "&actor.email=" + a.ActorEmail
}
if a.ZoneName != "" {
params += "&zone.name=" + a.ZoneName
}
if a.Direction != ... | go | {
"resource": ""
} |
q36790 | unmarshalReturn | train | func unmarshalReturn(res []byte) (AuditLogResponse, error) {
var auditResponse AuditLogResponse
err := json.Unmarshal(res, &auditResponse)
if err != nil {
return auditResponse, err
}
return auditResponse, nil
} | go | {
"resource": ""
} |
q36791 | ListZonesContext | train | func (api *API) ListZonesContext(ctx context.Context, opts ...ReqOption) (r ZonesResponse, err error) {
var res []byte
opt := reqOption{
params: url.Values{},
}
for _, of := range opts {
of(&opt)
}
res, err = api.makeRequestContext(ctx, "GET", "/zones?"+opt.params.Encode(), nil)
if err != nil {
return Zon... | go | {
"resource": ""
} |
q36792 | ZoneSetPaused | train | func (api *API) ZoneSetPaused(zoneID string, paused bool) (Zone, error) {
zoneopts := ZoneOptions{Paused: &paused}
zone, err := api.EditZone(zoneID, zoneopts)
if err != nil {
return Zone{}, err
}
return zone, nil
} | go | {
"resource": ""
} |
q36793 | ZoneSetVanityNS | train | func (api *API) ZoneSetVanityNS(zoneID string, ns []string) (Zone, error) {
zoneopts := ZoneOptions{VanityNS: ns}
zone, err := api.EditZone(zoneID, zoneopts)
if err != nil {
return Zone{}, err
}
return zone, nil
} | go | {
"resource": ""
} |
q36794 | ZoneSetPlan | train | func (api *API) ZoneSetPlan(zoneID string, plan ZonePlan) (Zone, error) {
zoneopts := ZoneOptions{Plan: &plan}
zone, err := api.EditZone(zoneID, zoneopts)
if err != nil {
return Zone{}, err
}
return zone, nil
} | go | {
"resource": ""
} |
q36795 | UsingRateLimit | train | func UsingRateLimit(rps float64) Option {
return func(api *API) error {
// because ratelimiter doesnt do any windowing
// setting burst makes it difficult to enforce a fixed rate
// so setting it equal to 1 this effectively disables bursting
// this doesn't check for sensible values, ultimately the api will en... | go | {
"resource": ""
} |
q36796 | UsingLogger | train | func UsingLogger(logger Logger) Option {
return func(api *API) error {
api.logger = logger
return nil
}
} | go | {
"resource": ""
} |
q36797 | VirtualDNSUserAnalytics | train | func (api *API) VirtualDNSUserAnalytics(virtualDNSID string, o VirtualDNSUserAnalyticsOptions) (VirtualDNSAnalytics, error) {
uri := "/user/virtual_dns/" + virtualDNSID + "/dns_analytics/report?" + o.encode()
res, err := api.makeRequest("GET", uri, nil)
if err != nil {
return VirtualDNSAnalytics{}, errors.Wrap(err... | go | {
"resource": ""
} |
q36798 | CustomHostnameIDByName | train | func (api *API) CustomHostnameIDByName(zoneID string, hostname string) (string, error) {
customHostnames, _, err := api.CustomHostnames(zoneID, 1, CustomHostname{Hostname: hostname})
if err != nil {
return "", errors.Wrap(err, "CustomHostnames command failed")
}
for _, ch := range customHostnames {
if ch.Hostna... | go | {
"resource": ""
} |
q36799 | newClient | train | func newClient(opts ...Option) (*API, error) {
silentLogger := log.New(ioutil.Discard, "", log.LstdFlags)
api := &API{
BaseURL: apiURL,
headers: make(http.Header),
rateLimiter: rate.NewLimiter(rate.Limit(4), 1), // 4rps equates to default api limit (1200 req/5 min)
retryPolicy: RetryPolicy{
MaxRet... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.