_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q8700 | SetDefaultLoggerName | train | func (client *Client) SetDefaultLoggerName(name string) {
client.mu.Lock()
defer client.mu.Unlock()
client.defaultLoggerName = name
} | go | {
"resource": ""
} |
q8701 | SetSampleRate | train | func (client *Client) SetSampleRate(rate float32) error {
client.mu.Lock()
defer client.mu.Unlock()
if rate < 0 || rate > 1 {
return ErrInvalidSampleRate
}
client.sampleRate = rate
return nil
} | go | {
"resource": ""
} |
q8702 | Capture | train | func (client *Client) Capture(packet *Packet, captureTags map[string]string) (eventID string, ch chan error) {
ch = make(chan error, 1)
if client == nil {
// return a chan that always returns nil when the caller receives from it
close(ch)
return
}
if client.sampleRate < 1.0 && mrand.Float32() > client.sampleRate {
return
}
if packet == nil {
close(ch)
return
}
if client.shouldExcludeErr(packet.Message) {
return
}
// Keep track of all running Captures so that we can wait for them all to finish
// *Must* call client.wg.Done() on any path that indicates that an event was
// finished being acted upon, whether success or failure
client.wg.Add(1)
// Merge capture tags and client tags
packet.AddTags(captureTags)
packet.AddTags(client.Tags)
// Initialize any required packet fields
client.mu.RLock()
packet.AddTags(client.context.tags)
projectID := client.projectID
release := client.release
environment := client.environment
defaultLoggerName := client.defaultLoggerName
client.mu.RUnlock()
// set the global logger name on the packet if we must
if packet.Logger == "" && defaultLoggerName != "" {
packet.Logger = defaultLoggerName
}
err := packet.Init(projectID)
if err != nil {
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.Do(func() {
go client.worker()
})
select {
case client.queue <- outgoingPacket:
default:
// Send would block, drop the packet
if client.DropHandler != nil {
client.DropHandler(packet)
}
ch <- ErrPacketDropped
client.wg.Done()
}
return packet.EventID, ch
} | go | {
"resource": ""
} |
q8703 | CaptureMessage | train | func (client *Client) CaptureMessage(message string, tags map[string]string, interfaces ...Interface) string {
if client == nil {
return ""
}
if client.shouldExcludeErr(message) {
return ""
}
packet := NewPacket(message, append(append(interfaces, client.context.interfaces()...), &Message{message, nil})...)
eventID, _ := client.Capture(packet, tags)
return eventID
} | go | {
"resource": ""
} |
q8704 | CaptureMessageAndWait | train | func CaptureMessageAndWait(message string, tags map[string]string, interfaces ...Interface) string {
return DefaultClient.CaptureMessageAndWait(message, tags, interfaces...)
} | go | {
"resource": ""
} |
q8705 | CaptureError | train | func (client *Client) CaptureError(err error, tags map[string]string, interfaces ...Interface) string {
if client == nil {
return ""
}
if err == nil {
return ""
}
if client.shouldExcludeErr(err.Error()) {
return ""
}
extra := extractExtra(err)
cause := Cause(err)
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
} | go | {
"resource": ""
} |
q8706 | CaptureErrorAndWait | train | func CaptureErrorAndWait(err error, tags map[string]string, interfaces ...Interface) string {
return DefaultClient.CaptureErrorAndWait(err, tags, interfaces...)
} | go | {
"resource": ""
} |
q8707 | CapturePanicAndWait | train | func CapturePanicAndWait(f func(), tags map[string]string, interfaces ...Interface) (interface{}, string) {
return DefaultClient.CapturePanicAndWait(f, tags, interfaces...)
} | go | {
"resource": ""
} |
q8708 | URL | train | func (client *Client) URL() string {
client.mu.RLock()
defer client.mu.RUnlock()
return client.url
} | go | {
"resource": ""
} |
q8709 | ProjectID | train | func (client *Client) ProjectID() string {
client.mu.RLock()
defer client.mu.RUnlock()
return client.projectID
} | go | {
"resource": ""
} |
q8710 | Release | train | func (client *Client) Release() string {
client.mu.RLock()
defer client.mu.RUnlock()
return client.release
} | go | {
"resource": ""
} |
q8711 | IncludePaths | train | func (client *Client) IncludePaths() []string {
client.mu.RLock()
defer client.mu.RUnlock()
return client.includePaths
} | go | {
"resource": ""
} |
q8712 | SetIncludePaths | train | func (client *Client) SetIncludePaths(p []string) {
client.mu.Lock()
defer client.mu.Unlock()
client.includePaths = p
} | go | {
"resource": ""
} |
q8713 | SetUserContext | train | func (client *Client) SetUserContext(u *User) {
client.mu.Lock()
defer client.mu.Unlock()
client.context.setUser(u)
} | go | {
"resource": ""
} |
q8714 | SetHttpContext | train | func (client *Client) SetHttpContext(h *Http) {
client.mu.Lock()
defer client.mu.Unlock()
client.context.setHttp(h)
} | go | {
"resource": ""
} |
q8715 | SetTagsContext | train | func (client *Client) SetTagsContext(t map[string]string) {
client.mu.Lock()
defer client.mu.Unlock()
client.context.setTags(t)
} | go | {
"resource": ""
} |
q8716 | ClearContext | train | func (client *Client) ClearContext() {
client.mu.Lock()
defer client.mu.Unlock()
client.context.clear()
} | go | {
"resource": ""
} |
q8717 | Send | train | func (t *HTTPTransport) Send(url, authHeader string, packet *Packet) error {
if url == "" {
return nil
}
body, contentType, err := serializedPacket(packet)
if err != nil {
return fmt.Errorf("raven: error serializing packet: %v", err)
}
req, err := http.NewRequest("POST", url, body)
if err != nil {
return fmt.Errorf("raven: can't create new request: %v", err)
}
req.Header.Set("X-Sentry-Auth", authHeader)
req.Header.Set("User-Agent", userAgent)
req.Header.Set("Content-Type", contentType)
res, err := t.Do(req)
if err != nil {
return err
}
// Response body needs to be drained and closed in order for 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 != 200 {
return fmt.Errorf("raven: got http status %d - x-sentry-error: %s", res.StatusCode, res.Header.Get("X-Sentry-Error"))
}
return nil
} | go | {
"resource": ""
} |
q8718 | NewHttp | train | func NewHttp(req *http.Request) *Http {
proto := "http"
if req.TLS != nil || req.Header.Get("X-Forwarded-Proto") == "https" {
proto = "https"
}
h := &Http{
Method: req.Method,
Cookies: req.Header.Get("Cookie"),
Query: sanitizeQuery(req.URL.Query()).Encode(),
URL: proto + "://" + req.Host + req.URL.Path,
Headers: make(map[string]string, 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
} | go | {
"resource": ""
} |
q8719 | Write | train | func (w *Writer) Write(p []byte) (int, error) {
message := string(p)
packet := NewPacket(message, &Message{message, nil})
packet.Level = w.Level
packet.Logger = w.Logger
w.Client.Capture(packet, nil)
return len(p), nil
} | go | {
"resource": ""
} |
q8720 | roundUpPower2 | train | func roundUpPower2(i uintptr) uintptr {
i--
i |= i >> 1
i |= i >> 2
i |= i >> 4
i |= i >> 8
i |= i >> 16
i |= i >> 32
i++
return i
} | go | {
"resource": ""
} |
q8721 | log2 | train | func log2(i uintptr) uintptr {
var n, p uintptr
for p = 1; p < i; p += p {
n++
}
return n
} | go | {
"resource": ""
} |
q8722 | getKeyHash | train | func getKeyHash(key interface{}) uintptr {
switch x := key.(type) {
case string:
return getStringHash(x)
case []byte:
return uintptr(siphash.Hash(sipHashKey1, sipHashKey2, x))
case int:
return getUintptrHash(uintptr(x))
case int8:
return getUintptrHash(uintptr(x))
case int16:
return getUintptrHash(uintptr(x))
case 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 getUintptrHash(uintptr(x))
case uintptr:
return getUintptrHash(x)
}
panic(fmt.Errorf("unsupported key type %T", key))
} | go | {
"resource": ""
} |
q8723 | New | train | func New(size uintptr) *HashMap {
m := &HashMap{}
m.allocate(size)
return m
} | go | {
"resource": ""
} |
q8724 | Fillrate | train | func (m *HashMap) Fillrate() uintptr {
data := m.mapData()
count := atomic.LoadUintptr(&data.count)
l := uintptr(len(data.index))
return (count * 100) / l
} | go | {
"resource": ""
} |
q8725 | DelHashedKey | train | func (m *HashMap) DelHashedKey(hashedKey uintptr) {
list := m.list()
if list == nil {
return
}
_, element := m.indexElement(hashedKey)
if element == nil {
return
}
m.deleteElement(element)
list.Delete(element)
} | go | {
"resource": ""
} |
q8726 | deleteElement | train | func (m *HashMap) deleteElement(element *ListElement) {
for {
data := m.mapData()
index := element.keyHash >> data.keyshifts
ptr := (*unsafe.Pointer)(unsafe.Pointer(uintptr(data.data) + index*intSizeBytes))
next := element.Next()
if next != nil && element.keyHash>>data.keyshifts != index {
next = nil // do not set index to next item if it's not the same slice index
}
atomic.CompareAndSwapPointer(ptr, unsafe.Pointer(element), unsafe.Pointer(next))
currentdata := m.mapData()
if data == currentdata { // check that no resize happened
break
}
}
} | go | {
"resource": ""
} |
q8727 | Insert | train | func (m *HashMap) Insert(key interface{}, value interface{}) bool {
h := getKeyHash(key)
element := &ListElement{
key: key,
keyHash: h,
value: unsafe.Pointer(&value),
}
return m.insertListElement(element, false)
} | go | {
"resource": ""
} |
q8728 | Set | train | func (m *HashMap) Set(key interface{}, value interface{}) {
h := getKeyHash(key)
element := &ListElement{
key: key,
keyHash: h,
value: unsafe.Pointer(&value),
}
m.insertListElement(element, true)
} | go | {
"resource": ""
} |
q8729 | SetHashedKey | train | func (m *HashMap) SetHashedKey(hashedKey uintptr, value interface{}) {
element := &ListElement{
key: hashedKey,
keyHash: hashedKey,
value: unsafe.Pointer(&value),
}
m.insertListElement(element, true)
} | go | {
"resource": ""
} |
q8730 | CasHashedKey | train | func (m *HashMap) CasHashedKey(hashedKey uintptr, from, to interface{}) bool {
data, existing := m.indexElement(hashedKey)
if data == nil {
return false
}
list := m.list()
if list == nil {
return false
}
element := &ListElement{
key: hashedKey,
keyHash: hashedKey,
value: unsafe.Pointer(&to),
}
return list.Cas(element, from, existing)
} | go | {
"resource": ""
} |
q8731 | Cas | train | func (m *HashMap) Cas(key, from, to interface{}) bool {
h := getKeyHash(key)
return m.CasHashedKey(h, from, to)
} | go | {
"resource": ""
} |
q8732 | addItemToIndex | train | func (mapData *hashMapData) addItemToIndex(item *ListElement) uintptr {
index := item.keyHash >> mapData.keyshifts
ptr := (*unsafe.Pointer)(unsafe.Pointer(uintptr(mapData.data) + index*intSizeBytes))
for { // loop until the smallest key hash is in the index
element := (*ListElement)(atomic.LoadPointer(ptr)) // get the current item in the index
if element == nil { // no item yet at this index
if atomic.CompareAndSwapPointer(ptr, nil, unsafe.Pointer(item)) {
return atomic.AddUintptr(&mapData.count, 1)
}
continue // a new item was inserted concurrently, 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
}
} | go | {
"resource": ""
} |
q8733 | Grow | train | func (m *HashMap) Grow(newSize uintptr) {
if atomic.CompareAndSwapUintptr(&m.resizing, uintptr(0), uintptr(1)) {
go m.grow(newSize, true)
}
} | go | {
"resource": ""
} |
q8734 | String | train | func (m *HashMap) String() string {
list := m.list()
if list == nil {
return "[]"
}
buffer := bytes.NewBufferString("")
buffer.WriteRune('[')
first := list.First()
item := first
for item != nil {
if item != first {
buffer.WriteRune(',')
}
fmt.Fprint(buffer, item.keyHash)
item = item.Next()
}
buffer.WriteRune(']')
return buffer.String()
} | go | {
"resource": ""
} |
q8735 | Iter | train | func (m *HashMap) Iter() <-chan KeyValue {
ch := make(chan KeyValue) // do not use a size here since items can get added during iteration
go func() {
list := m.list()
if list == nil {
close(ch)
return
}
item := list.First()
for item != nil {
value := item.Value()
ch <- KeyValue{item.key, value}
item = item.Next()
}
close(ch)
}()
return ch
} | go | {
"resource": ""
} |
q8736 | GetUintKey | train | func (m *HashMap) GetUintKey(key uintptr) (value interface{}, ok bool) {
// inline getUintptrHash()
bh := reflect.SliceHeader{
Data: uintptr(unsafe.Pointer(&key)),
Len: intSizeBytes,
Cap: intSizeBytes,
}
buf := *(*[]byte)(unsafe.Pointer(&bh))
h := 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, false
}
element = element.Next()
}
return nil, false
} | go | {
"resource": ""
} |
q8737 | GetHashedKey | train | func (m *HashMap) GetHashedKey(hashedKey uintptr) (value interface{}, ok bool) {
data, element := m.indexElement(hashedKey)
if data == nil {
return nil, false
}
// inline HashMap.searchItem()
for element != nil {
if element.keyHash == hashedKey {
return element.Value(), true
}
if element.keyHash > hashedKey {
return nil, false
}
element = element.Next()
}
return nil, false
} | go | {
"resource": ""
} |
q8738 | GetOrInsert | train | func (m *HashMap) GetOrInsert(key interface{}, value interface{}) (actual interface{}, loaded bool) {
h := getKeyHash(key)
var newelement *ListElement
for {
data, element := m.indexElement(h)
if data == nil {
m.allocate(DefaultSize)
continue
}
for element != nil {
if element.keyHash == h {
switch key.(type) {
case []byte:
if bytes.Compare(element.key.([]byte), key.([]byte)) == 0 {
return element.Value(), true
}
default:
if element.key == key {
actual = element.Value()
return actual, true
}
}
}
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
}
}
} | go | {
"resource": ""
} |
q8739 | Len | train | func (l *List) Len() int {
if l == nil { // not initialized yet?
return 0
}
return int(atomic.LoadUintptr(&l.count))
} | go | {
"resource": ""
} |
q8740 | First | train | func (l *List) First() *ListElement {
if l == nil { // not initialized yet?
return nil
}
return l.head.Next()
} | go | {
"resource": ""
} |
q8741 | Add | train | func (l *List) Add(element *ListElement, searchStart *ListElement) (existed bool, inserted bool) {
left, found, right := l.search(searchStart, element)
if found != nil { // existing item found
return true, false
}
return false, l.insertAt(element, left, right)
} | go | {
"resource": ""
} |
q8742 | AddOrUpdate | train | func (l *List) AddOrUpdate(element *ListElement, searchStart *ListElement) bool {
left, found, right := l.search(searchStart, element)
if found != nil { // existing item found
found.setValue(element.value) // update the value
return true
}
return l.insertAt(element, left, right)
} | go | {
"resource": ""
} |
q8743 | Cas | train | func (l *List) Cas(element *ListElement, oldValue interface{}, searchStart *ListElement) bool {
_, found, _ := l.search(searchStart, element)
if found == nil { // no existing item found
return false
}
if found.casValue(oldValue, element.value) {
atomic.AddUintptr(&l.count, 1)
return true
}
return false
} | go | {
"resource": ""
} |
q8744 | Delete | train | func (l *List) Delete(element *ListElement) {
if !atomic.CompareAndSwapUintptr(&element.deleted, uintptr(0), uintptr(1)) {
return // concurrent delete of the item in progress
}
for {
left := element.Previous()
right := element.Next()
if left == nil { // element is first item in list?
if !atomic.CompareAndSwapPointer(&l.head.nextElement, unsafe.Pointer(element), unsafe.Pointer(right)) {
continue // now head item was inserted concurrently
}
} else {
if !atomic.CompareAndSwapPointer(&left.nextElement, unsafe.Pointer(element), unsafe.Pointer(right)) {
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
} | go | {
"resource": ""
} |
q8745 | setValue | train | func (e *ListElement) setValue(value unsafe.Pointer) {
atomic.StorePointer(&e.value, value)
} | go | {
"resource": ""
} |
q8746 | casValue | train | func (e *ListElement) casValue(from interface{}, to unsafe.Pointer) bool {
old := atomic.LoadPointer(&e.value)
if *(*interface{})(old) != from {
return false
}
return atomic.CompareAndSwapPointer(&e.value, old, to)
} | go | {
"resource": ""
} |
q8747 | NewCookie | train | func NewCookie(name string, value string, age ...int64) *http.Cookie {
if !isValidCookieName(name) || !isValidCookieValue([]byte(value)) {
return nil
}
var utctime time.Time
if len(age) == 0 {
// 2^31 - 1 seconds (roughly 2038)
utctime = time.Unix(2147483647, 0)
} else {
utctime = time.Unix(time.Now().Unix()+age[0], 0)
}
return &http.Cookie{Name: name, Value: value, Expires: utctime}
} | go | {
"resource": ""
} |
q8748 | Get | train | func (c *cookies) Get(key string) *http.Cookie {
ck, err := c.req.Cookie(key)
if err != nil {
return nil
}
return ck
} | go | {
"resource": ""
} |
q8749 | Set | train | func (c *cookies) Set(ck *http.Cookie) {
http.SetCookie(c.ResponseWriter, ck)
} | go | {
"resource": ""
} |
q8750 | Expire | train | func (c *cookies) Expire(key string, expire time.Time) {
ck := c.Get(key)
if ck != nil {
ck.Expires = expire
ck.MaxAge = int(expire.Sub(time.Now()).Seconds())
c.Set(ck)
}
} | go | {
"resource": ""
} |
q8751 | Del | train | func (c *cookies) Del(key string) {
c.Expire(key, time.Date(1900, 1, 1, 0, 0, 0, 0, time.Local))
} | go | {
"resource": ""
} |
q8752 | String | train | func (c *cookies) String(key string) (string, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return "", err
}
return ck.Value, nil
} | go | {
"resource": ""
} |
q8753 | Int | train | func (c *cookies) Int(key string) (int, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return 0, err
}
return strconv.Atoi(ck.Value)
} | go | {
"resource": ""
} |
q8754 | Int32 | train | func (c *cookies) Int32(key string) (int32, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return 0, err
}
v, err := strconv.ParseInt(ck.Value, 10, 32)
return int32(v), err
} | go | {
"resource": ""
} |
q8755 | Int64 | train | func (c *cookies) Int64(key string) (int64, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return 0, err
}
return strconv.ParseInt(ck.Value, 10, 64)
} | go | {
"resource": ""
} |
q8756 | Uint | train | func (c *cookies) Uint(key string) (uint, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return 0, err
}
v, err := strconv.ParseUint(ck.Value, 10, 64)
return uint(v), err
} | go | {
"resource": ""
} |
q8757 | Uint32 | train | func (c *cookies) Uint32(key string) (uint32, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return 0, err
}
v, err := strconv.ParseUint(ck.Value, 10, 32)
return uint32(v), err
} | go | {
"resource": ""
} |
q8758 | Uint64 | train | func (c *cookies) Uint64(key string) (uint64, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return 0, err
}
return strconv.ParseUint(ck.Value, 10, 64)
} | go | {
"resource": ""
} |
q8759 | Float32 | train | func (c *cookies) Float32(key string) (float32, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return 0, err
}
v, err := strconv.ParseFloat(ck.Value, 32)
return float32(v), err
} | go | {
"resource": ""
} |
q8760 | Float64 | train | func (c *cookies) Float64(key string) (float64, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return 0, err
}
return strconv.ParseFloat(ck.Value, 32)
} | go | {
"resource": ""
} |
q8761 | Bool | train | func (c *cookies) Bool(key string) (bool, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return false, err
}
return strconv.ParseBool(ck.Value)
} | go | {
"resource": ""
} |
q8762 | MustString | train | func (c *cookies) MustString(key string, defaults ...string) string {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return ""
}
return ck.Value
} | go | {
"resource": ""
} |
q8763 | MustEscape | train | func (c *cookies) MustEscape(key string, defaults ...string) string {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return ""
}
return template.HTMLEscapeString(ck.Value)
} | go | {
"resource": ""
} |
q8764 | MustInt | train | func (c *cookies) MustInt(key string, defaults ...int) int {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return 0
}
v, err := strconv.Atoi(ck.Value)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return v
} | go | {
"resource": ""
} |
q8765 | MustInt32 | train | func (c *cookies) MustInt32(key string, defaults ...int32) int32 {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return 0
}
v, err := strconv.ParseInt(ck.Value, 10, 32)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return int32(v)
} | go | {
"resource": ""
} |
q8766 | MustInt64 | train | func (c *cookies) MustInt64(key string, defaults ...int64) int64 {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return 0
}
v, err := strconv.ParseInt(ck.Value, 10, 64)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return v
} | go | {
"resource": ""
} |
q8767 | MustUint | train | func (c *cookies) MustUint(key string, defaults ...uint) uint {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return 0
}
v, err := strconv.ParseUint(ck.Value, 10, 64)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return uint(v)
} | go | {
"resource": ""
} |
q8768 | MustUint32 | train | func (c *cookies) MustUint32(key string, defaults ...uint32) uint32 {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return 0
}
v, err := strconv.ParseUint(ck.Value, 10, 32)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return uint32(v)
} | go | {
"resource": ""
} |
q8769 | MustUint64 | train | func (c *cookies) MustUint64(key string, defaults ...uint64) uint64 {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return 0
}
v, err := strconv.ParseUint(ck.Value, 10, 64)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return v
} | go | {
"resource": ""
} |
q8770 | MustFloat32 | train | func (c *cookies) MustFloat32(key string, defaults ...float32) float32 {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return 0
}
v, err := strconv.ParseFloat(ck.Value, 32)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return float32(v)
} | go | {
"resource": ""
} |
q8771 | MustFloat64 | train | func (c *cookies) MustFloat64(key string, defaults ...float64) float64 {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return 0
}
v, err := strconv.ParseFloat(ck.Value, 32)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return v
} | go | {
"resource": ""
} |
q8772 | MustBool | train | func (c *cookies) MustBool(key string, defaults ...bool) bool {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return false
}
v, err := strconv.ParseBool(ck.Value)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return v
} | go | {
"resource": ""
} |
q8773 | Cookie | train | func (ctx *Context) Cookie(key string, defaults ...string) string {
return ctx.Cookies().MustString(key, defaults...)
} | go | {
"resource": ""
} |
q8774 | CookieEscape | train | func (ctx *Context) CookieEscape(key string, defaults ...string) string {
return ctx.Cookies().MustEscape(key, defaults...)
} | go | {
"resource": ""
} |
q8775 | CookieInt | train | func (ctx *Context) CookieInt(key string, defaults ...int) int {
return ctx.Cookies().MustInt(key, defaults...)
} | go | {
"resource": ""
} |
q8776 | CookieInt32 | train | func (ctx *Context) CookieInt32(key string, defaults ...int32) int32 {
return ctx.Cookies().MustInt32(key, defaults...)
} | go | {
"resource": ""
} |
q8777 | CookieInt64 | train | func (ctx *Context) CookieInt64(key string, defaults ...int64) int64 {
return ctx.Cookies().MustInt64(key, defaults...)
} | go | {
"resource": ""
} |
q8778 | CookieUint | train | func (ctx *Context) CookieUint(key string, defaults ...uint) uint {
return ctx.Cookies().MustUint(key, defaults...)
} | go | {
"resource": ""
} |
q8779 | CookieUint32 | train | func (ctx *Context) CookieUint32(key string, defaults ...uint32) uint32 {
return ctx.Cookies().MustUint32(key, defaults...)
} | go | {
"resource": ""
} |
q8780 | CookieUint64 | train | func (ctx *Context) CookieUint64(key string, defaults ...uint64) uint64 {
return ctx.Cookies().MustUint64(key, defaults...)
} | go | {
"resource": ""
} |
q8781 | CookieFloat32 | train | func (ctx *Context) CookieFloat32(key string, defaults ...float32) float32 {
return ctx.Cookies().MustFloat32(key, defaults...)
} | go | {
"resource": ""
} |
q8782 | CookieFloat64 | train | func (ctx *Context) CookieFloat64(key string, defaults ...float64) float64 {
return ctx.Cookies().MustFloat64(key, defaults...)
} | go | {
"resource": ""
} |
q8783 | CookieBool | train | func (ctx *Context) CookieBool(key string, defaults ...bool) bool {
return ctx.Cookies().MustBool(key, defaults...)
} | go | {
"resource": ""
} |
q8784 | Int32 | train | func (c *secureCookies) Int32(key string) (int32, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return 0, err
}
s := parseSecureCookie(c.secret, ck.Value)
v, err := strconv.ParseInt(s, 10, 32)
return int32(v), err
} | go | {
"resource": ""
} |
q8785 | Int64 | train | func (c *secureCookies) Int64(key string) (int64, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return 0, err
}
s := parseSecureCookie(c.secret, ck.Value)
return strconv.ParseInt(s, 10, 64)
} | go | {
"resource": ""
} |
q8786 | Uint | train | func (c *secureCookies) Uint(key string) (uint, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return 0, err
}
s := parseSecureCookie(c.secret, ck.Value)
v, err := strconv.ParseUint(s, 10, 64)
return uint(v), err
} | go | {
"resource": ""
} |
q8787 | Uint64 | train | func (c *secureCookies) Uint64(key string) (uint64, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return 0, err
}
s := parseSecureCookie(c.secret, ck.Value)
return strconv.ParseUint(s, 10, 64)
} | go | {
"resource": ""
} |
q8788 | Float32 | train | func (c *secureCookies) Float32(key string) (float32, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return 0, err
}
s := parseSecureCookie(c.secret, ck.Value)
v, err := strconv.ParseFloat(s, 32)
return float32(v), err
} | go | {
"resource": ""
} |
q8789 | Float64 | train | func (c *secureCookies) Float64(key string) (float64, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return 0, err
}
s := parseSecureCookie(c.secret, ck.Value)
return strconv.ParseFloat(s, 32)
} | go | {
"resource": ""
} |
q8790 | Bool | train | func (c *secureCookies) Bool(key string) (bool, error) {
ck, err := c.req.Cookie(key)
if err != nil {
return false, err
}
s := parseSecureCookie(c.secret, ck.Value)
return strconv.ParseBool(s)
} | go | {
"resource": ""
} |
q8791 | MustString | train | func (c *secureCookies) MustString(key string, defaults ...string) string {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return ""
}
s := parseSecureCookie(c.secret, ck.Value)
return s
} | go | {
"resource": ""
} |
q8792 | MustEscape | train | func (c *secureCookies) MustEscape(key string, defaults ...string) string {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return ""
}
s := parseSecureCookie(c.secret, ck.Value)
return template.HTMLEscapeString(s)
} | go | {
"resource": ""
} |
q8793 | MustInt | train | func (c *secureCookies) MustInt(key string, defaults ...int) int {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return 0
}
s := parseSecureCookie(c.secret, ck.Value)
v, err := strconv.Atoi(s)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return v
} | go | {
"resource": ""
} |
q8794 | MustInt32 | train | func (c *secureCookies) MustInt32(key string, defaults ...int32) int32 {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return 0
}
s := parseSecureCookie(c.secret, ck.Value)
v, err := strconv.ParseInt(s, 10, 32)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return int32(v)
} | go | {
"resource": ""
} |
q8795 | MustUint | train | func (c *secureCookies) MustUint(key string, defaults ...uint) uint {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return 0
}
s := parseSecureCookie(c.secret, ck.Value)
v, err := strconv.ParseUint(s, 10, 64)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return uint(v)
} | go | {
"resource": ""
} |
q8796 | MustFloat32 | train | func (c *secureCookies) MustFloat32(key string, defaults ...float32) float32 {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return 0
}
s := parseSecureCookie(c.secret, ck.Value)
v, err := strconv.ParseFloat(s, 32)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return float32(v)
} | go | {
"resource": ""
} |
q8797 | MustBool | train | func (c *secureCookies) MustBool(key string, defaults ...bool) bool {
ck, err := c.req.Cookie(key)
if err != nil {
if len(defaults) > 0 {
return defaults[0]
}
return false
}
s := parseSecureCookie(c.secret, ck.Value)
v, err := strconv.ParseBool(s)
if len(defaults) > 0 && err != nil {
return defaults[0]
}
return v
} | go | {
"resource": ""
} |
q8798 | NewSecureCookie | train | func NewSecureCookie(secret, name string, val string, age ...int64) *http.Cookie {
var buf bytes.Buffer
encoder := base64.NewEncoder(base64.StdEncoding, &buf)
encoder.Write([]byte(val))
encoder.Close()
cookie := secCookieValue(secret, buf.Bytes())
return NewCookie(name, cookie, age...)
} | go | {
"resource": ""
} |
q8799 | Expire | train | func (c *secureCookies) Expire(key string, expire time.Time) {
ck := c.Get(key)
if ck != nil {
ck.Expires = expire
ck.Value = secCookieValue(c.secret, []byte(ck.Value))
c.Set(ck)
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.