id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c7500 | defer p.Unlock()
p.ips = l
} | |
c7501 | defer p.Unlock()
return p.exposedServices
} | |
c7502 | defer p.Unlock()
return p.dependentServices
} | |
c7503 |
p.Lock()
defer p.Unlock()
return strconv.Itoa(p.servicesListeningPort)
} | |
c7504 |
defer p.Unlock()
p.DNSACLs = make(DNSRuleList, len(networks))
copy(p.DNSACLs, networks)
} | |
c7505 | {
p.Lock()
defer p.Unlock()
p.servicesCertificate = cert
p.servicesPrivateKey = key
} | |
c7506 | p.servicesCertificate, p.servicesPrivateKey, p.servicesCA
} | |
c7507 | defer p.Unlock()
return p.scopes
} | |
c7508 | ServicesListeningPort: p.servicesListeningPort,
ExposedServices: p.exposedServices,
DependentServices: p.dependentServices,
Scopes: p.scopes,
ServicesCA: p.servicesCA,
ServicesCertificate: p.servicesCertificate,
ServicesPrivateKey: p.servicesPrivateKey,
}
} | |
c7509 |
receiverRules: p.ReceiverRules.Copy(),
annotations: p.Annotations.Copy(),
identity: p.Identity.Copy(),
ips: p.IPs.Copy(),
servicesListeningPort: p.ServicesListeningPort,
exposedServices: exposedServices,
dependentServices: p.DependentServices,
... | |
c7510 | url.Parse("https://" + targetAddress + ":" + strconv.Itoa(int(network.Ports.Min)))
if err != nil {
return nil, fmt.Errorf("Invalid URL for secrets service")
}
return &GenericSecretsDriver{
transport: &http.Transport{
TLSClientConfig: &tls.Config{
RootCAs: caPool,
},
},
token: token,
targetU... | |
c7511 | = k.targetURL.Host
r.URL = k.targetURL
r.Header.Add("Authorization", "Bearer "+k.token)
return nil
} | |
c7512 | // From reflect: If v's Kind is Func, the returned pointer is an underlying code pointer, but not necessarily enough to identify a single function uniquely.
return false
}
return true
}
switch value1 := v1.(type) {
case error:
switch value2 := v2.(type) {
case error:
return value1.Error() == value2.... | |
c7513 | RunContext(context.Background(), stmt, env)
} | |
c7514 |
if runInfo.err == ErrReturn {
runInfo.err = nil
}
return runInfo.rv.Interface(), runInfo.err
} | |
c7515 |
return &Error{Message: err.Error(), Pos: ast.Position{Line: 1, Column: 1}}
}
return &Error{Message: err.Error(), Pos: pos.Position()}
} | |
c7516 | ast.Position{Line: 1, Column: 1}}
}
return &Error{Message: err, Pos: pos.Position()}
} | |
c7517 | != nil {
// if LHS is a float, e.g. "1.2", we need to set lhsV to a float64
lhsF, err := tryToFloat64(lhsV)
if err != nil {
return false
}
lhsV = reflect.ValueOf(lhsF)
} else {
lhsV = reflect.ValueOf(lhsI)
}
}
if isNum(lhsV) && isNum(rhsV) {
return fmt.Sprintf("%v", lhsV) == fmt.Sprintf(... | |
c7518 | } else {
return nilValue, newStringError(expr, "invalid type conversion")
}
}
return lhsV, nil
}
if (leftHasSubArray || lhsT == interfaceType) && (rightHasSubArray || rhsT == interfaceType) {
for i := 0; i < rhsV.Len(); i++ {
value := rhsV.Index(i)
if rhsT == interfaceType {
value = value.El... | |
c7519 |
return kind1
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
switch kind2 {
case reflect.String, reflect.Float64, reflect.Float32:
return kind2
}
}
return kind1
} | |
c7520 | == reflect.String {
return v.String()
}
return fmt.Sprint(v.Interface())
} | |
c7521 | _ := tryToBool(v)
return b
} | |
c7522 | _ := tryToFloat64(v)
return f
} | |
c7523 | _ := tryToInt64(v)
return i
} | |
c7524 | _ := tryToInt(v)
return i
} | |
c7525 | <= 'f') || ('A' <= ch && ch <= 'F')
} | |
c7526 | EOF
}
return s.src[s.offset]
} | |
c7527 | == '\n' {
s.lineHead = s.offset + 1
s.line++
}
s.offset++
}
} | |
c7528 | Column: s.offset - s.lineHead + 1}
} | |
c7529 | }
ret = append(ret, s.peek())
s.next()
}
return string(ret), nil
} | |
c7530 |
s.next()
// check if + or -
if s.peek() == '+' || s.peek() == '-' {
// add e with + or -
result = append(result, 'e')
result = append(result, s.peek())
s.next()
} else {
// add e, but next char not + or -
result = append(result, 'e')
}
continue
}
// not dig... | |
c7531 | {
s.next()
break
}
ret = append(ret, s.peek())
}
return string(ret), nil
} | |
c7532 | s.peek() {
case 'b':
ret = append(ret, '\b')
continue
case 'f':
ret = append(ret, '\f')
continue
case 'r':
ret = append(ret, '\r')
continue
case 'n':
ret = append(ret, '\n')
continue
case 't':
ret = append(ret, '\t')
continue
}
ret = append(ret, s.peek())
... | |
c7533 | = ast.Token{Tok: tok, Lit: lit}
lval.tok.SetPosition(pos)
l.lit = lit
l.pos = pos
return tok
} | |
c7534 | Pos: l.pos, Fatal: false}
} | |
c7535 | return nil, l.e
}
return l.stmt, l.e
} | |
c7536 | src: []rune(src),
}
return Parse(scanner)
} | |
c7537 | types, ok := PackageTypes[source]
if ok {
for typeName, typeValue := range types {
err = pack.DefineType(typeName, typeValue)
if err != nil {
panic(fmt.Sprintf("import DefineType error: %v", err))
}
}
}
return pack
})
} | |
c7538 | {
interfaceSlice = append(interfaceSlice, value.Interface())
} else {
interfaceSlice = append(interfaceSlice, nil)
}
}
return reflect.ValueOf(interfaceSlice)
} | |
c7539 | return rv, err
}
// need to make a new value to be able to set it
ptrV, err := makeValue(rt)
if err != nil {
return rv, err
}
// set value and return new pointer
ptrV.Elem().Set(value)
return ptrV, nil
}
}
if rv.Type() == interfaceType {
if rv.IsNil() {
// return nil of correct typ... | |
c7540 | {
v, err = convertReflectValueToType(rv.Index(i), rtElemType)
if err != nil {
return rv, err
}
value.Index(i).Set(v)
}
// return new converted slice or array
return value, nil
} | |
c7541 | ERROR: type should be string, got " https://github.com/golang/go/issues/11104\n\t// In the mean time using MapKeys, which will costly for large maps.\n\tmapKeys := rv.MapKeys()\n\tfor i := 0; i < len(mapKeys); i++ {\n\t\tnewKey, err := convertReflectValueToType(mapKeys[i], rtKey)\n\t\tif err != nil {\n\t\t\treturn rv, err\n\t\t}\n\t\tvalue := rv.MapIndex(mapKeys[i])\n\t\tvalue, err = convertReflectValueToType(value, rtElem)\n\t\tif err != nil {\n\t\t\treturn rv, err\n\t\t}\n\t\tnewMap.SetMapIndex(newKey, value)\n\t}\n\n\treturn newMap, nil\n}" | |
c7542 | wants more than one return value
// make sure we have a slice/array with enought values
if rv.Kind() != reflect.Slice && rv.Kind() != reflect.Array {
panic(fmt.Sprintf("function wants %v return values but received %v", rt.NumOut(), rv.Kind().String()))
}
if rv.Len() < rt.NumOut() {
panic(fmt.Sprintf("fu... | |
c7543 | len(from); i++ {
v := reflect.ValueOf(from[i])
if v.IsValid() && v.Type().ConvertibleTo(tt) {
val.Set(v.Convert(tt))
} else {
val.Set(reflect.Zero(tt))
}
slice.Index(i).Set(val)
}
// Ok now assign our slice to the target pointer
obj.Set(slice)
} | |
c7544 | i < len(funcExpr.Params)-1; i++ {
runInfo.rv = in[i+1].Interface().(reflect.Value)
runInfo.env.defineValue(funcExpr.Params[i], runInfo.rv)
}
// add last Params to newEnv
if len(funcExpr.Params) > 0 {
if funcExpr.VarArg {
// function is variadic, add last Params to newEnv without convert to Interface... | |
c7545 | newStringError(anonCallExpr, "cannot call type "+runInfo.rv.Kind().String())
runInfo.rv = nilValue
return
}
runInfo.expr = &ast.CallExpr{Func: runInfo.rv, SubExprs: anonCallExpr.SubExprs, VarArg: anonCallExpr.VarArg, Go: anonCallExpr.Go}
runInfo.invokeExpr()
} | |
c7546 | != reflectValueType {
return false
}
}
for i := 1; i < rt.NumIn()-1; i++ {
if rt.In(i) != reflectValueType {
return false
}
}
}
return true
} | |
c7547 | make(map[string]reflect.Type),
parent: nil,
}
} | |
c7548 | make(map[string]reflect.Type),
parent: e,
name: e.name,
}
} | |
c7549 | make(map[string]reflect.Type),
parent: nil,
name: n,
}
} | |
c7550 | {
err = pack.DefineType(typeName, typeValue)
if err != nil {
return pack, err
}
}
// can ignore error from Define because of check at the start of the function
e.Define(name, pack)
return pack, nil
} | |
c7551 | make(map[string]reflect.Type),
parent: e,
name: n,
}
e.Define(n, m)
return m
} | |
c7552 | e.name = n
e.Unlock()
} | |
c7553 | e.RUnlock()
return e.name
} | |
c7554 | }
return nilValue, fmt.Errorf("unaddressable")
}
}
if e.parent == nil {
return nilValue, fmt.Errorf("undefined symbol '%s'", k)
}
return e.parent.Addr(k)
} | |
c7555 | err := e.external.Type(k)
if err == nil {
return v, nil
}
}
if e.parent == nil {
if v, ok := basicTypes[k]; ok {
return v, nil
}
return nilType, fmt.Errorf("undefined type '%s'", k)
}
return e.parent.Type(k)
} | |
c7556 | err := e.get(k)
return rv.Interface(), err
} | |
c7557 |
return e.setValue(k, reflect.ValueOf(v))
} | |
c7558 | e = e.parent
}
return e.Define(k, v)
} | |
c7559 | e = e.parent
}
return e.defineValue(k, v)
} | |
c7560 |
return e.defineValue(k, reflect.ValueOf(v))
} | |
c7561 | ".") {
return fmt.Errorf("unknown symbol '%s'", k)
}
e.Lock()
e.env[k] = v
e.Unlock()
return nil
} | |
c7562 |
e.Lock()
delete(e.env, k)
e.Unlock()
return nil
} | |
c7563 | }
e.RLock()
_, ok := e.env[k]
e.RUnlock()
if ok {
return e.Delete(k)
}
return e.parent.DeleteGlobal(k)
} | |
c7564 | e = e.parent
}
return e.DefineType(k, t)
} | |
c7565 | e = e.parent
}
return e.DefineReflectType(k, t)
} | |
c7566 | if !ok {
typ = reflect.TypeOf(t)
}
}
return e.DefineReflectType(k, typ)
} | |
c7567 | ".") {
return fmt.Errorf("unknown symbol '%s'", k)
}
e.Lock()
e.typ[k] = t
e.Unlock()
return nil
} | |
c7568 | e.RUnlock()
return e.name
} | |
c7569 | := range e.env {
fmt.Printf("%v = %#v\n", k, v)
}
e.RUnlock()
} | |
c7570 | e.ExecuteContext(context.Background(), src)
} | |
c7571 | != nil {
return nilValue, err
}
return RunContext(ctx, stmt, e)
} | |
c7572 | ast.Stmt) (interface{}, error) {
return RunContext(ctx, stmt, e)
} | |
c7573 | := range e.env {
copy.env[name] = value
}
for name, typ := range e.typ {
copy.typ[name] = typ
}
return ©
} | |
c7574 | copy.parent != nil {
copy.parent = copy.parent.DeepCopy()
}
return copy
} | |
c7575 | append(c.AllowMethods, methods...)
} | |
c7576 | append(c.AllowHeaders, headers...)
} | |
c7577 | append(c.ExposeHeaders, headers...)
} | |
c7578 |
return nil
} else if !strings.Contains(origin, "*") && !c.validateAllowedSchemas(origin) {
return errors.New("bad origin: origins must contain '*' or include " + strings.Join(c.getAllowedSchemas(), ","))
}
}
return nil
} | |
c7579 | "Content-Length", "Content-Type"},
AllowCredentials: false,
MaxAge: 12 * time.Hour,
}
} | |
c7580 |
config.AllowAllOrigins = true
return New(config)
} | |
c7581 | *gin.Context) {
cors.applyCors(c)
}
} | |
c7582 | p.memProfileRate = rate
p.mode = memMode
}
} | |
c7583 | called close
return
}
p.closer()
atomic.StoreUint32(&started, 0)
} | |
c7584 | maxSlack: -10 * time.Second / time.Duration(rate),
}
for _, opt := range opts {
opt(l)
}
if l.clock == nil {
l.clock = clock.New()
}
return l
} | |
c7585 |
regconv: make(map[reflect.Type]Converter),
tag: "schema",
}
return &c
} | |
c7586 | c.regconv[reflect.TypeOf(value)] = converterFunc
} | |
c7587 |
if info == nil {
info = c.create(t, "")
c.l.Lock()
c.m[t] = info
c.l.Unlock()
}
return info
} | |
c7588 | []*structInfo{info}
others = append(others, anonymousInfos[:i]...)
others = append(others, anonymousInfos[i+1:]...)
for _, f := range a.fields {
if !containsAlias(others, f.alias) {
info.fields = append(info.fields, f)
}
}
}
return info
} | |
c7589 | = ft.Kind() == reflect.Struct; !isStruct {
if c.converter(ft) == nil && builtinConverters[ft.Kind()] == nil {
// Type is not supported.
return nil
}
}
return &fieldInfo{
typ: field.Type,
name: field.Name,
alias: alias,
canonicalAlias: canonicalAlias,
unmarsh... | |
c7590 |
return c.regconv[t]
} | |
c7591 | alias, options = parseTag(tag)
}
if alias == "" {
alias = field.Name
}
return alias, options
} | |
c7592 | strings.Split(tag, ",")
return s[0], s[1:]
} | |
c7593 | s == option {
return true
}
}
return false
} | |
c7594 | d.cache.registerConverter(value, converterFunc)
} | |
c7595 | {
if isEmptyFields(fields, src) {
errs[key] = EmptyFieldError{Key: key}
}
}
return errs
} | |
c7596 | fm, ferrs := d.findRequiredFields(f.typ, fcprefix, fspath+".")
for key, fields := range fm {
m[key] = append(m[key], fields...)
}
errs.merge(ferrs)
}
}
if f.isRequired {
key := canonicalPrefix + f.canonicalAlias
m[key] = append(m[key], fieldWithPrefix{
fieldInfo: f,
prefix: se... | |
c7597 | {
for _, path := range f.paths(f.prefix) {
if !isEmpty(f.typ, src[path]) {
return false
}
}
}
return true
} | |
c7598 | float32Type, float64Type, intType, int8Type, int32Type, int64Type, stringType, uint8Type, uint16Type, uint32Type, uint64Type:
return len(value[0]) == 0
}
return false
} | |
c7599 | make(map[reflect.Type]encoderFunc)}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.