_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q181000 | MustParseXML | test | func MustParseXML(r io.Reader, op ...ParseSettings) tree.Node {
ret, err := ParseXML(r, op...)
if err != nil {
panic(err)
}
return ret
} | go | {
"resource": ""
} |
q181001 | ParseXML | test | func ParseXML(r io.Reader, op ...ParseSettings) (tree.Node, error) {
ov := ParseOptions{
Strict: true,
XMLRoot: xmlele.Root,
}
for _, i := range op {
i(&ov)
}
dec := xml.NewDecoder(r)
dec.CharsetReader = charset.NewReaderLabel
dec.Strict = ov.Strict
ordrPos := 1
xmlTree := ov.XMLRoot()
t, err := dec.Token()
if err != nil {
return nil, err
}
if head, ok := t.(xml.ProcInst); ok && head.Target == "xml" {
t, err = dec.Token()
}
opts := xmlbuilder.BuilderOpts{
Dec: dec,
}
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
} | go | {
"resource": ""
} |
q181002 | Call | test | func (w Wrap) Call(c Ctx, args ...Result) (Result, error) {
switch w.LastArgOpt {
case Optional:
if len(args) == w.NArgs || len(args) == w.NArgs-1 {
return w.Fn(c, args...)
}
case Variadic:
if len(args) >= w.NArgs-1 {
return w.Fn(c, args...)
}
default:
if len(args) == w.NArgs {
return w.Fn(c, args...)
}
}
return nil, fmt.Errorf("Invalid number of arguments")
} | go | {
"resource": ""
} |
q181003 | Parse | test | func Parse(xp string) (XPathExec, error) {
n, err := parser.Parse(xp)
return XPathExec{n: n}, err
} | go | {
"resource": ""
} |
q181004 | MustParse | test | func MustParse(xp string) XPathExec {
ret, err := Parse(xp)
if err != nil {
panic(err)
}
return ret
} | go | {
"resource": ""
} |
q181005 | Exec | test | func (xp XPathExec) Exec(t tree.Node, opts ...FuncOpts) (tree.Result, error) {
o := &Opts{
NS: make(map[string]string),
Funcs: make(map[xml.Name]tree.Wrap),
Vars: make(map[string]tree.Result),
}
for _, i := range opts {
i(o)
}
return execxp.Exec(xp.n, t, o.NS, o.Funcs, o.Vars)
} | go | {
"resource": ""
} |
q181006 | ExecBool | test | func (xp XPathExec) ExecBool(t tree.Node, opts ...FuncOpts) (bool, error) {
res, err := xp.Exec(t, opts...)
if err != nil {
return false, err
}
b, ok := res.(tree.IsBool)
if !ok {
return false, fmt.Errorf("Cannot convert result to a boolean")
}
return bool(b.Bool()), nil
} | go | {
"resource": ""
} |
q181007 | ExecNum | test | func (xp XPathExec) ExecNum(t tree.Node, opts ...FuncOpts) (float64, error) {
res, err := xp.Exec(t, opts...)
if err != nil {
return 0, err
}
n, ok := res.(tree.IsNum)
if !ok {
return 0, fmt.Errorf("Cannot convert result to a number")
}
return float64(n.Num()), nil
} | go | {
"resource": ""
} |
q181008 | ExecNode | test | func (xp XPathExec) ExecNode(t tree.Node, opts ...FuncOpts) (tree.NodeSet, error) {
res, err := xp.Exec(t, opts...)
if err != nil {
return nil, err
}
n, ok := res.(tree.NodeSet)
if !ok {
return nil, fmt.Errorf("Cannot convert result to a node-set")
}
return n, nil
} | go | {
"resource": ""
} |
q181009 | MustExec | test | func (xp XPathExec) MustExec(t tree.Node, opts ...FuncOpts) tree.Result {
res, err := xp.Exec(t, opts...)
if err != nil {
panic(err)
}
return res
} | go | {
"resource": ""
} |
q181010 | ParseExec | test | func ParseExec(xpstr string, t tree.Node, opts ...FuncOpts) (tree.Result, error) {
xp, err := Parse(xpstr)
if err != nil {
return nil, err
}
return xp.Exec(t, opts...)
} | go | {
"resource": ""
} |
q181011 | CreateNode | test | func (x *XMLEle) CreateNode(opts *xmlbuilder.BuilderOpts) xmlbuilder.XMLBuilder {
if opts.NodeType == tree.NtElem {
ele := &XMLEle{
StartElement: opts.Tok.(xml.StartElement),
NSBuilder: tree.NSBuilder{NS: opts.NS},
Attrs: make([]tree.Node, len(opts.Attrs)),
Parent: x,
NodePos: tree.NodePos(opts.NodePos),
NodeType: opts.NodeType,
}
for i := range opts.Attrs {
ele.Attrs[i] = xmlnode.XMLNode{
Token: opts.Attrs[i],
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
} | go | {
"resource": ""
} |
q181012 | GetChildren | test | func (x *XMLEle) GetChildren() []tree.Node {
ret := make([]tree.Node, len(x.Children))
for i := range x.Children {
ret[i] = x.Children[i]
}
return ret
} | go | {
"resource": ""
} |
q181013 | GetAttrs | test | func (x *XMLEle) GetAttrs() []tree.Node {
ret := make([]tree.Node, len(x.Attrs))
for i := range x.Attrs {
ret[i] = x.Attrs[i]
}
return ret
} | go | {
"resource": ""
} |
q181014 | ResValue | test | func (x *XMLEle) ResValue() string {
ret := ""
for i := range x.Children {
switch x.Children[i].GetNodeType() {
case tree.NtChd, tree.NtElem, tree.NtRoot:
ret += x.Children[i].ResValue()
}
}
return ret
} | go | {
"resource": ""
} |
q181015 | Parse | test | func Parse(xp string) (*Node, error) {
var err error
c := lexer.Lex(xp)
n := &Node{}
p := &parseStack{cur: n}
for next := range c {
if next.Typ != lexer.XItemError {
parseMap[next.Typ](p, next)
} else if err == nil {
err = fmt.Errorf(next.Val)
}
}
return n, err
} | go | {
"resource": ""
} |
q181016 | GetToken | test | func (a XMLNode) GetToken() xml.Token {
if a.NodeType == tree.NtAttr {
ret := a.Token.(*xml.Attr)
return *ret
}
return a.Token
} | go | {
"resource": ""
} |
q181017 | ResValue | test | func (a XMLNode) ResValue() string {
switch a.NodeType {
case tree.NtAttr:
return a.Token.(*xml.Attr).Value
case tree.NtChd:
return string(a.Token.(xml.CharData))
case tree.NtComm:
return string(a.Token.(xml.Comment))
}
//case tree.NtPi:
return string(a.Token.(xml.ProcInst).Inst)
} | go | {
"resource": ""
} |
q181018 | Exec | test | func Exec(n *parser.Node, t tree.Node, ns map[string]string, fns map[xml.Name]tree.Wrap, v map[string]tree.Result) (tree.Result, error) {
f := xpFilt{
t: t,
ns: ns,
ctx: tree.NodeSet{t},
fns: fns,
variables: v,
}
return exec(&f, n)
} | go | {
"resource": ""
} |
q181019 | String | test | func (n Num) String() string {
if math.IsInf(float64(n), 0) {
if math.IsInf(float64(n), 1) {
return "Infinity"
}
return "-Infinity"
}
return fmt.Sprintf("%g", float64(n))
} | go | {
"resource": ""
} |
q181020 | Num | test | func (s String) Num() Num {
num, err := strconv.ParseFloat(strings.TrimSpace(string(s)), 64)
if err != nil {
return Num(math.NaN())
}
return Num(num)
} | go | {
"resource": ""
} |
q181021 | BuildNS | test | func BuildNS(t Elem) (ret []NS) {
vals := make(map[xml.Name]string)
if nselem, ok := t.(NSElem); ok {
buildNS(nselem, vals)
ret = make([]NS, 0, len(vals))
i := 1
for k, v := range vals {
if !(k.Local == "xmlns" && k.Space == "" && v == "") {
ret = append(ret, NS{
Attr: xml.Attr{Name: k, Value: v},
Parent: t,
NodeType: NtNs,
})
i++
}
}
sort.Sort(nsValueSort(ret))
for i := range ret {
ret[i].NodePos = NodePos(t.Pos() + i + 1)
}
}
return ret
} | go | {
"resource": ""
} |
q181022 | GetAttribute | test | func GetAttribute(n Elem, local, space string) (xml.Attr, bool) {
attrs := n.GetAttrs()
for _, i := range attrs {
attr := i.GetToken().(xml.Attr)
if local == attr.Name.Local && space == attr.Name.Space {
return attr, true
}
}
return xml.Attr{}, false
} | go | {
"resource": ""
} |
q181023 | GetAttributeVal | test | func GetAttributeVal(n Elem, local, space string) (string, bool) {
attr, ok := GetAttribute(n, local, space)
return attr.Value, ok
} | go | {
"resource": ""
} |
q181024 | GetAttrValOrEmpty | test | func GetAttrValOrEmpty(n Elem, local, space string) string {
val, ok := GetAttributeVal(n, local, space)
if !ok {
return ""
}
return val
} | go | {
"resource": ""
} |
q181025 | FindNodeByPos | test | func FindNodeByPos(n Node, pos int) Node {
if n.Pos() == pos {
return n
}
if elem, ok := n.(Elem); ok {
chldrn := elem.GetChildren()
for i := 1; i < len(chldrn); i++ {
if chldrn[i-1].Pos() <= pos && chldrn[i].Pos() > pos {
return FindNodeByPos(chldrn[i-1], pos)
}
}
if len(chldrn) > 0 {
if chldrn[len(chldrn)-1].Pos() <= pos {
return FindNodeByPos(chldrn[len(chldrn)-1], pos)
}
}
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
} | go | {
"resource": ""
} |
q181026 | Marshal | test | func Marshal(n tree.Node, w io.Writer) error {
return marshal(n, w)
} | go | {
"resource": ""
} |
q181027 | MarshalStr | test | func MarshalStr(n tree.Node) (string, error) {
ret := bytes.NewBufferString("")
err := marshal(n, ret)
return ret.String(), err
} | go | {
"resource": ""
} |
q181028 | NewLexer | test | func NewLexer(r io.Reader, posix, whitespacesplit bool) *Lexer {
return &Lexer{
reader: bufio.NewReader(r),
tokenizer: &DefaultTokenizer{},
posix: posix,
whitespacesplit: whitespacesplit,
}
} | go | {
"resource": ""
} |
q181029 | NewLexerString | test | func NewLexerString(s string, posix, whitespacesplit bool) *Lexer {
return NewLexer(strings.NewReader(s), posix, whitespacesplit)
} | go | {
"resource": ""
} |
q181030 | Split | test | func Split(s string, posix bool) ([]string, error) {
return NewLexerString(s, posix, true).Split()
} | go | {
"resource": ""
} |
q181031 | Register | test | func (r *registry) Register(err *ErrDescriptor) {
r.Lock()
defer r.Unlock()
if err.Code == NoCode {
panic(fmt.Errorf("No code defined in error descriptor (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
} | go | {
"resource": ""
} |
q181032 | Get | test | func (r *registry) Get(code Code) *ErrDescriptor {
r.RLock()
defer r.RUnlock()
return r.byCode[code]
} | go | {
"resource": ""
} |
q181033 | GetAll | test | func (r *registry) GetAll() []*ErrDescriptor {
r.RLock()
defer r.RUnlock()
res := make([]*ErrDescriptor, 0, len(r.byCode))
for _, d := range r.byCode {
res = append(res, d)
}
return res
} | go | {
"resource": ""
} |
q181034 | From | test | func From(in error) Error {
if err, ok := in.(Error); ok {
return err
}
return FromGRPC(in)
} | go | {
"resource": ""
} |
q181035 | Descriptor | test | func Descriptor(in error) (desc *ErrDescriptor) {
err := From(in)
descriptor := Get(err.Code())
if descriptor != nil {
return descriptor
}
// return a new error descriptor with sane defaults
return &ErrDescriptor{
MessageFormat: err.Error(),
Type: err.Type(),
Code: err.Code(),
}
} | go | {
"resource": ""
} |
q181036 | GetAttributes | test | func GetAttributes(err error) Attributes {
e, ok := err.(Error)
if ok {
return e.Attributes()
}
return Attributes{}
} | go | {
"resource": ""
} |
q181037 | HTTPStatusCode | test | func (t Type) HTTPStatusCode() int {
switch t {
case Canceled:
return http.StatusRequestTimeout
case InvalidArgument:
return http.StatusBadRequest
case OutOfRange:
return http.StatusBadRequest
case NotFound:
return http.StatusNotFound
case Conflict:
return http.StatusConflict
case AlreadyExists:
return http.StatusConflict
case Unauthorized:
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
} | go | {
"resource": ""
} |
q181038 | HTTPStatusCode | test | func HTTPStatusCode(err error) int {
e, ok := err.(Error)
if ok {
return e.Type().HTTPStatusCode()
}
return http.StatusInternalServerError
} | go | {
"resource": ""
} |
q181039 | HTTPStatusToType | test | func HTTPStatusToType(status int) Type {
switch status {
case http.StatusBadRequest:
return InvalidArgument
case http.StatusNotFound:
return NotFound
case http.StatusConflict:
return Conflict
case http.StatusUnauthorized:
return Unauthorized
case http.StatusForbidden:
return PermissionDenied
case http.StatusRequestTimeout:
return Timeout
case http.StatusNotImplemented:
return NotImplemented
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
} | go | {
"resource": ""
} |
q181040 | ToHTTP | test | func ToHTTP(in error, w http.ResponseWriter) error {
w.Header().Set("Content-Type", "application/json")
if err, ok := in.(Error); ok {
w.Header().Set(CodeHeader, err.Code().String())
w.WriteHeader(err.Type().HTTPStatusCode())
return json.NewEncoder(w).Encode(toJSON(err))
}
w.WriteHeader(http.StatusInternalServerError)
return json.NewEncoder(w).Encode(&jsonError{
Message: in.Error(),
Type: Unknown,
})
} | go | {
"resource": ""
} |
q181041 | toImpl | test | func toImpl(err Error) *impl {
if i, ok := err.(*impl); ok {
return i
}
return &impl{
message: err.Error(),
code: err.Code(),
typ: err.Type(),
attributes: err.Attributes(),
}
} | go | {
"resource": ""
} |
q181042 | MetadataFromIncomingContext | test | func MetadataFromIncomingContext(ctx context.Context) metadata.MD {
md, _ := metadata.FromIncomingContext(ctx)
return md
} | go | {
"resource": ""
} |
q181043 | MetadataFromOutgoingContext | test | func MetadataFromOutgoingContext(ctx context.Context) metadata.MD {
md, _ := metadata.FromOutgoingContext(ctx)
return md
} | go | {
"resource": ""
} |
q181044 | TokenFromMetadata | test | func TokenFromMetadata(md metadata.MD) (string, error) {
token, ok := md["token"]
if !ok || len(token) == 0 {
return "", ErrNoToken
}
return token[0], nil
} | go | {
"resource": ""
} |
q181045 | TokenFromIncomingContext | test | func TokenFromIncomingContext(ctx context.Context) (string, error) {
md := MetadataFromIncomingContext(ctx)
return TokenFromMetadata(md)
} | go | {
"resource": ""
} |
q181046 | OutgoingContextWithToken | test | func OutgoingContextWithToken(ctx context.Context, token string) context.Context {
return outgoingContextWithMergedMetadata(ctx, "token", token)
} | go | {
"resource": ""
} |
q181047 | KeyFromMetadata | test | func KeyFromMetadata(md metadata.MD) (string, error) {
key, ok := md["key"]
if !ok || len(key) == 0 {
return "", ErrNoKey
}
return key[0], nil
} | go | {
"resource": ""
} |
q181048 | KeyFromIncomingContext | test | func KeyFromIncomingContext(ctx context.Context) (string, error) {
md := MetadataFromIncomingContext(ctx)
return KeyFromMetadata(md)
} | go | {
"resource": ""
} |
q181049 | OutgoingContextWithKey | test | func OutgoingContextWithKey(ctx context.Context, key string) context.Context {
return outgoingContextWithMergedMetadata(ctx, "key", key)
} | go | {
"resource": ""
} |
q181050 | IDFromMetadata | test | func IDFromMetadata(md metadata.MD) (string, error) {
id, ok := md["id"]
if !ok || len(id) == 0 {
return "", ErrNoID
}
return id[0], nil
} | go | {
"resource": ""
} |
q181051 | IDFromIncomingContext | test | func IDFromIncomingContext(ctx context.Context) (string, error) {
md := MetadataFromIncomingContext(ctx)
return IDFromMetadata(md)
} | go | {
"resource": ""
} |
q181052 | OutgoingContextWithID | test | func OutgoingContextWithID(ctx context.Context, id string) context.Context {
return outgoingContextWithMergedMetadata(ctx, "id", id)
} | go | {
"resource": ""
} |
q181053 | ServiceInfoFromMetadata | test | func ServiceInfoFromMetadata(md metadata.MD) (serviceName, serviceVersion, netAddress string, err error) {
serviceNameL, ok := md["service-name"]
if ok && len(serviceNameL) > 0 {
serviceName = serviceNameL[0]
}
serviceVersionL, ok := md["service-version"]
if ok && len(serviceVersionL) > 0 {
serviceVersion = serviceVersionL[0]
}
netAddressL, ok := md["net-address"]
if ok && len(netAddressL) > 0 {
netAddress = netAddressL[0]
}
return
} | go | {
"resource": ""
} |
q181054 | ServiceInfoFromIncomingContext | test | func ServiceInfoFromIncomingContext(ctx context.Context) (serviceName, serviceVersion, netAddress string, err error) {
md := MetadataFromIncomingContext(ctx)
return ServiceInfoFromMetadata(md)
} | go | {
"resource": ""
} |
q181055 | OutgoingContextWithServiceInfo | test | func OutgoingContextWithServiceInfo(ctx context.Context, serviceName, serviceVersion, netAddress string) context.Context {
return outgoingContextWithMergedMetadata(ctx, "service-name", serviceName, "service-version", serviceVersion, "net-address", netAddress)
} | go | {
"resource": ""
} |
q181056 | LimitFromMetadata | test | func LimitFromMetadata(md metadata.MD) (uint64, error) {
limit, ok := md["limit"]
if !ok || len(limit) == 0 {
return 0, nil
}
return strconv.ParseUint(limit[0], 10, 64)
} | go | {
"resource": ""
} |
q181057 | OffsetFromMetadata | test | func OffsetFromMetadata(md metadata.MD) (uint64, error) {
offset, ok := md["offset"]
if !ok || len(offset) == 0 {
return 0, nil
}
return strconv.ParseUint(offset[0], 10, 64)
} | go | {
"resource": ""
} |
q181058 | LimitAndOffsetFromIncomingContext | test | func LimitAndOffsetFromIncomingContext(ctx context.Context) (limit, offset uint64, err error) {
md := MetadataFromIncomingContext(ctx)
limit, err = LimitFromMetadata(md)
if err != nil {
return 0, 0, err
}
offset, err = OffsetFromMetadata(md)
if err != nil {
return 0, 0, err
}
return limit, offset, nil
} | go | {
"resource": ""
} |
q181059 | OutgoingContextWithLimitAndOffset | test | func OutgoingContextWithLimitAndOffset(ctx context.Context, limit, offset uint64) context.Context {
var pairs []string
if limit != 0 {
pairs = append(pairs, "limit", 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...)
} | go | {
"resource": ""
} |
q181060 | before | test | func before(i, j ScheduleItem) bool {
iEnd := i.Time().UnixNano() + i.Duration().Nanoseconds()
jStart := j.Time().UnixNano()
if i, ok := i.(ScheduleItemWithTimestamp); ok {
if j, ok := j.(ScheduleItemWithTimestamp); ok {
iEnd = i.Timestamp() + i.Duration().Nanoseconds()
jStart = j.Timestamp()
}
}
return iEnd < jStart
} | go | {
"resource": ""
} |
q181061 | New | test | func (err *ErrDescriptor) New(attributes Attributes) Error {
if err.Code != NoCode && !err.registered {
panic(fmt.Errorf("Error descriptor with code %v was not registered", err.Code))
}
return &impl{
message: Format(err.MessageFormat, attributes),
code: err.Code,
typ: err.Type,
attributes: attributes,
}
} | go | {
"resource": ""
} |
q181062 | WithNamespace | test | func WithNamespace(namespace string, ctx log.Interface) log.Interface {
return ctx.WithField(NamespaceKey, namespace)
} | go | {
"resource": ""
} |
q181063 | Wrap | test | func Wrap(ctx log.Interface, namespaces ...string) *Namespaced {
return &Namespaced{
Interface: ctx,
namespaces: &ns{
namespaces: namespaces,
},
}
} | go | {
"resource": ""
} |
q181064 | WithField | test | func (n *Namespaced) WithField(k string, v interface{}) log.Interface {
if k == NamespaceKey {
if str, ok := v.(string); ok {
return &Namespaced{
Interface: n.Interface,
namespaces: n.namespaces,
namespace: str,
}
}
}
return &Namespaced{
Interface: n.Interface.WithField(k, v),
namespaces: n.namespaces,
namespace: n.namespace,
}
} | go | {
"resource": ""
} |
q181065 | WithFields | test | func (n *Namespaced) WithFields(fields log.Fields) log.Interface {
return &Namespaced{
Interface: n.Interface.WithFields(fields),
namespaces: n.namespaces,
namespace: n.namespace,
}
} | go | {
"resource": ""
} |
q181066 | Format | test | func Format(format string, values Attributes) string {
formatter, err := messageformat.New()
if err != nil {
return format
}
fm, err := formatter.Parse(format)
if err != nil {
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
} | go | {
"resource": ""
} |
q181067 | fix | test | func fix(v interface{}) interface{} {
if v == nil {
return "<nil>"
}
switch reflect.TypeOf(v).Kind() {
case reflect.Bool:
case reflect.Int:
case reflect.Int8:
case reflect.Int16:
case reflect.Int32:
case reflect.Int64:
case reflect.Uint:
case reflect.Uint8:
case reflect.Uint16:
case reflect.Uint32:
case reflect.Uint64:
case 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)
} | go | {
"resource": ""
} |
q181068 | GRPCCode | test | func (t Type) GRPCCode() codes.Code {
switch t {
case InvalidArgument:
return codes.InvalidArgument
case OutOfRange:
return codes.OutOfRange
case NotFound:
return codes.NotFound
case Conflict:
case AlreadyExists:
return codes.AlreadyExists
case Unauthorized:
return codes.Unauthenticated
case PermissionDenied:
return codes.PermissionDenied
case Timeout:
return codes.DeadlineExceeded
case NotImplemented:
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
} | go | {
"resource": ""
} |
q181069 | GRPCCodeToType | test | func GRPCCodeToType(code codes.Code) Type {
switch code {
case codes.InvalidArgument:
return InvalidArgument
case codes.OutOfRange:
return OutOfRange
case codes.NotFound:
return NotFound
case codes.AlreadyExists:
return AlreadyExists
case codes.Unauthenticated:
return Unauthorized
case codes.PermissionDenied:
return PermissionDenied
case codes.DeadlineExceeded:
return Timeout
case codes.Unimplemented:
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
} | go | {
"resource": ""
} |
q181070 | GRPCCode | test | func GRPCCode(err error) codes.Code {
e, ok := err.(Error)
if ok {
return e.Type().GRPCCode()
}
return grpc.Code(err)
} | go | {
"resource": ""
} |
q181071 | FromGRPC | test | func FromGRPC(in error) Error {
out := &impl{
message: grpc.ErrorDesc(in),
typ: GRPCCodeToType(grpc.Code(in)),
code: NoCode,
}
matches := grpcMessageFormat.FindStringSubmatch(in.Error())
if len(matches) < 4 {
return out
}
out.message = matches[1]
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)
} | go | {
"resource": ""
} |
q181072 | ToGRPC | test | func ToGRPC(in error) error {
if err, ok := in.(Error); ok {
attrs, _ := json.Marshal(err.Attributes())
return grpc.Errorf(err.Type().GRPCCode(), format, err.Error(), err.Code(), attrs)
}
return grpc.Errorf(codes.Unknown, in.Error())
} | go | {
"resource": ""
} |
q181073 | IsEnabled | test | func (n *ns) IsEnabled(namespace string) bool {
n.RLock()
defer n.RUnlock()
if namespace == "" {
return true
}
hasStar := false
included := false
for _, ns := range n.namespaces {
// if the namspace is negated, it can never be enabled
if ns == negate(namespace) {
return false
}
// if the namespace is explicitly enabled, mark it as included
if ns == 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
} | go | {
"resource": ""
} |
q181074 | Set | test | func (n *ns) Set(namespaces []string) {
n.Lock()
defer n.Unlock()
n.namespaces = namespaces
} | go | {
"resource": ""
} |
q181075 | Cause | test | func Cause(err Error) error {
attributes := err.Attributes()
if attributes == nil {
return nil
}
cause, ok := attributes[causeKey]
if !ok {
return nil
}
switch v := cause.(type) {
case error:
return v
case string:
return errors.New(v)
default:
return nil
}
} | go | {
"resource": ""
} |
q181076 | parseCode | test | func parseCode(str string) Code {
code, err := strconv.Atoi(str)
if err != nil {
return Code(0)
}
return Code(code)
} | go | {
"resource": ""
} |
q181077 | UnaryServerInterceptor | test | func UnaryServerInterceptor(fn ConvertFunc) grpc.UnaryServerInterceptor {
return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
resp, err = handler(ctx, req)
return resp, fn(err)
}
} | go | {
"resource": ""
} |
q181078 | StreamServerInterceptor | test | func StreamServerInterceptor(fn ConvertFunc) grpc.StreamServerInterceptor {
return func(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) (err error) {
return fn(handler(srv, ss))
}
} | go | {
"resource": ""
} |
q181079 | UnaryClientInterceptor | test | func UnaryClientInterceptor(fn ConvertFunc) grpc.UnaryClientInterceptor {
return func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) (err error) {
return fn(invoker(ctx, method, req, reply, cc, opts...))
}
} | go | {
"resource": ""
} |
q181080 | StreamClientInterceptor | test | func StreamClientInterceptor(fn ConvertFunc) grpc.StreamClientInterceptor {
return func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, 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)
}
} | go | {
"resource": ""
} |
q181081 | Interceptor | test | func Interceptor(settings Settings) grpc.StreamClientInterceptor {
return func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption) (stream grpc.ClientStream, err error) {
s := &restartingStream{
log: log.Get().WithField("method", method),
ctx: ctx,
desc: desc,
cc: cc,
method: method,
streamer: streamer,
opts: opts,
retryableCodes: settings.RetryableCodes,
backoff: settings.Backoff,
retries: -1,
}
err = s.start()
stream = s
return
}
} | go | {
"resource": ""
} |
q181082 | Wrap | test | func Wrap(logger *logrus.Logger) log.Interface {
return &logrusEntryWrapper{logrus.NewEntry(logger)}
} | go | {
"resource": ""
} |
q181083 | NewCounter | test | func NewCounter(bucketSize, retention time.Duration) Counter {
return &counter{
bucketSize: bucketSize,
retention: retention,
buckets: make([]uint64, 2*retention/bucketSize),
}
} | go | {
"resource": ""
} |
q181084 | NewRedisCounter | test | func NewRedisCounter(client *redis.Client, key string, bucketSize, retention time.Duration) Counter {
return &redisCounter{
client: client,
key: key,
bucketSize: bucketSize,
retention: retention,
}
} | go | {
"resource": ""
} |
q181085 | NewLimiter | test | func NewLimiter(counter Counter, duration time.Duration, limit uint64) Limiter {
return &limiter{
Counter: counter,
duration: duration,
limit: limit,
}
} | go | {
"resource": ""
} |
q181086 | WithInsecure | test | func (c *TokenCredentials) WithInsecure() *TokenCredentials {
return &TokenCredentials{token: c.token, tokenFunc: c.tokenFunc, allowInsecure: true}
} | go | {
"resource": ""
} |
q181087 | WithTokenFunc | test | func WithTokenFunc(k string, tokenFunc func(v string) string) *TokenCredentials {
return &TokenCredentials{
tokenFunc: tokenFunc,
tokenFuncKey: k,
}
} | go | {
"resource": ""
} |
q181088 | GetRequestMetadata | test | func (c *TokenCredentials) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) {
md := ttnctx.MetadataFromOutgoingContext(ctx)
token, _ := ttnctx.TokenFromMetadata(md)
if token != "" {
return map[string]string{tokenKey: token}, nil
}
if c.tokenFunc != nil {
var k string
if v, ok := md[c.tokenFuncKey]; ok && len(v) > 0 {
k = v[0]
}
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
} | go | {
"resource": ""
} |
q181089 | FieldsFromIncomingContext | test | func FieldsFromIncomingContext(ctx context.Context) ttnlog.Fields {
fields := make(fieldMap)
if peer, ok := peer.FromContext(ctx); ok {
fields.addFromPeer(peer)
}
if md, ok := metadata.FromIncomingContext(ctx); ok {
fields.addFromMD(md)
}
return fields.LogFields()
} | go | {
"resource": ""
} |
q181090 | String | test | func (t Type) String() string {
switch t {
case Unknown:
return "Unknown"
case Internal:
return "Internal"
case InvalidArgument:
return "Invalid argument"
case OutOfRange:
return "Out of range"
case NotFound:
return "Not found"
case Conflict:
return "Conflict"
case AlreadyExists:
return "Already exists"
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"
}
} | go | {
"resource": ""
} |
q181091 | UnmarshalText | test | func (t *Type) UnmarshalText(text []byte) error {
e, err := fromString(string(text))
if err != nil {
return err
}
*t = e
return nil
} | go | {
"resource": ""
} |
q181092 | fromString | test | func fromString(str string) (Type, error) {
enum := strings.ToLower(str)
switch enum {
case "unknown":
return Unknown, nil
case "internal":
return Internal, nil
case "invalid argument":
return InvalidArgument, nil
case "out of range":
return OutOfRange, nil
case "not found":
return NotFound, nil
case "conflict":
return Conflict, nil
case "already exists":
return AlreadyExists, nil
case "unauthorized":
return Unauthorized, nil
case "permission denied":
return PermissionDenied, nil
case "timeout":
return Timeout, nil
case "not implemented":
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")
}
} | go | {
"resource": ""
} |
q181093 | Start | test | func Start(ctx log.Interface, interval time.Duration) {
ctx.WithField("interval", interval).Debug("starting stats loop")
go func() {
memstats := new(runtime.MemStats)
for range time.Tick(interval) {
runtime.ReadMemStats(memstats)
ctx.WithFields(log.Fields{
"goroutines": runtime.NumGoroutine(),
"memory": float64(memstats.Alloc) / megaByte, // MegaBytes allocated and not yet freed
}).Debugf("memory stats")
}
}()
} | go | {
"resource": ""
} |
q181094 | NewSimple | test | func NewSimple() Simple {
q := &simpleQueue{
queue: make([]interface{}, 0),
}
q.available = sync.NewCond(&q.mu)
return q
} | go | {
"resource": ""
} |
q181095 | Wrap | test | func Wrap(logger log.Interface, filters ...Filter) *Filtered {
return &Filtered{
Interface: logger,
filters: filters,
}
} | go | {
"resource": ""
} |
q181096 | WithFilters | test | func (f *Filtered) WithFilters(filters ...Filter) *Filtered {
return &Filtered{
Interface: f.Interface,
filters: append(f.filters, filters...),
}
} | go | {
"resource": ""
} |
q181097 | WithField | test | func (f *Filtered) WithField(k string, v interface{}) log.Interface {
val := v
// apply the filters
for _, filter := range f.filters {
val = filter.Filter(k, val)
}
return &Filtered{
Interface: f.Interface.WithField(k, val),
filters: f.filters,
}
} | go | {
"resource": ""
} |
q181098 | WithFields | test | func (f *Filtered) WithFields(fields log.Fields) log.Interface {
res := make(map[string]interface{}, len(fields))
for k, v := range fields {
val := 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,
}
} | go | {
"resource": ""
} |
q181099 | FilterSensitive | test | func FilterSensitive(sensitive []string, elided interface{}) Filter {
return FilterFunc(func(key string, v interface{}) interface{} {
lower := strings.ToLower(key)
for _, s := range sensitive {
if lower == s {
return elided
}
}
return v
})
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.