_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q12100 | IsEmpty | train | func (q *Queue) IsEmpty() bool {
return atomic.LoadUint64(q.write.processing) == atomic.LoadUint64(q.read.processing)
} | go | {
"resource": ""
} |
q12101 | RegisterWithDepth | train | func (registry TypeRegistry) RegisterWithDepth(typeInstance interface{}, depth int) {
structType := reflect.TypeOf(typeInstance)
packageName := structType.PkgPath()
typeName := structType.Name()
pathTokens := strings.Split(packageName, "/")
maxDepth := 3
if len(pathTokens) < maxDepth {
maxDepth = len(pathTokens)
}
for n := depth; n <= maxDepth; n++ {
shortTypeName := strings.Join(pathTokens[len(pathTokens)-n:], ".") + "." + typeName
registry.namedType[shortTypeName] = structType
}
} | go | {
"resource": ""
} |
q12102 | GetTypeOf | train | func (registry TypeRegistry) GetTypeOf(typeName string) reflect.Type {
if structType, exists := registry.namedType[typeName]; exists {
return reflect.PtrTo(structType)
}
return nil
} | go | {
"resource": ""
} |
q12103 | IsTypeRegistered | train | func (registry TypeRegistry) IsTypeRegistered(typeName string) bool {
_, exists := registry.namedType[typeName]
return exists
} | go | {
"resource": ""
} |
q12104 | GetRegistered | train | func (registry TypeRegistry) GetRegistered(packageName string) []string {
var result []string
for key := range registry.namedType {
if strings.HasPrefix(key, packageName) {
result = append(result, key)
}
}
return result
} | go | {
"resource": ""
} |
q12105 | Colorize | train | func Colorize(c Color, b BackgroundColor, text string) string {
return fmt.Sprintf("%s%s%s%s%s", ResetColors, c, b, text, ResetColors.String())
} | go | {
"resource": ""
} |
q12106 | Colorizef | train | func Colorizef(c Color, b BackgroundColor, format string, args ...interface{}) string {
args = append([]interface{}{ResetColors, c, b}, args...)
args = append(args, ResetColors)
return fmt.Sprintf("%s%s%s"+format+"%s", args...)
} | go | {
"resource": ""
} |
q12107 | NewMutex | train | func NewMutex(priority SpinPriority) *Mutex {
return &Mutex{
state: new(int32),
priority: priority,
}
} | go | {
"resource": ""
} |
q12108 | TryLock | train | func (m *Mutex) TryLock() bool {
return atomic.CompareAndSwapInt32(m.state, mutexUnlocked, mutexLocked)
} | go | {
"resource": ""
} |
q12109 | Write | train | func (log logNull) Write(message []byte) (int, error) {
return len(message), nil
} | go | {
"resource": ""
} |
q12110 | NextPowerOf2U16 | train | func NextPowerOf2U16(v uint16) uint16 {
v--
v |= v >> 1
v |= v >> 2
v |= v >> 4
v |= v >> 8
v++
return v
} | go | {
"resource": ""
} |
q12111 | NextPowerOf2U32 | train | func NextPowerOf2U32(v uint32) uint32 {
v--
v |= v >> 1
v |= v >> 2
v |= v >> 4
v |= v >> 8
v |= v >> 16
v++
return v
} | go | {
"resource": ""
} |
q12112 | NextPowerOf2U64 | train | func NextPowerOf2U64(v uint64) uint64 {
v--
v |= v >> 1
v |= v >> 2
v |= v >> 4
v |= v >> 8
v |= v >> 16
v |= v >> 32
v++
return v
} | go | {
"resource": ""
} |
q12113 | NewStackWithGrowSize | train | func NewStackWithGrowSize(size, grow int) Stack {
return NewStackWithSpinnerAndGrowSize(size, grow, NewSpinner(SpinPriorityMedium))
} | go | {
"resource": ""
} |
q12114 | NewStackWithSpinner | train | func NewStackWithSpinner(size int, spin Spinner) Stack {
return NewStackWithSpinnerAndGrowSize(size, size, spin)
} | go | {
"resource": ""
} |
q12115 | NewStackWithSpinnerAndGrowSize | train | func NewStackWithSpinnerAndGrowSize(size, grow int, spin Spinner) Stack {
return Stack{
data: make([]interface{}, tmath.MinI(size, 1)),
growBy: tmath.MinI(grow, 1),
head: new(uint32),
spin: spin,
}
} | go | {
"resource": ""
} |
q12116 | Len | train | func (s *Stack) Len() int {
return int(atomic.LoadUint32(s.head) & unlockMask)
} | go | {
"resource": ""
} |
q12117 | Pop | train | func (s *Stack) Pop() (interface{}, error) {
spin := s.spin
for {
head := atomic.LoadUint32(s.head)
unlockedHead := head & unlockMask
lockedHead := head | lockMask
// Always work with unlocked head as head might be locked
if unlockedHead == 0 {
return nil, LimitError{"Stack is empty"}
}
if atomic.CompareAndSwapUint32(s.head, unlockedHead, lockedHead) {
data := s.data[unlockedHead-1] // copy data
atomic.StoreUint32(s.head, unlockedHead-1) // unlock
return data, nil // ### return ###
}
spin.Yield()
}
} | go | {
"resource": ""
} |
q12118 | Push | train | func (s *Stack) Push(v interface{}) error {
spin := s.spin
for {
head := atomic.LoadUint32(s.head)
unlockedHead := head & unlockMask
lockedHead := head | lockMask
// Always work with unlocked head as head might be locked
if unlockedHead == unlockMask {
return LimitError{"Stack is full"}
}
if atomic.CompareAndSwapUint32(s.head, unlockedHead, lockedHead) {
if unlockedHead == uint32(len(s.data)) {
// Grow stack
old := s.data
s.data = make([]interface{}, len(s.data)+s.growBy)
copy(s.data, old)
}
s.data[unlockedHead] = v // write to new head
atomic.StoreUint32(s.head, unlockedHead+1) // unlock
return nil // ### return ###
}
spin.Yield()
}
} | go | {
"resource": ""
} |
q12119 | ItoLen | train | func ItoLen(number uint64) int {
switch {
case number < 10:
return 1
default:
return int(math.Log10(float64(number)) + 1)
}
} | go | {
"resource": ""
} |
q12120 | Itob | train | func Itob(number uint64, buffer []byte) error {
numberLen := ItoLen(number)
bufferLen := len(buffer)
if numberLen > bufferLen {
return fmt.Errorf("Number too large for buffer")
}
for i := numberLen - 1; i >= 0; i-- {
buffer[i] = '0' + byte(number%10)
number /= 10
}
return nil
} | go | {
"resource": ""
} |
q12121 | Itobe | train | func Itobe(number uint64, buffer []byte) error {
for i := len(buffer) - 1; i >= 0; i-- {
buffer[i] = '0' + byte(number%10)
number /= 10
// Check here because the number 0 has to be written, too
if number == 0 {
return nil
}
}
return fmt.Errorf("Number too large for buffer")
} | go | {
"resource": ""
} |
q12122 | Btoi | train | func Btoi(buffer []byte) (uint64, int) {
number := uint64(0)
index := 0
bufferLen := len(buffer)
for index < bufferLen && buffer[index] >= '0' && buffer[index] <= '9' {
parsed := uint64(buffer[index] - '0')
number = number*10 + parsed
index++
}
return number, index
} | go | {
"resource": ""
} |
q12123 | IndexN | train | func IndexN(s, sep string, n int) int {
sepIdx := 0
for i := 0; i < n; i++ {
nextIdx := strings.Index(s[sepIdx:], sep)
if nextIdx == -1 {
return -1 // ### return, not found ###
}
sepIdx += nextIdx + 1
}
return sepIdx - 1
} | go | {
"resource": ""
} |
q12124 | LastIndexN | train | func LastIndexN(s, sep string, n int) int {
if n == 0 {
return -1 // ### return, nonsense ###
}
sepIdx := len(s)
for i := 0; i < n; i++ {
sepIdx = strings.LastIndex(s[:sepIdx], sep)
if sepIdx == -1 {
return -1 // ### return, not found ###
}
}
return sepIdx
} | go | {
"resource": ""
} |
q12125 | IsInt | train | func IsInt(s string) bool {
for i, c := range s {
if (c < '0' || c > '9') && (c != '-' || i != 0) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q12126 | IsJSON | train | func IsJSON(data []byte) (bool, error, *json.RawMessage) {
delayedResult := new(json.RawMessage)
err := json.Unmarshal(data, delayedResult)
return err == nil, err, delayedResult
} | go | {
"resource": ""
} |
q12127 | NewByteRef | train | func NewByteRef(a string) ByteRef {
stringHeader := (*reflect.StringHeader)(unsafe.Pointer(&a))
sliceHeader := &reflect.SliceHeader{
Data: stringHeader.Data,
Len: stringHeader.Len,
Cap: stringHeader.Len,
}
return *(*ByteRef)(unsafe.Pointer(sliceHeader))
} | go | {
"resource": ""
} |
q12128 | NewStringRef | train | func NewStringRef(a []byte) StringRef {
sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&a))
stringHeader := &reflect.StringHeader{
Data: sliceHeader.Data,
Len: sliceHeader.Len,
}
return *(*StringRef)(unsafe.Pointer(stringHeader))
} | go | {
"resource": ""
} |
q12129 | JoinStringers | train | func JoinStringers(a []fmt.Stringer, sep string) string {
if len(a) == 0 {
return ""
}
if len(a) == 1 {
return a[0].String()
}
str := make([]string, len(a))
for i, s := range a {
str[i] = s.String()
}
return strings.Join(str, sep)
} | go | {
"resource": ""
} |
q12130 | GetNumBase | train | func GetNumBase(num string) (string, int) {
switch {
case len(num) == 0:
return num, 10
case len(num) > 1 && num[0] == '0':
if num[1] == 'x' {
return num[2:], 16
}
return num[1:], 8
}
return num, 10
} | go | {
"resource": ""
} |
q12131 | AtoI64 | train | func AtoI64(num string) (int64, error) {
if len(num) == 0 {
return 0, nil
}
n, b := GetNumBase(num)
return strconv.ParseInt(n, b, 64)
} | go | {
"resource": ""
} |
q12132 | AtoU64 | train | func AtoU64(num string) (uint64, error) {
if len(num) == 0 {
return 0, nil
}
n, b := GetNumBase(num)
return strconv.ParseUint(n, b, 64)
} | go | {
"resource": ""
} |
q12133 | Serialize | train | func (s JSONSerializer) Serialize(ss *sessions.Session) ([]byte, error) {
m := make(map[string]interface{}, len(ss.Values))
for k, v := range ss.Values {
ks, ok := k.(string)
if !ok {
err := fmt.Errorf("Non-string key value, cannot serialize session to JSON: %v", k)
fmt.Printf("redistore.JSONSerializer.serialize() Error: %v", err)
return nil, err
}
m[ks] = v
}
return json.Marshal(m)
} | go | {
"resource": ""
} |
q12134 | Serialize | train | func (s GobSerializer) Serialize(ss *sessions.Session) ([]byte, error) {
buf := new(bytes.Buffer)
enc := gob.NewEncoder(buf)
err := enc.Encode(ss.Values)
if err == nil {
return buf.Bytes(), nil
}
return nil, err
} | go | {
"resource": ""
} |
q12135 | ping | train | func (s *RediStore) ping() (bool, error) {
conn := s.Pool.Get()
defer conn.Close()
data, err := conn.Do("PING")
if err != nil || data == nil {
return false, err
}
return (data == "PONG"), nil
} | go | {
"resource": ""
} |
q12136 | save | train | func (s *RediStore) save(session *sessions.Session) error {
b, err := s.serializer.Serialize(session)
if err != nil {
return err
}
if s.maxLength != 0 && len(b) > s.maxLength {
return errors.New("SessionStore: the value to store is too big")
}
conn := s.Pool.Get()
defer conn.Close()
if err = conn.Err(); err != nil {
return err
}
age := session.Options.MaxAge
if age == 0 {
age = s.DefaultMaxAge
}
_, err = conn.Do("SETEX", s.keyPrefix+session.ID, age, b)
return err
} | go | {
"resource": ""
} |
q12137 | load | train | func (s *RediStore) load(session *sessions.Session) (bool, error) {
conn := s.Pool.Get()
defer conn.Close()
if err := conn.Err(); err != nil {
return false, err
}
data, err := conn.Do("GET", s.keyPrefix+session.ID)
if err != nil {
return false, err
}
if data == nil {
return false, nil // no data was associated with this key
}
b, err := redis.Bytes(data, err)
if err != nil {
return false, err
}
return true, s.serializer.Deserialize(b, session)
} | go | {
"resource": ""
} |
q12138 | delete | train | func (s *RediStore) delete(session *sessions.Session) error {
conn := s.Pool.Get()
defer conn.Close()
if _, err := conn.Do("DEL", s.keyPrefix+session.ID); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q12139 | Load | train | func (m *Map) Load(key interface{}) (elem interface{}, found bool) {
m.lock.RLock()
elem, found = m.data[key]
m.lock.RUnlock()
return
} | go | {
"resource": ""
} |
q12140 | Store | train | func (m *Map) Store(key interface{}, elem interface{}) {
m.lock.Lock()
m.data[key] = elem
m.lock.Unlock()
} | go | {
"resource": ""
} |
q12141 | Go | train | func (executor *UnboundedExecutor) Go(handler func(ctx context.Context)) {
pc := reflect.ValueOf(handler).Pointer()
f := runtime.FuncForPC(pc)
funcName := f.Name()
file, line := f.FileLine(pc)
executor.activeGoroutinesMutex.Lock()
defer executor.activeGoroutinesMutex.Unlock()
startFrom := fmt.Sprintf("%s:%d", file, line)
executor.activeGoroutines[startFrom] += 1
go func() {
defer func() {
recovered := recover()
// if you want to quit a goroutine without trigger HandlePanic
// use runtime.Goexit() to quit
if recovered != nil {
if executor.HandlePanic == nil {
HandlePanic(recovered, funcName)
} else {
executor.HandlePanic(recovered, funcName)
}
}
executor.activeGoroutinesMutex.Lock()
executor.activeGoroutines[startFrom] -= 1
executor.activeGoroutinesMutex.Unlock()
}()
handler(executor.ctx)
}()
} | go | {
"resource": ""
} |
q12142 | StopAndWait | train | func (executor *UnboundedExecutor) StopAndWait(ctx context.Context) {
executor.cancel()
for {
oneHundredMilliseconds := time.NewTimer(time.Millisecond * 100)
select {
case <-oneHundredMilliseconds.C:
if executor.checkNoActiveGoroutines() {
return
}
case <-ctx.Done():
return
}
}
} | go | {
"resource": ""
} |
q12143 | AppendMeasure | train | func AppendMeasure(b []byte, t time.Time, m stats.Measure) []byte {
b = append(b, m.Name...)
for _, tag := range m.Tags {
b = append(b, ',')
b = append(b, tag.Name...)
b = append(b, '=')
b = append(b, tag.Value...)
}
for i, field := range m.Fields {
if len(field.Name) == 0 {
field.Name = "value"
}
if i == 0 {
b = append(b, ' ')
} else {
b = append(b, ',')
}
b = append(b, field.Name...)
b = append(b, '=')
switch v := field.Value; v.Type() {
case stats.Null:
case stats.Bool:
if v.Bool() {
b = append(b, "true"...)
} else {
b = append(b, "false"...)
}
case stats.Int:
b = strconv.AppendInt(b, v.Int(), 10)
case stats.Uint:
b = strconv.AppendUint(b, v.Uint(), 10)
case stats.Float:
b = strconv.AppendFloat(b, v.Float(), 'g', -1, 64)
case stats.Duration:
b = strconv.AppendFloat(b, v.Duration().Seconds(), 'g', -1, 64)
}
}
b = append(b, ' ')
b = strconv.AppendInt(b, t.UnixNano(), 10)
return append(b, '\n')
} | go | {
"resource": ""
} |
q12144 | NewEngine | train | func NewEngine(prefix string, handler Handler, tags ...Tag) *Engine {
return &Engine{
Handler: handler,
Prefix: prefix,
Tags: SortTags(copyTags(tags)),
}
} | go | {
"resource": ""
} |
q12145 | Register | train | func (eng *Engine) Register(handler Handler) {
if eng.Handler == Discard {
eng.Handler = handler
} else {
eng.Handler = MultiHandler(eng.Handler, handler)
}
} | go | {
"resource": ""
} |
q12146 | WithPrefix | train | func (eng *Engine) WithPrefix(prefix string, tags ...Tag) *Engine {
return &Engine{
Handler: eng.Handler,
Prefix: eng.makeName(prefix),
Tags: eng.makeTags(tags),
}
} | go | {
"resource": ""
} |
q12147 | Clock | train | func (eng *Engine) Clock(name string, tags ...Tag) *Clock {
return eng.ClockAt(name, time.Now(), tags...)
} | go | {
"resource": ""
} |
q12148 | ClockAt | train | func (eng *Engine) ClockAt(name string, start time.Time, tags ...Tag) *Clock {
cpy := make([]Tag, len(tags), len(tags)+1) // clock always appends a stamp.
copy(cpy, tags)
return &Clock{
name: name,
first: start,
last: start,
tags: cpy,
eng: eng,
}
} | go | {
"resource": ""
} |
q12149 | ReportAt | train | func (eng *Engine) ReportAt(time time.Time, metrics interface{}, tags ...Tag) {
var tb *tagsBuffer
if len(tags) == 0 {
// fast path for the common case where there are no dynamic tags
tags = eng.Tags
} else {
tb = tagsPool.Get().(*tagsBuffer)
tb.append(tags...)
tb.append(eng.Tags...)
tb.sort()
tags = tb.tags
}
mb := measurePool.Get().(*measuresBuffer)
mb.measures = appendMeasures(mb.measures[:0], &eng.cache, eng.Prefix, reflect.ValueOf(metrics), tags...)
ms := mb.measures
eng.Handler.HandleMeasures(time, ms...)
for i := range ms {
ms[i].reset()
}
if tb != nil {
tb.reset()
tagsPool.Put(tb)
}
measurePool.Put(mb)
} | go | {
"resource": ""
} |
q12150 | WithPrefix | train | func WithPrefix(prefix string, tags ...Tag) *Engine {
return DefaultEngine.WithPrefix(prefix, tags...)
} | go | {
"resource": ""
} |
q12151 | IncrAt | train | func IncrAt(time time.Time, name string, tags ...Tag) {
DefaultEngine.IncrAt(time, name, tags...)
} | go | {
"resource": ""
} |
q12152 | ObserveAt | train | func ObserveAt(time time.Time, name string, value interface{}, tags ...Tag) {
DefaultEngine.ObserveAt(time, name, value, tags...)
} | go | {
"resource": ""
} |
q12153 | ReportAt | train | func ReportAt(time time.Time, metrics interface{}, tags ...Tag) {
DefaultEngine.ReportAt(time, metrics, tags...)
} | go | {
"resource": ""
} |
q12154 | AppendMeasure | train | func AppendMeasure(b []byte, m stats.Measure) []byte {
return AppendMeasureFiltered(b, m, nil)
} | go | {
"resource": ""
} |
q12155 | statusCode | train | func statusCode(code int) string {
if code >= 100 {
switch {
case code < 200:
return statusCodeWithTable(code-100, statusCode100[:])
case code < 300:
return statusCodeWithTable(code-200, statusCode200[:])
case code < 400:
return statusCodeWithTable(code-300, statusCode300[:])
case code < 500:
return statusCodeWithTable(code-400, statusCode400[:])
case code < 600:
return statusCodeWithTable(code-500, statusCode500[:])
}
}
return strconv.Itoa(code)
} | go | {
"resource": ""
} |
q12156 | le | train | func le(buckets []stats.Value) string {
if len(buckets) == 0 {
return ""
}
b := make([]byte, 0, 8*len(buckets))
for i, v := range buckets {
if i != 0 {
b = append(b, ':')
}
b = appendFloat(b, valueOf(v))
}
return *(*string)(unsafe.Pointer(&reflect.StringHeader{
Data: uintptr(unsafe.Pointer(&b[0])),
Len: len(b),
}))
} | go | {
"resource": ""
} |
q12157 | HandleMeasures | train | func (b *Buffer) HandleMeasures(time time.Time, measures ...Measure) {
if len(measures) == 0 {
return
}
size := b.bufferSize()
b.prepare(size)
buffer := b.acquireBuffer()
length := buffer.len()
buffer.append(b.Serializer, time, measures...)
if buffer.len() >= size {
if length == 0 {
// When there were no data in the buffer prior to writing the set of
// measures we unfortunately have to overflow the configured buffer
// size, but the Serializer documentation mentions that this corner
// case has to be handled.
length = buffer.len()
}
buffer.flush(b.Serializer, length)
}
buffer.release()
} | go | {
"resource": ""
} |
q12158 | Flush | train | func (b *Buffer) Flush() {
b.prepare(b.bufferSize())
for i := range b.buffers {
if buffer := &b.buffers[i]; buffer.acquire() {
buffer.flush(b.Serializer, buffer.len())
buffer.release()
}
}
} | go | {
"resource": ""
} |
q12159 | ServeSearch | train | func (f SearchHandlerFunc) ServeSearch(ctx context.Context, res SearchResponse, req *SearchRequest) error {
return f(ctx, res, req)
} | go | {
"resource": ""
} |
q12160 | MakeField | train | func MakeField(name string, value interface{}, ftype FieldType) Field {
f := Field{Name: name, Value: ValueOf(value)}
f.setType(ftype)
return f
} | go | {
"resource": ""
} |
q12161 | NewTransport | train | func NewTransport(t http.RoundTripper) http.RoundTripper {
return NewTransportWith(stats.DefaultEngine, t)
} | go | {
"resource": ""
} |
q12162 | NewTransportWith | train | func NewTransportWith(eng *stats.Engine, t http.RoundTripper) http.RoundTripper {
return &transport{
transport: t,
eng: eng,
}
} | go | {
"resource": ""
} |
q12163 | RequestWithTags | train | func RequestWithTags(req *http.Request, tags ...stats.Tag) *http.Request {
ctx := req.Context()
ctx = context.WithValue(ctx, contextKeyReqTags, tags)
return req.WithContext(ctx)
} | go | {
"resource": ""
} |
q12164 | RoundTrip | train | func (t *transport) RoundTrip(req *http.Request) (res *http.Response, err error) {
start := time.Now()
rtrip := t.transport
eng := t.eng
if rtrip == nil {
rtrip = http.DefaultTransport
}
if tags, ok := req.Context().Value(contextKeyReqTags).([]stats.Tag); ok {
eng = eng.WithTags(tags...)
}
if req.Body == nil {
req.Body = &nullBody{}
}
m := &metrics{}
req.Body = &requestBody{
eng: eng,
req: req,
metrics: m,
body: req.Body,
op: "write",
}
res, err = rtrip.RoundTrip(req)
// safe guard, the transport should have done it already
req.Body.Close() // nolint
if err != nil {
m.observeError(time.Now().Sub(start))
eng.ReportAt(start, m)
} else {
res.Body = &responseBody{
eng: eng,
res: res,
metrics: m,
body: res.Body,
op: "read",
start: start,
}
}
return
} | go | {
"resource": ""
} |
q12165 | ServeQuery | train | func (f QueryHandlerFunc) ServeQuery(ctx context.Context, res QueryResponse, req *QueryRequest) error {
return f(ctx, res, req)
} | go | {
"resource": ""
} |
q12166 | Col | train | func Col(text string, colType ColumnType) Column {
return Column{Text: text, Type: colType}
} | go | {
"resource": ""
} |
q12167 | AscCol | train | func AscCol(text string, colType ColumnType) Column {
return Column{Text: text, Type: colType, Sort: true}
} | go | {
"resource": ""
} |
q12168 | DescCol | train | func DescCol(text string, colType ColumnType) Column {
return Column{Text: text, Type: colType, Sort: true, Desc: true}
} | go | {
"resource": ""
} |
q12169 | Set | train | func (b HistogramBuckets) Set(key string, buckets ...interface{}) {
v := make([]Value, len(buckets))
for i, b := range buckets {
v[i] = ValueOf(b)
}
b[makeKey(key)] = v
} | go | {
"resource": ""
} |
q12170 | NewProcMetricsWith | train | func NewProcMetricsWith(eng *stats.Engine, pid int) *ProcMetrics {
p := &ProcMetrics{engine: eng, pid: pid}
p.cpu.user.typ = "user"
p.cpu.system.typ = "system"
p.memory.resident.typ = "resident"
p.memory.shared.typ = "shared"
p.memory.text.typ = "text"
p.memory.data.typ = "data"
p.memory.pagefault.major.typ = "major"
p.memory.pagefault.minor.typ = "minor"
p.threads.switches.voluntary.typ = "voluntary"
p.threads.switches.involuntary.typ = "involuntary"
return p
} | go | {
"resource": ""
} |
q12171 | NewHandler | train | func NewHandler(prefix string, handler Handler) http.Handler {
mux := http.NewServeMux()
Handle(mux, prefix, handler)
return mux
} | go | {
"resource": ""
} |
q12172 | NewClient | train | func NewClient(addr string) *Client {
return NewClientWith(ClientConfig{ClientConfig: datadog.ClientConfig{Address: addr}})
} | go | {
"resource": ""
} |
q12173 | NewClientGlobal | train | func NewClientGlobal(addr string) *Client {
return NewClientWith(ClientConfig{ClientConfig: datadog.ClientConfig{Address: addr}, GlobalOnly: true})
} | go | {
"resource": ""
} |
q12174 | NewClientWith | train | func NewClientWith(config ClientConfig) *Client {
// Construct Veneur-specific Tags we will append to measures
tags := []stats.Tag{}
if config.GlobalOnly {
tags = append(tags, stats.Tag{Name: GlobalOnly})
} else if config.LocalOnly {
tags = append(tags, stats.Tag{Name: LocalOnly})
}
for _, t := range config.SinksOnly {
tags = append(tags, stats.Tag{Name: SinkOnly, Value: t})
}
return &Client{
Client: datadog.NewClientWith(datadog.ClientConfig{
Address: config.Address,
BufferSize: config.BufferSize,
Filters: config.Filters,
}),
tags: tags,
}
} | go | {
"resource": ""
} |
q12175 | NewHandler | train | func NewHandler(h http.Handler) http.Handler {
return NewHandlerWith(stats.DefaultEngine, h)
} | go | {
"resource": ""
} |
q12176 | NewHandlerWith | train | func NewHandlerWith(eng *stats.Engine, h http.Handler) http.Handler {
return &handler{
handler: h,
eng: eng,
}
} | go | {
"resource": ""
} |
q12177 | ListenAndServe | train | func ListenAndServe(addr string, handler Handler) (err error) {
var conn net.PacketConn
if conn, err = net.ListenPacket("udp", addr); err != nil {
return
}
err = Serve(conn, handler)
return
} | go | {
"resource": ""
} |
q12178 | Serve | train | func Serve(conn net.PacketConn, handler Handler) (err error) {
defer conn.Close()
concurrency := runtime.GOMAXPROCS(-1)
if concurrency <= 0 {
concurrency = 1
}
done := make(chan error, concurrency)
conn.SetDeadline(time.Time{})
for i := 0; i != concurrency; i++ {
go serve(conn, handler, done)
}
for i := 0; i != concurrency; i++ {
switch e := <-done; e {
case nil, io.EOF, io.ErrClosedPipe, io.ErrUnexpectedEOF:
default:
err = e
}
conn.Close()
}
return
} | go | {
"resource": ""
} |
q12179 | M | train | func M(m map[string]string) []Tag {
tags := make([]Tag, 0, len(m))
for k, v := range m {
tags = append(tags, T(k, v))
}
return tags
} | go | {
"resource": ""
} |
q12180 | TagsAreSorted | train | func TagsAreSorted(tags []Tag) bool {
if len(tags) > 1 {
min := tags[0].Name
for _, tag := range tags[1:] {
if tag.Name < min {
return false
}
min = tag.Name
}
}
return true
} | go | {
"resource": ""
} |
q12181 | SortTags | train | func SortTags(tags []Tag) []Tag {
// Insertion sort since these arrays are very small and allocation is the
// primary enemy of performance here.
if len(tags) >= 20 {
sort.Sort(tagsByName(tags))
} else {
for i := 0; i < len(tags); i++ {
for j := i; j > 0 && tags[j-1].Name > tags[j].Name; j-- {
tags[j], tags[j-1] = tags[j-1], tags[j]
}
}
}
return tags
} | go | {
"resource": ""
} |
q12182 | NewClientWith | train | func NewClientWith(config ClientConfig) *Client {
if len(config.Address) == 0 {
config.Address = DefaultAddress
}
if config.BufferSize == 0 {
config.BufferSize = DefaultBufferSize
}
if config.Filters == nil {
config.Filters = DefaultFilters
}
// transform filters from array to map
filterMap := make(map[string]struct{})
for _, f := range config.Filters {
filterMap[f] = struct{}{}
}
c := &Client{
serializer: serializer{
filters: filterMap,
},
}
conn, bufferSize, err := dial(config.Address, config.BufferSize)
if err != nil {
log.Printf("stats/datadog: %s", err)
}
c.conn, c.err, c.bufferSize = conn, err, bufferSize
c.buffer.BufferSize = bufferSize
c.buffer.Serializer = &c.serializer
log.Printf("stats/datadog: sending metrics with a buffer of size %d B", bufferSize)
return c
} | go | {
"resource": ""
} |
q12183 | ServeAnnotations | train | func (f AnnotationsHandlerFunc) ServeAnnotations(ctx context.Context, res AnnotationsResponse, req *AnnotationsRequest) error {
return f(ctx, res, req)
} | go | {
"resource": ""
} |
q12184 | HandleMeasures | train | func (f HandlerFunc) HandleMeasures(time time.Time, measures ...Measure) {
f(time, measures...)
} | go | {
"resource": ""
} |
q12185 | MultiHandler | train | func MultiHandler(handlers ...Handler) Handler {
multi := make([]Handler, 0, len(handlers))
for _, h := range handlers {
if h != nil {
if m, ok := h.(*multiHandler); ok {
multi = append(multi, m.handlers...) // flatten multi handlers
} else {
multi = append(multi, h)
}
}
}
if len(multi) == 1 {
return multi[0]
}
return &multiHandler{handlers: multi}
} | go | {
"resource": ""
} |
q12186 | NewHandlerWith | train | func NewHandlerWith(eng *stats.Engine, hdl Handler) Handler {
return &handler{
handler: hdl,
eng: eng,
}
} | go | {
"resource": ""
} |
q12187 | ServeHTTP | train | func (h *Handler) ServeHTTP(res http.ResponseWriter, req *http.Request) {
switch req.Method {
case "GET", "HEAD":
default:
res.WriteHeader(http.StatusMethodNotAllowed)
return
}
w := io.Writer(res)
res.Header().Set("Content-Type", "text/plain; version=0.0.4")
if acceptEncoding(req.Header.Get("Accept-Encoding"), "gzip") {
res.Header().Set("Content-Encoding", "gzip")
zw := gzip.NewWriter(w)
defer zw.Close()
w = zw
}
h.WriteStats(w)
} | go | {
"resource": ""
} |
q12188 | NewClientWith | train | func NewClientWith(config ClientConfig) *Client {
if len(config.Address) == 0 {
config.Address = DefaultAddress
}
if len(config.Database) == 0 {
config.Database = DefaultDatabase
}
if config.BufferSize == 0 {
config.BufferSize = DefaultBufferSize
}
if config.Timeout == 0 {
config.Timeout = DefaultTimeout
}
c := &Client{
serializer: serializer{
url: makeURL(config.Address, config.Database),
done: make(chan struct{}),
http: http.Client{
Timeout: config.Timeout,
Transport: config.Transport,
},
},
}
c.buffer.BufferSize = config.BufferSize
c.buffer.Serializer = &c.serializer
return c
} | go | {
"resource": ""
} |
q12189 | CreateDB | train | func (c *Client) CreateDB(db string) error {
u := *c.url
q := u.Query()
q.Del("db")
u.Path = "/query"
u.RawQuery = q.Encode()
r, err := c.http.Post(u.String(), "application/x-www-form-urlencoded", strings.NewReader(
fmt.Sprintf("q=CREATE DATABASE %q", db),
))
if err != nil {
return err
}
return readResponse(r)
} | go | {
"resource": ""
} |
q12190 | StopAt | train | func (c *Clock) StopAt(now time.Time) {
c.observe("total", now.Sub(c.first))
} | go | {
"resource": ""
} |
q12191 | NewDelayMetricsWith | train | func NewDelayMetricsWith(eng *stats.Engine, pid int) *DelayMetrics {
return &DelayMetrics{engine: eng, pid: pid}
} | go | {
"resource": ""
} |
q12192 | NewGoMetricsWith | train | func NewGoMetricsWith(eng *stats.Engine) *GoMetrics {
g := &GoMetrics{
engine: eng,
version: runtime.Version(),
}
g.memstats.total.memtype = "total"
g.memstats.heap.memtype = "heap"
g.memstats.stack.memtype = "stack"
g.memstats.mspan.memtype = "mspan"
g.memstats.mcache.memtype = "mcache"
g.memstats.buckhash.memtype = "bucket_hash_table"
g.memstats.gc.memtype = "gc"
g.memstats.other.memtype = "other"
return g
} | go | {
"resource": ""
} |
q12193 | NewConn | train | func NewConn(c net.Conn) net.Conn {
return NewConnWith(stats.DefaultEngine, c)
} | go | {
"resource": ""
} |
q12194 | NewConnWith | train | func NewConnWith(eng *stats.Engine, c net.Conn) net.Conn {
nc := &conn{Conn: c, eng: eng}
proto := c.LocalAddr().Network()
nc.r.metrics.protocol = proto
nc.w.metrics.protocol = proto
eng.Incr("conn.open:count", stats.T("protocol", proto))
return nc
} | go | {
"resource": ""
} |
q12195 | List | train | func List() ([]string, error) {
godelw, err := newGodelwRunner()
if err != nil {
return nil, err
}
products, err := godelw.run("products")
if err != nil {
return nil, err
}
return strings.Split(products, "\n"), nil
} | go | {
"resource": ""
} |
q12196 | Dist | train | func Dist(product string) (string, error) {
godelw, err := newGodelwRunner()
if err != nil {
return "", err
}
if _, err := godelw.run("dist", product); err != nil {
return "", err
}
return godelw.run("artifacts", "dist", "--absolute", product)
} | go | {
"resource": ""
} |
q12197 | MustNewPluginInfo | train | func MustNewPluginInfo(group, product, version string, params ...PluginInfoParam) PluginInfo {
cmd, err := NewPluginInfo(group, product, version, params...)
if err != nil {
panic(errors.Wrapf(err, "failed to create plugin info"))
}
return cmd
} | go | {
"resource": ""
} |
q12198 | String | train | func (o OSArch) String() string {
return fmt.Sprintf("%v-%v", o.OS, o.Arch)
} | go | {
"resource": ""
} |
q12199 | ConfigNotSupported | train | func ConfigNotSupported(name string, cfgBytes []byte) ([]byte, error) {
var mapSlice yaml.MapSlice
if err := yaml.Unmarshal(cfgBytes, &mapSlice); err != nil {
return nil, errors.Wrapf(err, "failed to unmarshal %s configuration as yaml.MapSlice", name)
}
if len(mapSlice) != 0 {
return nil, errors.Errorf("%s does not currently support configuration", name)
}
return cfgBytes, nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.