_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q13500 | Namespace | train | func (xmlNode *XmlNode) Namespace() (href string) {
if xmlNode.Ptr.ns != nil {
p := unsafe.Pointer(xmlNode.Ptr.ns.href)
href = C.GoString((*C.char)(p))
}
return
} | go | {
"resource": ""
} |
q13501 | ToXml | train | func (xmlNode *XmlNode) ToXml(encoding, outputBuffer []byte) ([]byte, int) {
return xmlNode.serialize(XML_SAVE_AS_XML|XML_SAVE_FORMAT, encoding, outputBuffer)
} | go | {
"resource": ""
} |
q13502 | ToUnformattedXml | train | func (xmlNode *XmlNode) ToUnformattedXml() string {
var b []byte
var size int
b, size = xmlNode.serialize(XML_SAVE_AS_XML|XML_SAVE_NO_DECL, nil, nil)
if b == nil {
return ""
}
return string(b[:size])
} | go | {
"resource": ""
} |
q13503 | ToHtml | train | func (xmlNode *XmlNode) ToHtml(encoding, outputBuffer []byte) ([]byte, int) {
return xmlNode.serialize(XML_SAVE_AS_HTML|XML_SAVE_FORMAT, encoding, outputBuffer)
} | go | {
"resource": ""
} |
q13504 | DeclareNamespace | train | func (xmlNode *XmlNode) DeclareNamespace(prefix, href string) {
//can only declare namespaces on elements
if xmlNode.NodeType() != XML_ELEMENT_NODE {
return
}
hrefBytes := GetCString([]byte(href))
hrefPtr := unsafe.Pointer(&hrefBytes[0])
//if the namespace is already declared using this prefix, just return
_n... | go | {
"resource": ""
} |
q13505 | ReadFile | train | func ReadFile(filename string, options ParseOption) (doc *XmlDocument, err error) {
// verify the file exists and can be read before we invoke C API
_, err = os.Stat(filename)
if err != nil {
return
}
dataBytes := GetCString([]byte(filename))
dataPtr := unsafe.Pointer(&dataBytes[0])
var docPtr *C.xmlDoc
docP... | go | {
"resource": ""
} |
q13506 | DocPtr | train | func (document *XmlDocument) DocPtr() (ptr unsafe.Pointer) {
ptr = unsafe.Pointer(document.Ptr)
return
} | go | {
"resource": ""
} |
q13507 | Root | train | func (document *XmlDocument) Root() (element *ElementNode) {
nodePtr := C.xmlDocGetRootElement(document.Ptr)
if nodePtr != nil {
element = NewNode(unsafe.Pointer(nodePtr), document).(*ElementNode)
}
return
} | go | {
"resource": ""
} |
q13508 | NodeById | train | func (document *XmlDocument) NodeById(id string) (element *ElementNode) {
dataBytes := GetCString([]byte(id))
dataPtr := unsafe.Pointer(&dataBytes[0])
nodePtr := C.xmlGetID(document.Ptr, (*C.xmlChar)(dataPtr))
if nodePtr != nil {
idattr := NewNode(unsafe.Pointer(nodePtr), document).(*AttributeNode)
element = id... | go | {
"resource": ""
} |
q13509 | CreateTextNode | train | func (document *XmlDocument) CreateTextNode(data string) (text *TextNode) {
dataBytes := GetCString([]byte(data))
dataPtr := unsafe.Pointer(&dataBytes[0])
nodePtr := C.xmlNewText((*C.xmlChar)(dataPtr))
if nodePtr != nil {
nodePtr.doc = (*_Ctype_struct__xmlDoc)(document.DocPtr())
text = NewNode(unsafe.Pointer(no... | go | {
"resource": ""
} |
q13510 | CreateCDataNode | train | func (document *XmlDocument) CreateCDataNode(data string) (cdata *CDataNode) {
dataLen := len(data)
dataBytes := GetCString([]byte(data))
dataPtr := unsafe.Pointer(&dataBytes[0])
nodePtr := C.xmlNewCDataBlock(document.Ptr, (*C.xmlChar)(dataPtr), C.int(dataLen))
if nodePtr != nil {
cdata = NewNode(unsafe.Pointer(... | go | {
"resource": ""
} |
q13511 | CreateCommentNode | train | func (document *XmlDocument) CreateCommentNode(data string) (comment *CommentNode) {
dataBytes := GetCString([]byte(data))
dataPtr := unsafe.Pointer(&dataBytes[0])
nodePtr := C.xmlNewComment((*C.xmlChar)(dataPtr))
if nodePtr != nil {
comment = NewNode(unsafe.Pointer(nodePtr), document).(*CommentNode)
}
return
} | go | {
"resource": ""
} |
q13512 | CreatePINode | train | func (document *XmlDocument) CreatePINode(name, data string) (pi *ProcessingInstructionNode) {
nameBytes := GetCString([]byte(name))
namePtr := unsafe.Pointer(&nameBytes[0])
dataBytes := GetCString([]byte(data))
dataPtr := unsafe.Pointer(&dataBytes[0])
nodePtr := C.xmlNewDocPI(document.Ptr, (*C.xmlChar)(namePtr), ... | go | {
"resource": ""
} |
q13513 | UnparsedEntityURI | train | func (document *XmlDocument) UnparsedEntityURI(name string) (val string) {
if name == "" {
return
}
nameBytes := GetCString([]byte(name))
namePtr := unsafe.Pointer(&nameBytes[0])
entity := C.xmlGetDocEntity(document.Ptr, (*C.xmlChar)(namePtr))
if entity == nil {
return
}
// unlike entity.content (which re... | go | {
"resource": ""
} |
q13514 | Free | train | func (document *XmlDocument) Free() {
//must free the xpath context before freeing the fragments or unlinked nodes
//otherwise, it causes memory leaks and crashes when dealing with very large documents (a few MB)
if document.XPathCtx != nil {
document.XPathCtx.Free()
document.XPathCtx = nil
}
//must clear the ... | go | {
"resource": ""
} |
q13515 | ToPointers | train | func (n Nodeset) ToPointers() (pointers []unsafe.Pointer) {
for _, node := range n {
pointers = append(pointers, node.NodePtr())
}
return
} | go | {
"resource": ""
} |
q13516 | ToXPathNodeset | train | func (n Nodeset) ToXPathNodeset() (ret C.xmlXPathObjectPtr) {
ret = C.xmlXPathNewNodeSet(nil)
for _, node := range n {
C.xmlXPathNodeSetAdd(ret.nodesetval, (*C.xmlNode)(node.NodePtr()))
}
return
} | go | {
"resource": ""
} |
q13517 | ToXPathValueTree | train | func (n Nodeset) ToXPathValueTree() (ret C.xmlXPathObjectPtr) {
if len(n) == 0 {
ret = C.xmlXPathNewValueTree(nil)
return
}
ret = C.xmlXPathNewValueTree(nil)
for _, node := range n {
C.xmlXPathNodeSetAdd(ret.nodesetval, (*C.xmlNode)(node.NodePtr()))
}
//this hack-ish looking line tells libxml2 not to free ... | go | {
"resource": ""
} |
q13518 | ValueToXPathObject | train | func ValueToXPathObject(val interface{}) (ret C.xmlXPathObjectPtr) {
if val == nil {
//return the empty node set
ret = C.xmlXPathNewNodeSet(nil)
return
}
switch v := val.(type) {
case unsafe.Pointer:
return (C.xmlXPathObjectPtr)(v)
case []unsafe.Pointer:
ptrs := v
if len(ptrs) > 0 {
//default - retu... | go | {
"resource": ""
} |
q13519 | NewDocument | train | func NewDocument(p unsafe.Pointer, contentLen int, inEncoding, outEncoding []byte) (doc *HtmlDocument) {
doc = &HtmlDocument{}
doc.XmlDocument = xml.NewDocument(p, contentLen, inEncoding, outEncoding)
doc.Me = doc
node := doc.Node.(*xml.XmlNode)
node.Document = doc
//runtime.SetFinalizer(doc, (*HtmlDocument).Free... | go | {
"resource": ""
} |
q13520 | Parse | train | func Parse(content, inEncoding, url []byte, options xml.ParseOption, outEncoding []byte) (doc *HtmlDocument, err error) {
inEncoding = AppendCStringTerminator(inEncoding)
outEncoding = AppendCStringTerminator(outEncoding)
var docPtr *C.xmlDoc
contentLen := len(content)
if contentLen > 0 {
var contentPtr, urlPt... | go | {
"resource": ""
} |
q13521 | LocalAssets | train | func LocalAssets(path string) ([]string, error) {
path, err := filepath.Abs(path)
if err != nil {
return nil, errors.Wrap(err, "failed to get abs path")
}
fi, err := os.Stat(path)
if err != nil {
return nil, errors.Wrap(err, "failed to get file stat")
}
if !fi.IsDir() {
return []string{path}, nil
}
//... | go | {
"resource": ""
} |
q13522 | Debugf | train | func Debugf(format string, args ...interface{}) {
if env := os.Getenv(EnvDebug); len(env) != 0 {
log.Printf("[DEBUG] "+format+"\n", args...)
}
} | go | {
"resource": ""
} |
q13523 | PrintRedf | train | func PrintRedf(w io.Writer, format string, args ...interface{}) {
format = fmt.Sprintf("[red]%s[reset]", format)
fmt.Fprint(w,
colorstring.Color(fmt.Sprintf(format, args...)))
} | go | {
"resource": ""
} |
q13524 | NewGitHubClient | train | func NewGitHubClient(owner, repo, token, urlStr string) (GitHub, error) {
if len(owner) == 0 {
return nil, errors.New("missing GitHub repository owner")
}
if len(repo) == 0 {
return nil, errors.New("missing GitHub repository name")
}
if len(token) == 0 {
return nil, errors.New("missing GitHub API token")
... | go | {
"resource": ""
} |
q13525 | SetUploadURL | train | func (c *GitHubClient) SetUploadURL(urlStr string) error {
i := strings.Index(urlStr, "repos/")
parsedURL, err := url.ParseRequestURI(urlStr[:i])
if err != nil {
return errors.Wrap(err, "failed to parse upload URL")
}
c.UploadURL = parsedURL
return nil
} | go | {
"resource": ""
} |
q13526 | CreateRelease | train | func (c *GitHubClient) CreateRelease(ctx context.Context, req *github.RepositoryRelease) (*github.RepositoryRelease, error) {
release, res, err := c.Repositories.CreateRelease(context.TODO(), c.Owner, c.Repo, req)
if err != nil {
return nil, errors.Wrap(err, "failed to create a release")
}
if res.StatusCode != ... | go | {
"resource": ""
} |
q13527 | GetRelease | train | func (c *GitHubClient) GetRelease(ctx context.Context, tag string) (*github.RepositoryRelease, error) {
// Check Release whether already exists or not
release, res, err := c.Repositories.GetReleaseByTag(context.TODO(), c.Owner, c.Repo, tag)
if err != nil {
if res == nil {
return nil, errors.Wrapf(err, "failed t... | go | {
"resource": ""
} |
q13528 | EditRelease | train | func (c *GitHubClient) EditRelease(ctx context.Context, releaseID int64, req *github.RepositoryRelease) (*github.RepositoryRelease, error) {
var release *github.RepositoryRelease
err := retry.Retry(3, 3*time.Second, func() error {
var (
res *github.Response
err error
)
release, res, err = c.Repositories.... | go | {
"resource": ""
} |
q13529 | DeleteRelease | train | func (c *GitHubClient) DeleteRelease(ctx context.Context, releaseID int64) error {
res, err := c.Repositories.DeleteRelease(context.TODO(), c.Owner, c.Repo, releaseID)
if err != nil {
return errors.Wrap(err, "failed to delete release")
}
if res.StatusCode != http.StatusNoContent {
return errors.Errorf("delete ... | go | {
"resource": ""
} |
q13530 | DeleteTag | train | func (c *GitHubClient) DeleteTag(ctx context.Context, tag string) error {
ref := fmt.Sprintf("tags/%s", tag)
res, err := c.Git.DeleteRef(context.TODO(), c.Owner, c.Repo, ref)
if err != nil {
return errors.Wrapf(err, "failed to delete tag: %s", ref)
}
if res.StatusCode != http.StatusNoContent {
return errors.E... | go | {
"resource": ""
} |
q13531 | UploadAsset | train | func (c *GitHubClient) UploadAsset(ctx context.Context, releaseID int64, filename string) (*github.ReleaseAsset, error) {
filename, err := filepath.Abs(filename)
if err != nil {
return nil, errors.Wrap(err, "failed to get abs path")
}
opts := &github.UploadOptions{
// Use base name by default
Name: filepath... | go | {
"resource": ""
} |
q13532 | ListAssets | train | func (c *GitHubClient) ListAssets(ctx context.Context, releaseID int64) ([]*github.ReleaseAsset, error) {
result := []*github.ReleaseAsset{}
page := 1
for {
assets, res, err := c.Repositories.ListReleaseAssets(context.TODO(), c.Owner, c.Repo, releaseID, &github.ListOptions{Page: page})
if err != nil {
return... | go | {
"resource": ""
} |
q13533 | OutputVersion | train | func OutputVersion() string {
var buf bytes.Buffer
fmt.Fprintf(&buf, "%s version v%s", Name, Version)
if len(GitCommit) != 0 {
fmt.Fprintf(&buf, " (%s)", GitCommit)
}
fmt.Fprintf(&buf, "\n")
// Check latest version is release or not.
verCheckCh := make(chan *latest.CheckResponse)
go func() {
githubTag := &... | go | {
"resource": ""
} |
q13534 | DeleteRelease | train | func (g *GHR) DeleteRelease(ctx context.Context, ID int64, tag string) error {
err := g.GitHub.DeleteRelease(ctx, ID)
if err != nil {
return err
}
err = g.GitHub.DeleteTag(ctx, tag)
if err != nil {
return err
}
// This is because sometimes the process of creating a release on GitHub
// is faster than del... | go | {
"resource": ""
} |
q13535 | DeleteAssets | train | func (g *GHR) DeleteAssets(ctx context.Context, releaseID int64, localAssets []string, parallel int) error {
start := time.Now()
defer func() {
Debugf("DeleteAssets: time: %d ms", int(time.Since(start).Seconds()*1000))
}()
eg, ctx := errgroup.WithContext(ctx)
assets, err := g.GitHub.ListAssets(ctx, releaseID)
... | go | {
"resource": ""
} |
q13536 | NewFormatter | train | func NewFormatter() *Formatter {
return &Formatter{
KeyColor: color.New(color.FgBlue, color.Bold),
StringColor: color.New(color.FgGreen, color.Bold),
BoolColor: color.New(color.FgYellow, color.Bold),
NumberColor: color.New(color.FgCyan, color.Bold),
NullColor: color.New(color.FgBla... | go | {
"resource": ""
} |
q13537 | Marshal | train | func (f *Formatter) Marshal(v interface{}) ([]byte, error) {
data, err := json.Marshal(v)
if err != nil {
return nil, err
}
return f.Format(data)
} | go | {
"resource": ""
} |
q13538 | Format | train | func (f *Formatter) Format(data []byte) ([]byte, error) {
var v interface{}
if err := json.Unmarshal(data, &v); err != nil {
return nil, err
}
return []byte(f.pretty(v, 1)), nil
} | go | {
"resource": ""
} |
q13539 | GetPairTickerInfo | train | func (v *TickerResponse) GetPairTickerInfo(pair string) PairTickerInfo {
r := reflect.ValueOf(v)
f := reflect.Indirect(r).FieldByName(pair)
return f.Interface().(PairTickerInfo)
} | go | {
"resource": ""
} |
q13540 | UnmarshalJSON | train | func (o *OrderBookItem) UnmarshalJSON(data []byte) error {
tmp_struct := struct {
price string
amount string
ts int64
}{}
tmp_arr := []interface{}{&tmp_struct.price, &tmp_struct.amount, &tmp_struct.ts}
err := json.Unmarshal(data, &tmp_arr)
if err != nil {
return err
}
o.Price, err = strconv.ParseFl... | go | {
"resource": ""
} |
q13541 | New | train | func New(key, secret string) *KrakenApi {
return NewWithClient(key, secret, http.DefaultClient)
} | go | {
"resource": ""
} |
q13542 | Time | train | func (api *KrakenApi) Time() (*TimeResponse, error) {
resp, err := api.queryPublic("Time", nil, &TimeResponse{})
if err != nil {
return nil, err
}
return resp.(*TimeResponse), nil
} | go | {
"resource": ""
} |
q13543 | Assets | train | func (api *KrakenApi) Assets() (*AssetsResponse, error) {
resp, err := api.queryPublic("Assets", nil, &AssetsResponse{})
if err != nil {
return nil, err
}
return resp.(*AssetsResponse), nil
} | go | {
"resource": ""
} |
q13544 | AssetPairs | train | func (api *KrakenApi) AssetPairs() (*AssetPairsResponse, error) {
resp, err := api.queryPublic("AssetPairs", nil, &AssetPairsResponse{})
if err != nil {
return nil, err
}
return resp.(*AssetPairsResponse), nil
} | go | {
"resource": ""
} |
q13545 | Ticker | train | func (api *KrakenApi) Ticker(pairs ...string) (*TickerResponse, error) {
resp, err := api.queryPublic("Ticker", url.Values{
"pair": {strings.Join(pairs, ",")},
}, &TickerResponse{})
if err != nil {
return nil, err
}
return resp.(*TickerResponse), nil
} | go | {
"resource": ""
} |
q13546 | Trades | train | func (api *KrakenApi) Trades(pair string, since int64) (*TradesResponse, error) {
values := url.Values{"pair": {pair}}
if since > 0 {
values.Set("since", strconv.FormatInt(since, 10))
}
resp, err := api.queryPublic("Trades", values, nil)
if err != nil {
return nil, err
}
v := resp.(map[string]interface{})
... | go | {
"resource": ""
} |
q13547 | Balance | train | func (api *KrakenApi) Balance() (*BalanceResponse, error) {
resp, err := api.queryPrivate("Balance", url.Values{}, &BalanceResponse{})
if err != nil {
return nil, err
}
return resp.(*BalanceResponse), nil
} | go | {
"resource": ""
} |
q13548 | TradeBalance | train | func (api *KrakenApi) TradeBalance(args map[string]string) (*TradeBalanceResponse, error) {
params := url.Values{}
if value, ok := args["aclass"]; ok {
params.Add("aclass", value)
}
if value, ok := args["asset"]; ok {
params.Add("asset", value)
}
resp, err := api.queryPrivate("TradeBalance", params, &TradeBal... | go | {
"resource": ""
} |
q13549 | OpenOrders | train | func (api *KrakenApi) OpenOrders(args map[string]string) (*OpenOrdersResponse, error) {
params := url.Values{}
if value, ok := args["trades"]; ok {
params.Add("trades", value)
}
if value, ok := args["userref"]; ok {
params.Add("userref", value)
}
resp, err := api.queryPrivate("OpenOrders", params, &OpenOrder... | go | {
"resource": ""
} |
q13550 | ClosedOrders | train | func (api *KrakenApi) ClosedOrders(args map[string]string) (*ClosedOrdersResponse, error) {
params := url.Values{}
if value, ok := args["trades"]; ok {
params.Add("trades", value)
}
if value, ok := args["userref"]; ok {
params.Add("userref", value)
}
if value, ok := args["start"]; ok {
params.Add("start", v... | go | {
"resource": ""
} |
q13551 | Depth | train | func (api *KrakenApi) Depth(pair string, count int) (*OrderBook, error) {
dr := DepthResponse{}
_, err := api.queryPublic("Depth", url.Values{
"pair": {pair}, "count": {strconv.Itoa(count)},
}, &dr)
if err != nil {
return nil, err
}
if book, found := dr[pair]; found {
return &book, nil
}
return nil, er... | go | {
"resource": ""
} |
q13552 | CancelOrder | train | func (api *KrakenApi) CancelOrder(txid string) (*CancelOrderResponse, error) {
params := url.Values{}
params.Add("txid", txid)
resp, err := api.queryPrivate("CancelOrder", params, &CancelOrderResponse{})
if err != nil {
return nil, err
}
return resp.(*CancelOrderResponse), nil
} | go | {
"resource": ""
} |
q13553 | QueryOrders | train | func (api *KrakenApi) QueryOrders(txids string, args map[string]string) (*QueryOrdersResponse, error) {
params := url.Values{"txid": {txids}}
if value, ok := args["trades"]; ok {
params.Add("trades", value)
}
if value, ok := args["userref"]; ok {
params.Add("userref", value)
}
resp, err := api.queryPrivate("Q... | go | {
"resource": ""
} |
q13554 | AddOrder | train | func (api *KrakenApi) AddOrder(pair string, direction string, orderType string, volume string, args map[string]string) (*AddOrderResponse, error) {
params := url.Values{
"pair": {pair},
"type": {direction},
"ordertype": {orderType},
"volume": {volume},
}
if value, ok := args["price"]; ok {
pa... | go | {
"resource": ""
} |
q13555 | Ledgers | train | func (api *KrakenApi) Ledgers(args map[string]string) (*LedgersResponse, error) {
params := url.Values{}
if value, ok := args["aclass"]; ok {
params.Add("aclass", value)
}
if value, ok := args["asset"]; ok {
params.Add("asset", value)
}
if value, ok := args["type"]; ok {
params.Add("type", value)
}
if val... | go | {
"resource": ""
} |
q13556 | DepositAddresses | train | func (api *KrakenApi) DepositAddresses(asset string, method string) (*DepositAddressesResponse, error) {
resp, err := api.queryPrivate("DepositAddresses", url.Values{
"asset": {asset},
"method": {method},
}, &DepositAddressesResponse{})
if err != nil {
return nil, err
}
return resp.(*DepositAddressesRespons... | go | {
"resource": ""
} |
q13557 | Withdraw | train | func (api *KrakenApi) Withdraw(asset string, key string, amount *big.Float) (*WithdrawResponse, error) {
resp, err := api.queryPrivate("Withdraw", url.Values{
"asset": {asset},
"key": {key},
"amount": {amount.String()},
}, &WithdrawResponse{})
if err != nil {
return nil, err
}
return resp.(*WithdrawRes... | go | {
"resource": ""
} |
q13558 | Query | train | func (api *KrakenApi) Query(method string, data map[string]string) (interface{}, error) {
values := url.Values{}
for key, value := range data {
values.Set(key, value)
}
// Check if method is public or private
if isStringInSlice(method, publicMethods) {
return api.queryPublic(method, values, nil)
} else if is... | go | {
"resource": ""
} |
q13559 | queryPublic | train | func (api *KrakenApi) queryPublic(method string, values url.Values, typ interface{}) (interface{}, error) {
url := fmt.Sprintf("%s/%s/public/%s", APIURL, APIVersion, method)
resp, err := api.doRequest(url, values, nil, typ)
return resp, err
} | go | {
"resource": ""
} |
q13560 | queryPrivate | train | func (api *KrakenApi) queryPrivate(method string, values url.Values, typ interface{}) (interface{}, error) {
urlPath := fmt.Sprintf("/%s/private/%s", APIVersion, method)
reqURL := fmt.Sprintf("%s%s", APIURL, urlPath)
secret, _ := base64.StdEncoding.DecodeString(api.secret)
values.Set("nonce", fmt.Sprintf("%d", time... | go | {
"resource": ""
} |
q13561 | doRequest | train | func (api *KrakenApi) doRequest(reqURL string, values url.Values, headers map[string]string, typ interface{}) (interface{}, error) {
// Create request
req, err := http.NewRequest("POST", reqURL, strings.NewReader(values.Encode()))
if err != nil {
return nil, fmt.Errorf("Could not execute request! #1 (%s)", err.Er... | go | {
"resource": ""
} |
q13562 | isStringInSlice | train | func isStringInSlice(term string, list []string) bool {
for _, found := range list {
if term == found {
return true
}
}
return false
} | go | {
"resource": ""
} |
q13563 | getHMacSha512 | train | func getHMacSha512(message, secret []byte) []byte {
mac := hmac.New(sha512.New, secret)
mac.Write(message)
return mac.Sum(nil)
} | go | {
"resource": ""
} |
q13564 | Sign | train | func (s *HMACSigner) Sign(tokenSecret, message string) (string, error) {
signingKey := strings.Join([]string{s.ConsumerSecret, tokenSecret}, "&")
mac := hmac.New(sha1.New, []byte(signingKey))
mac.Write([]byte(message))
signatureBytes := mac.Sum(nil)
return base64.StdEncoding.EncodeToString(signatureBytes), nil
} | go | {
"resource": ""
} |
q13565 | Sign | train | func (s *RSASigner) Sign(tokenSecret, message string) (string, error) {
digest := sha1.Sum([]byte(message))
signature, err := rsa.SignPKCS1v15(rand.Reader, s.PrivateKey, crypto.SHA1, digest[:])
if err != nil {
return "", err
}
return base64.StdEncoding.EncodeToString(signature), nil
} | go | {
"resource": ""
} |
q13566 | NewToken | train | func NewToken(token, tokenSecret string) *Token {
return &Token{
Token: token,
TokenSecret: tokenSecret,
}
} | go | {
"resource": ""
} |
q13567 | PercentEncode | train | func PercentEncode(input string) string {
var buf bytes.Buffer
for _, b := range []byte(input) {
// if in unreserved set
if shouldEscape(b) {
buf.Write([]byte(fmt.Sprintf("%%%02X", b)))
} else {
// do not escape, write byte as-is
buf.WriteByte(b)
}
}
return buf.String()
} | go | {
"resource": ""
} |
q13568 | shouldEscape | train | func shouldEscape(c byte) bool {
// RFC3986 2.3 unreserved characters
if 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' {
return false
}
switch c {
case '-', '.', '_', '~':
return false
}
// all other bytes must be escaped
return true
} | go | {
"resource": ""
} |
q13569 | RoundTrip | train | func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
if t.source == nil {
return nil, fmt.Errorf("oauth1: Transport's source is nil")
}
accessToken, err := t.source.Token()
if err != nil {
return nil, err
}
if t.auther == nil {
return nil, fmt.Errorf("oauth1: Transport's auther is nil"... | go | {
"resource": ""
} |
q13570 | contextTransport | train | func contextTransport(ctx context.Context) http.RoundTripper {
if client, ok := ctx.Value(HTTPClient).(*http.Client); ok {
return client.Transport
}
return nil
} | go | {
"resource": ""
} |
q13571 | NewConfig | train | func NewConfig(consumerKey, consumerSecret string) *Config {
return &Config{
ConsumerKey: consumerKey,
ConsumerSecret: consumerSecret,
}
} | go | {
"resource": ""
} |
q13572 | Client | train | func (c *Config) Client(ctx context.Context, t *Token) *http.Client {
return NewClient(ctx, c, t)
} | go | {
"resource": ""
} |
q13573 | NewClient | train | func NewClient(ctx context.Context, config *Config, token *Token) *http.Client {
transport := &Transport{
Base: contextTransport(ctx),
source: StaticTokenSource(token),
auther: newAuther(config),
}
return &http.Client{Transport: transport}
} | go | {
"resource": ""
} |
q13574 | ParseAuthorizationCallback | train | func ParseAuthorizationCallback(req *http.Request) (requestToken, verifier string, err error) {
// parse the raw query from the URL into req.Form
err = req.ParseForm()
if err != nil {
return "", "", err
}
requestToken = req.Form.Get(oauthTokenParam)
verifier = req.Form.Get(oauthVerifierParam)
if requestToken =... | go | {
"resource": ""
} |
q13575 | commonOAuthParams | train | func (a *auther) commonOAuthParams() map[string]string {
params := map[string]string{
oauthConsumerKeyParam: a.config.ConsumerKey,
oauthSignatureMethodParam: a.signer().Name(),
oauthTimestampParam: strconv.FormatInt(a.epoch(), 10),
oauthNonceParam: a.nonce(),
oauthVersionParam: de... | go | {
"resource": ""
} |
q13576 | epoch | train | func (a *auther) epoch() int64 {
if a.clock != nil {
return a.clock.Now().Unix()
}
return time.Now().Unix()
} | go | {
"resource": ""
} |
q13577 | signer | train | func (a *auther) signer() Signer {
if a.config.Signer != nil {
return a.config.Signer
}
return &HMACSigner{ConsumerSecret: a.config.ConsumerSecret}
} | go | {
"resource": ""
} |
q13578 | encodeParameters | train | func encodeParameters(params map[string]string) map[string]string {
encoded := map[string]string{}
for key, value := range params {
encoded[PercentEncode(key)] = PercentEncode(value)
}
return encoded
} | go | {
"resource": ""
} |
q13579 | signatureBase | train | func signatureBase(req *http.Request, params map[string]string) string {
method := strings.ToUpper(req.Method)
baseURL := baseURI(req)
parameterString := normalizedParameterString(params)
// signature base string constructed accoding to 3.4.1.1
baseParts := []string{method, PercentEncode(baseURL), PercentEncode(pa... | go | {
"resource": ""
} |
q13580 | baseURI | train | func baseURI(req *http.Request) string {
scheme := strings.ToLower(req.URL.Scheme)
host := strings.ToLower(req.URL.Host)
if hostPort := strings.Split(host, ":"); len(hostPort) == 2 && (hostPort[1] == "80" || hostPort[1] == "443") {
host = hostPort[0]
}
// TODO: use req.URL.EscapedPath() once Go 1.5 is more gener... | go | {
"resource": ""
} |
q13581 | main | train | func main() {
// read credentials from environment variables
consumerKey := os.Getenv("TWITTER_CONSUMER_KEY")
consumerSecret := os.Getenv("TWITTER_CONSUMER_SECRET")
if consumerKey == "" || consumerSecret == "" {
log.Fatal("Required environment variable missing.")
}
config = oauth1.Config{
ConsumerKey: con... | go | {
"resource": ""
} |
q13582 | Bytes | train | func (adp *BufferAdapter) Bytes() [][]byte {
bufs := make([][]byte, len(adp.bufs))
for i, buf := range adp.bufs {
bufs[i] = buf.Bytes()
}
return bufs
} | go | {
"resource": ""
} |
q13583 | PingSearchEngines | train | func PingSearchEngines(opts *Options, urls ...string) {
urls = append(urls, []string{
"http://www.google.com/webmasters/tools/ping?sitemap=%s",
"http://www.bing.com/webmaster/ping.aspx?siteMap=%s",
}...)
sitemapURL := opts.IndexLocation().URL()
bufs := len(urls)
does := make(chan string, bufs)
client := http... | go | {
"resource": ""
} |
q13584 | NewSitemapURL | train | func NewSitemapURL(opts *Options, url URL) (SitemapURL, error) {
smu := &sitemapURL{opts: opts, data: url}
err := smu.validate()
return smu, err
} | go | {
"resource": ""
} |
q13585 | XML | train | func (su *sitemapURL) XML() []byte {
doc := etree.NewDocument()
url := doc.CreateElement("url")
SetBuilderElementValue(url, su.data.URLJoinBy("loc", "host", "loc"), "loc")
if _, ok := SetBuilderElementValue(url, su.data, "lastmod"); !ok {
lastmod := url.CreateElement("lastmod")
lastmod.SetText(time.Now().Forma... | go | {
"resource": ""
} |
q13586 | Write | train | func (adp *S3Adapter) Write(loc *Location, data []byte) {
var reader io.Reader = bytes.NewReader(data)
if GzipPtn.MatchString(loc.Filename()) {
var writer *io.PipeWriter
reader, writer = io.Pipe()
go func() {
gz := gzip.NewWriter(writer)
io.Copy(gz, bytes.NewReader(data))
gz.Close()
writer.Close(... | go | {
"resource": ""
} |
q13587 | URLJoinBy | train | func (u URL) URLJoinBy(key string, joins ...string) URL {
var values []string
for _, k := range joins {
var vals interface{}
for _, v := range u {
if v[0] == k {
vals = v[1]
break
}
}
values = append(values, fmt.Sprint(vals))
}
var index int
var v []interface{}
for index, v = range u {
if ... | go | {
"resource": ""
} |
q13588 | NewSitemap | train | func NewSitemap(maxProc int) *Sitemap {
log.SetFlags(log.LstdFlags | log.Llongfile)
if maxProc < 1 || maxProc > runtime.NumCPU() {
maxProc = runtime.NumCPU()
}
log.Printf("Max processors %d\n", maxProc)
runtime.GOMAXPROCS(maxProc)
sm := &Sitemap{
opts: NewOptions(),
}
return sm
} | go | {
"resource": ""
} |
q13589 | Create | train | func (sm *Sitemap) Create() *Sitemap {
sm.bldrs = NewBuilderIndexfile(sm.opts, sm.opts.IndexLocation())
return sm
} | go | {
"resource": ""
} |
q13590 | Add | train | func (sm *Sitemap) Add(url interface{}) *Sitemap {
if sm.bldr == nil {
sm.bldr = NewBuilderFile(sm.opts, sm.opts.Location())
}
err := sm.bldr.Add(url)
if err != nil {
if err.FullError() {
sm.Finalize()
return sm.Add(url)
}
}
return sm
} | go | {
"resource": ""
} |
q13591 | Finalize | train | func (sm *Sitemap) Finalize() *Sitemap {
sm.bldrs.Add(sm.bldr)
sm.bldrs.Write()
sm.bldr = nil
return sm
} | go | {
"resource": ""
} |
q13592 | NewBuilderIndexfile | train | func NewBuilderIndexfile(opts *Options, loc *Location) *BuilderIndexfile {
return &BuilderIndexfile{opts: opts, loc: loc}
} | go | {
"resource": ""
} |
q13593 | Add | train | func (b *BuilderIndexfile) Add(link interface{}) BuilderError {
bldr := link.(*BuilderFile)
bldr.Write()
smu := NewSitemapIndexURL(b.opts, URL{{"loc", bldr.loc.URL()}})
b.content = append(b.content, smu.XML()...)
b.totalcnt += bldr.linkcnt
b.linkcnt++
return nil
} | go | {
"resource": ""
} |
q13594 | XMLContent | train | func (b *BuilderIndexfile) XMLContent() []byte {
c := bytes.Join(bytes.Fields(IndexXMLHeader), []byte(" "))
c = append(append(c, b.Content()...), IndexXMLFooter...)
return c
} | go | {
"resource": ""
} |
q13595 | Write | train | func (b *BuilderIndexfile) Write() {
c := b.XMLContent()
b.loc.Write(c, b.linkcnt)
} | go | {
"resource": ""
} |
q13596 | Directory | train | func (loc *Location) Directory() string {
return filepath.Join(
loc.opts.publicPath,
loc.opts.sitemapsPath,
)
} | go | {
"resource": ""
} |
q13597 | Path | train | func (loc *Location) Path() string {
return filepath.Join(
loc.opts.publicPath,
loc.opts.sitemapsPath,
loc.Filename(),
)
} | go | {
"resource": ""
} |
q13598 | PathInPublic | train | func (loc *Location) PathInPublic() string {
return filepath.Join(
loc.opts.sitemapsPath,
loc.Filename(),
)
} | go | {
"resource": ""
} |
q13599 | URL | train | func (loc *Location) URL() string {
base, _ := url.Parse(loc.opts.SitemapsHost())
for _, ref := range []string{
loc.opts.sitemapsPath + "/", loc.Filename(),
} {
base, _ = base.Parse(ref)
}
return base.String()
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.