_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q7500 | SetIPAddresses | train | func (p *PUPolicy) SetIPAddresses(l ExtendedMap) {
p.Lock()
defer p.Unlock()
p.ips = l
} | go | {
"resource": ""
} |
q7501 | ExposedServices | train | func (p *PUPolicy) ExposedServices() ApplicationServicesList {
p.Lock()
defer p.Unlock()
return p.exposedServices
} | go | {
"resource": ""
} |
q7502 | DependentServices | train | func (p *PUPolicy) DependentServices() ApplicationServicesList {
p.Lock()
defer p.Unlock()
return p.dependentServices
} | go | {
"resource": ""
} |
q7503 | ServicesListeningPort | train | func (p *PUPolicy) ServicesListeningPort() string {
p.Lock()
defer p.Unlock()
return strconv.Itoa(p.servicesListeningPort)
} | go | {
"resource": ""
} |
q7504 | UpdateDNSNetworks | train | func (p *PUPolicy) UpdateDNSNetworks(networks DNSRuleList) {
p.Lock()
defer p.Unlock()
p.DNSACLs = make(DNSRuleList, len(networks))
copy(p.DNSACLs, networks)
} | go | {
"resource": ""
} |
q7505 | UpdateServiceCertificates | train | func (p *PUPolicy) UpdateServiceCertificates(cert, key string) {
p.Lock()
defer p.Unlock()
p.servicesCertificate = cert
p.servicesPrivateKey = key
} | go | {
"resource": ""
} |
q7506 | ServiceCertificates | train | func (p *PUPolicy) ServiceCertificates() (string, string, string) {
p.Lock()
defer p.Unlock()
return p.servicesCertificate, p.servicesPrivateKey, p.servicesCA
} | go | {
"resource": ""
} |
q7507 | Scopes | train | func (p *PUPolicy) Scopes() []string {
p.Lock()
defer p.Unlock()
return p.scopes
} | go | {
"resource": ""
} |
q7508 | ToPublicPolicy | train | func (p *PUPolicy) ToPublicPolicy() *PUPolicyPublic {
p.Lock()
defer p.Unlock()
return &PUPolicyPublic{
ManagementID: p.managementID,
TriremeAction: p.triremeAction,
ApplicationACLs: p.applicationACLs.Copy(),
NetworkACLs: p.networkACLs.Copy(),
DNSACLs: p.DNSACLs.Copy(),
TransmitterRules: p.transmitterRules.Copy(),
ReceiverRules: p.receiverRules.Copy(),
Annotations: p.annotations.Copy(),
Identity: p.identity.Copy(),
IPs: p.ips.Copy(),
ServicesListeningPort: p.servicesListeningPort,
ExposedServices: p.exposedServices,
DependentServices: p.dependentServices,
Scopes: p.scopes,
ServicesCA: p.servicesCA,
ServicesCertificate: p.servicesCertificate,
ServicesPrivateKey: p.servicesPrivateKey,
}
} | go | {
"resource": ""
} |
q7509 | ToPrivatePolicy | train | func (p *PUPolicyPublic) ToPrivatePolicy(convert bool) (*PUPolicy, error) {
var err error
exposedServices := ApplicationServicesList{}
for _, e := range p.ExposedServices {
if convert {
e.UserAuthorizationHandler, err = usertokens.NewVerifier(e.UserAuthorizationHandler)
if err != nil {
return nil, fmt.Errorf("unable to initialize user authorization handler for service: %s - error %s", e.ID, err)
}
}
exposedServices = append(exposedServices, e)
}
return &PUPolicy{
managementID: p.ManagementID,
triremeAction: p.TriremeAction,
applicationACLs: p.ApplicationACLs,
networkACLs: p.NetworkACLs.Copy(),
DNSACLs: p.DNSACLs.Copy(),
transmitterRules: p.TransmitterRules.Copy(),
receiverRules: p.ReceiverRules.Copy(),
annotations: p.Annotations.Copy(),
identity: p.Identity.Copy(),
ips: p.IPs.Copy(),
servicesListeningPort: p.ServicesListeningPort,
exposedServices: exposedServices,
dependentServices: p.DependentServices,
scopes: p.Scopes,
servicesCA: p.ServicesCA,
servicesCertificate: p.ServicesCertificate,
servicesPrivateKey: p.ServicesPrivateKey,
}, nil
} | go | {
"resource": ""
} |
q7510 | NewGenericSecretsDriver | train | func NewGenericSecretsDriver(ca []byte, token string, network *common.Service) (SecretsDriver, error) {
caPool := x509.NewCertPool()
if !caPool.AppendCertsFromPEM(ca) {
return nil, fmt.Errorf("No valid CA provided")
}
targetAddress := ""
if len(network.FQDNs) > 0 {
targetAddress = network.FQDNs[0]
} else if len(network.Addresses) > 0 {
targetAddress = network.Addresses[0].IP.String()
} else {
return nil, fmt.Errorf("No valid target")
}
if network.Ports.Min == 0 {
return nil, fmt.Errorf("Invalid port specification")
}
targetURL, err := 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,
targetURL: targetURL,
}, nil
} | go | {
"resource": ""
} |
q7511 | Transform | train | func (k *GenericSecretsDriver) Transform(r *http.Request) error {
r.Host = k.targetURL.Host
r.URL = k.targetURL
r.Header.Add("Authorization", "Bearer "+k.token)
return nil
} | go | {
"resource": ""
} |
q7512 | ValueEqual | train | func ValueEqual(v1 interface{}, v2 interface{}) bool {
v1RV := reflect.ValueOf(v1)
switch v1RV.Kind() {
case reflect.Func:
// This is best effort to check if functions match, but it could be wrong
v2RV := reflect.ValueOf(v2)
if !v1RV.IsValid() || !v2RV.IsValid() {
if v1RV.IsValid() != !v2RV.IsValid() {
return false
}
return true
} else if v1RV.Kind() != v2RV.Kind() {
return false
} else if v1RV.Type() != v2RV.Type() {
return false
} else if v1RV.Pointer() != v2RV.Pointer() {
// 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.Error()
}
}
return reflect.DeepEqual(v1, v2)
} | go | {
"resource": ""
} |
q7513 | Run | train | func Run(stmt ast.Stmt, env *Env) (interface{}, error) {
return RunContext(context.Background(), stmt, env)
} | go | {
"resource": ""
} |
q7514 | RunContext | train | func RunContext(ctx context.Context, stmt ast.Stmt, env *Env) (interface{}, error) {
runInfo := runInfoStruct{ctx: ctx, env: env, stmt: stmt, rv: nilValue}
runInfo.runSingleStmt()
if runInfo.err == ErrReturn {
runInfo.err = nil
}
return runInfo.rv.Interface(), runInfo.err
} | go | {
"resource": ""
} |
q7515 | newError | train | func newError(pos ast.Pos, err error) error {
if err == nil {
return nil
}
if pos == nil {
return &Error{Message: err.Error(), Pos: ast.Position{Line: 1, Column: 1}}
}
return &Error{Message: err.Error(), Pos: pos.Position()}
} | go | {
"resource": ""
} |
q7516 | newStringError | train | func newStringError(pos ast.Pos, err string) error {
if err == "" {
return nil
}
if pos == nil {
return &Error{Message: err, Pos: ast.Position{Line: 1, Column: 1}}
}
return &Error{Message: err, Pos: pos.Position()}
} | go | {
"resource": ""
} |
q7517 | equal | train | func equal(lhsV, rhsV reflect.Value) bool {
lhsIsNil, rhsIsNil := isNil(lhsV), isNil(rhsV)
if lhsIsNil && rhsIsNil {
return true
}
if (!lhsIsNil && rhsIsNil) || (lhsIsNil && !rhsIsNil) {
return false
}
if lhsV.Kind() == reflect.Interface || lhsV.Kind() == reflect.Ptr {
lhsV = lhsV.Elem()
}
if rhsV.Kind() == reflect.Interface || rhsV.Kind() == reflect.Ptr {
rhsV = rhsV.Elem()
}
// Compare a string and a number.
// This will attempt to convert the string to a number,
// while leaving the other side alone. Code further
// down takes care of converting ints and floats as needed.
if isNum(lhsV) && rhsV.Kind() == reflect.String {
rhsF, err := tryToFloat64(rhsV)
if err != nil {
// Couldn't convert RHS to a float, they can't be compared.
return false
}
rhsV = reflect.ValueOf(rhsF)
} else if lhsV.Kind() == reflect.String && isNum(rhsV) {
// If the LHS is a string formatted as an int, try that before trying float
lhsI, err := tryToInt64(lhsV)
if err != 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("%v", rhsV)
}
// Try to compare bools to strings and numbers
if lhsV.Kind() == reflect.Bool || rhsV.Kind() == reflect.Bool {
lhsB, err := tryToBool(lhsV)
if err != nil {
return false
}
rhsB, err := tryToBool(rhsV)
if err != nil {
return false
}
return lhsB == rhsB
}
return reflect.DeepEqual(lhsV.Interface(), rhsV.Interface())
} | go | {
"resource": ""
} |
q7518 | appendSlice | train | func appendSlice(expr ast.Expr, lhsV reflect.Value, rhsV reflect.Value) (reflect.Value, error) {
lhsT := lhsV.Type().Elem()
rhsT := rhsV.Type().Elem()
if lhsT == rhsT {
return reflect.AppendSlice(lhsV, rhsV), nil
}
if rhsT.ConvertibleTo(lhsT) {
for i := 0; i < rhsV.Len(); i++ {
lhsV = reflect.Append(lhsV, rhsV.Index(i).Convert(lhsT))
}
return lhsV, nil
}
leftHasSubArray := lhsT.Kind() == reflect.Slice || lhsT.Kind() == reflect.Array
rightHasSubArray := rhsT.Kind() == reflect.Slice || rhsT.Kind() == reflect.Array
if leftHasSubArray != rightHasSubArray && lhsT != interfaceType && rhsT != interfaceType {
return nilValue, newStringError(expr, "invalid type conversion")
}
if !leftHasSubArray && !rightHasSubArray {
for i := 0; i < rhsV.Len(); i++ {
value := rhsV.Index(i)
if rhsT == interfaceType {
value = value.Elem()
}
if lhsT == value.Type() {
lhsV = reflect.Append(lhsV, value)
} else if value.Type().ConvertibleTo(lhsT) {
lhsV = reflect.Append(lhsV, value.Convert(lhsT))
} 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.Elem()
if value.Kind() != reflect.Slice && value.Kind() != reflect.Array {
return nilValue, newStringError(expr, "invalid type conversion")
}
}
newSlice, err := appendSlice(expr, reflect.MakeSlice(lhsT, 0, value.Len()), value)
if err != nil {
return nilValue, err
}
lhsV = reflect.Append(lhsV, newSlice)
}
return lhsV, nil
}
return nilValue, newStringError(expr, "invalid type conversion")
} | go | {
"resource": ""
} |
q7519 | precedenceOfKinds | train | func precedenceOfKinds(kind1 reflect.Kind, kind2 reflect.Kind) reflect.Kind {
if kind1 == kind2 {
return kind1
}
switch kind1 {
case reflect.String:
return kind1
case reflect.Float64, reflect.Float32:
switch kind2 {
case reflect.String:
return kind2
}
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
} | go | {
"resource": ""
} |
q7520 | toString | train | func toString(v reflect.Value) string {
if v.Kind() == reflect.Interface && !v.IsNil() {
v = v.Elem()
}
if v.Kind() == reflect.Ptr {
v = v.Elem()
}
if v.Kind() == reflect.String {
return v.String()
}
return fmt.Sprint(v.Interface())
} | go | {
"resource": ""
} |
q7521 | toBool | train | func toBool(v reflect.Value) bool {
b, _ := tryToBool(v)
return b
} | go | {
"resource": ""
} |
q7522 | toFloat64 | train | func toFloat64(v reflect.Value) float64 {
f, _ := tryToFloat64(v)
return f
} | go | {
"resource": ""
} |
q7523 | toInt64 | train | func toInt64(v reflect.Value) int64 {
i, _ := tryToInt64(v)
return i
} | go | {
"resource": ""
} |
q7524 | toInt | train | func toInt(v reflect.Value) int {
i, _ := tryToInt(v)
return i
} | go | {
"resource": ""
} |
q7525 | isHex | train | func isHex(ch rune) bool {
return ('0' <= ch && ch <= '9') || ('a' <= ch && ch <= 'f') || ('A' <= ch && ch <= 'F')
} | go | {
"resource": ""
} |
q7526 | peek | train | func (s *Scanner) peek() rune {
if s.reachEOF() {
return EOF
}
return s.src[s.offset]
} | go | {
"resource": ""
} |
q7527 | next | train | func (s *Scanner) next() {
if !s.reachEOF() {
if s.peek() == '\n' {
s.lineHead = s.offset + 1
s.line++
}
s.offset++
}
} | go | {
"resource": ""
} |
q7528 | pos | train | func (s *Scanner) pos() ast.Position {
return ast.Position{Line: s.line + 1, Column: s.offset - s.lineHead + 1}
} | go | {
"resource": ""
} |
q7529 | scanIdentifier | train | func (s *Scanner) scanIdentifier() (string, error) {
var ret []rune
for {
if !isLetter(s.peek()) && !isDigit(s.peek()) {
break
}
ret = append(ret, s.peek())
s.next()
}
return string(ret), nil
} | go | {
"resource": ""
} |
q7530 | scanNumber | train | func (s *Scanner) scanNumber() (string, error) {
result := []rune{s.peek()}
s.next()
if result[0] == '0' && (s.peek() == 'x' || s.peek() == 'X') {
// hex
result = append(result, 'x')
s.next()
for isHex(s.peek()) {
result = append(result, s.peek())
s.next()
}
} else {
// non-hex
found := false
for {
if isDigit(s.peek()) {
// is digit
result = append(result, s.peek())
s.next()
continue
}
if s.peek() == '.' {
// is .
result = append(result, '.')
s.next()
continue
}
if s.peek() == 'e' || s.peek() == 'E' {
// is e
if found {
return "", errors.New("unexpected " + string(s.peek()))
}
found = true
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 digit, e, nor .
break
}
}
if isLetter(s.peek()) {
return "", errors.New("identifier starts immediately after numeric literal")
}
return string(result), nil
} | go | {
"resource": ""
} |
q7531 | scanRawString | train | func (s *Scanner) scanRawString(l rune) (string, error) {
var ret []rune
for {
s.next()
if s.peek() == EOF {
return "", errors.New("unexpected EOF")
}
if s.peek() == l {
s.next()
break
}
ret = append(ret, s.peek())
}
return string(ret), nil
} | go | {
"resource": ""
} |
q7532 | scanString | train | func (s *Scanner) scanString(l rune) (string, error) {
var ret []rune
eos:
for {
s.next()
switch s.peek() {
case EOL:
return "", errors.New("unexpected EOL")
case EOF:
return "", errors.New("unexpected EOF")
case l:
s.next()
break eos
case '\\':
s.next()
switch 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())
continue
default:
ret = append(ret, s.peek())
}
}
return string(ret), nil
} | go | {
"resource": ""
} |
q7533 | Lex | train | func (l *Lexer) Lex(lval *yySymType) int {
tok, lit, pos, err := l.s.Scan()
if err != nil {
l.e = &Error{Message: err.Error(), Pos: pos, Fatal: true}
}
lval.tok = ast.Token{Tok: tok, Lit: lit}
lval.tok.SetPosition(pos)
l.lit = lit
l.pos = pos
return tok
} | go | {
"resource": ""
} |
q7534 | Error | train | func (l *Lexer) Error(msg string) {
l.e = &Error{Message: msg, Pos: l.pos, Fatal: false}
} | go | {
"resource": ""
} |
q7535 | Parse | train | func Parse(s *Scanner) (ast.Stmt, error) {
l := Lexer{s: s}
if yyParse(&l) != 0 {
return nil, l.e
}
return l.stmt, l.e
} | go | {
"resource": ""
} |
q7536 | ParseSrc | train | func ParseSrc(src string) (ast.Stmt, error) {
scanner := &Scanner{
src: []rune(src),
}
return Parse(scanner)
} | go | {
"resource": ""
} |
q7537 | DefineImport | train | func DefineImport(e *vm.Env) {
e.Define("import", func(source string) *vm.Env {
methods, ok := Packages[source]
if !ok {
panic(fmt.Sprintf("package '%s' not found", source))
}
var err error
pack := e.NewPackage(source)
for methodName, methodValue := range methods {
err = pack.Define(methodName, methodValue)
if err != nil {
panic(fmt.Sprintf("import Define error: %v", err))
}
}
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
})
} | go | {
"resource": ""
} |
q7538 | reflectValueSlicetoInterfaceSlice | train | func reflectValueSlicetoInterfaceSlice(valueSlice []reflect.Value) reflect.Value {
interfaceSlice := make([]interface{}, 0, len(valueSlice))
for _, value := range valueSlice {
if value.Kind() == reflect.Interface && !value.IsNil() {
value = value.Elem()
}
if value.CanInterface() {
interfaceSlice = append(interfaceSlice, value.Interface())
} else {
interfaceSlice = append(interfaceSlice, nil)
}
}
return reflect.ValueOf(interfaceSlice)
} | go | {
"resource": ""
} |
q7539 | convertReflectValueToType | train | func convertReflectValueToType(rv reflect.Value, rt reflect.Type) (reflect.Value, error) {
if rt == interfaceType || rv.Type() == rt {
// if reflect.Type is interface or the types match, return the provided reflect.Value
return rv, nil
}
if rv.Type().ConvertibleTo(rt) {
// if reflect can covert, do that conversion and return
return rv.Convert(rt), nil
}
if (rv.Kind() == reflect.Slice || rv.Kind() == reflect.Array) &&
(rt.Kind() == reflect.Slice || rt.Kind() == reflect.Array) {
// covert slice or array
return convertSliceOrArray(rv, rt)
}
if rv.Kind() == rt.Kind() {
// kind matches
switch rv.Kind() {
case reflect.Map:
// convert map
return convertMap(rv, rt)
case reflect.Func:
// for runVMFunction conversions, call convertVMFunctionToType
return convertVMFunctionToType(rv, rt)
case reflect.Ptr:
// both rv and rt are pointers, convert what they are pointing to
value, err := convertReflectValueToType(rv.Elem(), rt.Elem())
if err != nil {
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 type
return reflect.Zero(rt), nil
}
// try to convert the element
return convertReflectValueToType(rv.Elem(), rt)
}
// TODO: need to handle the case where either rv or rt are a pointer but not both
return rv, fmt.Errorf("invalid type conversion")
} | go | {
"resource": ""
} |
q7540 | convertSliceOrArray | train | func convertSliceOrArray(rv reflect.Value, rt reflect.Type) (reflect.Value, error) {
rtElemType := rt.Elem()
// try to covert elements to new slice/array
var value reflect.Value
if rt.Kind() == reflect.Slice {
// make slice
value = reflect.MakeSlice(rt, rv.Len(), rv.Len())
} else {
// make array
value = reflect.New(rt).Elem()
}
var err error
var v reflect.Value
for i := 0; i < rv.Len(); i++ {
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
} | go | {
"resource": ""
} |
q7541 | convertMap | train | func convertMap(rv reflect.Value, rt reflect.Type) (reflect.Value, error) {
rtKey := rt.Key()
rtElem := rt.Elem()
// create new map
// note creating slice as work around to create map
// just doing MakeMap can give incorrect type for defined types
newMap := reflect.MakeSlice(reflect.SliceOf(rt), 0, 1)
newMap = reflect.Append(newMap, reflect.MakeMap(reflect.MapOf(rtKey, rtElem))).Index(0)
// copy keys to new map
// The only way to do this right now is to get all the keys.
// At some point there will be a MapRange that could be used.
// https://github.com/golang/go/issues/11104
// In the mean time using MapKeys, which will costly for large maps.
mapKeys := rv.MapKeys()
for i := 0; i < len(mapKeys); i++ {
newKey, err := convertReflectValueToType(mapKeys[i], rtKey)
if err != nil {
return rv, err
}
value := rv.MapIndex(mapKeys[i])
value, err = convertReflectValueToType(value, rtElem)
if err != nil {
return rv, err
}
newMap.SetMapIndex(newKey, value)
}
return newMap, nil
} | go | {
"resource": ""
} |
q7542 | convertVMFunctionToType | train | func convertVMFunctionToType(rv reflect.Value, rt reflect.Type) (reflect.Value, error) {
// only translates runVMFunction type
if !checkIfRunVMFunction(rv.Type()) {
return rv, fmt.Errorf("invalid type conversion")
}
// create runVMConvertFunction to match reflect.Type
// this function is being called by the Go function
runVMConvertFunction := func(in []reflect.Value) []reflect.Value {
// note: this function is being called by another reflect Call
// only way to pass along any errors is by panic
// make the reflect.Value slice of each of the VM reflect.Value
args := make([]reflect.Value, 0, rt.NumIn()+1)
// for runVMFunction first arg is always context
// TOFIX: use normal context
args = append(args, reflect.ValueOf(context.Background()))
for i := 0; i < rt.NumIn(); i++ {
// have to do the double reflect.ValueOf that runVMFunction expects
args = append(args, reflect.ValueOf(in[i]))
}
// Call runVMFunction
rvs := rv.Call(args)
// call processCallReturnValues to process runVMFunction return values
// returns normal VM reflect.Value form
rv, err := processCallReturnValues(rvs, true, false)
if err != nil {
panic("function run error: " + err.Error())
}
if rt.NumOut() < 1 {
// Go function does not want any return values, so give it none
return []reflect.Value{}
}
if rt.NumOut() < 2 {
// Go function wants one return value
// will try to covert to reflect.Value correct type and return
rv, err = convertReflectValueToType(rv, rt.Out(0))
if err != nil {
panic("function wants return type " + rt.Out(0).String() + " but received type " + rv.Type().String())
}
return []reflect.Value{rv}
}
// Go function 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("function wants %v return values but received %v values", rt.NumOut(), rv.Len()))
}
// try to covert each value in slice to wanted type and put into a reflect.Value slice
rvs = make([]reflect.Value, rt.NumOut())
for i := 0; i < rv.Len(); i++ {
rvs[i], err = convertReflectValueToType(rv.Index(i), rt.Out(i))
if err != nil {
panic("function wants return type " + rt.Out(i).String() + " but received type " + rvs[i].Type().String())
}
}
// return created reflect.Value slice
return rvs
}
// make the reflect.Value function that calls runVMConvertFunction
return reflect.MakeFunc(rt, runVMConvertFunction), nil
} | go | {
"resource": ""
} |
q7543 | toSlice | train | func toSlice(from []interface{}, ptr interface{}) {
// Value of the pointer to the target
obj := reflect.Indirect(reflect.ValueOf(ptr))
// We can't just convert from interface{} to whatever the target is (diff memory layout),
// so we need to create a New slice of the proper type and copy the values individually
t := reflect.TypeOf(ptr).Elem()
tt := t.Elem()
slice := reflect.MakeSlice(t, len(from), len(from))
// Copying the data, val is an addressable Pointer of the actual target type
val := reflect.Indirect(reflect.New(tt))
for i := 0; i < 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)
} | go | {
"resource": ""
} |
q7544 | funcExpr | train | func (runInfo *runInfoStruct) funcExpr() {
funcExpr := runInfo.expr.(*ast.FuncExpr)
// create the inTypes needed by reflect.FuncOf
inTypes := make([]reflect.Type, len(funcExpr.Params)+1)
// for runVMFunction first arg is always context
inTypes[0] = contextType
for i := 1; i < len(inTypes); i++ {
inTypes[i] = reflectValueType
}
if funcExpr.VarArg {
inTypes[len(inTypes)-1] = interfaceSliceType
}
// create funcType, output is always slice of reflect.Type with two values
funcType := reflect.FuncOf(inTypes, []reflect.Type{reflectValueType, reflectValueType}, funcExpr.VarArg)
// for adding env into saved function
envFunc := runInfo.env
// create a function that can be used by reflect.MakeFunc
// this function is a translator that converts a function call into a vm run
// returns slice of reflect.Type with two values:
// return value of the function and error value of the run
runVMFunction := func(in []reflect.Value) []reflect.Value {
runInfo := runInfoStruct{ctx: in[0].Interface().(context.Context), env: envFunc.NewEnv(), stmt: funcExpr.Stmt, rv: nilValue}
// add Params to newEnv, except last Params
for i := 0; 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 and then reflect.Value
runInfo.rv = in[len(funcExpr.Params)]
runInfo.env.defineValue(funcExpr.Params[len(funcExpr.Params)-1], runInfo.rv)
} else {
// function is not variadic, add last Params to newEnv
runInfo.rv = in[len(funcExpr.Params)].Interface().(reflect.Value)
runInfo.env.defineValue(funcExpr.Params[len(funcExpr.Params)-1], runInfo.rv)
}
}
// run function statements
runInfo.runSingleStmt()
if runInfo.err != nil && runInfo.err != ErrReturn {
runInfo.err = newError(funcExpr, runInfo.err)
// return nil value and error
// need to do single reflect.ValueOf because nilValue is already reflect.Value of nil
// need to do double reflect.ValueOf of newError in order to match
return []reflect.Value{reflectValueNilValue, reflect.ValueOf(reflect.ValueOf(newError(funcExpr, runInfo.err)))}
}
// the reflect.ValueOf of rv is needed to work in the reflect.Value slice
// reflectValueErrorNilValue is already a double reflect.ValueOf
return []reflect.Value{reflect.ValueOf(runInfo.rv), reflectValueErrorNilValue}
}
// make the reflect.Value function that calls runVMFunction
runInfo.rv = reflect.MakeFunc(funcType, runVMFunction)
// if function name is not empty, define it in the env
if funcExpr.Name != "" {
runInfo.env.defineValue(funcExpr.Name, runInfo.rv)
}
} | go | {
"resource": ""
} |
q7545 | anonCallExpr | train | func (runInfo *runInfoStruct) anonCallExpr() {
anonCallExpr := runInfo.expr.(*ast.AnonCallExpr)
runInfo.expr = anonCallExpr.Expr
runInfo.invokeExpr()
if runInfo.err != nil {
return
}
if runInfo.rv.Kind() == reflect.Interface && !runInfo.rv.IsNil() {
runInfo.rv = runInfo.rv.Elem()
}
if runInfo.rv.Kind() != reflect.Func {
runInfo.err = 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()
} | go | {
"resource": ""
} |
q7546 | checkIfRunVMFunction | train | func checkIfRunVMFunction(rt reflect.Type) bool {
if rt.NumIn() < 1 || rt.NumOut() != 2 || rt.In(0) != contextType || rt.Out(0) != reflectValueType || rt.Out(1) != reflectValueType {
return false
}
if rt.NumIn() > 1 {
if rt.IsVariadic() {
if rt.In(rt.NumIn()-1) != interfaceSliceType {
return false
}
} else {
if rt.In(rt.NumIn()-1) != reflectValueType {
return false
}
}
for i := 1; i < rt.NumIn()-1; i++ {
if rt.In(i) != reflectValueType {
return false
}
}
}
return true
} | go | {
"resource": ""
} |
q7547 | NewEnv | train | func NewEnv() *Env {
return &Env{
env: make(map[string]reflect.Value),
typ: make(map[string]reflect.Type),
parent: nil,
}
} | go | {
"resource": ""
} |
q7548 | NewEnv | train | func (e *Env) NewEnv() *Env {
return &Env{
env: make(map[string]reflect.Value),
typ: make(map[string]reflect.Type),
parent: e,
name: e.name,
}
} | go | {
"resource": ""
} |
q7549 | NewPackage | train | func NewPackage(n string) *Env {
return &Env{
env: make(map[string]reflect.Value),
typ: make(map[string]reflect.Type),
parent: nil,
name: n,
}
} | go | {
"resource": ""
} |
q7550 | AddPackage | train | func (e *Env) AddPackage(name string, methods map[string]interface{}, types map[string]interface{}) (*Env, error) {
if strings.Contains(name, ".") {
return nil, fmt.Errorf("unknown symbol '%s'", name)
}
var err error
pack := e.NewPackage(name)
for methodName, methodValue := range methods {
err = pack.Define(methodName, methodValue)
if err != nil {
return pack, err
}
}
for typeName, typeValue := range types {
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
} | go | {
"resource": ""
} |
q7551 | NewModule | train | func (e *Env) NewModule(n string) *Env {
m := &Env{
env: make(map[string]reflect.Value),
typ: make(map[string]reflect.Type),
parent: e,
name: n,
}
e.Define(n, m)
return m
} | go | {
"resource": ""
} |
q7552 | SetName | train | func (e *Env) SetName(n string) {
e.Lock()
e.name = n
e.Unlock()
} | go | {
"resource": ""
} |
q7553 | GetName | train | func (e *Env) GetName() string {
e.RLock()
defer e.RUnlock()
return e.name
} | go | {
"resource": ""
} |
q7554 | Addr | train | func (e *Env) Addr(k string) (reflect.Value, error) {
e.RLock()
defer e.RUnlock()
if v, ok := e.env[k]; ok {
if v.CanAddr() {
return v.Addr(), nil
}
return nilValue, fmt.Errorf("unaddressable")
}
if e.external != nil {
v, err := e.external.Get(k)
if err == nil {
if v.CanAddr() {
return v.Addr(), nil
}
return nilValue, fmt.Errorf("unaddressable")
}
}
if e.parent == nil {
return nilValue, fmt.Errorf("undefined symbol '%s'", k)
}
return e.parent.Addr(k)
} | go | {
"resource": ""
} |
q7555 | Type | train | func (e *Env) Type(k string) (reflect.Type, error) {
e.RLock()
defer e.RUnlock()
if v, ok := e.typ[k]; ok {
return v, nil
}
if e.external != nil {
v, 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)
} | go | {
"resource": ""
} |
q7556 | Get | train | func (e *Env) Get(k string) (interface{}, error) {
rv, err := e.get(k)
return rv.Interface(), err
} | go | {
"resource": ""
} |
q7557 | Set | train | func (e *Env) Set(k string, v interface{}) error {
if v == nil {
return e.setValue(k, nilValue)
}
return e.setValue(k, reflect.ValueOf(v))
} | go | {
"resource": ""
} |
q7558 | DefineGlobal | train | func (e *Env) DefineGlobal(k string, v interface{}) error {
for e.parent != nil {
e = e.parent
}
return e.Define(k, v)
} | go | {
"resource": ""
} |
q7559 | defineGlobalValue | train | func (e *Env) defineGlobalValue(k string, v reflect.Value) error {
for e.parent != nil {
e = e.parent
}
return e.defineValue(k, v)
} | go | {
"resource": ""
} |
q7560 | Define | train | func (e *Env) Define(k string, v interface{}) error {
if v == nil {
return e.defineValue(k, nilValue)
}
return e.defineValue(k, reflect.ValueOf(v))
} | go | {
"resource": ""
} |
q7561 | defineValue | train | func (e *Env) defineValue(k string, v reflect.Value) error {
if strings.Contains(k, ".") {
return fmt.Errorf("unknown symbol '%s'", k)
}
e.Lock()
e.env[k] = v
e.Unlock()
return nil
} | go | {
"resource": ""
} |
q7562 | Delete | train | func (e *Env) Delete(k string) error {
if strings.Contains(k, ".") {
return fmt.Errorf("Unknown symbol '%s'", k)
}
e.Lock()
delete(e.env, k)
e.Unlock()
return nil
} | go | {
"resource": ""
} |
q7563 | DeleteGlobal | train | func (e *Env) DeleteGlobal(k string) error {
if e.parent == nil {
return e.Delete(k)
}
e.RLock()
_, ok := e.env[k]
e.RUnlock()
if ok {
return e.Delete(k)
}
return e.parent.DeleteGlobal(k)
} | go | {
"resource": ""
} |
q7564 | DefineGlobalType | train | func (e *Env) DefineGlobalType(k string, t interface{}) error {
for e.parent != nil {
e = e.parent
}
return e.DefineType(k, t)
} | go | {
"resource": ""
} |
q7565 | DefineGlobalReflectType | train | func (e *Env) DefineGlobalReflectType(k string, t reflect.Type) error {
for e.parent != nil {
e = e.parent
}
return e.DefineReflectType(k, t)
} | go | {
"resource": ""
} |
q7566 | DefineType | train | func (e *Env) DefineType(k string, t interface{}) error {
var typ reflect.Type
if t == nil {
typ = nilType
} else {
var ok bool
typ, ok = t.(reflect.Type)
if !ok {
typ = reflect.TypeOf(t)
}
}
return e.DefineReflectType(k, typ)
} | go | {
"resource": ""
} |
q7567 | DefineReflectType | train | func (e *Env) DefineReflectType(k string, t reflect.Type) error {
if strings.Contains(k, ".") {
return fmt.Errorf("unknown symbol '%s'", k)
}
e.Lock()
e.typ[k] = t
e.Unlock()
return nil
} | go | {
"resource": ""
} |
q7568 | String | train | func (e *Env) String() string {
e.RLock()
defer e.RUnlock()
return e.name
} | go | {
"resource": ""
} |
q7569 | Dump | train | func (e *Env) Dump() {
e.RLock()
fmt.Printf("Name: %v\n", e.name)
fmt.Printf("Has parent: %v\n", e.parent != nil)
for k, v := range e.env {
fmt.Printf("%v = %#v\n", k, v)
}
e.RUnlock()
} | go | {
"resource": ""
} |
q7570 | Execute | train | func (e *Env) Execute(src string) (interface{}, error) {
return e.ExecuteContext(context.Background(), src)
} | go | {
"resource": ""
} |
q7571 | ExecuteContext | train | func (e *Env) ExecuteContext(ctx context.Context, src string) (interface{}, error) {
stmt, err := parser.ParseSrc(src)
if err != nil {
return nilValue, err
}
return RunContext(ctx, stmt, e)
} | go | {
"resource": ""
} |
q7572 | RunContext | train | func (e *Env) RunContext(ctx context.Context, stmt ast.Stmt) (interface{}, error) {
return RunContext(ctx, stmt, e)
} | go | {
"resource": ""
} |
q7573 | Copy | train | func (e *Env) Copy() *Env {
e.Lock()
defer e.Unlock()
copy := Env{
name: e.name,
env: make(map[string]reflect.Value),
typ: make(map[string]reflect.Type),
parent: e.parent,
external: e.external,
}
for name, value := range e.env {
copy.env[name] = value
}
for name, typ := range e.typ {
copy.typ[name] = typ
}
return ©
} | go | {
"resource": ""
} |
q7574 | DeepCopy | train | func (e *Env) DeepCopy() *Env {
copy := e.Copy()
if copy.parent != nil {
copy.parent = copy.parent.DeepCopy()
}
return copy
} | go | {
"resource": ""
} |
q7575 | AddAllowMethods | train | func (c *Config) AddAllowMethods(methods ...string) {
c.AllowMethods = append(c.AllowMethods, methods...)
} | go | {
"resource": ""
} |
q7576 | AddAllowHeaders | train | func (c *Config) AddAllowHeaders(headers ...string) {
c.AllowHeaders = append(c.AllowHeaders, headers...)
} | go | {
"resource": ""
} |
q7577 | AddExposeHeaders | train | func (c *Config) AddExposeHeaders(headers ...string) {
c.ExposeHeaders = append(c.ExposeHeaders, headers...)
} | go | {
"resource": ""
} |
q7578 | Validate | train | func (c *Config) Validate() error {
if c.AllowAllOrigins && (c.AllowOriginFunc != nil || len(c.AllowOrigins) > 0) {
return errors.New("conflict settings: all origins are allowed. AllowOriginFunc or AllowOrigins is not needed")
}
if !c.AllowAllOrigins && c.AllowOriginFunc == nil && len(c.AllowOrigins) == 0 {
return errors.New("conflict settings: all origins disabled")
}
for _, origin := range c.AllowOrigins {
if origin == "*" {
c.AllowAllOrigins = true
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
} | go | {
"resource": ""
} |
q7579 | DefaultConfig | train | func DefaultConfig() Config {
return Config{
AllowMethods: []string{"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"},
AllowHeaders: []string{"Origin", "Content-Length", "Content-Type"},
AllowCredentials: false,
MaxAge: 12 * time.Hour,
}
} | go | {
"resource": ""
} |
q7580 | Default | train | func Default() gin.HandlerFunc {
config := DefaultConfig()
config.AllowAllOrigins = true
return New(config)
} | go | {
"resource": ""
} |
q7581 | New | train | func New(config Config) gin.HandlerFunc {
cors := newCors(config)
return func(c *gin.Context) {
cors.applyCors(c)
}
} | go | {
"resource": ""
} |
q7582 | MemProfileRate | train | func MemProfileRate(rate int) func(*Profile) {
return func(p *Profile) {
p.memProfileRate = rate
p.mode = memMode
}
} | go | {
"resource": ""
} |
q7583 | Stop | train | func (p *Profile) Stop() {
if !atomic.CompareAndSwapUint32(&p.stopped, 0, 1) {
// someone has already called close
return
}
p.closer()
atomic.StoreUint32(&started, 0)
} | go | {
"resource": ""
} |
q7584 | New | train | func New(rate int, opts ...Option) Limiter {
l := &limiter{
perRequest: time.Second / time.Duration(rate),
maxSlack: -10 * time.Second / time.Duration(rate),
}
for _, opt := range opts {
opt(l)
}
if l.clock == nil {
l.clock = clock.New()
}
return l
} | go | {
"resource": ""
} |
q7585 | newCache | train | func newCache() *cache {
c := cache{
m: make(map[reflect.Type]*structInfo),
regconv: make(map[reflect.Type]Converter),
tag: "schema",
}
return &c
} | go | {
"resource": ""
} |
q7586 | registerConverter | train | func (c *cache) registerConverter(value interface{}, converterFunc Converter) {
c.regconv[reflect.TypeOf(value)] = converterFunc
} | go | {
"resource": ""
} |
q7587 | get | train | func (c *cache) get(t reflect.Type) *structInfo {
c.l.RLock()
info := c.m[t]
c.l.RUnlock()
if info == nil {
info = c.create(t, "")
c.l.Lock()
c.m[t] = info
c.l.Unlock()
}
return info
} | go | {
"resource": ""
} |
q7588 | create | train | func (c *cache) create(t reflect.Type, parentAlias string) *structInfo {
info := &structInfo{}
var anonymousInfos []*structInfo
for i := 0; i < t.NumField(); i++ {
if f := c.createField(t.Field(i), parentAlias); f != nil {
info.fields = append(info.fields, f)
if ft := indirectType(f.typ); ft.Kind() == reflect.Struct && f.isAnonymous {
anonymousInfos = append(anonymousInfos, c.create(ft, f.canonicalAlias))
}
}
}
for i, a := range anonymousInfos {
others := []*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
} | go | {
"resource": ""
} |
q7589 | createField | train | func (c *cache) createField(field reflect.StructField, parentAlias string) *fieldInfo {
alias, options := fieldAlias(field, c.tag)
if alias == "-" {
// Ignore this field.
return nil
}
canonicalAlias := alias
if parentAlias != "" {
canonicalAlias = parentAlias + "." + alias
}
// Check if the type is supported and don't cache it if not.
// First let's get the basic type.
isSlice, isStruct := false, false
ft := field.Type
m := isTextUnmarshaler(reflect.Zero(ft))
if ft.Kind() == reflect.Ptr {
ft = ft.Elem()
}
if isSlice = ft.Kind() == reflect.Slice; isSlice {
ft = ft.Elem()
if ft.Kind() == reflect.Ptr {
ft = ft.Elem()
}
}
if ft.Kind() == reflect.Array {
ft = ft.Elem()
if ft.Kind() == reflect.Ptr {
ft = ft.Elem()
}
}
if isStruct = 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,
unmarshalerInfo: m,
isSliceOfStructs: isSlice && isStruct,
isAnonymous: field.Anonymous,
isRequired: options.Contains("required"),
}
} | go | {
"resource": ""
} |
q7590 | converter | train | func (c *cache) converter(t reflect.Type) Converter {
return c.regconv[t]
} | go | {
"resource": ""
} |
q7591 | fieldAlias | train | func fieldAlias(field reflect.StructField, tagName string) (alias string, options tagOptions) {
if tag := field.Tag.Get(tagName); tag != "" {
alias, options = parseTag(tag)
}
if alias == "" {
alias = field.Name
}
return alias, options
} | go | {
"resource": ""
} |
q7592 | parseTag | train | func parseTag(tag string) (string, tagOptions) {
s := strings.Split(tag, ",")
return s[0], s[1:]
} | go | {
"resource": ""
} |
q7593 | Contains | train | func (o tagOptions) Contains(option string) bool {
for _, s := range o {
if s == option {
return true
}
}
return false
} | go | {
"resource": ""
} |
q7594 | RegisterConverter | train | func (d *Decoder) RegisterConverter(value interface{}, converterFunc Converter) {
d.cache.registerConverter(value, converterFunc)
} | go | {
"resource": ""
} |
q7595 | checkRequired | train | func (d *Decoder) checkRequired(t reflect.Type, src map[string][]string) MultiError {
m, errs := d.findRequiredFields(t, "", "")
for key, fields := range m {
if isEmptyFields(fields, src) {
errs[key] = EmptyFieldError{Key: key}
}
}
return errs
} | go | {
"resource": ""
} |
q7596 | findRequiredFields | train | func (d *Decoder) findRequiredFields(t reflect.Type, canonicalPrefix, searchPrefix string) (map[string][]fieldWithPrefix, MultiError) {
struc := d.cache.get(t)
if struc == nil {
// unexpect, cache.get never return nil
return nil, MultiError{canonicalPrefix + "*": errors.New("cache fail")}
}
m := map[string][]fieldWithPrefix{}
errs := MultiError{}
for _, f := range struc.fields {
if f.typ.Kind() == reflect.Struct {
fcprefix := canonicalPrefix + f.canonicalAlias + "."
for _, fspath := range f.paths(searchPrefix) {
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: searchPrefix,
})
}
}
return m, errs
} | go | {
"resource": ""
} |
q7597 | isEmptyFields | train | func isEmptyFields(fields []fieldWithPrefix, src map[string][]string) bool {
for _, f := range fields {
for _, path := range f.paths(f.prefix) {
if !isEmpty(f.typ, src[path]) {
return false
}
}
}
return true
} | go | {
"resource": ""
} |
q7598 | isEmpty | train | func isEmpty(t reflect.Type, value []string) bool {
if len(value) == 0 {
return true
}
switch t.Kind() {
case boolType, float32Type, float64Type, intType, int8Type, int32Type, int64Type, stringType, uint8Type, uint16Type, uint32Type, uint64Type:
return len(value[0]) == 0
}
return false
} | go | {
"resource": ""
} |
q7599 | NewEncoder | train | func NewEncoder() *Encoder {
return &Encoder{cache: newCache(), regenc: make(map[reflect.Type]encoderFunc)}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.