id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c182500 | json.NewDecoder(res.Body).Decode(&data)
if !data.Success && data.Error != "" {
return nil, errors.New(data.Error)
}
return data.Rants, nil
} | |
c182501 |
return RantModel{}, err
}
var data RantResponse
json.NewDecoder(res.Body).Decode(&data)
if !data.Success && data.Error != "" {
return RantModel{}, errors.New(data.Error)
}
return data.Rant, nil
} | |
c182502 | nil {
return nil, err
}
var data RantsResponse
json.NewDecoder(res.Body).Decode(&data)
if !data.Success && data.Error != "" {
return nil, errors.New(data.Error)
}
return data.Rants, nil
} | |
c182503 | if !data.Success && data.Error != "" {
return 0, errors.New(data.Error)
}
return data.UserId, nil
} | |
c182504 | shutdown of store %s: %s", addr, err)
}
delete(rs.stores, addr)
select {
case <-ctx.Done():
rs.storesLock.Unlock()
return ctx.Err()
default:
}
}
rs.storesLock.Unlock()
rs.ringLock.Unlock()
return nil
} | |
c182505 | {
return false
}
return true
} | |
c182506 | // Forward outbound messages to conn
data, _ := msg.MarshalBinary()
if _, err := m.conn.Write(data); err != nil {
log.Warnln("OutboundError:", err)
m.Error <- err
m.Shutdown <- true
}
log.Debugf("Sent(%d): %v", len(data), data)
}
}
} | |
c182507 | m.parser.Parse(b.Bytes())
// Log all message parsing errors.
if err != nil {
log.Print(err)
}
m.Inbound <- msg
b.Reset()
m.pool.Empty <- b
}
} | |
c182508 | &Group{Domain: dom, Name: name, Members: members}
} | |
c182509 | := range vals {
g, err := dom.GetGroup(v)
if err != nil {
return grps, err
}
grps[i] = g
}
return grps, nil
} | |
c182510 | if err != nil {
return dom.Group(name, mems), err
}
if a == "" {
continue
}
mems = append(mems, dom.Account(a))
}
return dom.Group(name, mems), nil
} | |
c182511 | ' ', ',', '?', ';', ':', '\'', '"', '!':
i--
case '.':
if i-2 > 0 && str[i-2:i] == ".." {
i -= 3
}
}
}
if i >= 2 {
if i+3 >= len(str) {
return str
}
return str[:i] + "..."
}
if length >= 2 && length < len(str) {
if length+3 >= len(str) {
return str
}
return str[:length] + "..."
}
return str
} | |
c182512 | pass {
if !unicode.IsGraphic(r) {
return e.New(ErrInvalidPassChar)
}
}
return nil
} | |
c182513 | err)
}
if u.Scheme == "" {
return u.String(), e.New(ErrNoScheme)
}
return u.String(), nil
} | |
c182514 | name,
Value: value,
}
return ¶meter
} | |
c182515 | make([]*Parameter, 0, fieldCount),
}
} | |
c182516 | p.Set(parameter.Name, parameter); err != nil {
return err
}
if parameter.Alias != "" {
if err := p.Set(parameter.Alias, parameter); err != nil {
return err
}
}
p.Listing = append(p.Listing, parameter)
}
return nil
} | |
c182517 | fmt.Sprintf("%s@%s", f.Name, f.Domain.Name)
} | |
c182518 | &Forwarder{Domain: dom, Name: name, To: to}
} | |
c182519 | for i, v := range vals {
f, err := dom.GetForwarder(v)
if err != nil {
return fs, err
}
fs[i] = f
}
return fs, err
} | |
c182520 | {
return &Forwarder{}, err
}
return &Forwarder{Domain: dom, Name: name, To: f}, nil
} | |
c182521 | url, user: user, pass: pass}
} | |
c182522 | "%252F", -1)
escaped = strings.Replace(escaped, "\"", "%22", -1)
escaped = strings.Replace(escaped, " ", "%20", -1)
out += escaped
if i < len(in)-1 {
out += ","
}
}
return out
} | |
c182523 | &Alias{account: acc, Name: name}
} | |
c182524 | fmt.Sprintf("%s@%s", a.Name, a.account.Domain.Name)
} | |
c182525 | := vl.compact()
as := make([]*Alias, len(vals))
for i, v := range vals {
as[i] = acc.Alias(v)
}
return as, nil
} | |
c182526 | err != nil {
return "", err
}
return d.toMap()["RealName"], nil
} | |
c182527 | return fmt.Sprintf("%s@%s", a.Name, a.Domain.Name)
} | |
c182528 | &Account{Domain: dom, Name: name}
} | |
c182529 |
as := make([]*Account, len(keys))
for i, k := range keys {
as[i] = dom.Account(k.Name)
}
return as, nil
} | |
c182530 | {
return false, nil
}
if err != nil {
return false, err
}
return true, nil
} | |
c182531 | err != nil {
return []string{}, err
}
return vl.compact(), nil
} | |
c182532 | &Domain{cgp: cgp, Name: name}
} | |
c182533 | nil {
return []*Domain{}, err
}
vals := vl.SubValues
ds := make([]*Domain, len(vals))
for i, d := range vals {
ds[i] = cgp.Domain(d)
}
return ds, nil
} | |
c182534 | newErr(debug.Stack(), nil, false, info, publicMsg)
} | |
c182535 | IsErr(wrapErr); isErr {
if errStructErr, isErrsErr := errsErr.(*err); isErrsErr {
errStructErr.mergeIn(info, publicMsg)
return errStructErr
}
return errsErr
}
return newErr(debug.Stack(), wrapErr, false, info, publicMsg)
} | |
c182536 | nothing
} else if e.publicMsg == "" {
e.publicMsg = publicMsgPrefix
} else {
e.publicMsg = publicMsgPrefix + " - " + e.publicMsg
}
} | |
c182537 |
return ""
}
return e.wrappedErr.Error()
} | |
c182538 | : len(res)-1] // Remove newline at the end
} | |
c182539 | &MailingList{Domain: dom, Name: name}
} | |
c182540 | {
return &Subscriber{MailingList: ml, Email: email, RealName: name}
} | |
c182541 | res.SubValues[1].SubValues
subs := make([]*Subscriber, len(ds))
for i, d := range ds {
m := d.toMap()
subs[i] = ml.Subscriber(m["Sub"], m["RealName"])
}
return subs, nil
} | |
c182542 |
mls := make([]*MailingList, len(vals))
for i, v := range vals {
mls[i] = dom.MailingList(v)
}
return mls, nil
} | |
c182543 | byteKeyItem(k)
return unsafe.Pointer(&itm)
} | |
c182544 |
return bytes.Compare([]byte(*thisItem), []byte(*thatItem))
} | |
c182545 | (*intKeyItem)(that)
return int(*thisItem - *thatItem)
} | |
c182546 | }
return C.mm_malloc(C.size_t(l))
} | |
c182547 | {
atomic.AddUint64(&stats.frees, 1)
}
C.mm_free(p)
} | |
c182548 | fmt.Sprintf("Mallocs = %d\n"+
"Frees = %d\n", stats.allocs, stats.frees)
}
if buf != nil {
s += C.GoString(buf)
C.free(unsafe.Pointer(buf))
}
return s
} | |
c182549 | fmt.Errorf("status: %d", errCode)
}
return nil
} | |
c182550 |
s.sts.AddInt64(&s.sts.usedBytes, int64(s.builder.store.Size(x)))
for l := 0; l <= itemLevel; l++ {
if s.tail[l] != nil {
s.tail[l].setNext(l, x, false)
} else {
s.head[l] = x
}
s.tail[l] = x
}
if s.callb != nil {
s.callb(x)
}
} | |
c182551 | rand.New(rand.NewSource(int64(rand.Int()))),
}
seg.sts.IsLocal(true)
return seg
} | |
c182552 | } else if head[l] == nil && seg.head[l] != nil {
head[l] = seg.head[l]
}
if seg.tail[l] != nil {
tail[l] = seg.tail[l]
}
}
}
for l := 0; l <= MaxLevel; l++ {
if head[l] != nil {
b.store.head.setNext(l, head[l], false)
}
if tail[l] != nil {
tail[l].setNext(l, b.store.tail, false)
}
}
for _, seg := range segments {
b.store.Stats.Merge(&seg.sts)
}
return b.store
} | |
c182553 | int(uintptr(a)) - int(uintptr(b))
} | |
c182554 | dbInstances.MakeBuf()
defer dbInstances.FreeBuf(buf)
dbInstances.Insert(unsafe.Pointer(nt), CompareNodeTable, buf, &dbInstances.Stats)
return nt
} | |
c182555 | %d\n"+
"Conflicts = %d\n"+
"MemoryInUse = %d\n",
nt.fastHTCount, nt.slowHTCount, nt.conflicts, nt.MemoryInUse())
} | |
c182556 | (nt.fastHTCount + nt.slowHTCount))
} | |
c182557 | return decodePointer(res.fastHTValue)
}
return decodePointer(res.slowHTValues[res.slowHTPos])
}
return nil
} | |
c182558 | fastHT for same crc32 hash
// We have inserted first entry into the slowHT. Now mark conflict bit.
if newSlowValue {
nt.fastHT[res.hash] = encodePointer(decodePointer(nt.fastHT[res.hash]), true)
nt.conflicts++
}
nt.slowHTCount++
} else {
// Insert new item into fastHT
nt.fastHT[res.hash] = encodePointer(nptr, false)
nt.fastHTCount++
}
}
return
} | |
c182559 | nt.fastHTCount--
}
} else {
nptr = decodePointer(res.slowHTValues[res.slowHTPos])
// Remove key from slowHT
newSlowValue := append([]uint64(nil), res.slowHTValues[:res.slowHTPos]...)
if res.slowHTPos+1 != len(res.slowHTValues) {
newSlowValue = append(newSlowValue, res.slowHTValues[res.slowHTPos+1:]...)
}
nt.slowHTCount--
if len(newSlowValue) == 0 {
delete(nt.slowHT, res.hash)
nt.fastHT[res.hash] = encodePointer(decodePointer(nt.fastHT[res.hash]), false)
nt.conflicts--
} else {
nt.slowHT[res.hash] = newSlowValue
}
}
}
return
} | |
c182560 |
defer dbInstances.FreeBuf(buf)
dbInstances.Delete(unsafe.Pointer(nt), CompareNodeTable, buf, &dbInstances.Stats)
} | |
c182561 | iter.Valid(); iter.Next() {
db := (*NodeTable)(iter.Get())
sz += db.MemoryInUse()
}
return
} | |
c182562 |
sh.Data = uintptr(unsafe.Pointer(n))
sh.Len = l
sh.Cap = l
copy(block, freeBlockContent)
} | |
c182563 | it.iter.Seek(unsafe.Pointer(itm))
it.skipUnwanted()
} | |
c182564 |
if it.refreshRate > 0 && it.count > it.refreshRate {
it.Refresh()
it.count = 0
}
} | |
c182565 |
it.iter.Close()
it.iter = it.snap.db.store.NewIterator(it.snap.db.iterCmp, it.buf)
it.iter.Seek(unsafe.Pointer(itm))
}
} | |
c182566 |
it.snap.db.store.FreeBuf(it.buf)
it.iter.Close()
} | |
c182567 |
snap: snap,
iter: m.store.NewIterator(m.iterCmp, buf),
buf: buf,
}
} | |
c182568 | if it.Valid() {
n := it.GetNode()
mit.h = append(mit.h, heapItem{iter: it, n: n})
}
}
heap.Init(&mit.h)
mit.Next()
} | |
c182569 | hi.iter.Next()
if hi.iter.Valid() {
hi.n = hi.iter.GetNode()
heap.Push(&mit.h, hi)
}
} | |
c182570 | n := it.GetNode()
mit.h = append(mit.h, heapItem{iter: it, n: n})
}
}
heap.Init(&mit.h)
mit.Next()
return found
} | |
c182571 | keys = append(keys, key)
node = node.GetLink()
}
return
} | |
c182572 | l.head = node.GetLink()
return node
}
prev.SetLink(node.GetLink())
return node
}
prev = node
node = node.GetLink()
}
return nil
} | |
c182573 | node.SetLink(l.head)
l.head = node
} | |
c182574 |
}
} else {
s.freeNode = func(*Node) {}
}
head := allocNode(minItem, MaxLevel, nil)
tail := allocNode(maxItem, MaxLevel, nil)
for i := 0; i <= MaxLevel; i++ {
head.setNext(i, tail, false)
}
s.head = head
s.tail = tail
return s
} | |
c182575 |
sts.AddInt64(&sts.nodeFrees, 1)
} | |
c182576 | MaxLevel+1),
succs: make([]*Node, MaxLevel+1),
}
} | |
c182577 | s.ItemSize(n.Item()) + n.Size()
} | |
c182578 | }
level := int(atomic.LoadInt32(&s.level))
if nextLevel > level {
if atomic.CompareAndSwapInt32(&s.level, int32(level), int32(level+1)) {
nextLevel = level + 1
} else {
nextLevel = level
}
}
return nextLevel
} | |
c182579 | s.Insert2(itm, cmp, nil, buf, rand.Float32, sts)
return
} | |
c182580 | itemLevel := s.NewLevel(randFn)
return s.Insert3(itm, inscmp, eqCmp, buf, itemLevel, false, sts)
} | |
c182581 | pointer at current level if required.
// This is the only thread which can modify next pointer at this level
// The dcas operation can fail only if another thread marked delete
if deleted || (nodeNext != next && !x.dcasNext(i, nodeNext, next, false, false)) {
goto finished
}
if buf.preds[i].dcasNext(i, next, x, false, false) {
break fixThisLevel
}
s.findPath(itm, insCmp, buf, sts)
}
}
finished:
sts.AddInt64(&sts.nodeAllocs, 1)
sts.AddInt64(&sts.levelNodesCount[itemLevel], 1)
sts.AddInt64(&sts.usedBytes, int64(s.Size(x)))
return x, true
} | |
c182582 | defer s.barrier.Release(token)
found := s.findPath(itm, cmp, buf, sts) != nil
if !found {
return false
}
delNode := buf.succs[0]
return s.deleteNode(delNode, cmp, buf, sts)
} | |
c182583 | bool {
token := s.barrier.Acquire()
defer s.barrier.Release(token)
return s.deleteNode(n, cmp, buf, sts)
} | |
c182584 | {
if j == perSplit {
j = -1
itms = append(itms, node.Item())
finished = len(itms) == nways-1
}
node, deleted = node.getNext(l)
if deleted {
goto repeat
}
}
break
}
}
return itms
} | |
c182585 | hdr := (*reflect.SliceHeader)(unsafe.Pointer(&bs))
hdr.Data = dataOffset
hdr.Len = int(l)
hdr.Cap = hdr.Len
return
} | |
c182586 | (*Item)(p)
return int(itemHeaderSize + uintptr(itm.dataLen))
} | |
c182587 | int(binary.LittleEndian.Uint16(bs[0:2]))
return bs[2 : 2+klen], bs[2+klen:]
} | |
c182588 |
lb := int(binary.LittleEndian.Uint16(b[0:2]))
return bytes.Compare(a[2:2+la], b[2:2+lb])
} | |
c182589 | gorountine for each handler.
// By design the is no waiting for any Handlers to complete
// before firing another. Therefore there is also no guarantee
// that any Handler will predictably fire before another one.
//
// Any synchronizing needs to be within the Handler.
for _, h := range e.Handlers {
i++
go h.HandleGomitEvent(event)
}
return i, nil
} | |
c182590 |
delete(e.Handlers, n)
e.handlerMutex.Unlock()
return nil
} | |
c182591 | _, x := e.Handlers[n]
return x
} | |
c182592 |
thisItem := (*Nitro)(this)
thatItem := (*Nitro)(that)
return int(thisItem.id - thatItem.id)
} | |
c182593 |
cfg.fileType = RawdbFile
cfg.useMemoryMgmt = false
cfg.refreshRate = defaultRefreshRate
return cfg
} | |
c182594 | success = w.Delete2(bs)
return
} | |
c182595 |
x := w.newItem(bs, false)
x.bornSn = w.getCurrSn()
if found := iter.SeekWithCmp(unsafe.Pointer(x), w.insCmp, w.existCmp); found {
return iter.GetNode()
}
return nil
} | |
c182596 | cfg.iterCmp = newIterCompare(cmp)
cfg.existCmp = newExistCompare(cmp)
} | |
c182597 | cfg.useMemoryMgmt = true
cfg.mallocFun = malloc
cfg.freeFun = free
}
} | |
c182598 |
m.initSizeFuns()
buf := dbInstances.MakeBuf()
defer dbInstances.FreeBuf(buf)
dbInstances.Insert(unsafe.Pointer(m), CompareNitro, buf, &dbInstances.Stats)
return m
} | |
c182599 | m.snapshots.MemoryInUse() + m.gcsnapshots.MemoryInUse()
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.