_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q21100 | isLongitude | train | func isLongitude(fl FieldLevel) bool {
field := fl.Field()
var v string
switch field.Kind() {
case reflect.String:
v = field.String()
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
v = strconv.FormatInt(field.Int(), 10)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.U... | go | {
"resource": ""
} |
q21101 | isDataURI | train | func isDataURI(fl FieldLevel) bool {
uri := strings.SplitN(fl.Field().String(), ",", 2)
if len(uri) != 2 {
return false
}
if !dataURIRegex.MatchString(uri[0]) {
return false
}
return base64Regex.MatchString(uri[1])
} | go | {
"resource": ""
} |
q21102 | hasMultiByteCharacter | train | func hasMultiByteCharacter(fl FieldLevel) bool {
field := fl.Field()
if field.Len() == 0 {
return true
}
return multibyteRegex.MatchString(field.String())
} | go | {
"resource": ""
} |
q21103 | isISBN13 | train | func isISBN13(fl FieldLevel) bool {
s := strings.Replace(strings.Replace(fl.Field().String(), "-", "", 4), " ", "", 4)
if !iSBN13Regex.MatchString(s) {
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 (in... | go | {
"resource": ""
} |
q21104 | isISBN10 | train | func isISBN10(fl FieldLevel) bool {
s := strings.Replace(strings.Replace(fl.Field().String(), "-", "", 3), " ", "", 3)
if !iSBN10Regex.MatchString(s) {
return false
}
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
}... | go | {
"resource": ""
} |
q21105 | isEthereumAddress | train | func isEthereumAddress(fl FieldLevel) bool {
address := fl.Field().String()
if !ethAddressRegex.MatchString(address) {
return false
}
if ethaddressRegexUpper.MatchString(address) || ethAddressRegexLower.MatchString(address) {
return true
}
// checksum validation is blocked by https://github.com/golang/cryp... | go | {
"resource": ""
} |
q21106 | isBitcoinAddress | train | func isBitcoinAddress(fl FieldLevel) bool {
address := fl.Field().String()
if !btcAddressRegex.MatchString(address) {
return false
}
alphabet := []byte("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")
decode := [25]byte{}
for _, n := range []byte(address) {
d := bytes.IndexByte(alphabet, n)
... | go | {
"resource": ""
} |
q21107 | isBitcoinBech32Address | train | func isBitcoinBech32Address(fl FieldLevel) bool {
address := fl.Field().String()
if !btcLowerAddressRegexBech32.MatchString(address) && !btcUpperAddressRegexBech32.MatchString(address) {
return false
}
am := len(address) % 8
if am == 0 || am == 3 || am == 5 {
return false
}
address = strings.ToLower(addr... | go | {
"resource": ""
} |
q21108 | containsRune | train | func containsRune(fl FieldLevel) bool {
r, _ := utf8.DecodeRuneInString(fl.Param())
return strings.ContainsRune(fl.Field().String(), r)
} | go | {
"resource": ""
} |
q21109 | containsAny | train | func containsAny(fl FieldLevel) bool {
return strings.ContainsAny(fl.Field().String(), fl.Param())
} | go | {
"resource": ""
} |
q21110 | contains | train | func contains(fl FieldLevel) bool {
return strings.Contains(fl.Field().String(), fl.Param())
} | go | {
"resource": ""
} |
q21111 | startsWith | train | func startsWith(fl FieldLevel) bool {
return strings.HasPrefix(fl.Field().String(), fl.Param())
} | go | {
"resource": ""
} |
q21112 | endsWith | train | func endsWith(fl FieldLevel) bool {
return strings.HasSuffix(fl.Field().String(), fl.Param())
} | go | {
"resource": ""
} |
q21113 | fieldContains | train | func fieldContains(fl FieldLevel) bool {
field := fl.Field()
currentField, _, ok := fl.GetStructFieldOK()
if !ok {
return false
}
return strings.Contains(field.String(), currentField.String())
} | go | {
"resource": ""
} |
q21114 | fieldExcludes | train | func fieldExcludes(fl FieldLevel) bool {
field := fl.Field()
currentField, _, ok := fl.GetStructFieldOK()
if !ok {
return true
}
return !strings.Contains(field.String(), currentField.String())
} | go | {
"resource": ""
} |
q21115 | isEqCrossStructField | train | func isEqCrossStructField(fl FieldLevel) bool {
field := fl.Field()
kind := field.Kind()
topField, topKind, ok := fl.GetStructFieldOK()
if !ok || topKind != kind {
return false
}
switch kind {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return topField.Int() == field.Int(... | go | {
"resource": ""
} |
q21116 | isEq | train | func isEq(fl FieldLevel) bool {
field := fl.Field()
param := fl.Param()
switch field.Kind() {
case reflect.String:
return field.String() == param
case reflect.Slice, reflect.Map, reflect.Array:
p := asInt(param)
return int64(field.Len()) == p
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int3... | go | {
"resource": ""
} |
q21117 | isURI | train | func isURI(fl FieldLevel) bool {
field := fl.Field()
switch field.Kind() {
case reflect.String:
s := field.String()
// checks needed as of Go 1.6 because of change https://github.com/golang/go/commit/617c93ce740c3c3cc28cdd1a0d712be183d0b328#diff-6c2d018290e298803c0c9419d8739885L195
// emulate browser and ... | go | {
"resource": ""
} |
q21118 | isUrnRFC2141 | train | func isUrnRFC2141(fl FieldLevel) bool {
field := fl.Field()
switch field.Kind() {
case reflect.String:
str := field.String()
_, match := urn.Parse([]byte(str))
return match
}
panic(fmt.Sprintf("Bad field type %T", field.Interface()))
} | go | {
"resource": ""
} |
q21119 | isFile | train | func isFile(fl FieldLevel) bool {
field := fl.Field()
switch field.Kind() {
case reflect.String:
fileInfo, err := os.Stat(field.String())
if err != nil {
return false
}
return !fileInfo.IsDir()
}
panic(fmt.Sprintf("Bad field type %T", field.Interface()))
} | go | {
"resource": ""
} |
q21120 | isNumber | train | func isNumber(fl FieldLevel) bool {
switch fl.Field().Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.Float32, reflect.Float64:
return true
default:
return numberRegex.Match... | go | {
"resource": ""
} |
q21121 | hasValue | train | func hasValue(fl FieldLevel) bool {
field := fl.Field()
switch field.Kind() {
case reflect.Slice, reflect.Map, reflect.Ptr, reflect.Interface, reflect.Chan, reflect.Func:
return !field.IsNil()
default:
if fl.(*validate).fldIsPointer && field.Interface() != nil {
return true
}
return field.IsValid() &... | go | {
"resource": ""
} |
q21122 | isLte | train | func isLte(fl FieldLevel) bool {
field := fl.Field()
param := fl.Param()
switch field.Kind() {
case reflect.String:
p := asInt(param)
return int64(utf8.RuneCountInString(field.String())) <= p
case reflect.Slice, reflect.Map, reflect.Array:
p := asInt(param)
return int64(field.Len()) <= p
case refle... | go | {
"resource": ""
} |
q21123 | isTCP4AddrResolvable | train | func isTCP4AddrResolvable(fl FieldLevel) bool {
if !isIP4Addr(fl) {
return false
}
_, err := net.ResolveTCPAddr("tcp4", fl.Field().String())
return err == nil
} | go | {
"resource": ""
} |
q21124 | isUDPAddrResolvable | train | func isUDPAddrResolvable(fl FieldLevel) bool {
if !isIP4Addr(fl) && !isIP6Addr(fl) {
return false
}
_, err := net.ResolveUDPAddr("udp", fl.Field().String())
return err == nil
} | go | {
"resource": ""
} |
q21125 | isIP4AddrResolvable | train | func isIP4AddrResolvable(fl FieldLevel) bool {
if !isIPv4(fl) {
return false
}
_, err := net.ResolveIPAddr("ip4", fl.Field().String())
return err == nil
} | go | {
"resource": ""
} |
q21126 | isIP6AddrResolvable | train | func isIP6AddrResolvable(fl FieldLevel) bool {
if !isIPv6(fl) {
return false
}
_, err := net.ResolveIPAddr("ip6", fl.Field().String())
return err == nil
} | go | {
"resource": ""
} |
q21127 | isIPAddrResolvable | train | func isIPAddrResolvable(fl FieldLevel) bool {
if !isIP(fl) {
return false
}
_, err := net.ResolveIPAddr("ip", fl.Field().String())
return err == nil
} | go | {
"resource": ""
} |
q21128 | isUnixAddrResolvable | train | func isUnixAddrResolvable(fl FieldLevel) bool {
_, err := net.ResolveUnixAddr("unix", fl.Field().String())
return err == nil
} | go | {
"resource": ""
} |
q21129 | extractTypeInternal | train | func (v *validate) extractTypeInternal(current reflect.Value, nullable bool) (reflect.Value, reflect.Kind, bool) {
BEGIN:
switch current.Kind() {
case reflect.Ptr:
nullable = true
if current.IsNil() {
return current, reflect.Ptr, nullable
}
current = current.Elem()
goto BEGIN
case reflect.Interface... | go | {
"resource": ""
} |
q21130 | asInt | train | func asInt(param string) int64 {
i, err := strconv.ParseInt(param, 0, 64)
panicIf(err)
return i
} | go | {
"resource": ""
} |
q21131 | asUint | train | func asUint(param string) uint64 {
i, err := strconv.ParseUint(param, 0, 64)
panicIf(err)
return i
} | go | {
"resource": ""
} |
q21132 | asFloat | train | func asFloat(param string) float64 {
i, err := strconv.ParseFloat(param, 64)
panicIf(err)
return i
} | go | {
"resource": ""
} |
q21133 | New | train | func New() *Validate {
tc := new(tagCache)
tc.m.Store(make(map[string]*cTag))
sc := new(structCache)
sc.m.Store(make(map[reflect.Type]*cStruct))
v := &Validate{
tagName: defaultTagName,
aliases: make(map[string]string, len(bakedInAliases)),
validations: make(map[string]FuncCtx, len(bakedInValidato... | go | {
"resource": ""
} |
q21134 | RegisterValidationCtx | train | func (v *Validate) RegisterValidationCtx(tag string, fn FuncCtx) error {
return v.registerValidation(tag, fn, false)
} | go | {
"resource": ""
} |
q21135 | RegisterTranslation | train | func (v *Validate) RegisterTranslation(tag string, trans ut.Translator, registerFn RegisterTranslationsFunc, translationFn TranslationFunc) (err error) {
if v.transTagFunc == nil {
v.transTagFunc = make(map[ut.Translator]map[string]TranslationFunc)
}
if err = registerFn(trans); err != nil {
return
}
m, ok :... | go | {
"resource": ""
} |
q21136 | validateStruct | train | func (v *validate) validateStruct(ctx context.Context, parent reflect.Value, current reflect.Value, typ reflect.Type, ns []byte, structNs []byte, ct *cTag) {
cs, ok := v.v.structCache.Get(typ)
if !ok {
cs = v.v.extractStructCache(current, typ.Name())
}
if len(ns) == 0 && len(cs.name) != 0 {
ns = append(ns, c... | go | {
"resource": ""
} |
q21137 | GetStructFieldOK | train | func (v *validate) GetStructFieldOK() (reflect.Value, reflect.Kind, bool) {
return v.getStructFieldOKInternal(v.slflParent, v.ct.param)
} | go | {
"resource": ""
} |
q21138 | Register | train | func (r *ActionResource) Register(container *restful.Container, config smolder.APIConfig, context smolder.APIContextFactory) {
r.Name = "ActionResource"
r.TypeName = "action"
r.Endpoint = "actions"
r.Doc = "Manage actions"
r.Config = config
r.Context = context
r.Init(container, r)
} | go | {
"resource": ""
} |
q21139 | Validate | train | func (r *BeeResource) Validate(context smolder.APIContext, data interface{}, request *restful.Request) error {
// ps := data.(*BeePostStruct)
// FIXME
return nil
} | go | {
"resource": ""
} |
q21140 | RegisterBee | train | func RegisterBee(bee BeeInterface) {
log.Println("Worker bee ready:", bee.Name(), "-", bee.Description())
bees[bee.Name()] = &bee
} | go | {
"resource": ""
} |
q21141 | GetBee | train | func GetBee(identifier string) *BeeInterface {
bee, ok := bees[identifier]
if ok {
return bee
}
return nil
} | go | {
"resource": ""
} |
q21142 | GetBees | train | func GetBees() []*BeeInterface {
r := []*BeeInterface{}
for _, bee := range bees {
r = append(r, bee)
}
return r
} | go | {
"resource": ""
} |
q21143 | startBee | train | func startBee(bee *BeeInterface, fatals int) {
if fatals >= 3 {
log.Println("Terminating evil bee", (*bee).Name(), "after", fatals, "failed tries!")
(*bee).Stop()
return
}
(*bee).WaitGroup().Add(1)
defer (*bee).WaitGroup().Done()
defer func(bee *BeeInterface) {
if e := recover(); e != nil {
log.Printl... | go | {
"resource": ""
} |
q21144 | NewBeeInstance | train | func NewBeeInstance(bee BeeConfig) *BeeInterface {
factory := GetFactory(bee.Class)
if factory == nil {
panic("Unknown bee-class in config file: " + bee.Class)
}
mod := (*factory).New(bee.Name, bee.Description, bee.Options)
RegisterBee(mod)
return &mod
} | go | {
"resource": ""
} |
q21145 | StartBee | train | func StartBee(bee BeeConfig) *BeeInterface {
b := NewBeeInstance(bee)
(*b).Start()
go func(mod *BeeInterface) {
startBee(mod, 0)
}(b)
return b
} | go | {
"resource": ""
} |
q21146 | StartBees | train | func StartBees(beeList []BeeConfig) {
eventsIn = make(chan Event)
go handleEvents()
for _, bee := range beeList {
StartBee(bee)
}
} | go | {
"resource": ""
} |
q21147 | StopBees | train | func StopBees() {
for _, bee := range bees {
log.Println("Stopping bee:", (*bee).Name())
(*bee).Stop()
}
close(eventsIn)
bees = make(map[string]*BeeInterface)
} | go | {
"resource": ""
} |
q21148 | RestartBee | train | func RestartBee(bee *BeeInterface) {
(*bee).Stop()
(*bee).SetSigChan(make(chan bool))
(*bee).Start()
go func(mod *BeeInterface) {
startBee(mod, 0)
}(bee)
} | go | {
"resource": ""
} |
q21149 | NewBee | train | func NewBee(name, factoryName, description string, options []BeeOption) Bee {
c := BeeConfig{
Name: name,
Class: factoryName,
Description: description,
Options: options,
}
b := Bee{
config: c,
SigChan: make(chan bool),
waitGroup: &sync.WaitGroup{},
}
return b
} | go | {
"resource": ""
} |
q21150 | Stop | train | func (bee *Bee) Stop() {
if !bee.IsRunning() {
return
}
log.Println(bee.Name(), "stopping gracefully!")
close(bee.SigChan)
bee.waitGroup.Wait()
bee.Running = false
log.Println(bee.Name(), "stopped gracefully!")
} | go | {
"resource": ""
} |
q21151 | Logln | train | func (bee *Bee) Logln(args ...interface{}) {
a := []interface{}{"[" + bee.Name() + "]:"}
for _, v := range args {
a = append(a, v)
}
log.Println(a...)
Log(bee.Name(), fmt.Sprintln(args...), 0)
} | go | {
"resource": ""
} |
q21152 | Logf | train | func (bee *Bee) Logf(format string, args ...interface{}) {
s := fmt.Sprintf(format, args...)
log.Printf("[%s]: %s", bee.Name(), s)
Log(bee.Name(), s, 0)
} | go | {
"resource": ""
} |
q21153 | LogErrorf | train | func (bee *Bee) LogErrorf(format string, args ...interface{}) {
s := fmt.Sprintf(format, args...)
log.Errorf("[%s]: %s", bee.Name(), s)
Log(bee.Name(), s, 1)
} | go | {
"resource": ""
} |
q21154 | LogFatal | train | func (bee *Bee) LogFatal(args ...interface{}) {
a := []interface{}{"[" + bee.Name() + "]:"}
for _, v := range args {
a = append(a, v)
}
log.Panicln(a...)
Log(bee.Name(), fmt.Sprintln(args...), 2)
} | go | {
"resource": ""
} |
q21155 | handleEvents | train | func handleEvents() {
for {
event, ok := <-eventsIn
if !ok {
log.Println()
log.Println("Stopped event handler!")
break
}
bee := GetBee(event.Bee)
(*bee).LogEvent()
log.Println()
log.Println("Event received:", event.Bee, "/", event.Name, "-", GetEventDescriptor(&event).Description)
for _, v :... | go | {
"resource": ""
} |
q21156 | GetFilter | train | func GetFilter(identifier string) *FilterInterface {
filter, ok := filters[identifier]
if ok {
return filter
}
return nil
} | go | {
"resource": ""
} |
q21157 | AddAction | train | func (r *ActionResponse) AddAction(action *bees.Action) {
r.actions = append(r.actions, action)
r.Actions = append(r.Actions, prepareActionResponse(r.Context, action))
} | go | {
"resource": ""
} |
q21158 | AddLog | train | func (r *LogResponse) AddLog(log *bees.LogMessage) {
r.logs = append(r.logs, log)
r.Logs = append(r.Logs, prepareLogResponse(r.Context, log))
} | go | {
"resource": ""
} |
q21159 | GetAction | train | func GetAction(id string) *Action {
for _, a := range actions {
if a.ID == id {
return &a
}
}
return nil
} | go | {
"resource": ""
} |
q21160 | execAction | train | func execAction(action Action, opts map[string]interface{}) bool {
a := Action{
Bee: action.Bee,
Name: action.Name,
}
for _, opt := range action.Options {
ph := Placeholder{
Name: opt.Name,
}
switch opt.Value.(type) {
case string:
var value bytes.Buffer
tmpl, err := template.New(action.Bee +... | go | {
"resource": ""
} |
q21161 | NewAPIContext | train | func (context *APIContext) NewAPIContext() smolder.APIContext {
ctx := &APIContext{
Config: context.Config,
}
return ctx
} | go | {
"resource": ""
} |
q21162 | SetValue | train | func (ph *Placeholders) SetValue(name string, _type string, value interface{}) {
if ph.Value(name) == nil {
p := Placeholder{
Name: name,
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].V... | go | {
"resource": ""
} |
q21163 | Value | train | func (ph Placeholders) Value(name string) interface{} {
for _, p := range ph {
if p.Name == name {
return p.Value
}
}
return nil
} | go | {
"resource": ""
} |
q21164 | Bind | train | func (ph Placeholders) Bind(name string, dst interface{}) error {
v := ph.Value(name)
if v == nil {
return errors.New("Placeholder with name " + name + " not found")
}
return ConvertValue(v, dst)
} | go | {
"resource": ""
} |
q21165 | GetActionDescriptor | train | func GetActionDescriptor(action *Action) ActionDescriptor {
bee := GetBee(action.Bee)
if bee == nil {
panic("Bee " + action.Bee + " not registered")
}
factory := (*GetFactory((*bee).Namespace()))
for _, ac := range factory.Actions() {
if ac.Name == action.Name {
return ac
}
}
return ActionDescriptor{}
... | go | {
"resource": ""
} |
q21166 | GetEventDescriptor | train | func GetEventDescriptor(event *Event) EventDescriptor {
bee := GetBee(event.Bee)
if bee == nil {
panic("Bee " + event.Bee + " not registered")
}
factory := (*GetFactory((*bee).Namespace()))
for _, ev := range factory.Events() {
if ev.Name == event.Name {
return ev
}
}
return EventDescriptor{}
} | go | {
"resource": ""
} |
q21167 | States | train | func (factory *IrcBeeFactory) States() []bees.StateDescriptor {
opts := []bees.StateDescriptor{
{
Name: "connected",
Description: "Whether this bee is currently connected to IRC",
Type: "bool",
},
{
Name: "channels",
Description: "Which channels this bee is currently connected... | go | {
"resource": ""
} |
q21168 | AddChain | train | func (r *ChainResponse) AddChain(chain bees.Chain) {
r.chains[chain.Name] = &chain
} | go | {
"resource": ""
} |
q21169 | checkValues | train | func (c *crontime) checkValues() {
for _, sec := range c.second {
if sec >= 60 || sec < 0 {
log.Panicln("Cronbee: Your config seems messed up. Check the range of \"Second\".")
}
}
for _, min := range c.second {
if min >= 60 || min < 0 {
log.Panicln("Cronbee: Your config seems messed up. Check the range ... | go | {
"resource": ""
} |
q21170 | valueRange | train | func valueRange(a, b, base int) []int {
value := make([]int, absoluteOverBreakpoint(a, b, base)+1)
i := 0
for ; a != b; a++ {
if a == base {
a = 0
}
value[i] = a
i++
}
value[i] = a
return value
} | go | {
"resource": ""
} |
q21171 | NewLogMessage | train | func NewLogMessage(bee string, message string, messageType uint) LogMessage {
return LogMessage{
ID: UUID(),
Bee: bee,
Message: message,
MessageType: messageType,
Timestamp: time.Now(),
}
} | go | {
"resource": ""
} |
q21172 | Log | train | func Log(bee string, message string, messageType uint) {
logMutex.Lock()
defer logMutex.Unlock()
logs[bee] = append(logs[bee], NewLogMessage(bee, message, messageType))
} | go | {
"resource": ""
} |
q21173 | GetLogs | train | func GetLogs(bee string) []LogMessage {
r := []LogMessage{}
logMutex.RLock()
for b, ls := range logs {
if len(bee) == 0 || bee == b {
for _, l := range ls {
r = append(r, l)
}
}
}
logMutex.RUnlock()
sort.Sort(LogSorter(r))
return r
} | go | {
"resource": ""
} |
q21174 | Colored | train | func Colored(val string, color string) string {
// 00 white 01 black 02 blue (navy) 03 green 04 red 05 brown (maroon)
// 06 purple 07 orange (olive) 08 yellow 09 light green (lime)
// 10 teal (a green/blue cyan) 11 light cyan (cyan) (aqua) 12 light blue (royal)
// 13 pink (light purple) (fuchsia) 14 grey 15 light g... | go | {
"resource": ""
} |
q21175 | Value | train | func (opts BeeOptions) Value(name string) interface{} {
for _, opt := range opts {
if opt.Name == name {
return opt.Value
}
}
return nil
} | go | {
"resource": ""
} |
q21176 | Bind | train | func (opts BeeOptions) Bind(name string, dst interface{}) error {
v := opts.Value(name)
if v == nil {
return errors.New("Option with name " + name + " not found")
}
return ConvertValue(v, dst)
} | go | {
"resource": ""
} |
q21177 | getAPIKey | train | func getAPIKey(options *bees.BeeOptions) string {
var apiKey string
options.Bind("api_key", &apiKey)
if strings.HasPrefix(apiKey, "file://") {
buf, err := ioutil.ReadFile(strings.TrimPrefix(apiKey, "file://"))
if err != nil {
panic("Error reading API key file " + apiKey)
}
apiKey = string(buf)
}
if st... | go | {
"resource": ""
} |
q21178 | NewBeeConfig | train | func NewBeeConfig(name, class, description string, options BeeOptions) (BeeConfig, error) {
if len(name) == 0 {
return BeeConfig{}, errors.New("A Bee's name can't be empty")
}
b := GetBee(name)
if b != nil {
return BeeConfig{}, errors.New("A Bee with that name already exists")
}
f := GetFactory(class)
if f... | go | {
"resource": ""
} |
q21179 | BeeConfigs | train | func BeeConfigs() []BeeConfig {
bs := []BeeConfig{}
for _, b := range bees {
bs = append(bs, (*b).Config())
}
return bs
} | go | {
"resource": ""
} |
q21180 | execFilter | train | func execFilter(filter string, opts map[string]interface{}) bool {
f := *filters.GetFilter("template")
log.Println("\tExecuting filter:", filter)
defer func() {
if e := recover(); e != nil {
log.Println("Fatal filter event:", e)
}
}()
return f.Passes(opts, filter)
} | go | {
"resource": ""
} |
q21181 | TriggerWeatherInformationEvent | train | func (mod *OpenweathermapBee) TriggerWeatherInformationEvent(v *owm.Weather) {
weather := bees.Event{
Bee: mod.Name(),
Name: "main_weather",
Options: []bees.Placeholder{
{
Name: "id",
Type: "int",
Value: v.ID,
},
{
Name: "main",
Type: "string",
Value: v.Main,
},
{
... | go | {
"resource": ""
} |
q21182 | Passes | train | func (filter *TemplateFilter) Passes(data interface{}, value interface{}) bool {
switch v := value.(type) {
case string:
var res bytes.Buffer
if strings.Index(v, "{{test") >= 0 {
v = strings.Replace(v, "{{test", "{{if", -1)
v += "true{{end}}"
}
tmpl, err := template.New("_" + v).Funcs(templatehelper.F... | go | {
"resource": ""
} |
q21183 | AddHive | train | func (r *HiveResponse) AddHive(hive *bees.BeeFactoryInterface) {
r.hives[(*hive).Name()] = hive
} | go | {
"resource": ""
} |
q21184 | AddBee | train | func (r *BeeResponse) AddBee(bee *bees.BeeInterface) {
r.bees[(*bee).Name()] = bee
hive := bees.GetFactory((*bee).Namespace())
if hive == nil {
panic("Hive for Bee not found")
}
r.hives[(*hive).Name()] = hive
r.Hives = append(r.Hives, hives.PrepareHiveResponse(r.Context, hive))
} | go | {
"resource": ""
} |
q21185 | Run | train | func Run() {
// to see what happens in the package, uncomment the following
//restful.TraceLogger(log.New(os.Stdout, "[restful] ", log.LstdFlags|log.Lshortfile))
// Setup web-service
smolderConfig := smolder.APIConfig{
BaseURL: canonicalURL,
PathPrefix: "v1/",
}
context := &context.APIContext{
Config: s... | go | {
"resource": ""
} |
q21186 | DurationUntilNextEvent | train | func (c *crontime) DurationUntilNextEvent() time.Duration {
return c.nextEvent().Sub(time.Now())
} | go | {
"resource": ""
} |
q21187 | calculateEvent | train | func (c *crontime) calculateEvent(baseTime time.Time) time.Time {
c.calculationInProgress = true
defer c.setCalculationInProgress(false)
baseTime = setNanoecond(baseTime, 10000)
c.calculatedTime = baseTime // Ignore all Events in the Past & initial 'result'
//c.calculatedTime = setNanoecond(c.calculatedTime, 10000... | go | {
"resource": ""
} |
q21188 | nextValidMonth | train | func (c *crontime) nextValidMonth(baseTime time.Time) {
for _, mon := range c.month {
if mon >= int(c.calculatedTime.Month()) {
//log.Print("Inside Month", mon, c.calculatedTime)
c.calculatedTime = setMonth(c.calculatedTime, mon)
//log.Println(" :: and out", c.calculatedTime)
return
}
}
// If no resu... | go | {
"resource": ""
} |
q21189 | nextValidDay | train | func (c *crontime) nextValidDay(baseTime time.Time) {
for _, dom := range c.dom {
if dom >= c.calculatedTime.Day() {
for _, dow := range c.dow {
if monthHasDow(dow, dom, int(c.calculatedTime.Month()), c.calculatedTime.Year()) {
c.calculatedTime = setDay(c.calculatedTime, dom)
//log.Println("Cronbee:... | go | {
"resource": ""
} |
q21190 | nextValidHour | train | func (c *crontime) nextValidHour(baseTime time.Time) {
for _, hour := range c.hour {
if c.calculatedTime.Day() == baseTime.Day() {
if !hasPassed(hour, c.calculatedTime.Hour()) {
c.calculatedTime = setHour(c.calculatedTime, hour)
return
}
} else {
c.calculatedTime = setHour(c.calculatedTime, hour)
... | go | {
"resource": ""
} |
q21191 | nextValidMinute | train | func (c *crontime) nextValidMinute(baseTime time.Time) {
for _, min := range c.minute {
if c.calculatedTime.Hour() == baseTime.Hour() {
if !hasPassed(min, c.calculatedTime.Minute()) {
c.calculatedTime = setMinute(c.calculatedTime, min)
return
}
} else {
c.calculatedTime = setMinute(c.calculatedTim... | go | {
"resource": ""
} |
q21192 | nextValidSecond | train | func (c *crontime) nextValidSecond(baseTime time.Time) {
for _, sec := range c.second {
if !c.minuteHasPassed(baseTime) {
// check if sec is in the past. <= prevents triggering the same event twice
if sec > c.calculatedTime.Second() {
c.calculatedTime = setSecond(c.calculatedTime, sec)
return
}
} ... | go | {
"resource": ""
} |
q21193 | GetFactory | train | func GetFactory(identifier string) *BeeFactoryInterface {
factory, ok := factories[identifier]
if ok {
return factory
}
return nil
} | go | {
"resource": ""
} |
q21194 | GetFactories | train | func GetFactories() []*BeeFactoryInterface {
r := []*BeeFactoryInterface{}
for _, factory := range factories {
r = append(r, factory)
}
return r
} | go | {
"resource": ""
} |
q21195 | GetChain | train | func GetChain(id string) *Chain {
for _, c := range chains {
if c.Name == id {
return &c
}
}
return nil
} | go | {
"resource": ""
} |
q21196 | SetChains | train | func SetChains(cs []Chain) {
newcs := []Chain{}
// migrate old chain style
for _, c := range cs {
for _, el := range c.Elements {
if el.Action.Name != "" {
el.Action.ID = UUID()
c.Actions = append(c.Actions, el.Action.ID)
actions = append(actions, el.Action)
}
if el.Filter.Name != "" {
//F... | go | {
"resource": ""
} |
q21197 | execChains | train | func execChains(event *Event) {
for _, c := range chains {
if c.Event.Name != event.Name || c.Event.Bee != event.Bee {
continue
}
m := make(map[string]interface{})
for _, opt := range event.Options {
m[opt.Name] = opt.Value
}
ctx.FillMap(m)
failed := false
log.Println("Executing chain:", c.Name... | go | {
"resource": ""
} |
q21198 | AddFlags | train | func AddFlags(flags []CliFlag) {
for _, flag := range flags {
appflags = append(appflags, flag)
}
} | go | {
"resource": ""
} |
q21199 | Run | train | func Run() {
for _, f := range appflags {
switch f.Value.(type) {
case string:
flag.StringVar((f.V).(*string), f.Name, f.Value.(string), f.Desc)
case bool:
flag.BoolVar((f.V).(*bool), f.Name, f.Value.(bool), f.Desc)
}
}
flag.Parse()
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.