id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c15500 | w.collectWkrSize = v
return CollectWkrSizeOption(previous)
}
} | |
c15501 | w.processWkrSize = v
return ProcessWkrSizeOption(previous)
}
} | |
c15502 | w.publishWkrSize = v
return PublishWkrSizeOption(previous)
}
} | |
c15503 | //TODO: log error
case <-w.publishq.Err:
//TODO: log error
case <-w.kill:
return
}
}
}()
}
} | |
c15504 |
close(workerKillChan)
close(w.kill)
} | |
c15505 | w.processq.Event <- qj
case publishJobType:
w.publishq.Event <- qj
}
return qj
} | |
c15506 | w.collectWkrs = append(w.collectWkrs, nw)
w.collectWkrSize++
} | |
c15507 | w.publishWkrs = append(w.publishWkrs, nw)
w.publishWkrSize++
} | |
c15508 | w.processWkrs = append(w.processWkrs, nw)
w.processWkrSize++
} | |
c15509 | w.publishchan <- j
case processJobType:
w.processchan <- j
}
} | |
c15510 | := m["config"]; ok {
if node, ok := config["root"]; ok {
if n, ok := node.(map[string]interface{}); ok {
return unmarshalJSON(n, &[]string{}, c.config)
}
}
}
return nil
} | |
c15511 | *ctree.ConfigTree `json:"config"`
}{
Config: c.config,
})
} | |
c15512 | {
c.config.Add(ns, cpn)
} | |
c15513 | {
return NewPolicyNode()
}
switch t := n.(type) {
case ConfigPolicyNode:
return &t
default:
return t.(*ConfigPolicyNode)
}
} | |
c15514 | data,
Timestamp_: timestamp,
LastAdvertisedTime_: timestamp,
Unit_: unit,
}
} | |
c15515 | "error": err1.Error(),
}).Error("error while swaping")
return nil, "", err1
}
newPayload, newContentType, err2 := MarshalMetricTypes(requestedContentType, metrics)
if err2 != nil {
log.WithFields(log.Fields{
"_module": "control-plugin",
"block": "swap-content-type",
"error": err2.Error(),
})... | |
c15516 | return nil, err
}
default:
reader = this.Body
}
defer reader.Close()
return ioutil.ReadAll(reader)
} | |
c15517 |
return "", err
}
return string(bytes), nil
} | |
c15518 | options[OPT_REFERER]; ok {
if refererStr, ok := referer.(string); ok {
req.Header.Set("Referer", refererStr)
}
}
// OPT_USERAGENT
if useragent, ok := options[OPT_USERAGENT]; ok {
if useragentStr, ok := useragent.(string); ok {
req.Header.Set("User-Agent", useragentStr)
}
}
for k, v := range header... | |
c15519 | !followlocation || maxredirs <= 0 {
return &Error{
Code: ERR_REDIRECT_POLICY,
Message: fmt.Sprintf("redirect not allowed"),
}
}
if len(via) >= maxredirs {
return &Error{
Code: ERR_REDIRECT_POLICY,
Message: fmt.Sprintf("stopped after %d redirects", len(via)),
}
}
... | |
c15520 | nil {
return nil, err
}
}
} else if optCookieJar, ok := optCookieJar_.(http.CookieJar); ok {
jar = optCookieJar
} else {
return nil, fmt.Errorf("invalid cookiejar")
}
}
return jar, nil
} | |
c15521 | true,
lock: new(sync.Mutex),
}
return c
} | |
c15522 |
} else {
for k, v := range options {
this.options[k] = v
}
}
// merge headers
if this.Headers == nil {
this.Headers = headers
} else {
for k, v := range headers {
this.Headers[k] = v
}
}
return this
} | |
c15523 | this.withLock = true
return this
} | |
c15524 | true
this.reuseJar = true
// nil means the Begin has not been called, asume requests are not
// concurrent.
if this.withLock {
this.lock.Unlock()
}
} | |
c15525 | this.reuseTransport = false
}
// Conditions we cann't reuse the cookie jar.
if hasOption(k, jarOptions) {
this.reuseJar = false
}
return this
} | |
c15526 | options {
this.WithOption(k, v)
}
return this
} | |
c15527 | == nil {
this.oneTimeHeaders = make(map[string]string)
}
this.oneTimeHeaders[k] = v
return this
} | |
c15528 | {
this.WithHeader(k, v)
}
return this
} | |
c15529 | append(this.oneTimeCookies, cookies...)
return this
} | |
c15530 |
if this.jar == nil || !this.reuseJar {
jar, err = prepareJar(options)
if err != nil {
this.reset()
return nil, err
}
if this.reuseJar {
this.jar = jar
}
} else {
jar = this.jar
}
// release lock
this.reset()
redirect, err := prepareRedirect(options)
if err != nil {
return nil, err
}
... | |
c15531 | return this.Do("HEAD", url, nil, nil)
} | |
c15532 | return this.Do("PUT", url, nil, body)
} | |
c15533 | {
for _, p := range params {
url = addParams(url, toUrlValues(p))
}
return this.Do("TRACE", url, nil, nil)
} | |
c15534 | := url.Parse(url_)
return this.jar.Cookies(u)
}
return nil
} | |
c15535 |
if c.Name == key {
return c.Value
}
}
return ""
} | |
c15536 | %s", this.Code, this.Message)
} | |
c15537 | ok && e.Timeout() {
return true
}
// TODO: make it reliable
if strings.Contains(err.Error(), "timeout") {
return true
}
return false
} | |
c15538 | ERR_REDIRECT_POLICY {
return true
}
// TODO: make it reliable
if strings.Contains(err.Error(), "redirect") {
return true
}
return false
} | |
c15539 | {
url_ += "?"
}
if strings.HasSuffix(url_, "?") || strings.HasSuffix(url_, "&") {
url_ += params.Encode()
} else {
url_ += "&" + params.Encode()
}
return url_
} | |
c15540 | err := writer.CreateFormFile(name, filepath.Base(path))
if err != nil {
return err
}
_, err = io.Copy(part, file)
return err
} | |
c15541 | for k, v := range o {
k := "OPT_" + strings.ToUpper(k)
if num, ok := CONST[k]; ok {
rst[num] = v
}
}
return rst
} | |
c15542 | == '@' {
return true
}
}
return false
} | |
c15543 | == v {
return true
}
}
return false
} | |
c15544 | ok := CONST[kStringUpper]; ok {
options[kInt] = v
} else {
// it should be header, but we still need to validate it's type
if vString, ok := v.(string); ok {
headers[kString] = vString
}
}
}
}
return options, headers
} | |
c15545 |
DKKristiHimmelfartsdag,
DKPinsedag,
DKAndenPinsedag,
DKJuledag,
DKAndenJuledag,
)
} | |
c15546 |
GBSummerHoliday,
GBChristmasDay,
GBBoxingDay,
)
} | |
c15547 | 0, 0, 0, loc)
switch day.Weekday() {
case time.Saturday:
day = day.AddDate(0, 0, 2)
case time.Sunday:
day = day.AddDate(0, 0, 1)
}
return time.January, day.Day()
} | |
c15548 | NZChristmasDay,
NZBoxingDays,
NZQueensBirthday,
NZLabourDay,
NZWanagiDay,
)
} | |
c15549 |
AUChristmasDay,
AUBoxingDays,
AUQueenBirthDay,
AULabourDay,
)
} | |
c15550 | == 0 {
date = date.AddDate(0, 0, 1)
}
if wd == 6 {
date = date.AddDate(0, 0, 2)
}
return date
} | |
c15551 |
USColumbus,
USVeterans,
USThanksgiving,
USChristmas,
)
} | |
c15552 |
NOKristihimmelfartsdag,
NOFoerstePinsedag,
NOAndrePinsedag,
NOFoersteJuledag,
NOAndreJuledag,
)
} | |
c15553 | return Holiday{Month: month, Day: day}
} | |
c15554 | return Holiday{Month: month, Day: day, Year: year}
} | |
c15555 |
return Holiday{Month: month, Weekday: weekday, Offset: offset}
} | |
c15556 | return false
}
if h.Day > 0 {
return date.Day() == h.Day
}
if h.Weekday > 0 && h.Offset != 0 {
return IsWeekdayN(date, h.Weekday, h.Offset)
}
} else if h.Offset > 0 {
return date.YearDay() == h.Offset
}
return false
} | |
c15557 | SEForstaMaj,
SEKristiHimmelfardsdag,
SEPingstdagen,
SENationaldagen,
SEMidsommarafton,
SEMidsommardagen,
SEAllaHelgonsDag,
SEJulafton,
SEJuldagen,
SEAnnandagJul,
SENewYearsEve,
)
} | |
c15558 | BEOnzeLieveVrouwHemelvaart,
BEAllerheiligen,
BEWapenstilstand,
BEKerstmis,
)
} | |
c15559 |
ECBEasterMonday,
ECBNewYearsDay,
ECBLabourDay,
ECBChristmasDay,
ECBChristmasHoliday,
)
} | |
c15560 |
NLPinksterMaandag,
NLEersteKerstdag,
NLTweedeKerstdag,
)
} | |
c15561 | == time.Saturday || day == time.Sunday
} | |
c15562 | t.Second(),
t.Nanosecond(), t.Location())
} | |
c15563 | true
c.workday[time.Wednesday] = true
c.workday[time.Thursday] = true
c.workday[time.Friday] = true
return c
} | |
c15564 | hd := range h {
c.holidays[hd.Month] = append(c.holidays[hd.Month], hd)
}
} | |
c15565 | workday bool) {
c.workday[day] = workday
} | |
c15566 | {
return true
}
}
for i := range c.holidays[0] {
if c.holidays[0][i].matches(date) {
return true
}
}
return false
} | |
c15567 | = dt.AddDate(0, 0, 1) {
if c.IsWorkday(dt) {
n++
}
}
return n
} | |
c15568 | {
return c.countWorkdays(time.Date(year, month, 1, 12, 0, 0, 0, time.UTC), month)
} | |
c15569 | c.countWorkdays(date.AddDate(0, 0, 1), date.Month())
} | |
c15570 | date := start.AddDate(0, 0, day)
if !c.IsWorkday(date) {
holidayHours += 24
days++
}
day++
}
return holidayHours
} | |
c15571 | 1) {
if c.IsWorkday(i) {
result++
}
}
if i.Equal(end) && c.IsWorkday(end) {
result++
}
return int64(factor * result)
} | |
c15572 |
for !c.IsWorkday(s) {
s = s.Add(day)
}
if d >= day {
s = s.Add(day)
d = d - day
} else if d > 0 {
s = s.Add(d)
d = 0
} else {
break
}
}
return s
} | |
c15573 | Tokenizer{dic: dic.SysDic()}, err
}
return NewWithDic(Dic{d}), nil
} | |
c15574 | t.Analyze(input, Normal)
} | |
c15575 | n.ID,
Class: TokenClass(n.Class),
Start: n.Start,
End: n.Start + utf8.RuneCountInString(n.Surface),
Surface: n.Surface,
dic: t.dic,
udic: t.udic,
}
if tok.ID == lattice.BosEosID {
if i == 0 {
tok.Surface = "BOS"
} else {
tok.Surface = "EOS"
}
}
tokens = append(... | |
c15576 | return t.AnalyzeGraph(input, Normal, w)
} | |
c15577 | token []byte, err error) {
return defaultSplitter.ScanSentences(data, atEOF)
} | |
c15578 | }
} else if s.isDelim(r) || s.isFollower(r) {
if end != p {
for i := 0; i < size; i++ {
data[end+i] = data[p+i]
}
}
p += size
end += size
} else {
break
}
}
return p, data[start:end], nil
}
if !atEOF {
// Request more data
for i := end; i < len(data); i++ {
... | |
c15579 | idx.Dup[int32(prev.no)]++
continue
}
prev.no = i
prev.word = key
keys = append(keys, key)
ids = append(ids, i)
}
d, err := da.BuildWithIDs(keys, ids)
if err != nil {
return idx, fmt.Errorf("build error, %v", err)
}
idx.Da = d
return idx, nil
} | |
c15580 | list := make([]int, 1+dup)
for i := 0; i < len(list); i++ {
list[i] = id + i
}
return list
} | |
c15581 | if err = binary.Write(w, binary.LittleEndian, k); err != nil {
return
}
n += int64(binary.Size(k))
v := idx.Dup[k]
if err = binary.Write(w, binary.LittleEndian, v); err != nil {
return
}
n += int64(binary.Size(v))
}
return
} | |
c15582 | := binary.Read(r, binary.LittleEndian, &k); err != nil {
return idx, err
}
var v int32
if err := binary.Read(r, binary.LittleEndian, &v); err != nil {
return idx, err
}
idx.Dup[k] = v
}
return idx, nil
} | |
c15583 |
return fmt.Errorf("%v, %v", CommandName, e)
}
return nil
} | |
c15584 | PrintDefaults(flag.ExitOnError)
return fmt.Errorf("%v, %v", CommandName, e)
}
return command(opt)
} | |
c15585 |
if e := binary.Read(r, binary.LittleEndian, &m[i].RightID); e != nil {
return m, e
}
if e := binary.Read(r, binary.LittleEndian, &m[i].Weight); e != nil {
return m, e
}
}
return m, nil
} | |
c15586 | fmt.Fprintf(errorWriter, "usage: %s <command>\n", filepath.Base(os.Args[0]))
} | |
c15587 | := strings.Split(vec[1], " ")
yomi := strings.Split(vec[2], " ")
if len(tokens) == 0 || len(tokens) != len(yomi) {
return nil, fmt.Errorf("invalid format: %s", line)
}
r := UserDicRecord{
Text: vec[0],
Tokens: tokens,
Yomi: yomi,
Pos: vec[3],
}
records = append(records, r)
}
return ... | |
c15588 |
}
c := dic.UserDicContent{
Tokens: r.Tokens,
Yomi: r.Yomi,
Pos: r.Pos,
}
udic.Contents = append(udic.Contents, c)
}
idx, err := dic.BuildIndexTable(keys)
udic.Index = idx
return UserDic{dic: udic}, err
} | |
c15589 | d.CharCategory[r]
}
return d.CharCategory[0] // default
} | |
c15590 | d, err
}
defer r.Close()
return load(&r.Reader, true)
} | |
c15591 | d, err
}
defer r.Close()
return load(&r.Reader, false)
} | |
c15592 | err := enc.Encode(p.NameList); err != nil {
return 0, err
}
return b.WriteTo(w)
} | |
c15593 | dec.Decode(&t.NameList); err != nil {
return t, fmt.Errorf("name list read error, %v", err)
}
return t, nil
} | |
c15594 | id := p.add(name)
ret = append(ret, id)
}
return ret
} | |
c15595 | v := range p {
ret[v] = k
}
return ret
} | |
c15596 | key := range keywords {
ids = append(ids, h[key])
}
}
branches := make([]int, len(keywords))
for i := range keywords {
branches[i] = i
}
d.add(0, 0, branches, keywords, ids)
d.truncate()
return d, nil
} | |
c15597 | int(d[q].Check) != p || d[q].Base > 0 {
return
}
return int(-d[q].Base), true
} | |
c15598 | int(terminator)
if ahead < bufLen && int(d[ahead].Check) == q && int(d[ahead].Base) <= 0 {
id = int(-d[ahead].Base)
ok = true
}
}
return
} | |
c15599 | int64(binary.Size(sz))
for _, v := range d {
if err = binary.Write(w, binary.LittleEndian, v.Base); err != nil {
return
}
n += int64(binary.Size(v.Base))
if err = binary.Write(w, binary.LittleEndian, v.Check); err != nil {
return
}
n += int64(binary.Size(v.Check))
}
return
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.