id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c181000 | if err != nil {
panic(err)
}
return ret
} | |
c181001 |
for err == nil {
switch xt := t.(type) {
case xml.StartElement:
setEle(&opts, xmlTree, xt, &ordrPos)
xmlTree = xmlTree.CreateNode(&opts)
case xml.CharData:
setNode(&opts, xmlTree, xt, tree.NtChd, &ordrPos)
xmlTree = xmlTree.CreateNode(&opts)
case xml.Comment:
setNode(&opts, xmlTree, xt, tree.NtComm, &ordrPos)
xmlTree = xmlTree.CreateNode(&opts)
case xml.ProcInst:
setNode(&opts, xmlTree, xt, tree.NtPi, &ordrPos)
xmlTree = xmlTree.CreateNode(&opts)
case xml.EndElement:
xmlTree = xmlTree.EndElem()
case xml.Directive:
if dp, ok := xmlTree.(DirectiveParser); ok {
dp.Directive(xt.Copy(), dec)
}
}
t, err = dec.Token()
}
if err == io.EOF {
err = nil
}
return xmlTree, err
} | |
c181002 | return w.Fn(c, args...)
}
default:
if len(args) == w.NArgs {
return w.Fn(c, args...)
}
}
return nil, fmt.Errorf("Invalid number of arguments")
} | |
c181003 | := parser.Parse(xp)
return XPathExec{n: n}, err
} | |
c181004 | err := Parse(xp)
if err != nil {
panic(err)
}
return ret
} | |
c181005 |
}
for _, i := range opts {
i(o)
}
return execxp.Exec(xp.n, t, o.NS, o.Funcs, o.Vars)
} | |
c181006 | !ok {
return false, fmt.Errorf("Cannot convert result to a boolean")
}
return bool(b.Bool()), nil
} | |
c181007 | if !ok {
return 0, fmt.Errorf("Cannot convert result to a number")
}
return float64(n.Num()), nil
} | |
c181008 | res.(tree.NodeSet)
if !ok {
return nil, fmt.Errorf("Cannot convert result to a node-set")
}
return n, nil
} | |
c181009 | {
res, err := xp.Exec(t, opts...)
if err != nil {
panic(err)
}
return res
} | |
c181010 | err != nil {
return nil, err
}
return xp.Exec(t, opts...)
} | |
c181011 | NodePos: tree.NodePos(opts.AttrStartPos + i),
NodeType: tree.NtAttr,
Parent: ele,
}
}
x.Children = append(x.Children, ele)
return ele
}
node := xmlnode.XMLNode{
Token: opts.Tok,
NodePos: tree.NodePos(opts.NodePos),
NodeType: opts.NodeType,
Parent: x,
}
x.Children = append(x.Children, node)
return x
} | |
c181012 | len(x.Children))
for i := range x.Children {
ret[i] = x.Children[i]
}
return ret
} | |
c181013 | := range x.Attrs {
ret[i] = x.Attrs[i]
}
return ret
} | |
c181014 | tree.NtChd, tree.NtElem, tree.NtRoot:
ret += x.Children[i].ResValue()
}
}
return ret
} | |
c181015 | parseMap[next.Typ](p, next)
} else if err == nil {
err = fmt.Errorf(next.Val)
}
}
return n, err
} | |
c181016 | == tree.NtAttr {
ret := a.Token.(*xml.Attr)
return *ret
}
return a.Token
} | |
c181017 | return string(a.Token.(xml.Comment))
}
//case tree.NtPi:
return string(a.Token.(xml.ProcInst).Inst)
} | |
c181018 | {
f := xpFilt{
t: t,
ns: ns,
ctx: tree.NodeSet{t},
fns: fns,
variables: v,
}
return exec(&f, n)
} | |
c181019 | }
return "-Infinity"
}
return fmt.Sprintf("%g", float64(n))
} | |
c181020 | != nil {
return Num(math.NaN())
}
return Num(num)
} | |
c181021 | Parent: t,
NodeType: NtNs,
})
i++
}
}
sort.Sort(nsValueSort(ret))
for i := range ret {
ret[i].NodePos = NodePos(t.Pos() + i + 1)
}
}
return ret
} | |
c181022 | if local == attr.Name.Local && space == attr.Name.Space {
return attr, true
}
}
return xml.Attr{}, false
} | |
c181023 | ok := GetAttribute(n, local, space)
return attr.Value, ok
} | |
c181024 | {
val, ok := GetAttributeVal(n, local, space)
if !ok {
return ""
}
return val
} | |
c181025 | }
attrs := elem.GetAttrs()
for _, i := range attrs {
if i.Pos() == pos {
return i
}
}
ns := BuildNS(elem)
for _, i := range ns {
if i.Pos() == pos {
return i
}
}
}
return nil
} | |
c181026 | error {
return marshal(n, w)
} | |
c181027 | marshal(n, ret)
return ret.String(), err
} | |
c181028 | &DefaultTokenizer{},
posix: posix,
whitespacesplit: whitespacesplit,
}
} | |
c181029 | return NewLexer(strings.NewReader(s), posix, whitespacesplit)
} | |
c181030 | NewLexerString(s, posix, true).Split()
} | |
c181031 | (message: `%s`)", err.MessageFormat))
}
if r.byCode[err.Code] != nil {
panic(fmt.Errorf("errors: Duplicate error code %v registered", err.Code))
}
err.registered = true
r.byCode[err.Code] = err
} | |
c181032 | defer r.RUnlock()
return r.byCode[code]
} | |
c181033 | := range r.byCode {
res = append(res, d)
}
return res
} | |
c181034 | := in.(Error); ok {
return err
}
return FromGRPC(in)
} | |
c181035 |
}
// return a new error descriptor with sane defaults
return &ErrDescriptor{
MessageFormat: err.Error(),
Type: err.Type(),
Code: err.Code(),
}
} | |
c181036 | e.Attributes()
}
return Attributes{}
} | |
c181037 | return http.StatusUnauthorized
case PermissionDenied:
return http.StatusForbidden
case Timeout:
return http.StatusRequestTimeout
case NotImplemented:
return http.StatusNotImplemented
case TemporarilyUnavailable:
return http.StatusBadGateway
case PermanentlyUnavailable:
return http.StatusGone
case ResourceExhausted:
return http.StatusForbidden
case Internal:
return http.StatusInternalServerError
case Unknown:
return http.StatusInternalServerError
}
return http.StatusInternalServerError
} | |
c181038 |
if ok {
return e.Type().HTTPStatusCode()
}
return http.StatusInternalServerError
} | |
c181039 |
case http.StatusBadGateway:
case http.StatusServiceUnavailable:
return TemporarilyUnavailable
case http.StatusGone:
return PermanentlyUnavailable
case http.StatusTooManyRequests:
return ResourceExhausted
case http.StatusInternalServerError:
return Unknown
}
return Unknown
} | |
c181040 |
w.WriteHeader(http.StatusInternalServerError)
return json.NewEncoder(w).Encode(&jsonError{
Message: in.Error(),
Type: Unknown,
})
} | |
c181041 |
typ: err.Type(),
attributes: err.Attributes(),
}
} | |
c181042 | _ := metadata.FromIncomingContext(ctx)
return md
} | |
c181043 | _ := metadata.FromOutgoingContext(ctx)
return md
} | |
c181044 | 0 {
return "", ErrNoToken
}
return token[0], nil
} | |
c181045 | := MetadataFromIncomingContext(ctx)
return TokenFromMetadata(md)
} | |
c181046 | outgoingContextWithMergedMetadata(ctx, "token", token)
} | |
c181047 | 0 {
return "", ErrNoKey
}
return key[0], nil
} | |
c181048 | := MetadataFromIncomingContext(ctx)
return KeyFromMetadata(md)
} | |
c181049 | outgoingContextWithMergedMetadata(ctx, "key", key)
} | |
c181050 | 0 {
return "", ErrNoID
}
return id[0], nil
} | |
c181051 | := MetadataFromIncomingContext(ctx)
return IDFromMetadata(md)
} | |
c181052 | outgoingContextWithMergedMetadata(ctx, "id", id)
} | |
c181053 | {
serviceVersion = serviceVersionL[0]
}
netAddressL, ok := md["net-address"]
if ok && len(netAddressL) > 0 {
netAddress = netAddressL[0]
}
return
} | |
c181054 | netAddress string, err error) {
md := MetadataFromIncomingContext(ctx)
return ServiceInfoFromMetadata(md)
} | |
c181055 | outgoingContextWithMergedMetadata(ctx, "service-name", serviceName, "service-version", serviceVersion, "net-address", netAddress)
} | |
c181056 |
return 0, nil
}
return strconv.ParseUint(limit[0], 10, 64)
} | |
c181057 |
return 0, nil
}
return strconv.ParseUint(offset[0], 10, 64)
} | |
c181058 | }
offset, err = OffsetFromMetadata(md)
if err != nil {
return 0, 0, err
}
return limit, offset, nil
} | |
c181059 | strconv.FormatUint(limit, 10))
}
if offset != 0 {
pairs = append(pairs, "offset", strconv.FormatUint(offset, 10))
}
if len(pairs) == 0 {
return ctx
}
return outgoingContextWithMergedMetadata(ctx, pairs...)
} | |
c181060 | i.(ScheduleItemWithTimestamp); ok {
if j, ok := j.(ScheduleItemWithTimestamp); ok {
iEnd = i.Timestamp() + i.Duration().Nanoseconds()
jStart = j.Timestamp()
}
}
return iEnd < jStart
} | |
c181061 | Format(err.MessageFormat, attributes),
code: err.Code,
typ: err.Type,
attributes: attributes,
}
} | |
c181062 | ctx.WithField(NamespaceKey, namespace)
} | |
c181063 | namespaces: &ns{
namespaces: namespaces,
},
}
} | |
c181064 | Interface: n.Interface,
namespaces: n.namespaces,
namespace: str,
}
}
}
return &Namespaced{
Interface: n.Interface.WithField(k, v),
namespaces: n.namespaces,
namespace: n.namespace,
}
} | |
c181065 |
Interface: n.Interface.WithFields(fields),
namespaces: n.namespaces,
namespace: n.namespace,
}
} | |
c181066 | return format
}
fixed := make(map[string]interface{}, len(values))
for k, v := range values {
fixed[k] = fix(v)
}
// todo format unsupported types
res, err := fm.FormatMap(fixed)
if err != nil {
fmt.Println("err", err)
return format
}
return res
} | |
c181067 | reflect.Uintptr:
case reflect.Float32:
case reflect.Float64:
return v
case reflect.Ptr:
// dereference and fix
return fix(reflect.ValueOf(v).Elem())
}
return fmt.Sprintf("%v", v)
} | |
c181068 | return codes.Unimplemented
case TemporarilyUnavailable:
return codes.Unavailable
case PermanentlyUnavailable:
return codes.FailedPrecondition
case Canceled:
return codes.Canceled
case ResourceExhausted:
return codes.ResourceExhausted
case Internal:
case Unknown:
return codes.Unknown
}
return codes.Unknown
} | |
c181069 | return NotImplemented
case codes.Unavailable:
return TemporarilyUnavailable
case codes.FailedPrecondition:
return PermanentlyUnavailable
case codes.Canceled:
return Canceled
case codes.ResourceExhausted:
return ResourceExhausted
case codes.Unknown:
return Unknown
}
return Unknown
} | |
c181070 |
if ok {
return e.Type().GRPCCode()
}
return grpc.Code(err)
} | |
c181071 |
out.code = parseCode(matches[2])
_ = json.Unmarshal([]byte(matches[3]), &out.attributes)
got := Get(Code(out.code))
if got == nil {
return out
}
return got.New(out.attributes)
} | |
c181072 | format, err.Error(), err.Code(), attrs)
}
return grpc.Errorf(codes.Unknown, in.Error())
} | |
c181073 | namespace {
included = true
}
// mark that we have a *
if ns == "*" {
hasStar = true
}
}
// non-mentioned namespaces are only enabled if we got the catch-all *
return hasStar || included
} | |
c181074 | n.Unlock()
n.namespaces = namespaces
} | |
c181075 | {
case error:
return v
case string:
return errors.New(v)
default:
return nil
}
} | |
c181076 |
if err != nil {
return Code(0)
}
return Code(code)
} | |
c181077 | grpc.UnaryHandler) (resp interface{}, err error) {
resp, err = handler(ctx, req)
return resp, fn(err)
}
} | |
c181078 | handler grpc.StreamHandler) (err error) {
return fn(handler(srv, ss))
}
} | |
c181079 | req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) (err error) {
return fn(invoker(ctx, method, req, reply, cc, opts...))
}
} | |
c181080 | method string, streamer grpc.Streamer, opts ...grpc.CallOption) (stream grpc.ClientStream, err error) {
stream, err = streamer(ctx, desc, cc, method, opts...)
return stream, fn(err)
}
} | |
c181081 | cc: cc,
method: method,
streamer: streamer,
opts: opts,
retryableCodes: settings.RetryableCodes,
backoff: settings.Backoff,
retries: -1,
}
err = s.start()
stream = s
return
}
} | |
c181082 | {
return &logrusEntryWrapper{logrus.NewEntry(logger)}
} | |
c181083 |
buckets: make([]uint64, 2*retention/bucketSize),
}
} | |
c181084 | {
return &redisCounter{
client: client,
key: key,
bucketSize: bucketSize,
retention: retention,
}
} | |
c181085 | counter,
duration: duration,
limit: limit,
}
} | |
c181086 | tokenFunc: c.tokenFunc, allowInsecure: true}
} | |
c181087 |
tokenFunc: tokenFunc,
tokenFuncKey: k,
}
} | |
c181088 | }
return map[string]string{tokenKey: c.tokenFunc(k)}, nil
}
if c.token != "" {
return map[string]string{tokenKey: c.token}, nil
}
return map[string]string{tokenKey: ""}, nil
} | |
c181089 | md, ok := metadata.FromIncomingContext(ctx); ok {
fields.addFromMD(md)
}
return fields.LogFields()
} | |
c181090 |
case Unauthorized:
return "Unauthorized"
case PermissionDenied:
return "Permission denied"
case Timeout:
return "Timeout"
case NotImplemented:
return "Not implemented"
case TemporarilyUnavailable:
return "Temporarily unavailable"
case PermanentlyUnavailable:
return "Permanently unavailable"
case Canceled:
return "Canceled"
case ResourceExhausted:
return "Resource exhausted"
default:
return "Unknown"
}
} | |
c181091 | err != nil {
return err
}
*t = e
return nil
} | |
c181092 | return NotImplemented, nil
case "temporarily unavailable":
return TemporarilyUnavailable, nil
case "permanently unavailable":
return PermanentlyUnavailable, nil
case "canceled":
return Canceled, nil
case "resource exhausted":
return ResourceExhausted, nil
default:
return Unknown, fmt.Errorf("Invalid error type")
}
} | |
c181093 | {
runtime.ReadMemStats(memstats)
ctx.WithFields(log.Fields{
"goroutines": runtime.NumGoroutine(),
"memory": float64(memstats.Alloc) / megaByte, // MegaBytes allocated and not yet freed
}).Debugf("memory stats")
}
}()
} | |
c181094 |
q.available = sync.NewCond(&q.mu)
return q
} | |
c181095 |
Interface: logger,
filters: filters,
}
} | |
c181096 | return &Filtered{
Interface: f.Interface,
filters: append(f.filters, filters...),
}
} | |
c181097 | filter := range f.filters {
val = filter.Filter(k, val)
}
return &Filtered{
Interface: f.Interface.WithField(k, val),
filters: f.filters,
}
} | |
c181098 | := v
// apply the filters
for _, filter := range f.filters {
val = filter.Filter(k, val)
}
res[k] = val
}
return &Filtered{
Interface: f.Interface.WithFields(res),
filters: f.filters,
}
} | |
c181099 | interface{}) interface{} {
lower := strings.ToLower(key)
for _, s := range sensitive {
if lower == s {
return elided
}
}
return v
})
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.