_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
_ns := C.xmlSearchNsByHref((*C.xmlDoc)(xmlNode.Document.DocPtr()), xmlNode.Ptr, (*C.xmlChar)(hrefPtr))
if _ns != nil {
_prefixPtr := unsafe.Pointer(_ns.prefix)
_prefix := C.GoString((*C.char)(_prefixPtr))
if prefix == _prefix {
return
}
}
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))
} | 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
docPtr = C.xmlReadFile((*C.char)(dataPtr), nil, C.int(options))
if docPtr == nil {
err = ERR_FAILED_TO_PARSE_XML
} else {
var encoding []byte
// capture the detected 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
} | 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 = idattr.Parent().(*ElementNode)
}
return
} | 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(nodePtr), document).(*TextNode)
}
return
} | 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(nodePtr), document).(*CDataNode)
}
return
} | 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), (*C.xmlChar)(dataPtr))
if nodePtr != nil {
pi = NewNode(unsafe.Pointer(nodePtr), document).(*ProcessingInstructionNode)
}
return
} | 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 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))
return
} | 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 fragments first
//because the nodes are put in the unlinked list
if document.fragments != nil {
for _, fragment := range document.fragments {
fragment.Remove()
}
}
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
}
} | 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 the RVT
//if we don't do this we get horrible double-free crashes everywhere
ret.boolval = 0
return
} | 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 - return a node set
ret = C.xmlXPathNewNodeSet(nil)
for _, p := range ptrs {
C.xmlXPathNodeSetAdd(ret.nodesetval, (*C.xmlNode)(p))
}
} else {
ret = C.xmlXPathNewNodeSet(nil)
return
}
case float64:
ret = C.xmlXPathNewFloat(C.double(v))
case string:
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 the unknown type, return an empty node set
//fmt.Println("go-resolve wrong-type", typ.Kind())
ret = C.xmlXPathNewNodeSet(nil)
}
return
} | 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)
return
} | 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, urlPtr, encodingPtr unsafe.Pointer
contentPtr = unsafe.Pointer(&content[0])
if len(url) > 0 {
url = AppendCStringTerminator(url)
urlPtr = unsafe.Pointer(&url[0])
}
if len(inEncoding) > 0 {
encodingPtr = unsafe.Pointer(&inEncoding[0])
}
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, outEncoding)
}
return
} | 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
}
// Glob all files in the given path
files, err := filepath.Glob(filepath.Join(path, "*"))
if err != nil {
return nil, errors.Wrap(err, "failed to glob files")
}
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
} | 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")
}
if len(urlStr) == 0 {
return nil, errors.New("missing GitHub API URL")
}
baseURL, err := url.ParseRequestURI(urlStr)
if err != nil {
return nil, errors.Wrap(err, "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
} | 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 != http.StatusCreated {
return nil, errors.Errorf("create release: invalid status: %s", res.Status)
}
return release, nil
} | 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 to get release tag: %s", tag)
}
// TODO(tcnksm): Handle 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
} | 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.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)
}
return nil
})
return release, err
} | 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 release: invalid status: %s", res.Status)
}
return nil
} | 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.Errorf("delete tag: invalid status: %s", res.Status)
}
return nil
} | 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.Base(filename),
}
var asset *github.ReleaseAsset
err = retry.Retry(3, 3*time.Second, func() error {
var (
res *github.Response
err error
)
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", filename)
}
switch res.StatusCode {
case http.StatusCreated:
return nil
case 422:
return errors.Errorf(
"upload release asset: invalid status code: %s",
"422 (this is probably because the asset already uploaded)")
default:
return errors.Errorf(
"upload release asset: invalid status code: %s", res.Status)
}
})
return asset, err
} | 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 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
}
return result, nil
} | 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 := &latest.GithubTag{
Owner: "tcnksm",
Repository: "ghr",
}
res, err := latest.Check(githubTag, Version)
if err != nil {
// 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)
}
}
return buf.String()
} | 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 deleting a tag.
time.Sleep(5 * time.Second)
return nil
} | 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)
if err != nil {
return errors.Wrap(err, "failed to list assets")
}
semaphore := make(chan struct{}, parallel)
for _, localAsset := range localAssets {
for _, asset := range assets {
// https://golang.org/doc/faq#closures_and_goroutines
localAsset, asset := localAsset, asset
// Uploaded asset name is same as basename of local file
if *asset.Name == filepath.Base(localAsset) {
eg.Go(func() error {
semaphore <- struct{}{}
defer func() {
<-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 {
return errors.Wrap(err, "one of the goroutines failed")
}
return nil
} | 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.FgBlack, color.Bold),
StringMaxLength: 0,
DisabledColor: false,
Indent: 2,
Newline: "\n",
}
} | 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.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
} | 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{})
last, err := strconv.ParseInt(v["last"].(string), 10, 64)
if err != nil {
return nil, err
}
result := &TradesResponse{
Last: last,
Trades: make([]TradeInfo, 0),
}
trades := v[pair].([]interface{})
for _, v := range trades {
trade := v.([]interface{})
priceString := trade[0].(string)
price, _ := strconv.ParseFloat(priceString, 64)
volumeString := trade[1].(string)
volume, _ := strconv.ParseFloat(trade[1].(string), 64)
tradeInfo := TradeInfo{
Price: priceString,
PriceFloat: price,
Volume: 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),
}
result.Trades = append(result.Trades, tradeInfo)
}
return result, nil
} | 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, &TradeBalanceResponse{})
if err != nil {
return nil, err
}
return resp.(*TradeBalanceResponse), nil
} | 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, &OpenOrdersResponse{})
if err != nil {
return nil, err
}
return resp.(*OpenOrdersResponse), nil
} | 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", value)
}
if value, ok := args["end"]; ok {
params.Add("end", value)
}
if value, ok := args["ofs"]; ok {
params.Add("ofs", value)
}
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
} | 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, errors.New("invalid response")
} | 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("QueryOrders", params, &QueryOrdersResponse{})
if err != nil {
return nil, err
}
return resp.(*QueryOrdersResponse), nil
} | 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 {
params.Add("price", value)
}
if value, ok := args["price2"]; ok {
params.Add("price2", value)
}
if value, ok := args["leverage"]; ok {
params.Add("leverage", value)
}
if value, ok := args["oflags"]; ok {
params.Add("oflags", value)
}
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 value, ok := args["close_price"]; ok {
params.Add("close[price]", value)
}
if value, ok := args["close_price2"]; ok {
params.Add("close[price2]", value)
}
if value, ok := args["trading_agreement"]; ok {
params.Add("trading_agreement", value)
}
if value, ok := args["userref"]; ok {
params.Add("userref", value)
}
resp, err := api.queryPrivate("AddOrder", params, &AddOrderResponse{})
if err != nil {
return nil, err
}
return resp.(*AddOrderResponse), nil
} | 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 value, ok := args["start"]; ok {
params.Add("start", value)
}
if value, ok := args["end"]; ok {
params.Add("end", value)
}
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
} | 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.(*DepositAddressesResponse), nil
} | 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.(*WithdrawResponse), nil
} | 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 isStringInSlice(method, privateMethods) {
return api.queryPrivate(method, values, nil)
}
return nil, fmt.Errorf("Method '%s' is not valid", method)
} | 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.Now().UnixNano()))
// Create signature
signature := createSignature(urlPath, values, secret)
// 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
} | 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.Error())
}
req.Header.Add("User-Agent", APIUserAgent)
for key, value := range headers {
req.Header.Add(key, value)
}
// Execute request
resp, err := api.client.Do(req)
if err != nil {
return nil, fmt.Errorf("Could not execute request! #2 (%s)", err.Error())
}
defer resp.Body.Close()
// Read request
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("Could not execute request! #3 (%s)", err.Error())
}
// Check mime type of response
mimeType, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
if err != nil {
return nil, fmt.Errorf("Could not execute request #4! (%s)", err.Error())
}
if mimeType != "application/json" {
return nil, fmt.Errorf("Could not execute request #5! (%s)", fmt.Sprintf("Response Content-Type is '%s', but should be 'application/json'.", 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("Could not execute request! #6 (%s)", err.Error())
}
// Check for Kraken API error
if len(jsonData.Error) > 0 {
return nil, fmt.Errorf("Could not execute request! #7 (%s)", jsonData.Error)
}
return jsonData.Result, nil
} | 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")
}
// 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)
} | 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 == "" || verifier == "" {
return "", "", errors.New("oauth1: Request missing oauth_token or oauth_verifier")
}
return requestToken, verifier, nil
} | 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: defaultOauthVersion,
}
if a.config.Realm != "" {
params[realmParam] = a.config.Realm
}
return params
} | 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(parameterString)}
return strings.Join(baseParts, "&")
} | 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 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]
}
return fmt.Sprintf("%v://%v%v", scheme, host, path)
} | 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: consumerKey,
ConsumerSecret: consumerSecret,
CallbackURL: outOfBand,
Endpoint: twauth.AuthorizeEndpoint,
}
requestToken, err := login()
if err != nil {
log.Fatalf("Request 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)
} | 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.Client{Timeout: time.Duration(5 * time.Second)}
for _, url := range urls {
go func(baseurl string) {
url := fmt.Sprintf(baseurl, sitemapURL)
println("Ping now:", url)
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)
}
} | 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().Format(time.RFC3339))
}
if _, ok := SetBuilderElementValue(url, su.data, "changefreq"); !ok {
changefreq := url.CreateElement("changefreq")
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")
SetBuilderElementValue(url, su.data, "video")
SetBuilderElementValue(url, su.data, "image")
SetBuilderElementValue(url, su.data, "geo")
if su.opts.pretty {
doc.Indent(2)
}
buf := poolBuffer.Get()
doc.WriteTo(buf)
bytes := buf.Bytes()
poolBuffer.Put(buf)
return bytes
} | 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()
}()
}
creds := adp.Creds
if creds == nil {
creds = credentials.NewEnvCredentials()
}
creds.Get()
sess := session.New(&aws.Config{
Credentials: creds, Region: &adp.Region})
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)
}
} | 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 v[0] == key {
break
}
}
u[index][1] = URLJoin("", values...)
return u
} | 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.