_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.DNSA... | 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.E... | 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... | 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() {
... | 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() ... | 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,... | 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, re... | 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
... | 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':
... | 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, metho... | 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(... | 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 conver... | 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 = r... | 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 = ... | 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 ... | 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... | 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] = r... | 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() !=... | 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
}
... | 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(m... | 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(... | 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 nilTyp... | 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 {
... | 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 {
retu... | 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() == reflec... | 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 support... | 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][]f... | 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.