id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c21100 | strconv.FormatFloat(field.Float(), 'f', -1, 32)
case reflect.Float64:
v = strconv.FormatFloat(field.Float(), 'f', -1, 64)
default:
panic(fmt.Sprintf("Bad field type %T", field.Interface()))
}
return longitudeRegex.MatchString(v)
} | |
c21101 | }
if !dataURIRegex.MatchString(uri[0]) {
return false
}
return base64Regex.MatchString(uri[1])
} | |
c21102 |
if field.Len() == 0 {
return true
}
return multibyteRegex.MatchString(field.String())
} | |
c21103 | return false
}
var checksum int32
var i int32
factor := []int32{1, 3}
for i = 0; i < 12; i++ {
checksum += factor[i%2] * int32(s[i]-'0')
}
return (int32(s[12]-'0'))-((10-(checksum%10))%10) == 0
} | |
c21104 |
}
var checksum int32
var i int32
for i = 0; i < 9; i++ {
checksum += (i + 1) * int32(s[i]-'0')
}
if s[9] == 'X' {
checksum += 10 * 10
} else {
checksum += 10 * int32(s[9]-'0')
}
return checksum%11 == 0
} | |
c21105 | return true
}
// checksum validation is blocked by https://github.com/golang/crypto/pull/28
return true
} | |
c21106 | 256
}
}
h := sha256.New()
_, _ = h.Write(decode[:21])
d := h.Sum([]byte{})
h = sha256.New()
_, _ = h.Write(d)
validchecksum := [4]byte{}
computedchecksum := [4]byte{}
copy(computedchecksum[:], h.Sum(d[:0]))
copy(validchecksum[:], decode[21:])
return validchecksum == computedchecksum
} | |
c21107 | 0x1ea119fa, 0x3d4233dd, 0x2a1462b3}
p := 1
for _, v := range values {
b := p >> 25
p = (p&0x1ffffff)<<5 ^ v
for i := 0; i < 5; i++ {
if (b>>uint(i))&1 == 1 {
p ^= GEN[i]
}
}
}
if p != 1 {
return false
}
b := uint(0)
acc := 0
mv := (1 << 5) - 1
var sw []int
for _, v := range dp[1 : l... | |
c21108 |
return strings.ContainsRune(fl.Field().String(), r)
} | |
c21109 | strings.ContainsAny(fl.Field().String(), fl.Param())
} | |
c21110 | strings.Contains(fl.Field().String(), fl.Param())
} | |
c21111 | strings.HasPrefix(fl.Field().String(), fl.Param())
} | |
c21112 | strings.HasSuffix(fl.Field().String(), fl.Param())
} | |
c21113 | fl.GetStructFieldOK()
if !ok {
return false
}
return strings.Contains(field.String(), currentField.String())
} | |
c21114 | true
}
return !strings.Contains(field.String(), currentField.String())
} | |
c21115 | fieldType := field.Type()
// Not Same underlying type i.e. struct and time
if fieldType != topField.Type() {
return false
}
if fieldType == timeType {
t := field.Interface().(time.Time)
fieldTime := topField.Interface().(time.Time)
return fieldTime.Equal(t)
}
}
// default reflect.String:
... | |
c21116 | case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
p := asUint(param)
return field.Uint() == p
case reflect.Float32, reflect.Float64:
p := asFloat(param)
return field.Float() == p
}
panic(fmt.Sprintf("Bad field type %T", field.Interface()))
} | |
c21117 | i := strings.Index(s, "#"); i > -1 {
s = s[:i]
}
if len(s) == 0 {
return false
}
_, err := url.ParseRequestURI(s)
return err == nil
}
panic(fmt.Sprintf("Bad field type %T", field.Interface()))
} | |
c21118 |
str := field.String()
_, match := urn.Parse([]byte(str))
return match
}
panic(fmt.Sprintf("Bad field type %T", field.Interface()))
} | |
c21119 |
return !fileInfo.IsDir()
}
panic(fmt.Sprintf("Bad field type %T", field.Interface()))
} | |
c21120 | reflect.Uint64, reflect.Uintptr, reflect.Float32, reflect.Float64:
return true
default:
return numberRegex.MatchString(fl.Field().String())
}
} | |
c21121 |
return !field.IsNil()
default:
if fl.(*validate).fldIsPointer && field.Interface() != nil {
return true
}
return field.IsValid() && field.Interface() != reflect.Zero(field.Type()).Interface()
}
} | |
c21122 | case reflect.Float32, reflect.Float64:
p := asFloat(param)
return field.Float() <= p
case reflect.Struct:
if field.Type() == timeType {
now := time.Now().UTC()
t := field.Interface().(time.Time)
return t.Before(now) || t.Equal(now)
}
}
panic(fmt.Sprintf("Bad field type %T", field.Interface())... | |
c21123 | _, err := net.ResolveTCPAddr("tcp4", fl.Field().String())
return err == nil
} | |
c21124 | _, err := net.ResolveUDPAddr("udp", fl.Field().String())
return err == nil
} | |
c21125 | err := net.ResolveIPAddr("ip4", fl.Field().String())
return err == nil
} | |
c21126 | err := net.ResolveIPAddr("ip6", fl.Field().String())
return err == nil
} | |
c21127 | := net.ResolveIPAddr("ip", fl.Field().String())
return err == nil
} | |
c21128 | err := net.ResolveUnixAddr("unix", fl.Field().String())
return err == nil
} | |
c21129 |
case reflect.Invalid:
return current, reflect.Invalid, nullable
default:
if v.v.hasCustomFuncs {
if fn, ok := v.v.customFuncs[current.Type()]; ok {
current = reflect.ValueOf(fn(current))
goto BEGIN
}
}
return current, current.Kind(), nullable
}
} | |
c21130 | := strconv.ParseInt(param, 0, 64)
panicIf(err)
return i
} | |
c21131 | 0, 64)
panicIf(err)
return i
} | |
c21132 | := strconv.ParseFloat(param, 64)
panicIf(err)
return i
} | |
c21133 | in each instance
for k, val := range bakedInValidators {
// no need to error check here, baked in will always be valid
_ = v.registerValidation(k, wrapFunc(val), true)
}
v.pool = &sync.Pool{
New: func() interface{} {
return &validate{
v: v,
ns: make([]byte, 0, 64),
actualNs: make... | |
c21134 |
return v.registerValidation(tag, fn, false)
} | |
c21135 | return
}
m, ok := v.transTagFunc[trans]
if !ok {
m = make(map[string]TranslationFunc)
v.transTagFunc[trans] = m
}
m[tag] = translationFn
return
} | |
c21136 |
for i := 0; i < len(cs.fields); i++ {
f = cs.fields[i]
if v.isPartial {
if v.ffn != nil {
// used with StructFiltered
if v.ffn(append(structNs, f.name...)) {
continue
}
} else {
// used with StructPartial & StructExcept
_, ok = v.includeExclude[string(append(structNs,... | |
c21137 | v.getStructFieldOKInternal(v.slflParent, v.ct.param)
} | |
c21138 |
r.Endpoint = "actions"
r.Doc = "Manage actions"
r.Config = config
r.Context = context
r.Init(container, r)
} | |
c21139 |
// ps := data.(*BeePostStruct)
// FIXME
return nil
} | |
c21140 | bee.Description())
bees[bee.Name()] = &bee
} | |
c21141 |
bee, ok := bees[identifier]
if ok {
return bee
}
return nil
} | |
c21142 |
for _, bee := range bees {
r = append(r, bee)
}
return r
} | |
c21143 | if e := recover(); e != nil {
log.Println("Fatal bee event:", e, fatals)
go startBee(bee, fatals+1)
}
}(bee)
(*bee).Run(eventsIn)
} | |
c21144 | panic("Unknown bee-class in config file: " + bee.Class)
}
mod := (*factory).New(bee.Name, bee.Description, bee.Options)
RegisterBee(mod)
return &mod
} | |
c21145 | go func(mod *BeeInterface) {
startBee(mod, 0)
}(b)
return b
} | |
c21146 | Event)
go handleEvents()
for _, bee := range beeList {
StartBee(bee)
}
} | |
c21147 | close(eventsIn)
bees = make(map[string]*BeeInterface)
} | |
c21148 | go func(mod *BeeInterface) {
startBee(mod, 0)
}(bee)
} | |
c21149 | options,
}
b := Bee{
config: c,
SigChan: make(chan bool),
waitGroup: &sync.WaitGroup{},
}
return b
} | |
c21150 | gracefully!")
close(bee.SigChan)
bee.waitGroup.Wait()
bee.Running = false
log.Println(bee.Name(), "stopped gracefully!")
} | |
c21151 |
log.Println(a...)
Log(bee.Name(), fmt.Sprintln(args...), 0)
} | |
c21152 | fmt.Sprintf(format, args...)
log.Printf("[%s]: %s", bee.Name(), s)
Log(bee.Name(), s, 0)
} | |
c21153 |
log.Errorf("[%s]: %s", bee.Name(), s)
Log(bee.Name(), s, 1)
} | |
c21154 |
log.Panicln(a...)
Log(bee.Name(), fmt.Sprintln(args...), 2)
} | |
c21155 | log.Println("\tOptions:", v)
}
go func() {
defer func() {
if e := recover(); e != nil {
log.Printf("Fatal chain event: %s %s", e, debug.Stack())
}
}()
execChains(&event)
}()
}
} | |
c21156 |
filter, ok := filters[identifier]
if ok {
return filter
}
return nil
} | |
c21157 | r.Actions = append(r.Actions, prepareActionResponse(r.Context, action))
} | |
c21158 | r.Logs = append(r.Logs, prepareLogResponse(r.Context, log))
} | |
c21159 | {
return &a
}
}
return nil
} | |
c21160 | (*bee).LogAction()
log.Println("\tExecuting action:", a.Bee, "/", a.Name, "-", GetActionDescriptor(&a).Description)
for _, v := range a.Options {
log.Println("\t\tOptions:", v)
}
(*bee).Action(a)
} else {
log.Println("\tNot executing action on stopped bee:", a.Bee, "/", a.Name, "-", GetActionDescriptor... | |
c21161 | {
ctx := &APIContext{
Config: context.Config,
}
return ctx
} | |
c21162 | Type: _type,
Value: value,
}
*ph = append(*ph, p)
} else {
for i := 0; i < len(*ph); i++ {
if (*ph)[i].Name == name {
(*ph)[i].Type = _type
(*ph)[i].Value = value
}
}
}
} | |
c21163 | if p.Name == name {
return p.Value
}
}
return nil
} | |
c21164 | errors.New("Placeholder with name " + name + " not found")
}
return ConvertValue(v, dst)
} | |
c21165 | " not registered")
}
factory := (*GetFactory((*bee).Namespace()))
for _, ac := range factory.Actions() {
if ac.Name == action.Name {
return ac
}
}
return ActionDescriptor{}
} | |
c21166 | " not registered")
}
factory := (*GetFactory((*bee).Namespace()))
for _, ev := range factory.Events() {
if ev.Name == event.Name {
return ev
}
}
return EventDescriptor{}
} | |
c21167 | "channels",
Description: "Which channels this bee is currently connected to",
Type: "[]string",
},
}
return opts
} | |
c21168 | bees.Chain) {
r.chains[chain.Name] = &chain
} | |
c21169 | 0 {
log.Panicln("Cronbee: Your config seems messed up. Check the range of \"Hour\".")
}
}
for _, dow := range c.dow {
if dow >= 7 || dow < 0 {
log.Panicln("Cronbee: Your config seems messed up. Check the range of \"DayOfWeek\".")
}
}
for _, dom := range c.dom {
if dom >= 32 || dom < 1 {
log.Pani... | |
c21170 | == base {
a = 0
}
value[i] = a
i++
}
value[i] = a
return value
} | |
c21171 | ID: UUID(),
Bee: bee,
Message: message,
MessageType: messageType,
Timestamp: time.Now(),
}
} | |
c21172 |
defer logMutex.Unlock()
logs[bee] = append(logs[bee], NewLogMessage(bee, message, messageType))
} | |
c21173 | := range ls {
r = append(r, l)
}
}
}
logMutex.RUnlock()
sort.Sort(LogSorter(r))
return r
} | |
c21174 | case "yellow":
c = "08"
case "lime":
c = "09"
case "teal":
c = "10"
case "cyan":
c = "11"
case "lightblue":
c = "12"
case "pink":
c = "13"
case "grey":
c = "14"
case "silver":
c = "15"
}
return "\x03" + c + val + "\x03"
} | |
c21175 | opt.Name == name {
return opt.Value
}
}
return nil
} | |
c21176 | errors.New("Option with name " + name + " not found")
}
return ConvertValue(v, dst)
} | |
c21177 | if err != nil {
panic("Error reading API key file " + apiKey)
}
apiKey = string(buf)
}
if strings.HasPrefix(apiKey, "env://") {
buf := strings.TrimPrefix(apiKey, "env://")
apiKey = os.Getenv(string(buf))
}
return strings.TrimSpace(apiKey)
} | |
c21178 | := GetFactory(class)
if f == nil {
return BeeConfig{}, errors.New("Invalid class specified")
}
return BeeConfig{
Name: name,
Class: class,
Description: description,
Options: options,
}, nil
} | |
c21179 | bs = append(bs, (*b).Config())
}
return bs
} | |
c21180 | filter)
defer func() {
if e := recover(); e != nil {
log.Println("Fatal filter event:", e)
}
}()
return f.Passes(opts, filter)
} | |
c21181 | Value: v.Main,
},
{
Name: "description",
Type: "string",
Value: v.Description,
},
{
Name: "icon",
Type: "string",
Value: v.Icon,
},
},
}
mod.evchan <- weather
} | |
c21182 | template.New("_" + v).Funcs(templatehelper.FuncMap).Parse(v)
if err == nil {
err = tmpl.Execute(&res, data)
}
if err != nil {
panic(err)
}
return strings.TrimSpace(res.String()) == "true"
}
return false
} | |
c21183 | r.hives[(*hive).Name()] = hive
} | |
c21184 | if hive == nil {
panic("Hive for Bee not found")
}
r.hives[(*hive).Name()] = hive
r.Hives = append(r.Hives, hives.PrepareHiveResponse(r.Context, hive))
} | |
c21185 | {
for _, r := range resources {
r.Register(wsContainer, smolderConfig, context)
}
}(
&hives.HiveResource{},
&bees.BeeResource{},
&chains.ChainResource{},
&actions.ActionResource{},
&logs.LogResource{},
)
server := &http.Server{Addr: bind, Handler: wsContainer}
go func() {
log.Fatal(server.Liste... | |
c21186 | c.nextEvent().Sub(time.Now())
} | |
c21187 | in the Past & initial 'result'
//c.calculatedTime = setNanoecond(c.calculatedTime, 10000)
c.nextValidMonth(baseTime)
c.nextValidDay(baseTime)
c.nextValidHour(baseTime)
c.nextValidMinute(baseTime)
c.nextValidSecond(baseTime)
log.Println("Cronbee has found a time stamp: ", c.calculatedTime)
return c.calculatedTi... | |
c21188 | //log.Println(" :: and out", c.calculatedTime)
return
}
}
// If no result was found try it again in the following year
c.calculatedTime = c.calculatedTime.AddDate(1, 0, 0)
c.calculatedTime = setMonth(c.calculatedTime, c.month[0])
//log.Println("Cronbee: Month", c.calculatedTime, baseTime, c.month)
c.nextV... | |
c21189 | log.Println("Cronbee: Day-INS-2:", c.calculatedTime)
return
}
}
}*/
// If no result was found try it again in the following month.
c.calculatedTime = c.calculatedTime.AddDate(0, 1, 0)
c.calculatedTime = setDay(c.calculatedTime, c.dom[0])
//log.Println("Cronbee: Day", c.calculatedTime, baseTime)
c.nex... | |
c21190 | <-|
c.calculatedTime = setHour(c.calculatedTime, c.hour[0]) // |
//log.Println("Cronbee: Hour", c.calculatedTime, baseTime) // |
c.nextValidMonth(baseTime) // May trigger a new month --------|
c.nextValidDay(baseTime)
c.nextValidHour(baseTime)
} | |
c21191 | time.Hour)
c.calculatedTime = setMinute(c.calculatedTime, c.minute[0])
//log.Println("Cronbee: Minute", c.calculatedTime, baseTime)
c.nextValidHour(baseTime)
c.nextValidMinute(baseTime)
} | |
c21192 | c.calculatedTime.Add(1 * time.Minute)
c.calculatedTime = setSecond(c.calculatedTime, 0)
//log.Println("Cronbee: Second", c.calculatedTime, baseTime)
c.nextValidMinute(baseTime)
c.nextValidSecond(baseTime)
} | |
c21193 | {
factory, ok := factories[identifier]
if ok {
return factory
}
return nil
} | |
c21194 | := range factories {
r = append(r, factory)
}
return r
} | |
c21195 | {
return &c
}
}
return nil
} | |
c21196 |
actions = append(actions, el.Action)
}
if el.Filter.Name != "" {
//FIXME: migrate old style filters
c.Filters = append(c.Filters, el.Filter.Options.Value.(string))
}
}
c.Elements = []ChainElement{}
newcs = append(newcs, c)
}
chains = newcs
} | |
c21197 | log.Println("\t\tDid not pass filter!")
failed = true
break
}
}
if failed {
continue
}
for _, el := range c.Actions {
action := GetAction(el)
if action == nil {
log.Println("\t\tERROR: Unknown action referenced!")
continue
}
execAction(*action, m)
}
}
} | |
c21198 |
appflags = append(appflags, flag)
}
} | |
c21199 | flag.BoolVar((f.V).(*bool), f.Name, f.Value.(bool), f.Desc)
}
}
flag.Parse()
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.