_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(pathToken... | 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.C... | 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... | 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.seri... | 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... | 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 assoc... | 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", fi... | 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"
}
... | 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 = ... | 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:
ret... | 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]))... | 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... | 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 ==... | 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 ... | 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.... | 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 :... | 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], t... | 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... | 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 ... | 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-Encodin... | 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 = DefaultTime... | 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 readRespo... | 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.buckha... | 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... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.