id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c13500 | != nil {
p := unsafe.Pointer(xmlNode.Ptr.ns.href)
href = C.GoString((*C.char)(p))
}
return
} | |
c13501 | xmlNode.serialize(XML_SAVE_AS_XML|XML_SAVE_FORMAT, encoding, outputBuffer)
} | |
c13502 | size = xmlNode.serialize(XML_SAVE_AS_XML|XML_SAVE_NO_DECL, nil, nil)
if b == nil {
return ""
}
return string(b[:size])
} | |
c13503 | xmlNode.serialize(XML_SAVE_AS_HTML|XML_SAVE_FORMAT, encoding, outputBuffer)
} | |
c13504 | prefixBytes := GetCString([]byte(prefix))
prefixPtr := unsafe.Pointer(&prefixBytes[0])
if prefix == "" {
prefixPtr = nil
}
//this adds the namespace declaration to the node
_ = C.xmlNewNs(xmlNode.Ptr, (*C.xmlChar)(hrefPtr), (*C.xmlChar)(prefixPtr))
} | |
c13505 | input encoding
p := docPtr.encoding
if p != nil {
encoding = []byte(C.GoString((*C.char)(unsafe.Pointer(p))))
}
doc = NewDocument(unsafe.Pointer(docPtr), 0, encoding, DefaultEncodingBytes)
}
return
} | |
c13506 | = unsafe.Pointer(document.Ptr)
return
} | |
c13507 | = NewNode(unsafe.Pointer(nodePtr), document).(*ElementNode)
}
return
} | |
c13508 | nodePtr := C.xmlGetID(document.Ptr, (*C.xmlChar)(dataPtr))
if nodePtr != nil {
idattr := NewNode(unsafe.Pointer(nodePtr), document).(*AttributeNode)
element = idattr.Parent().(*ElementNode)
}
return
} | |
c13509 | {
nodePtr.doc = (*_Ctype_struct__xmlDoc)(document.DocPtr())
text = NewNode(unsafe.Pointer(nodePtr), document).(*TextNode)
}
return
} | |
c13510 | := unsafe.Pointer(&dataBytes[0])
nodePtr := C.xmlNewCDataBlock(document.Ptr, (*C.xmlChar)(dataPtr), C.int(dataLen))
if nodePtr != nil {
cdata = NewNode(unsafe.Pointer(nodePtr), document).(*CDataNode)
}
return
} | |
c13511 | := unsafe.Pointer(&dataBytes[0])
nodePtr := C.xmlNewComment((*C.xmlChar)(dataPtr))
if nodePtr != nil {
comment = NewNode(unsafe.Pointer(nodePtr), document).(*CommentNode)
}
return
} | |
c13512 | C.xmlNewDocPI(document.Ptr, (*C.xmlChar)(namePtr), (*C.xmlChar)(dataPtr))
if nodePtr != nil {
pi = NewNode(unsafe.Pointer(nodePtr), document).(*ProcessingInstructionNode)
}
return
} | |
c13513 | entity == nil {
return
}
// unlike entity.content (which returns the raw, unprocessed string value of the entity),
// it looks like entity.URI includes any escaping needed to treat the value as a URI.
valPtr := unsafe.Pointer(entity.URI)
if valPtr == nil {
return
}
val = C.GoString((*C.char)(valPtr))
ret... | |
c13514 | }
}
document.fragments = nil
var p *C.xmlNode
if document.UnlinkedNodes != nil {
for p, _ = range document.UnlinkedNodes {
C.xmlFreeNode(p)
}
}
document.UnlinkedNodes = nil
if document.Ptr != nil {
C.xmlFreeDoc(document.Ptr)
document.Ptr = nil
}
} | |
c13515 |
pointers = append(pointers, node.NodePtr())
}
return
} | |
c13516 | C.xmlXPathNodeSetAdd(ret.nodesetval, (*C.xmlNode)(node.NodePtr()))
}
return
} | |
c13517 | node := range n {
C.xmlXPathNodeSetAdd(ret.nodesetval, (*C.xmlNode)(node.NodePtr()))
}
//this hack-ish looking line tells libxml2 not to free the RVT
//if we don't do this we get horrible double-free crashes everywhere
ret.boolval = 0
return
} | |
c13518 | xpathBytes := GetCString([]byte(v))
xpathPtr := unsafe.Pointer(&xpathBytes[0])
ret = C.xmlXPathNewString((*C.xmlChar)(xpathPtr))
default:
typ := reflect.TypeOf(val)
// if a pointer to a struct is passed, get the type of the dereferenced object
if typ.Kind() == reflect.Ptr {
typ = typ.Elem()
}
//log t... | |
c13519 |
node := doc.Node.(*xml.XmlNode)
node.Document = doc
//runtime.SetFinalizer(doc, (*HtmlDocument).Free)
return
} | |
c13520 |
}
docPtr = C.htmlParse(contentPtr, C.int(contentLen), urlPtr, encodingPtr, C.int(options), nil, 0)
if docPtr == nil {
err = ERR_FAILED_TO_PARSE_HTML
} else {
doc = NewDocument(unsafe.Pointer(docPtr), contentLen, inEncoding, outEncoding)
}
}
if docPtr == nil {
doc = CreateEmptyDocument(inEncoding,... | |
c13521 |
if len(files) == 0 {
return nil, errors.New("no local assets are found")
}
assets := make([]string, 0, len(files))
for _, f := range files {
// Exclude directory.
if fi, _ := os.Stat(f); fi.IsDir() {
continue
}
assets = append(assets, f)
}
return assets, nil
} | |
c13522 | os.Getenv(EnvDebug); len(env) != 0 {
log.Printf("[DEBUG] "+format+"\n", args...)
}
} | |
c13523 | fmt.Fprint(w,
colorstring.Color(fmt.Sprintf(format, args...)))
} | |
c13524 | "failed to parse Github API URL")
}
ts := oauth2.StaticTokenSource(&oauth2.Token{
AccessToken: token,
})
tc := oauth2.NewClient(context.TODO(), ts)
client := github.NewClient(tc)
client.BaseURL = baseURL
return &GitHubClient{
Owner: owner,
Repo: repo,
Client: client,
}, nil
} | |
c13525 |
return errors.Wrap(err, "failed to parse upload URL")
}
c.UploadURL = parsedURL
return nil
} | |
c13526 | release")
}
if res.StatusCode != http.StatusCreated {
return nil, errors.Errorf("create release: invalid status: %s", res.Status)
}
return release, nil
} | |
c13527 | invalid token
if res.StatusCode != http.StatusNotFound {
return nil, errors.Wrapf(err,
"get release tag: invalid status: %s", res.Status)
}
return nil, ErrReleaseNotFound
}
return release, nil
} | |
c13528 | err error
)
release, res, err = c.Repositories.EditRelease(context.TODO(), c.Owner, c.Repo, releaseID, req)
if err != nil {
return errors.Wrapf(err, "failed to edit release: %d", releaseID)
}
if res.StatusCode != http.StatusOK {
return errors.Errorf("edit release: invalid status: %s", res.Status)
}... | |
c13529 |
if res.StatusCode != http.StatusNoContent {
return errors.Errorf("delete release: invalid status: %s", res.Status)
}
return nil
} | |
c13530 |
}
if res.StatusCode != http.StatusNoContent {
return errors.Errorf("delete tag: invalid status: %s", res.Status)
}
return nil
} | |
c13531 |
f, err := os.Open(filename)
if err != nil {
return errors.Wrap(err, "failed to open file")
}
defer f.Close()
asset, res, err = c.Repositories.UploadReleaseAsset(context.TODO(), c.Owner, c.Repo, releaseID, opts, f)
if err != nil {
return errors.Wrapf(err, "failed to upload release asset: %s", filena... | |
c13532 |
if err != nil {
return nil, errors.Wrap(err, "failed to list assets")
}
if res.StatusCode != http.StatusOK {
return nil, errors.Errorf("list release assets: invalid status code: %s", res.Status)
}
result = append(result, assets...)
if res.NextPage <= page {
break
}
page = res.NextPage
}
... | |
c13533 | // Don't return error
Debugf("[ERROR] Check latest version is failed: %s", err)
return
}
verCheckCh <- res
}()
select {
case <-time.After(defaultCheckTimeout):
case res := <-verCheckCh:
if res.Outdated {
fmt.Fprintf(&buf,
"Latest version of ghr is v%s, please upgrade!\n",
res.Current)
}
... | |
c13534 | }
// This is because sometimes the process of creating a release on GitHub
// is faster than deleting a tag.
time.Sleep(5 * time.Second)
return nil
} | |
c13535 | <-semaphore
}()
fmt.Fprintf(g.outStream, "--> Deleting: %15s\n", *asset.Name)
if err := g.GitHub.DeleteAsset(ctx, *asset.ID); err != nil {
return errors.Wrapf(err,
"failed to delete asset: %s", *asset.Name)
}
return nil
})
}
}
}
if err := eg.Wait(); err != nil {
r... | |
c13536 | NullColor: color.New(color.FgBlack, color.Bold),
StringMaxLength: 0,
DisabledColor: false,
Indent: 2,
Newline: "\n",
}
} | |
c13537 | {
return nil, err
}
return f.Format(data)
} | |
c13538 | {
return nil, err
}
return []byte(f.pretty(v, 1)), nil
} | |
c13539 | f := reflect.Indirect(r).FieldByName(pair)
return f.Interface().(PairTickerInfo)
} | |
c13540 |
o.Price, err = strconv.ParseFloat(tmp_struct.price, 64)
if err != nil {
return err
}
o.Amount, err = strconv.ParseFloat(tmp_struct.amount, 64)
if err != nil {
return err
}
o.Ts = tmp_struct.ts
return nil
} | |
c13541 | secret, http.DefaultClient)
} | |
c13542 | return nil, err
}
return resp.(*TimeResponse), nil
} | |
c13543 | nil, &AssetsResponse{})
if err != nil {
return nil, err
}
return resp.(*AssetsResponse), nil
} | |
c13544 | nil, &AssetPairsResponse{})
if err != nil {
return nil, err
}
return resp.(*AssetPairsResponse), nil
} | |
c13545 | url.Values{
"pair": {strings.Join(pairs, ",")},
}, &TickerResponse{})
if err != nil {
return nil, err
}
return resp.(*TickerResponse), nil
} | |
c13546 | volumeString,
VolumeFloat: volume,
Time: int64(trade[2].(float64)),
Buy: trade[3].(string) == BUY,
Sell: trade[3].(string) == SELL,
Market: trade[4].(string) == MARKET,
Limit: trade[4].(string) == LIMIT,
Miscellaneous: trade[5].(string),
}
re... | |
c13547 | err != nil {
return nil, err
}
return resp.(*BalanceResponse), nil
} | |
c13548 | resp, err := api.queryPrivate("TradeBalance", params, &TradeBalanceResponse{})
if err != nil {
return nil, err
}
return resp.(*TradeBalanceResponse), nil
} | |
c13549 |
resp, err := api.queryPrivate("OpenOrders", params, &OpenOrdersResponse{})
if err != nil {
return nil, err
}
return resp.(*OpenOrdersResponse), nil
} | |
c13550 |
if value, ok := args["closetime"]; ok {
params.Add("closetime", value)
}
resp, err := api.queryPrivate("ClosedOrders", params, &ClosedOrdersResponse{})
if err != nil {
return nil, err
}
return resp.(*ClosedOrdersResponse), nil
} | |
c13551 | return nil, err
}
if book, found := dr[pair]; found {
return &book, nil
}
return nil, errors.New("invalid response")
} | |
c13552 | txid)
resp, err := api.queryPrivate("CancelOrder", params, &CancelOrderResponse{})
if err != nil {
return nil, err
}
return resp.(*CancelOrderResponse), nil
} | |
c13553 | value)
}
resp, err := api.queryPrivate("QueryOrders", params, &QueryOrdersResponse{})
if err != nil {
return nil, err
}
return resp.(*QueryOrdersResponse), nil
} | |
c13554 | if value, ok := args["starttm"]; ok {
params.Add("starttm", value)
}
if value, ok := args["expiretm"]; ok {
params.Add("expiretm", value)
}
if value, ok := args["validate"]; ok {
params.Add("validate", value)
}
if value, ok := args["close_order_type"]; ok {
params.Add("close[ordertype]", value)
}
if va... | |
c13555 |
if value, ok := args["ofs"]; ok {
params.Add("ofs", value)
}
resp, err := api.queryPrivate("Ledgers", params, &LedgersResponse{})
if err != nil {
return nil, err
}
return resp.(*LedgersResponse), nil
} | |
c13556 | {method},
}, &DepositAddressesResponse{})
if err != nil {
return nil, err
}
return resp.(*DepositAddressesResponse), nil
} | |
c13557 | }, &WithdrawResponse{})
if err != nil {
return nil, err
}
return resp.(*WithdrawResponse), nil
} | |
c13558 | if isStringInSlice(method, privateMethods) {
return api.queryPrivate(method, values, nil)
}
return nil, fmt.Errorf("Method '%s' is not valid", method)
} | |
c13559 | error) {
url := fmt.Sprintf("%s/%s/public/%s", APIURL, APIVersion, method)
resp, err := api.doRequest(url, values, nil, typ)
return resp, err
} | |
c13560 | Add Key and signature to request headers
headers := map[string]string{
"API-Key": api.key,
"API-Sign": signature,
}
resp, err := api.doRequest(reqURL, values, headers, typ)
return resp, err
} | |
c13561 | mimeType))
}
// Parse request
var jsonData KrakenResponse
// Set the KrakenResponse.Result to typ so `json.Unmarshal` will
// unmarshal it into given type, instead of `interface{}`.
if typ != nil {
jsonData.Result = typ
}
err = json.Unmarshal(body, &jsonData)
if err != nil {
return nil, fmt.Errorf("Cou... | |
c13562 | term == found {
return true
}
}
return false
} | |
c13563 |
mac.Write(message)
return mac.Sum(nil)
} | |
c13564 |
signatureBytes := mac.Sum(nil)
return base64.StdEncoding.EncodeToString(signatureBytes), nil
} | |
c13565 | != nil {
return "", err
}
return base64.StdEncoding.EncodeToString(signature), nil
} | |
c13566 | token,
TokenSecret: tokenSecret,
}
} | |
c13567 |
if shouldEscape(b) {
buf.Write([]byte(fmt.Sprintf("%%%02X", b)))
} else {
// do not escape, write byte as-is
buf.WriteByte(b)
}
}
return buf.String()
} | |
c13568 |
switch c {
case '-', '.', '_', '~':
return false
}
// all other bytes must be escaped
return true
} | |
c13569 | nil, err
}
if t.auther == nil {
return nil, fmt.Errorf("oauth1: Transport's auther is nil")
}
// RoundTripper should not modify the given request, clone it
req2 := cloneRequest(req)
err = t.auther.setRequestAuthHeader(req2, accessToken)
if err != nil {
return nil, err
}
return t.base().RoundTrip(req2)
} | |
c13570 | client, ok := ctx.Value(HTTPClient).(*http.Client); ok {
return client.Transport
}
return nil
} | |
c13571 | consumerKey,
ConsumerSecret: consumerSecret,
}
} | |
c13572 |
return NewClient(ctx, c, t)
} | |
c13573 | StaticTokenSource(token),
auther: newAuther(config),
}
return &http.Client{Transport: transport}
} | |
c13574 | "" || verifier == "" {
return "", "", errors.New("oauth1: Request missing oauth_token or oauth_verifier")
}
return requestToken, verifier, nil
} | |
c13575 | a.nonce(),
oauthVersionParam: defaultOauthVersion,
}
if a.config.Realm != "" {
params[realmParam] = a.config.Realm
}
return params
} | |
c13576 | return a.clock.Now().Unix()
}
return time.Now().Unix()
} | |
c13577 | &HMACSigner{ConsumerSecret: a.config.ConsumerSecret}
} | |
c13578 | encoded[PercentEncode(key)] = PercentEncode(value)
}
return encoded
} | |
c13579 | to 3.4.1.1
baseParts := []string{method, PercentEncode(baseURL), PercentEncode(parameterString)}
return strings.Join(baseParts, "&")
} | |
c13580 |
// TODO: use req.URL.EscapedPath() once Go 1.5 is more generally adopted
// For now, hacky workaround accomplishes the same internal escaping mode
// escape(u.Path, encodePath) for proper compliance with the OAuth1 spec.
path := req.URL.Path
if path != "" {
path = strings.Split(req.URL.RequestURI(), "?")[0]
}
... | |
c13581 | Token Phase: %s", err.Error())
}
accessToken, err := receivePIN(requestToken)
if err != nil {
log.Fatalf("Access Token Phase: %s", err.Error())
}
fmt.Println("Consumer was granted an access token to act on behalf of a user.")
fmt.Printf("token: %s\nsecret: %s\n", accessToken.Token, accessToken.TokenSecret)
} | |
c13582 | len(adp.bufs))
for i, buf := range adp.bufs {
bufs[i] = buf.Bytes()
}
return bufs
} | |
c13583 | resp, err := client.Get(url)
if err != nil {
does <- fmt.Sprintf("[E] Ping failed: %s (URL:%s)",
err, url)
return
}
defer resp.Body.Close()
does <- fmt.Sprintf("Successful ping of `%s`", url)
}(url)
}
for i := 0; i < bufs; i++ {
println(<-does)
}
} | |
c13584 | {
smu := &sitemapURL{opts: opts, data: url}
err := smu.validate()
return smu, err
} | |
c13585 | changefreq.SetText("weekly")
}
if _, ok := SetBuilderElementValue(url, su.data, "priority"); !ok {
priority := url.CreateElement("priority")
priority.SetText("0.5")
}
SetBuilderElementValue(url, su.data, "expires")
SetBuilderElementValue(url, su.data, "mobile")
SetBuilderElementValue(url, su.data, "news")
... | |
c13586 |
uploader := s3manager.NewUploader(sess)
_, err := uploader.Upload(&s3manager.UploadInput{
Bucket: aws.String(adp.Bucket),
Key: aws.String(loc.PathInPublic()),
ACL: aws.String(adp.ACL),
Body: reader,
})
if err != nil {
log.Fatal("[F] S3 Upload file Error:", err)
}
} | |
c13587 | v []interface{}
for index, v = range u {
if v[0] == key {
break
}
}
u[index][1] = URLJoin("", values...)
return u
} | |
c13588 | log.Printf("Max processors %d\n", maxProc)
runtime.GOMAXPROCS(maxProc)
sm := &Sitemap{
opts: NewOptions(),
}
return sm
} | |
c13589 | sm.opts.IndexLocation())
return sm
} | |
c13590 |
}
err := sm.bldr.Add(url)
if err != nil {
if err.FullError() {
sm.Finalize()
return sm.Add(url)
}
}
return sm
} | |
c13591 |
sm.bldrs.Write()
sm.bldr = nil
return sm
} | |
c13592 | &BuilderIndexfile{opts: opts, loc: loc}
} | |
c13593 | := NewSitemapIndexURL(b.opts, URL{{"loc", bldr.loc.URL()}})
b.content = append(b.content, smu.XML()...)
b.totalcnt += bldr.linkcnt
b.linkcnt++
return nil
} | |
c13594 | = append(append(c, b.Content()...), IndexXMLFooter...)
return c
} | |
c13595 | {
c := b.XMLContent()
b.loc.Write(c, b.linkcnt)
} | |
c13596 | filepath.Join(
loc.opts.publicPath,
loc.opts.sitemapsPath,
)
} | |
c13597 | loc.opts.sitemapsPath,
loc.Filename(),
)
} | |
c13598 | filepath.Join(
loc.opts.sitemapsPath,
loc.Filename(),
)
} | |
c13599 | "/", loc.Filename(),
} {
base, _ = base.Parse(ref)
}
return base.String()
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.