_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q15500 | CollectWkrSizeOption | train | func CollectWkrSizeOption(v uint) workManagerOption {
return func(w *workManager) workManagerOption {
previous := w.collectWkrSize
w.collectWkrSize = v
return CollectWkrSizeOption(previous)
}
} | go | {
"resource": ""
} |
q15501 | ProcessWkrSizeOption | train | func ProcessWkrSizeOption(v uint) workManagerOption {
return func(w *workManager) workManagerOption {
previous := w.processWkrSize
w.processWkrSize = v
return ProcessWkrSizeOption(previous)
}
} | go | {
"resource": ""
} |
q15502 | PublishWkrSizeOption | train | func PublishWkrSizeOption(v uint) workManagerOption {
return func(w *workManager) workManagerOption {
previous := w.publishWkrSize
w.publishWkrSize = v
return PublishWkrSizeOption(previous)
}
} | go | {
"resource": ""
} |
q15503 | Start | train | func (w *workManager) Start() {
w.mutex.Lock()
defer w.mutex.Unlock()
if w.state == workManagerStopped {
w.state = workManagerRunning
go func() {
for {
select {
case <-w.collectq.Err:
//TODO: log error
case <-w.processq.Err:
//TODO: log error
case <-w.publishq.Err:
//TODO: log error
case <-w.kill:
return
}
}
}()
}
} | go | {
"resource": ""
} |
q15504 | Stop | train | func (w *workManager) Stop() {
w.collectq.Stop()
close(workerKillChan)
close(w.kill)
} | go | {
"resource": ""
} |
q15505 | Work | train | func (w *workManager) Work(j job) queuedJob {
qj := newQueuedJob(j)
switch j.Type() {
case collectJobType:
w.collectq.Event <- qj
case processJobType:
w.processq.Event <- qj
case publishJobType:
w.publishq.Event <- qj
}
return qj
} | go | {
"resource": ""
} |
q15506 | AddCollectWorker | train | func (w *workManager) AddCollectWorker() {
nw := newWorker(w.collectchan)
go nw.start()
w.collectWkrs = append(w.collectWkrs, nw)
w.collectWkrSize++
} | go | {
"resource": ""
} |
q15507 | AddPublishWorker | train | func (w *workManager) AddPublishWorker() {
nw := newWorker(w.publishchan)
go nw.start()
w.publishWkrs = append(w.publishWkrs, nw)
w.publishWkrSize++
} | go | {
"resource": ""
} |
q15508 | AddProcessWorker | train | func (w *workManager) AddProcessWorker() {
nw := newWorker(w.processchan)
go nw.start()
w.processWkrs = append(w.processWkrs, nw)
w.processWkrSize++
} | go | {
"resource": ""
} |
q15509 | sendToWorker | train | func (w *workManager) sendToWorker(j queuedJob) {
switch j.Job().Type() {
case collectJobType:
w.collectchan <- j
case publishJobType:
w.publishchan <- j
case processJobType:
w.processchan <- j
}
} | go | {
"resource": ""
} |
q15510 | UnmarshalJSON | train | func (c *ConfigPolicy) UnmarshalJSON(data []byte) error {
m := map[string]map[string]interface{}{}
decoder := json.NewDecoder(bytes.NewReader(data))
if err := decoder.Decode(&m); err != nil {
return err
}
c.config = ctree.New()
if config, ok := 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
} | go | {
"resource": ""
} |
q15511 | MarshalJSON | train | func (c *ConfigPolicy) MarshalJSON() ([]byte, error) {
return json.Marshal(&struct {
Config *ctree.ConfigTree `json:"config"`
}{
Config: c.config,
})
} | go | {
"resource": ""
} |
q15512 | Add | train | func (c *ConfigPolicy) Add(ns []string, cpn *ConfigPolicyNode) {
c.config.Add(ns, cpn)
} | go | {
"resource": ""
} |
q15513 | Get | train | func (c *ConfigPolicy) Get(ns []string) *ConfigPolicyNode {
n := c.config.Get(ns)
if n == nil {
return NewPolicyNode()
}
switch t := n.(type) {
case ConfigPolicyNode:
return &t
default:
return t.(*ConfigPolicyNode)
}
} | go | {
"resource": ""
} |
q15514 | NewMetricType | train | func NewMetricType(namespace core.Namespace, timestamp time.Time, tags map[string]string, unit string, data interface{}) *MetricType {
return &MetricType{
Namespace_: namespace,
Tags_: tags,
Data_: data,
Timestamp_: timestamp,
LastAdvertisedTime_: timestamp,
Unit_: unit,
}
} | go | {
"resource": ""
} |
q15515 | SwapMetricContentType | train | func SwapMetricContentType(contentType, requestedContentType string, payload []byte) ([]byte, string, error) {
metrics, err1 := UnmarshallMetricTypes(contentType, payload)
if err1 != nil {
log.WithFields(log.Fields{
"_module": "control-plugin",
"block": "swap-content-type",
"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(),
}).Error("error while swaping")
return nil, "", err2
}
return newPayload, newContentType, nil
} | go | {
"resource": ""
} |
q15516 | ReadAll | train | func (this *Response) ReadAll() ([]byte, error) {
var reader io.ReadCloser
var err error
switch this.Header.Get("Content-Encoding") {
case "gzip":
reader, err = gzip.NewReader(this.Body)
if err != nil {
return nil, err
}
default:
reader = this.Body
}
defer reader.Close()
return ioutil.ReadAll(reader)
} | go | {
"resource": ""
} |
q15517 | ToString | train | func (this *Response) ToString() (string, error) {
bytes, err := this.ReadAll()
if err != nil {
return "", err
}
return string(bytes), nil
} | go | {
"resource": ""
} |
q15518 | prepareRequest | train | func prepareRequest(method string, url_ string, headers map[string]string,
body io.Reader, options map[int]interface{}) (*http.Request, error) {
req, err := http.NewRequest(method, url_, body)
if err != nil {
return nil, err
}
// OPT_REFERER
if referer, ok := 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 headers {
req.Header.Set(k, v)
}
return req, nil
} | go | {
"resource": ""
} |
q15519 | prepareRedirect | train | func prepareRedirect(options map[int]interface{}) (func(req *http.Request, via []*http.Request) error, error) {
var redirectPolicy func(req *http.Request, via []*http.Request) error
if redirectPolicy_, ok := options[OPT_REDIRECT_POLICY]; ok {
if redirectPolicy, ok = redirectPolicy_.(func(*http.Request, []*http.Request) error); !ok {
return nil, fmt.Errorf("OPT_REDIRECT_POLICY is not a desired function")
}
} else {
var followlocation bool
if followlocation_, ok := options[OPT_FOLLOWLOCATION]; ok {
if followlocation, ok = followlocation_.(bool); !ok {
return nil, fmt.Errorf("OPT_FOLLOWLOCATION must be bool")
}
}
var maxredirs int
if maxredirs_, ok := options[OPT_MAXREDIRS]; ok {
if maxredirs, ok = maxredirs_.(int); !ok {
return nil, fmt.Errorf("OPT_MAXREDIRS must be int")
}
}
redirectPolicy = func(req *http.Request, via []*http.Request) error {
// no follow
if !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)),
}
}
last := via[len(via)-1]
// keep necessary headers
// TODO: pass all headers or add other headers?
if useragent := last.Header.Get("User-Agent"); useragent != "" {
req.Header.Set("User-Agent", useragent)
}
return nil
}
}
return redirectPolicy, nil
} | go | {
"resource": ""
} |
q15520 | prepareJar | train | func prepareJar(options map[int]interface{}) (http.CookieJar, error) {
var jar http.CookieJar
var err error
if optCookieJar_, ok := options[OPT_COOKIEJAR]; ok {
// is bool
if optCookieJar, ok := optCookieJar_.(bool); ok {
// default jar
if optCookieJar {
// TODO: PublicSuffixList
jar, err = cookiejar.New(nil)
if err != nil {
return nil, err
}
}
} else if optCookieJar, ok := optCookieJar_.(http.CookieJar); ok {
jar = optCookieJar
} else {
return nil, fmt.Errorf("invalid cookiejar")
}
}
return jar, nil
} | go | {
"resource": ""
} |
q15521 | NewHttpClient | train | func NewHttpClient() *HttpClient {
c := &HttpClient{
reuseTransport: true,
reuseJar: true,
lock: new(sync.Mutex),
}
return c
} | go | {
"resource": ""
} |
q15522 | Defaults | train | func (this *HttpClient) Defaults(defaults Map) *HttpClient {
options, headers := parseMap(defaults)
// merge options
if this.options == nil {
this.options = options
} 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
} | go | {
"resource": ""
} |
q15523 | Begin | train | func (this *HttpClient) Begin() *HttpClient {
this.lock.Lock()
this.withLock = true
return this
} | go | {
"resource": ""
} |
q15524 | reset | train | func (this *HttpClient) reset() {
this.oneTimeOptions = nil
this.oneTimeHeaders = nil
this.oneTimeCookies = nil
this.reuseTransport = true
this.reuseJar = true
// nil means the Begin has not been called, asume requests are not
// concurrent.
if this.withLock {
this.lock.Unlock()
}
} | go | {
"resource": ""
} |
q15525 | WithOption | train | func (this *HttpClient) WithOption(k int, v interface{}) *HttpClient {
if this.oneTimeOptions == nil {
this.oneTimeOptions = make(map[int]interface{})
}
this.oneTimeOptions[k] = v
// Conditions we cann't reuse the transport.
if hasOption(k, transportOptions) {
this.reuseTransport = false
}
// Conditions we cann't reuse the cookie jar.
if hasOption(k, jarOptions) {
this.reuseJar = false
}
return this
} | go | {
"resource": ""
} |
q15526 | WithOptions | train | func (this *HttpClient) WithOptions(m Map) *HttpClient {
options, _ := parseMap(m)
for k, v := range options {
this.WithOption(k, v)
}
return this
} | go | {
"resource": ""
} |
q15527 | WithHeader | train | func (this *HttpClient) WithHeader(k string, v string) *HttpClient {
if this.oneTimeHeaders == nil {
this.oneTimeHeaders = make(map[string]string)
}
this.oneTimeHeaders[k] = v
return this
} | go | {
"resource": ""
} |
q15528 | WithHeaders | train | func (this *HttpClient) WithHeaders(m map[string]string) *HttpClient {
for k, v := range m {
this.WithHeader(k, v)
}
return this
} | go | {
"resource": ""
} |
q15529 | WithCookie | train | func (this *HttpClient) WithCookie(cookies ...*http.Cookie) *HttpClient {
this.oneTimeCookies = append(this.oneTimeCookies, cookies...)
return this
} | go | {
"resource": ""
} |
q15530 | Do | train | func (this *HttpClient) Do(method string, url string, headers map[string]string,
body io.Reader) (*Response, error) {
options := mergeOptions(defaultOptions, this.options, this.oneTimeOptions)
headers = mergeHeaders(this.Headers, headers, this.oneTimeHeaders)
cookies := this.oneTimeCookies
var transport http.RoundTripper
var jar http.CookieJar
var err error
// transport
if this.transport == nil || !this.reuseTransport {
transport, err = prepareTransport(options)
if err != nil {
this.reset()
return nil, err
}
if this.reuseTransport {
this.transport = transport
}
} else {
transport = this.transport
}
// jar
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
}
c := &http.Client{
Transport: transport,
CheckRedirect: redirect,
Jar: jar,
}
req, err := prepareRequest(method, url, headers, body, options)
if err != nil {
return nil, err
}
if debugEnabled, ok := options[OPT_DEBUG]; ok {
if debugEnabled.(bool) {
dump, err := httputil.DumpRequestOut(req, true)
if err == nil {
fmt.Printf("%s\n", dump)
}
}
}
if jar != nil {
jar.SetCookies(req.URL, cookies)
} else {
for _, cookie := range cookies {
req.AddCookie(cookie)
}
}
res, err := c.Do(req)
return &Response{res}, err
} | go | {
"resource": ""
} |
q15531 | Head | train | func (this *HttpClient) Head(url string) (*Response, error) {
return this.Do("HEAD", url, nil, nil)
} | go | {
"resource": ""
} |
q15532 | Put | train | func (this *HttpClient) Put(url string, body io.Reader) (*Response, error) {
return this.Do("PUT", url, nil, body)
} | go | {
"resource": ""
} |
q15533 | Trace | train | func (this *HttpClient) Trace(url string, params ...map[string]string) (*Response, error) {
for _, p := range params {
url = addParams(url, toUrlValues(p))
}
return this.Do("TRACE", url, nil, nil)
} | go | {
"resource": ""
} |
q15534 | Cookies | train | func (this *HttpClient) Cookies(url_ string) []*http.Cookie {
if this.jar != nil {
u, _ := url.Parse(url_)
return this.jar.Cookies(u)
}
return nil
} | go | {
"resource": ""
} |
q15535 | CookieValue | train | func (this *HttpClient) CookieValue(url_ string, key string) string {
for _, c := range this.Cookies(url_) {
if c.Name == key {
return c.Value
}
}
return ""
} | go | {
"resource": ""
} |
q15536 | Error | train | func (this Error) Error() string {
return fmt.Sprintf("httpclient #%d: %s", this.Code, this.Message)
} | go | {
"resource": ""
} |
q15537 | IsTimeoutError | train | func IsTimeoutError(err error) bool {
if err == nil {
return false
}
// TODO: does not work?
if e, ok := err.(net.Error); ok && e.Timeout() {
return true
}
// TODO: make it reliable
if strings.Contains(err.Error(), "timeout") {
return true
}
return false
} | go | {
"resource": ""
} |
q15538 | IsRedirectError | train | func IsRedirectError(err error) bool {
if err == nil {
return false
}
// TODO: does not work?
if getErrorCode(err) == ERR_REDIRECT_POLICY {
return true
}
// TODO: make it reliable
if strings.Contains(err.Error(), "redirect") {
return true
}
return false
} | go | {
"resource": ""
} |
q15539 | addParams | train | func addParams(url_ string, params url.Values) string {
if len(params) == 0 {
return url_
}
if !strings.Contains(url_, "?") {
url_ += "?"
}
if strings.HasSuffix(url_, "?") || strings.HasSuffix(url_, "&") {
url_ += params.Encode()
} else {
url_ += "&" + params.Encode()
}
return url_
} | go | {
"resource": ""
} |
q15540 | addFormFile | train | func addFormFile(writer *multipart.Writer, name, path string) error {
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
part, err := writer.CreateFormFile(name, filepath.Base(path))
if err != nil {
return err
}
_, err = io.Copy(part, file)
return err
} | go | {
"resource": ""
} |
q15541 | Option | train | func Option(o map[string]interface{}) map[int]interface{} {
rst := make(map[int]interface{})
for k, v := range o {
k := "OPT_" + strings.ToUpper(k)
if num, ok := CONST[k]; ok {
rst[num] = v
}
}
return rst
} | go | {
"resource": ""
} |
q15542 | checkParamFile | train | func checkParamFile(params url.Values) bool {
for k, _ := range params {
if k[0] == '@' {
return true
}
}
return false
} | go | {
"resource": ""
} |
q15543 | hasOption | train | func hasOption(opt int, options []int) bool {
for _, v := range options {
if opt == v {
return true
}
}
return false
} | go | {
"resource": ""
} |
q15544 | parseMap | train | func parseMap(m Map) (map[int]interface{}, map[string]string) {
var options = make(map[int]interface{})
var headers = make(map[string]string)
if m == nil {
return options, headers
}
for k, v := range m {
// integer is option
if kInt, ok := k.(int); ok {
// don't need to validate
options[kInt] = v
} else if kString, ok := k.(string); ok {
kStringUpper := strings.ToUpper(kString)
if kInt, 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
} | go | {
"resource": ""
} |
q15545 | AddDanishHolidays | train | func AddDanishHolidays(c *Calendar) {
c.AddHoliday(
DKNytaarsdag,
DKSkaertorsdag,
DKLangfredag,
DKPaaskedag,
DKAndenPaaskedag,
DKStoreBededag,
DKKristiHimmelfartsdag,
DKPinsedag,
DKAndenPinsedag,
DKJuledag,
DKAndenJuledag,
)
} | go | {
"resource": ""
} |
q15546 | AddBritishHolidays | train | func AddBritishHolidays(c *Calendar) {
c.AddHoliday(
GBNewYear,
GBGoodFriday,
GBEasterMonday,
GBEarlyMay,
GBSpringHoliday,
GBSummerHoliday,
GBChristmasDay,
GBBoxingDay,
)
} | go | {
"resource": ""
} |
q15547 | calculateNewYearsHoliday | train | func calculateNewYearsHoliday(year int, loc *time.Location) (time.Month, int) {
day := time.Date(year, time.January, 1, 0, 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()
} | go | {
"resource": ""
} |
q15548 | AddNewZealandHoliday | train | func AddNewZealandHoliday(c *Calendar) {
c.AddHoliday(
NZNewYear,
NZDayAfterNewYear,
NZGoodFriday,
NZEasterMonday,
NZAnzacDay,
NZChristmasDay,
NZBoxingDays,
NZQueensBirthday,
NZLabourDay,
NZWanagiDay,
)
} | go | {
"resource": ""
} |
q15549 | AddAustralianHolidays | train | func AddAustralianHolidays(c *Calendar) {
c.AddHoliday(
AUNewYear,
AUAustralianDay,
AUGoodFriday,
AUEasterMonday,
AUAnzacDay,
AUChristmasDay,
AUBoxingDays,
AUQueenBirthDay,
AULabourDay,
)
} | go | {
"resource": ""
} |
q15550 | closestMonday | train | func closestMonday(date time.Time) time.Time {
wd := date.Weekday()
if wd == 0 {
date = date.AddDate(0, 0, 1)
}
if wd == 6 {
date = date.AddDate(0, 0, 2)
}
return date
} | go | {
"resource": ""
} |
q15551 | AddUsHolidays | train | func AddUsHolidays(cal *Calendar) {
cal.AddHoliday(
USNewYear,
USMLK,
USPresidents,
USMemorial,
USIndependence,
USLabor,
USColumbus,
USVeterans,
USThanksgiving,
USChristmas,
)
} | go | {
"resource": ""
} |
q15552 | AddNorwegianHolidays | train | func AddNorwegianHolidays(c *Calendar) {
c.AddHoliday(
NOFoersteNyttaarsdag,
NOSkjaertorsdag,
NOLangfredag,
NOFoerstePaaskedag,
NOAndrePaaskedag,
NOArbeiderenesdag,
NOGrunnlovsdag,
NOKristihimmelfartsdag,
NOFoerstePinsedag,
NOAndrePinsedag,
NOFoersteJuledag,
NOAndreJuledag,
)
} | go | {
"resource": ""
} |
q15553 | NewHoliday | train | func NewHoliday(month time.Month, day int) Holiday {
return Holiday{Month: month, Day: day}
} | go | {
"resource": ""
} |
q15554 | NewHolidayExact | train | func NewHolidayExact(month time.Month, day int, year int) Holiday {
return Holiday{Month: month, Day: day, Year: year}
} | go | {
"resource": ""
} |
q15555 | NewHolidayFloat | train | func NewHolidayFloat(month time.Month, weekday time.Weekday, offset int) Holiday {
return Holiday{Month: month, Weekday: weekday, Offset: offset}
} | go | {
"resource": ""
} |
q15556 | matches | train | func (h *Holiday) matches(date time.Time) bool {
if h.Func != nil && (date.Year() != h.lastYear || date.Location() != h.lastLoc) {
h.Month, h.Day = h.Func(date.Year(), date.Location())
h.lastYear = date.Year()
h.lastLoc = date.Location()
}
if h.Month > 0 {
if date.Month() != h.Month {
return false
}
if h.Year > 0 && date.Year() != h.Year {
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
} | go | {
"resource": ""
} |
q15557 | AddSwedishHolidays | train | func AddSwedishHolidays(c *Calendar) {
c.AddHoliday(
SENyarsdagen,
SETrettondedagJul,
SELangfredagen,
SEPaskdagen,
SEAnnandagPask,
SEForstaMaj,
SEKristiHimmelfardsdag,
SEPingstdagen,
SENationaldagen,
SEMidsommarafton,
SEMidsommardagen,
SEAllaHelgonsDag,
SEJulafton,
SEJuldagen,
SEAnnandagJul,
SENewYearsEve,
)
} | go | {
"resource": ""
} |
q15558 | AddBelgiumHolidays | train | func AddBelgiumHolidays(c *Calendar) {
c.AddHoliday(
BENieuwjaar,
BEPaasmaandag,
BEDagVanDeArbeid,
BEOnzeLieveHeerHemelvaart,
BEPinkstermaandag,
BENationaleFeestdag,
BEOnzeLieveVrouwHemelvaart,
BEAllerheiligen,
BEWapenstilstand,
BEKerstmis,
)
} | go | {
"resource": ""
} |
q15559 | AddEcbHolidays | train | func AddEcbHolidays(c *Calendar) {
c.AddHoliday(
ECBGoodFriday,
ECBEasterMonday,
ECBNewYearsDay,
ECBLabourDay,
ECBChristmasDay,
ECBChristmasHoliday,
)
} | go | {
"resource": ""
} |
q15560 | AddDutchHolidays | train | func AddDutchHolidays(c *Calendar) {
c.AddHoliday(
NLNieuwjaar,
NLGoedeVrijdag,
NLPaasMaandag,
NLKoningsDag,
NLBevrijdingsDag,
NLHemelvaart,
NLPinksterMaandag,
NLEersteKerstdag,
NLTweedeKerstdag,
)
} | go | {
"resource": ""
} |
q15561 | IsWeekend | train | func IsWeekend(date time.Time) bool {
day := date.Weekday()
return day == time.Saturday || day == time.Sunday
} | go | {
"resource": ""
} |
q15562 | MonthStart | train | func MonthStart(t time.Time) time.Time {
return time.Date(t.Year(), t.Month(), 1, t.Hour(), t.Minute(), t.Second(),
t.Nanosecond(), t.Location())
} | go | {
"resource": ""
} |
q15563 | NewCalendar | train | func NewCalendar() *Calendar {
c := &Calendar{}
for i := range c.holidays {
c.holidays[i] = make([]Holiday, 0, 2)
}
c.workday[time.Monday] = true
c.workday[time.Tuesday] = true
c.workday[time.Wednesday] = true
c.workday[time.Thursday] = true
c.workday[time.Friday] = true
return c
} | go | {
"resource": ""
} |
q15564 | AddHoliday | train | func (c *Calendar) AddHoliday(h ...Holiday) {
for _, hd := range h {
c.holidays[hd.Month] = append(c.holidays[hd.Month], hd)
}
} | go | {
"resource": ""
} |
q15565 | SetWorkday | train | func (c *Calendar) SetWorkday(day time.Weekday, workday bool) {
c.workday[day] = workday
} | go | {
"resource": ""
} |
q15566 | IsHoliday | train | func (c *Calendar) IsHoliday(date time.Time) bool {
idx := date.Month()
for i := range c.holidays[idx] {
if c.holidays[idx][i].matches(date) {
return true
}
}
for i := range c.holidays[0] {
if c.holidays[0][i].matches(date) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q15567 | countWorkdays | train | func (c *Calendar) countWorkdays(dt time.Time, month time.Month) int {
n := 0
for ; month == dt.Month(); dt = dt.AddDate(0, 0, 1) {
if c.IsWorkday(dt) {
n++
}
}
return n
} | go | {
"resource": ""
} |
q15568 | Workdays | train | func (c *Calendar) Workdays(year int, month time.Month) int {
return c.countWorkdays(time.Date(year, month, 1, 12, 0, 0, 0, time.UTC), month)
} | go | {
"resource": ""
} |
q15569 | WorkdaysRemain | train | func (c *Calendar) WorkdaysRemain(date time.Time) int {
return c.countWorkdays(date.AddDate(0, 0, 1), date.Month())
} | go | {
"resource": ""
} |
q15570 | CountHolidayHoursWithOffset | train | func (c *Calendar) CountHolidayHoursWithOffset(start time.Time, offsetHour int) int {
days := int(math.Ceil(float64(offsetHour) / float64(24)))
holidayHours := 0
day := 0
for day <= days {
date := start.AddDate(0, 0, day)
if !c.IsWorkday(date) {
holidayHours += 24
days++
}
day++
}
return holidayHours
} | go | {
"resource": ""
} |
q15571 | CountWorkdays | train | func (c *Calendar) CountWorkdays(start, end time.Time) int64 {
factor := 1
if end.Before(start) {
factor = -1
start, end = end, start
}
result := 0
var i time.Time
for i = start; i.Before(end); i = i.AddDate(0, 0, 1) {
if c.IsWorkday(i) {
result++
}
}
if i.Equal(end) && c.IsWorkday(end) {
result++
}
return int64(factor * result)
} | go | {
"resource": ""
} |
q15572 | AddSkipNonWorkdays | train | func (c *Calendar) AddSkipNonWorkdays(start time.Time, d time.Duration) time.Time {
const day = 24 * time.Hour
s := start
for {
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
} | go | {
"resource": ""
} |
q15573 | NewWithDicPath | train | func NewWithDicPath(p string) (Tokenizer, error) {
d, err := dic.Load(p)
if err != nil {
return Tokenizer{dic: dic.SysDic()}, err
}
return NewWithDic(Dic{d}), nil
} | go | {
"resource": ""
} |
q15574 | Tokenize | train | func (t Tokenizer) Tokenize(input string) []Token {
return t.Analyze(input, Normal)
} | go | {
"resource": ""
} |
q15575 | Analyze | train | func (t Tokenizer) Analyze(input string, mode TokenizeMode) (tokens []Token) {
la := lattice.New(t.dic, t.udic)
defer la.Free()
la.Build(input)
m := lattice.Normal
switch mode {
case Normal:
m = lattice.Normal
case Search:
m = lattice.Search
case Extended:
m = lattice.Extended
}
la.Forward(m)
la.Backward(m)
size := len(la.Output)
tokens = make([]Token, 0, size)
for i := range la.Output {
n := la.Output[size-1-i]
tok := Token{
ID: 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(tokens, tok)
}
return
} | go | {
"resource": ""
} |
q15576 | Dot | train | func (t Tokenizer) Dot(input string, w io.Writer) (tokens []Token) {
return t.AnalyzeGraph(input, Normal, w)
} | go | {
"resource": ""
} |
q15577 | ScanSentences | train | func ScanSentences(data []byte, atEOF bool) (advance int, token []byte, err error) {
return defaultSplitter.ScanSentences(data, atEOF)
} | go | {
"resource": ""
} |
q15578 | ScanSentences | train | func (s SentenceSplitter) ScanSentences(data []byte, atEOF bool) (advance int, token []byte, err error) {
if atEOF && len(data) == 0 {
return 0, nil, nil
}
var (
start, end, rcount int
head, nn bool
)
head = true
for p := 0; p < len(data); {
r, size := utf8.DecodeRune(data[p:])
if s.SkipWhiteSpace && unicode.IsSpace(r) {
p += size
if head {
start, end = p, p
} else if s.isDelim(r) {
return p, data[start:end], nil
} else if s.DoubleLineFeedSplit && r == '\n' {
if nn {
return p, data[start:end], nil
}
nn = true
}
continue
}
head, nn = false, false // clear flags
if end != p {
for i := 0; i < size; i++ {
data[end+i] = data[p+i]
}
}
p += size
end += size
rcount++
if !s.isDelim(r) && rcount < s.MaxRuneLen {
continue
}
// split
nn = false
for p < len(data) {
r, size := utf8.DecodeRune(data[p:])
if s.SkipWhiteSpace && unicode.IsSpace(r) {
p += size
if s.DoubleLineFeedSplit && r == '\n' {
if nn {
return p, data[start:end], nil
}
nn = true
}
} 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++ {
data[i] = ' '
}
return start, nil, nil
}
// If we're at EOF, we have a final, non-terminated line. Return it.
return len(data), data[start:end], nil
} | go | {
"resource": ""
} |
q15579 | BuildIndexTable | train | func BuildIndexTable(sortedKeywords []string) (IndexTable, error) {
idx := IndexTable{Dup: map[int32]int32{}}
if !sort.StringsAreSorted(sortedKeywords) {
return idx, fmt.Errorf("unsorted keywords")
}
keys := make([]string, 0, len(sortedKeywords))
ids := make([]int, 0, len(sortedKeywords))
prev := struct {
no int
word string
}{}
for i, key := range sortedKeywords {
if key == prev.word {
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
} | go | {
"resource": ""
} |
q15580 | Search | train | func (idx IndexTable) Search(input string) []int {
id, ok := idx.Da.Find(input)
if !ok {
return nil
}
dup := idx.Dup[int32(id)]
list := make([]int, 1+dup)
for i := 0; i < len(list); i++ {
list[i] = id + i
}
return list
} | go | {
"resource": ""
} |
q15581 | WriteTo | train | func (idx IndexTable) WriteTo(w io.Writer) (n int64, err error) {
if n, err = idx.Da.WriteTo(w); err != nil {
return
}
keys := make([]int32, 0, len(idx.Dup))
for k := range idx.Dup {
keys = append(keys, k)
}
sort.Slice(keys, func(i, j int) bool {
return keys[i] < keys[j]
})
sz := int64(len(keys))
if err = binary.Write(w, binary.LittleEndian, sz); err != nil {
return
}
n += int64(binary.Size(sz))
for _, k := range keys {
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
} | go | {
"resource": ""
} |
q15582 | ReadIndexTable | train | func ReadIndexTable(r io.Reader) (IndexTable, error) {
idx := IndexTable{}
d, err := da.Read(r)
if err != nil {
return idx, fmt.Errorf("read index error, %v", err)
}
idx.Da = d
var sz int64
if err := binary.Read(r, binary.LittleEndian, &sz); err != nil {
return idx, err
}
idx.Dup = make(map[int32]int32, sz)
for i := int64(0); i < sz; i++ {
var k int32
if err := 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
} | go | {
"resource": ""
} |
q15583 | OptionCheck | train | func OptionCheck(args []string) (err error) {
opt := newOption(ioutil.Discard, flag.ContinueOnError)
if e := opt.parse(args); e != nil {
return fmt.Errorf("%v, %v", CommandName, e)
}
return nil
} | go | {
"resource": ""
} |
q15584 | Run | train | func Run(args []string) error {
opt := newOption(ErrorWriter, flag.ExitOnError)
if e := opt.parse(args); e != nil {
Usage()
PrintDefaults(flag.ExitOnError)
return fmt.Errorf("%v, %v", CommandName, e)
}
return command(opt)
} | go | {
"resource": ""
} |
q15585 | LoadMorphSlice | train | func LoadMorphSlice(r io.Reader) ([]Morph, error) {
var l int64
if e := binary.Read(r, binary.LittleEndian, &l); e != nil {
return nil, e
}
m := make([]Morph, l)
for i := range m {
if e := binary.Read(r, binary.LittleEndian, &m[i].LeftID); e != nil {
return m, e
}
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
} | go | {
"resource": ""
} |
q15586 | Usage | train | func Usage() {
fmt.Fprintf(errorWriter, "Japanese Morphological Analyzer -- github.com/ikawaha/kagome\n")
fmt.Fprintf(errorWriter, "usage: %s <command>\n", filepath.Base(os.Args[0]))
} | go | {
"resource": ""
} |
q15587 | NewUserDicRecords | train | func NewUserDicRecords(r io.Reader) (UserDicRecords, error) {
var text []string
scanner := bufio.NewScanner(r)
for scanner.Scan() {
line := scanner.Text()
if line == "" || strings.HasPrefix(line, "#") {
continue
}
text = append(text, line)
}
if err := scanner.Err(); err != nil {
return nil, err
}
var records UserDicRecords
for _, line := range text {
vec := strings.Split(line, ",")
if len(vec) != dic.UserDicColumnSize {
return nil, fmt.Errorf("invalid format: %s", line)
}
tokens := 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 records, nil
} | go | {
"resource": ""
} |
q15588 | NewUserDic | train | func (u UserDicRecords) NewUserDic() (UserDic, error) {
udic := new(dic.UserDic)
sort.Sort(u)
prev := ""
keys := make([]string, 0, len(u))
for _, r := range u {
k := strings.TrimSpace(r.Text)
if prev == k {
return UserDic{}, fmt.Errorf("duplicated error, %+v", r)
}
prev = k
keys = append(keys, k)
if len(r.Tokens) == 0 || len(r.Tokens) != len(r.Yomi) {
return UserDic{}, fmt.Errorf("invalid format, %+v", r)
}
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
} | go | {
"resource": ""
} |
q15589 | CharacterCategory | train | func (d Dic) CharacterCategory(r rune) byte {
if int(r) < len(d.CharCategory) {
return d.CharCategory[r]
}
return d.CharCategory[0] // default
} | go | {
"resource": ""
} |
q15590 | Load | train | func Load(path string) (d *Dic, err error) {
r, err := zip.OpenReader(path)
if err != nil {
return d, err
}
defer r.Close()
return load(&r.Reader, true)
} | go | {
"resource": ""
} |
q15591 | LoadSimple | train | func LoadSimple(path string) (d *Dic, err error) {
r, err := zip.OpenReader(path)
if err != nil {
return d, err
}
defer r.Close()
return load(&r.Reader, false)
} | go | {
"resource": ""
} |
q15592 | WriteTo | train | func (p POSTable) WriteTo(w io.Writer) (int64, error) {
var b bytes.Buffer
enc := gob.NewEncoder(&b)
if err := enc.Encode(p.POSs); err != nil {
return 0, err
}
if err := enc.Encode(p.NameList); err != nil {
return 0, err
}
return b.WriteTo(w)
} | go | {
"resource": ""
} |
q15593 | ReadPOSTable | train | func ReadPOSTable(r io.Reader) (POSTable, error) {
t := POSTable{}
dec := gob.NewDecoder(r)
if err := dec.Decode(&t.POSs); err != nil {
return t, fmt.Errorf("POSs read error, %v", err)
}
if err := dec.Decode(&t.NameList); err != nil {
return t, fmt.Errorf("name list read error, %v", err)
}
return t, nil
} | go | {
"resource": ""
} |
q15594 | Add | train | func (p POSMap) Add(pos []string) POS {
ret := make(POS, 0, len(pos))
for _, name := range pos {
id := p.add(name)
ret = append(ret, id)
}
return ret
} | go | {
"resource": ""
} |
q15595 | List | train | func (p POSMap) List() []string {
ret := make([]string, len(p)+1)
for k, v := range p {
ret[v] = k
}
return ret
} | go | {
"resource": ""
} |
q15596 | BuildWithIDs | train | func BuildWithIDs(keywords []string, ids []int) (DoubleArray, error) {
d := DoubleArray{}
d.init()
if len(keywords) != len(ids) {
return d, fmt.Errorf("invalid arguments")
}
if len(keywords) == 0 {
return d, nil
}
if !sort.StringsAreSorted(keywords) {
h := make(map[string]int)
for i, key := range keywords {
h[key] = ids[i]
}
sort.Strings(keywords)
ids = ids[:0]
for _, 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
} | go | {
"resource": ""
} |
q15597 | Find | train | func (d DoubleArray) Find(input string) (id int, ok bool) {
_, q, _, ok := d.search(input)
if !ok {
return
}
p := q
q = int(d[p].Base) + int(terminator)
if q >= len(d) || int(d[q].Check) != p || d[q].Base > 0 {
return
}
return int(-d[q].Base), true
} | go | {
"resource": ""
} |
q15598 | PrefixSearch | train | func (d DoubleArray) PrefixSearch(input string) (id int, ok bool) {
var p, q, i int
bufLen := len(d)
for size := len(input); i < size; i++ {
if input[i] == terminator {
return
}
p = q
q = int(d[p].Base) + int(input[i])
if q >= bufLen || int(d[q].Check) != p {
break
}
ahead := int(d[q].Base) + int(terminator)
if ahead < bufLen && int(d[ahead].Check) == q && int(d[ahead].Base) <= 0 {
id = int(-d[ahead].Base)
ok = true
}
}
return
} | go | {
"resource": ""
} |
q15599 | WriteTo | train | func (d DoubleArray) WriteTo(w io.Writer) (n int64, err error) {
sz := int64(len(d))
//fmt.Println("write data len:", sz)
if err = binary.Write(w, binary.LittleEndian, sz); err != nil {
return
}
n += 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
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.