id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c8700 | defer client.mu.Unlock()
client.defaultLoggerName = name
} | |
c8701 |
if rate < 0 || rate > 1 {
return ErrInvalidSampleRate
}
client.sampleRate = rate
return nil
} | |
c8702 | {
ch <- err
client.wg.Done()
return
}
if packet.Release == "" {
packet.Release = release
}
if packet.Environment == "" {
packet.Environment = environment
}
outgoingPacket := &outgoingPacket{packet, ch}
// Lazily start background worker until we
// do our first write into the queue.
client.start.... | |
c8703 | packet := NewPacket(message, append(append(interfaces, client.context.interfaces()...), &Message{message, nil})...)
eventID, _ := client.Capture(packet, tags)
return eventID
} | |
c8704 | return DefaultClient.CaptureMessageAndWait(message, tags, interfaces...)
} | |
c8705 | packet := NewPacketWithExtra(err.Error(), extra, append(append(interfaces, client.context.interfaces()...), NewException(cause, GetOrNewStacktrace(cause, 1, 3, client.includePaths)))...)
eventID, _ := client.Capture(packet, tags)
return eventID
} | |
c8706 | return DefaultClient.CaptureErrorAndWait(err, tags, interfaces...)
} | |
c8707 | return DefaultClient.CapturePanicAndWait(f, tags, interfaces...)
} | |
c8708 | client.mu.RUnlock()
return client.url
} | |
c8709 | client.mu.RUnlock()
return client.projectID
} | |
c8710 | client.mu.RUnlock()
return client.release
} | |
c8711 | client.mu.RUnlock()
return client.includePaths
} | |
c8712 | defer client.mu.Unlock()
client.includePaths = p
} | |
c8713 | client.mu.Lock()
defer client.mu.Unlock()
client.context.setUser(u)
} | |
c8714 | client.mu.Lock()
defer client.mu.Unlock()
client.context.setHttp(h)
} | |
c8715 | defer client.mu.Unlock()
client.context.setTags(t)
} | |
c8716 | client.mu.Unlock()
client.context.clear()
} | |
c8717 | TCP connection to stay opened (via keep-alive) and reused
_, err = io.Copy(ioutil.Discard, res.Body)
if err != nil {
debugLogger.Println("Error while reading response body", res)
}
err = res.Body.Close()
if err != nil {
debugLogger.Println("Error while closing response body", err)
}
if res.StatusCode != 2... | |
c8718 | len(req.Header)),
}
if addr, port, err := net.SplitHostPort(req.RemoteAddr); err == nil {
h.Env = map[string]string{"REMOTE_ADDR": addr, "REMOTE_PORT": port}
}
for k, v := range req.Header {
h.Headers[k] = strings.Join(v, ",")
}
h.Headers["Host"] = req.Host
return h
} | |
c8719 | &Message{message, nil})
packet.Level = w.Level
packet.Logger = w.Logger
w.Client.Capture(packet, nil)
return len(p), nil
} | |
c8720 |
i |= i >> 16
i |= i >> 32
i++
return i
} | |
c8721 | i; p += p {
n++
}
return n
} | |
c8722 | int32:
return getUintptrHash(uintptr(x))
case int64:
return getUintptrHash(uintptr(x))
case uint:
return getUintptrHash(uintptr(x))
case uint8:
return getUintptrHash(uintptr(x))
case uint16:
return getUintptrHash(uintptr(x))
case uint32:
return getUintptrHash(uintptr(x))
case uint64:
return getUint... | |
c8723 |
m.allocate(size)
return m
} | |
c8724 | := uintptr(len(data.index))
return (count * 100) / l
} | |
c8725 | if element == nil {
return
}
m.deleteElement(element)
list.Delete(element)
} | |
c8726 | atomic.CompareAndSwapPointer(ptr, unsafe.Pointer(element), unsafe.Pointer(next))
currentdata := m.mapData()
if data == currentdata { // check that no resize happened
break
}
}
} | |
c8727 | unsafe.Pointer(&value),
}
return m.insertListElement(element, false)
} | |
c8728 | unsafe.Pointer(&value),
}
m.insertListElement(element, true)
} | |
c8729 | key: hashedKey,
keyHash: hashedKey,
value: unsafe.Pointer(&value),
}
m.insertListElement(element, true)
} | |
c8730 | }
list := m.list()
if list == nil {
return false
}
element := &ListElement{
key: hashedKey,
keyHash: hashedKey,
value: unsafe.Pointer(&to),
}
return list.Cas(element, from, existing)
} | |
c8731 | bool {
h := getKeyHash(key)
return m.CasHashedKey(h, from, to)
} | |
c8732 | retry
}
if item.keyHash < element.keyHash {
// the new item is the smallest for this index?
if !atomic.CompareAndSwapPointer(ptr, unsafe.Pointer(element), unsafe.Pointer(item)) {
continue // a new item was inserted concurrently, retry
}
}
return 0
}
} | |
c8733 | uintptr(0), uintptr(1)) {
go m.grow(newSize, true)
}
} | |
c8734 | if item != first {
buffer.WriteRune(',')
}
fmt.Fprint(buffer, item.keyHash)
item = item.Next()
}
buffer.WriteRune(']')
return buffer.String()
} | |
c8735 |
value := item.Value()
ch <- KeyValue{item.key, value}
item = item.Next()
}
close(ch)
}()
return ch
} | |
c8736 | := uintptr(siphash.Hash(sipHashKey1, sipHashKey2, buf))
data, element := m.indexElement(h)
if data == nil {
return nil, false
}
// inline HashMap.searchItem()
for element != nil {
if element.keyHash == h && element.key == key {
return element.Value(), true
}
if element.keyHash > h {
return nil, f... | |
c8737 | hashedKey {
return element.Value(), true
}
if element.keyHash > hashedKey {
return nil, false
}
element = element.Next()
}
return nil, false
} | |
c8738 | if element.keyHash > h {
break
}
element = element.Next()
}
if newelement == nil { // allocate only once
newelement = &ListElement{
key: key,
keyHash: h,
value: unsafe.Pointer(&value),
}
}
if m.insertListElement(newelement, false) {
return value, false
}
}
} | |
c8739 | return int(atomic.LoadUintptr(&l.count))
} | |
c8740 | nil { // not initialized yet?
return nil
}
return l.head.Next()
} | |
c8741 | { // existing item found
return true, false
}
return false, l.insertAt(element, left, right)
} | |
c8742 | item found
found.setValue(element.value) // update the value
return true
}
return l.insertAt(element, left, right)
} | |
c8743 |
if found.casValue(oldValue, element.value) {
atomic.AddUintptr(&l.count, 1)
return true
}
return false
} | |
c8744 | continue // item was modified concurrently
}
}
if right != nil {
atomic.CompareAndSwapPointer(&right.previousElement, unsafe.Pointer(element), unsafe.Pointer(left))
}
break
}
atomic.AddUintptr(&l.count, ^uintptr(0)) // decrease counter
} | |
c8745 | atomic.StorePointer(&e.value, value)
} | |
c8746 | false
}
return atomic.CompareAndSwapPointer(&e.value, old, to)
} | |
c8747 | utctime = time.Unix(2147483647, 0)
} else {
utctime = time.Unix(time.Now().Unix()+age[0], 0)
}
return &http.Cookie{Name: name, Value: value, Expires: utctime}
} | |
c8748 | ck, err := c.req.Cookie(key)
if err != nil {
return nil
}
return ck
} | |
c8749 | http.SetCookie(c.ResponseWriter, ck)
} | |
c8750 | if ck != nil {
ck.Expires = expire
ck.MaxAge = int(expire.Sub(time.Now()).Seconds())
c.Set(ck)
}
} | |
c8751 | 1, 0, 0, 0, 0, time.Local))
} | |
c8752 |
return "", err
}
return ck.Value, nil
} | |
c8753 | return 0, err
}
return strconv.Atoi(ck.Value)
} | |
c8754 | if err != nil {
return 0, err
}
v, err := strconv.ParseInt(ck.Value, 10, 32)
return int32(v), err
} | |
c8755 | 0, err
}
return strconv.ParseInt(ck.Value, 10, 64)
} | |
c8756 | if err != nil {
return 0, err
}
v, err := strconv.ParseUint(ck.Value, 10, 64)
return uint(v), err
} | |
c8757 | if err != nil {
return 0, err
}
v, err := strconv.ParseUint(ck.Value, 10, 32)
return uint32(v), err
} | |
c8758 | return 0, err
}
return strconv.ParseUint(ck.Value, 10, 64)
} | |
c8759 | if err != nil {
return 0, err
}
v, err := strconv.ParseFloat(ck.Value, 32)
return float32(v), err
} | |
c8760 | return 0, err
}
return strconv.ParseFloat(ck.Value, 32)
} | |
c8761 | false, err
}
return strconv.ParseBool(ck.Value)
} | |
c8762 | if len(defaults) > 0 {
return defaults[0]
}
return ""
}
return ck.Value
} | |
c8763 | if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return ""
}
return template.HTMLEscapeString(ck.Value)
} | |
c8764 |
v, err := strconv.Atoi(ck.Value)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return v
} | |
c8765 | v, err := strconv.ParseInt(ck.Value, 10, 32)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return int32(v)
} | |
c8766 | v, err := strconv.ParseInt(ck.Value, 10, 64)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return v
} | |
c8767 | v, err := strconv.ParseUint(ck.Value, 10, 64)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return uint(v)
} | |
c8768 | v, err := strconv.ParseUint(ck.Value, 10, 32)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return uint32(v)
} | |
c8769 |
v, err := strconv.ParseUint(ck.Value, 10, 64)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return v
} | |
c8770 |
v, err := strconv.ParseFloat(ck.Value, 32)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return float32(v)
} | |
c8771 |
}
v, err := strconv.ParseFloat(ck.Value, 32)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return v
} | |
c8772 | v, err := strconv.ParseBool(ck.Value)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return v
} | |
c8773 | ctx.Cookies().MustString(key, defaults...)
} | |
c8774 | return ctx.Cookies().MustEscape(key, defaults...)
} | |
c8775 | return ctx.Cookies().MustInt(key, defaults...)
} | |
c8776 | return ctx.Cookies().MustInt32(key, defaults...)
} | |
c8777 | return ctx.Cookies().MustInt64(key, defaults...)
} | |
c8778 | return ctx.Cookies().MustUint(key, defaults...)
} | |
c8779 | return ctx.Cookies().MustUint32(key, defaults...)
} | |
c8780 | return ctx.Cookies().MustUint64(key, defaults...)
} | |
c8781 | return ctx.Cookies().MustFloat32(key, defaults...)
} | |
c8782 | return ctx.Cookies().MustFloat64(key, defaults...)
} | |
c8783 | return ctx.Cookies().MustBool(key, defaults...)
} | |
c8784 | != nil {
return 0, err
}
s := parseSecureCookie(c.secret, ck.Value)
v, err := strconv.ParseInt(s, 10, 32)
return int32(v), err
} | |
c8785 | if err != nil {
return 0, err
}
s := parseSecureCookie(c.secret, ck.Value)
return strconv.ParseInt(s, 10, 64)
} | |
c8786 | }
s := parseSecureCookie(c.secret, ck.Value)
v, err := strconv.ParseUint(s, 10, 64)
return uint(v), err
} | |
c8787 | if err != nil {
return 0, err
}
s := parseSecureCookie(c.secret, ck.Value)
return strconv.ParseUint(s, 10, 64)
} | |
c8788 | != nil {
return 0, err
}
s := parseSecureCookie(c.secret, ck.Value)
v, err := strconv.ParseFloat(s, 32)
return float32(v), err
} | |
c8789 | if err != nil {
return 0, err
}
s := parseSecureCookie(c.secret, ck.Value)
return strconv.ParseFloat(s, 32)
} | |
c8790 | if err != nil {
return false, err
}
s := parseSecureCookie(c.secret, ck.Value)
return strconv.ParseBool(s)
} | |
c8791 |
}
return ""
}
s := parseSecureCookie(c.secret, ck.Value)
return s
} | |
c8792 | }
return ""
}
s := parseSecureCookie(c.secret, ck.Value)
return template.HTMLEscapeString(s)
} | |
c8793 | s := parseSecureCookie(c.secret, ck.Value)
v, err := strconv.Atoi(s)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return v
} | |
c8794 | := parseSecureCookie(c.secret, ck.Value)
v, err := strconv.ParseInt(s, 10, 32)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return int32(v)
} | |
c8795 | parseSecureCookie(c.secret, ck.Value)
v, err := strconv.ParseUint(s, 10, 64)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return uint(v)
} | |
c8796 | s := parseSecureCookie(c.secret, ck.Value)
v, err := strconv.ParseFloat(s, 32)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return float32(v)
} | |
c8797 | s := parseSecureCookie(c.secret, ck.Value)
v, err := strconv.ParseBool(s)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return v
} | |
c8798 | encoder.Close()
cookie := secCookieValue(secret, buf.Bytes())
return NewCookie(name, cookie, age...)
} | |
c8799 | if ck != nil {
ck.Expires = expire
ck.Value = secCookieValue(c.secret, []byte(ck.Value))
c.Set(ck)
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.