_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q36100 | lookup | train | func (l *lNode) lookup(e *Entry) (interface{}, bool) {
found, ok := l.Find(func(sn interface{}) bool {
return bytes.Equal(e.Key, sn.(*sNode).Key)
})
if !ok {
return nil, false
}
return found.(*sNode).Value, true
} | go | {
"resource": ""
} |
q36101 | inserted | train | func (l *lNode) inserted(entry *Entry) *lNode {
return &lNode{l.removed(entry).Add(&sNode{entry})}
} | go | {
"resource": ""
} |
q36102 | removed | train | func (l *lNode) removed(e *Entry) *lNode {
idx := l.FindIndex(func(sn interface{}) bool {
return bytes.Equal(e.Key, sn.(*sNode).Key)
})
if idx < 0 {
return l
}
nl, _ := l.Remove(uint(idx))
return &lNode{nl}
} | go | {
"resource": ""
} |
q36103 | New | train | func New(hashFactory HashFactory) *Ctrie {
if hashFactory == nil {
hashFactory = defaultHashFactory
}
root := &iNode{main: &mainNode{cNode: &cNode{}}}
return newCtrie(root, hashFactory, false)
} | go | {
"resource": ""
} |
q36104 | Insert | train | func (c *Ctrie) Insert(key []byte, value interface{}) {
c.assertReadWrite()
c.insert(&Entry{
Key: key,
Value: value,
hash: c.hash(key),
})
} | go | {
"resource": ""
} |
q36105 | Lookup | train | func (c *Ctrie) Lookup(key []byte) (interface{}, bool) {
return c.lookup(&Entry{Key: key, hash: c.hash(key)})
} | go | {
"resource": ""
} |
q36106 | Remove | train | func (c *Ctrie) Remove(key []byte) (interface{}, bool) {
c.assertReadWrite()
return c.remove(&Entry{Key: key, hash: c.hash(key)})
} | go | {
"resource": ""
} |
q36107 | snapshot | train | func (c *Ctrie) snapshot(readOnly bool) *Ctrie {
if readOnly && c.readOnly {
return c
}
for {
root := c.readRoot()
main := gcasRead(root, c)
if c.rdcssRoot(root, main, root.copyToGen(&generation{}, c)) {
if readOnly {
// For a read-only snapshot, we can share the old generation
// root.
return... | go | {
"resource": ""
} |
q36108 | Clear | train | func (c *Ctrie) Clear() {
for {
root := c.readRoot()
gen := &generation{}
newRoot := &iNode{
main: &mainNode{cNode: &cNode{array: make([]branch, 0), gen: gen}},
gen: gen,
}
if c.rdcssRoot(root, gcasRead(root, c), newRoot) {
return
}
}
} | go | {
"resource": ""
} |
q36109 | Iterator | train | func (c *Ctrie) Iterator(cancel <-chan struct{}) <-chan *Entry {
ch := make(chan *Entry)
snapshot := c.ReadOnlySnapshot()
go func() {
snapshot.traverse(snapshot.readRoot(), ch, cancel)
close(ch)
}()
return ch
} | go | {
"resource": ""
} |
q36110 | Size | train | func (c *Ctrie) Size() uint {
// TODO: The size operation can be optimized further by caching the size
// information in main nodes of a read-only Ctrie – this reduces the
// amortized complexity of the size operation to O(1) because the size
// computation is amortized across the update operations that occurred
/... | go | {
"resource": ""
} |
q36111 | iinsert | train | func (c *Ctrie) iinsert(i *iNode, entry *Entry, lev uint, parent *iNode, startGen *generation) bool {
// Linearization point.
main := gcasRead(i, c)
switch {
case main.cNode != nil:
cn := main.cNode
flag, pos := flagPos(entry.hash, lev, cn.bmp)
if cn.bmp&flag == 0 {
// If the relevant bit is not in the bit... | go | {
"resource": ""
} |
q36112 | ilookup | train | func (c *Ctrie) ilookup(i *iNode, entry *Entry, lev uint, parent *iNode, startGen *generation) (interface{}, bool, bool) {
// Linearization point.
main := gcasRead(i, c)
switch {
case main.cNode != nil:
cn := main.cNode
flag, pos := flagPos(entry.hash, lev, cn.bmp)
if cn.bmp&flag == 0 {
// If the bitmap do... | go | {
"resource": ""
} |
q36113 | iremove | train | func (c *Ctrie) iremove(i *iNode, entry *Entry, lev uint, parent *iNode, startGen *generation) (interface{}, bool, bool) {
// Linearization point.
main := gcasRead(i, c)
switch {
case main.cNode != nil:
cn := main.cNode
flag, pos := flagPos(entry.hash, lev, cn.bmp)
if cn.bmp&flag == 0 {
// If the bitmap do... | go | {
"resource": ""
} |
q36114 | toContracted | train | func toContracted(cn *cNode, lev uint) *mainNode {
if lev > 0 && len(cn.array) == 1 {
branch := cn.array[0]
switch branch.(type) {
case *sNode:
return entomb(branch.(*sNode))
default:
return &mainNode{cNode: cn}
}
}
return &mainNode{cNode: cn}
} | go | {
"resource": ""
} |
q36115 | toCompressed | train | func toCompressed(cn *cNode, lev uint) *mainNode {
tmpArray := make([]branch, len(cn.array))
for i, sub := range cn.array {
switch sub.(type) {
case *iNode:
inode := sub.(*iNode)
mainPtr := (*unsafe.Pointer)(unsafe.Pointer(&inode.main))
main := (*mainNode)(atomic.LoadPointer(mainPtr))
tmpArray[i] = re... | go | {
"resource": ""
} |
q36116 | gcas | train | func gcas(in *iNode, old, n *mainNode, ct *Ctrie) bool {
prevPtr := (*unsafe.Pointer)(unsafe.Pointer(&n.prev))
atomic.StorePointer(prevPtr, unsafe.Pointer(old))
if atomic.CompareAndSwapPointer(
(*unsafe.Pointer)(unsafe.Pointer(&in.main)),
unsafe.Pointer(old), unsafe.Pointer(n)) {
gcasComplete(in, n, ct)
retu... | go | {
"resource": ""
} |
q36117 | gcasRead | train | func gcasRead(in *iNode, ctrie *Ctrie) *mainNode {
m := (*mainNode)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&in.main))))
prev := (*mainNode)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&m.prev))))
if prev == nil {
return m
}
return gcasComplete(in, m, ctrie)
} | go | {
"resource": ""
} |
q36118 | gcasComplete | train | func gcasComplete(i *iNode, m *mainNode, ctrie *Ctrie) *mainNode {
for {
if m == nil {
return nil
}
prev := (*mainNode)(atomic.LoadPointer(
(*unsafe.Pointer)(unsafe.Pointer(&m.prev))))
root := ctrie.rdcssReadRoot(true)
if prev == nil {
return m
}
if prev.failed != nil {
// Signals GCAS failu... | go | {
"resource": ""
} |
q36119 | rdcssReadRoot | train | func (c *Ctrie) rdcssReadRoot(abort bool) *iNode {
r := (*iNode)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&c.root))))
if r.rdcss != nil {
return c.rdcssComplete(abort)
}
return r
} | go | {
"resource": ""
} |
q36120 | rdcssRoot | train | func (c *Ctrie) rdcssRoot(old *iNode, expected *mainNode, nv *iNode) bool {
desc := &iNode{
rdcss: &rdcssDescriptor{
old: old,
expected: expected,
nv: nv,
},
}
if c.casRoot(old, desc) {
c.rdcssComplete(false)
return atomic.LoadInt32(&desc.rdcss.committed) == 1
}
return false
} | go | {
"resource": ""
} |
q36121 | rdcssComplete | train | func (c *Ctrie) rdcssComplete(abort bool) *iNode {
for {
r := (*iNode)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(&c.root))))
if r.rdcss == nil {
return r
}
var (
desc = r.rdcss
ov = desc.old
exp = desc.expected
nv = desc.nv
)
if abort {
if c.casRoot(r, ov) {
return ov... | go | {
"resource": ""
} |
q36122 | casRoot | train | func (c *Ctrie) casRoot(ov, nv *iNode) bool {
c.assertReadWrite()
return atomic.CompareAndSwapPointer(
(*unsafe.Pointer)(unsafe.Pointer(&c.root)), unsafe.Pointer(ov), unsafe.Pointer(nv))
} | go | {
"resource": ""
} |
q36123 | copy | train | func (n *Node) copy() *Node {
cpValues := make([]interface{}, len(n.ChildValues))
copy(cpValues, n.ChildValues)
cpKeys := make(Keys, len(n.ChildKeys))
copy(cpKeys, n.ChildKeys)
return &Node{
ID: newID(),
IsLeaf: n.IsLeaf,
ChildValues: cpValues,
ChildKeys: cpKeys,
}
} | go | {
"resource": ""
} |
q36124 | searchKey | train | func (n *Node) searchKey(comparator Comparator, value interface{}) (*Key, int) {
i := n.search(comparator, value)
if n.IsLeaf && i == len(n.ChildValues) { // not found
return nil, i
}
if n.IsLeaf { // equal number of ids and values
return n.ChildKeys[i], i
}
if i == len(n.ChildValues) { // we need to go to... | go | {
"resource": ""
} |
q36125 | insert | train | func (n *Node) insert(comparator Comparator, key *Key) *Key {
var overwrittenKey *Key
i := n.search(comparator, key.Value)
if i == len(n.ChildValues) {
n.ChildValues = append(n.ChildValues, key.Value)
} else {
if n.ChildValues[i] == key.Value {
overwrittenKey = n.ChildKeys[i]
n.ChildKeys[i] = key
retur... | go | {
"resource": ""
} |
q36126 | delete | train | func (n *Node) delete(comparator Comparator, key *Key) *Key {
i := n.search(comparator, key.Value)
if i == len(n.ChildValues) {
return nil
}
n.deleteValueAt(i)
n.deleteKeyAt(i)
return key
} | go | {
"resource": ""
} |
q36127 | replaceKeyAt | train | func (n *Node) replaceKeyAt(key *Key, i int) {
n.ChildKeys[i] = key
} | go | {
"resource": ""
} |
q36128 | iter | train | func (n *Node) iter(comparator Comparator, start, stop interface{}) iterator {
pointer := n.search(comparator, start)
pointer--
return &sliceIterator{
stop: stop,
n: n,
pointer: pointer,
comparator: comparator,
}
} | go | {
"resource": ""
} |
q36129 | splitAt | train | func (n *Node) splitAt(i int) (interface{}, *Node) {
if n.IsLeaf {
return n.splitLeafAt(i)
}
return n.splitInternalAt(i)
} | go | {
"resource": ""
} |
q36130 | nodeFromBytes | train | func nodeFromBytes(t *Tr, data []byte) (*Node, error) {
n := &Node{}
_, err := n.UnmarshalMsg(data)
if err != nil {
panic(err)
return nil, err
}
return n, nil
} | go | {
"resource": ""
} |
q36131 | Marshal | train | func Marshal(ba BitArray) ([]byte, error) {
if eba, ok := ba.(*bitArray); ok {
return eba.Serialize()
} else if sba, ok := ba.(*sparseBitArray); ok {
return sba.Serialize()
} else {
return nil, errors.New("not a valid BitArray")
}
} | go | {
"resource": ""
} |
q36132 | Unmarshal | train | func Unmarshal(input []byte) (BitArray, error) {
if len(input) == 0 {
return nil, errors.New("no data in input")
}
if input[0] == 'B' {
ret := newBitArray(0)
err := ret.Deserialize(input)
if err != nil {
return nil, err
}
return ret, nil
} else if input[0] == 'S' {
ret := newSparseBitArray()
err ... | go | {
"resource": ""
} |
q36133 | Serialize | train | func (ba *sparseBitArray) Serialize() ([]byte, error) {
w := new(bytes.Buffer)
var identifier uint8 = 'S'
err := binary.Write(w, binary.LittleEndian, identifier)
if err != nil {
return nil, err
}
blocksLen := uint64(len(ba.blocks))
indexLen := uint64(len(ba.indices))
err = binary.Write(w, binary.LittleEndi... | go | {
"resource": ""
} |
q36134 | Uint64FromBytes | train | func Uint64FromBytes(b []byte) (uint64, int) {
if len(b) < 8 {
return 0, -1
}
val := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |
uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
return val, 8
} | go | {
"resource": ""
} |
q36135 | Deserialize | train | func (ret *sparseBitArray) Deserialize(incoming []byte) error {
var intsize = uint64(s / 8)
var curLoc = uint64(1) // Ignore the identifier byte
var intsToRead uint64
var bytesRead int
intsToRead, bytesRead = Uint64FromBytes(incoming[curLoc : curLoc+intsize])
if bytesRead < 0 {
return errors.New("Invalid data ... | go | {
"resource": ""
} |
q36136 | Serialize | train | func (ba *bitArray) Serialize() ([]byte, error) {
w := new(bytes.Buffer)
var identifier uint8 = 'B'
err := binary.Write(w, binary.LittleEndian, identifier)
if err != nil {
return nil, err
}
err = binary.Write(w, binary.LittleEndian, ba.lowest)
if err != nil {
return nil, err
}
err = binary.Write(w, binar... | go | {
"resource": ""
} |
q36137 | Deserialize | train | func (ret *bitArray) Deserialize(incoming []byte) error {
r := bytes.NewReader(incoming[1:]) // Discard identifier
err := binary.Read(r, binary.LittleEndian, &ret.lowest)
if err != nil {
return err
}
err = binary.Read(r, binary.LittleEndian, &ret.highest)
if err != nil {
return err
}
var encodedanyset ui... | go | {
"resource": ""
} |
q36138 | Iter | train | func (tree *btree) Iter(key Key) Iterator {
if tree.root == nil {
return nilIterator()
}
return tree.root.find(key)
} | go | {
"resource": ""
} |
q36139 | Get | train | func (ptree *ptree) Get(keys ...common.Comparator) common.Comparators {
ga := newGetAction(keys)
ptree.checkAndRun(ga)
ga.completer.Wait()
return ga.result
} | go | {
"resource": ""
} |
q36140 | Query | train | func (ptree *ptree) Query(start, stop common.Comparator) common.Comparators {
cmps := make(common.Comparators, 0, 32)
aa := newApplyAction(func(cmp common.Comparator) bool {
cmps = append(cmps, cmp)
return true
}, start, stop)
ptree.checkAndRun(aa)
aa.completer.Wait()
return cmps
} | go | {
"resource": ""
} |
q36141 | chunkRectangles | train | func chunkRectangles(slice rtree.Rectangles, numParts int64) []rtree.Rectangles {
parts := make([]rtree.Rectangles, numParts)
for i := int64(0); i < numParts; i++ {
parts[i] = slice[i*int64(len(slice))/numParts : (i+1)*int64(len(slice))/numParts]
}
return parts
} | go | {
"resource": ""
} |
q36142 | MultithreadedSortComparators | train | func MultithreadedSortComparators(comparators Comparators) Comparators {
toBeSorted := make(Comparators, len(comparators))
copy(toBeSorted, comparators)
var wg sync.WaitGroup
numCPU := int64(runtime.NumCPU())
if numCPU%2 == 1 { // single core machine
numCPU++
}
chunks := chunk(toBeSorted, numCPU)
wg.Add(le... | go | {
"resource": ""
} |
q36143 | Search | train | func (tree *tree) Search(rect rtree.Rectangle) rtree.Rectangles {
ga := newGetAction(rect)
tree.checkAndRun(ga)
ga.completer.Wait()
return ga.result
} | go | {
"resource": ""
} |
q36144 | Length | train | func (l *list) Length() uint {
curr := l
length := uint(0)
for {
length += 1
tail, _ := curr.Tail()
if tail.IsEmpty() {
return length
}
curr = tail.(*list)
}
} | go | {
"resource": ""
} |
q36145 | Get | train | func (l *list) Get(pos uint) (interface{}, bool) {
if pos == 0 {
return l.head, true
}
return l.tail.Get(pos - 1)
} | go | {
"resource": ""
} |
q36146 | Remove | train | func (l *list) Remove(pos uint) (PersistentList, error) {
if pos == 0 {
nl, _ := l.Tail()
return nl, nil
}
nl, err := l.tail.Remove(pos - 1)
if err != nil {
return nil, err
}
return &list{l.head, nl}, nil
} | go | {
"resource": ""
} |
q36147 | Find | train | func (l *list) Find(pred func(interface{}) bool) (interface{}, bool) {
if pred(l.head) {
return l.head, true
}
return l.tail.Find(pred)
} | go | {
"resource": ""
} |
q36148 | FindIndex | train | func (l *list) FindIndex(pred func(interface{}) bool) int {
curr := l
idx := 0
for {
if pred(curr.head) {
return idx
}
tail, _ := curr.Tail()
if tail.IsEmpty() {
return -1
}
curr = tail.(*list)
idx += 1
}
} | go | {
"resource": ""
} |
q36149 | Map | train | func (l *list) Map(f func(interface{}) interface{}) []interface{} {
return append(l.tail.Map(f), f(l.head))
} | go | {
"resource": ""
} |
q36150 | Encode | train | func Encode(x, y int32) int64 {
var rx, ry int32
var d int64
for s := int32(n / 2); s > 0; s /= 2 {
rx = boolToInt(x&s > 0)
ry = boolToInt(y&s > 0)
d += int64(int64(s) * int64(s) * int64(((3 * rx) ^ ry)))
rotate(s, rx, ry, &x, &y)
}
return d
} | go | {
"resource": ""
} |
q36151 | Decode | train | func Decode(h int64) (int32, int32) {
var ry, rx int64
var x, y int32
t := h
for s := int64(1); s < int64(n); s *= 2 {
rx = 1 & (t / 2)
ry = 1 & (t ^ rx)
rotate(int32(s), int32(rx), int32(ry), &x, &y)
x += int32(s * rx)
y += int32(s * ry)
t /= 4
}
return x, y
} | go | {
"resource": ""
} |
q36152 | insert | train | func (entries *Entries) insert(entry Entry) Entry {
i := entries.search(entry.Key())
if i == len(*entries) {
*entries = append(*entries, entry)
return nil
}
if (*entries)[i].Key() == entry.Key() {
oldEntry := (*entries)[i]
(*entries)[i] = entry
return oldEntry
}
(*entries) = append(*entries, nil)
co... | go | {
"resource": ""
} |
q36153 | delete | train | func (entries *Entries) delete(key uint64) Entry {
i := entries.search(key)
if i == len(*entries) { // key not found
return nil
}
if (*entries)[i].Key() != key {
return nil
}
oldEntry := (*entries)[i]
copy((*entries)[i:], (*entries)[i+1:])
(*entries)[len(*entries)-1] = nil // GC
*entries = (*entries)[:le... | go | {
"resource": ""
} |
q36154 | max | train | func (entries Entries) max() (uint64, bool) {
if len(entries) == 0 {
return 0, false
}
return entries[len(entries)-1].Key(), true
} | go | {
"resource": ""
} |
q36155 | get | train | func (entries Entries) get(key uint64) Entry {
i := entries.search(key)
if i == len(entries) {
return nil
}
if entries[i].Key() == key {
return entries[i]
}
return nil
} | go | {
"resource": ""
} |
q36156 | successor | train | func (entries Entries) successor(key uint64) (Entry, int) {
i := entries.search(key)
if i == len(entries) {
return nil, -1
}
return entries[i], i
} | go | {
"resource": ""
} |
q36157 | predecessor | train | func (entries Entries) predecessor(key uint64) (Entry, int) {
if len(entries) == 0 {
return nil, -1
}
i := entries.search(key)
if i == len(entries) {
return entries[i-1], i - 1
}
if entries[i].Key() == key {
return entries[i], i
}
i--
if i < 0 {
return nil, -1
}
return entries[i], i
} | go | {
"resource": ""
} |
q36158 | Put | train | func (pq *PriorityQueue) Put(items ...Item) error {
if len(items) == 0 {
return nil
}
pq.lock.Lock()
defer pq.lock.Unlock()
if pq.disposed {
return ErrDisposed
}
for _, item := range items {
if pq.allowDuplicates {
pq.items.push(item)
} else if _, ok := pq.itemMap[item]; !ok {
pq.itemMap[item] =... | go | {
"resource": ""
} |
q36159 | Get | train | func (pq *PriorityQueue) Get(number int) ([]Item, error) {
if number < 1 {
return nil, nil
}
pq.lock.Lock()
if pq.disposed {
pq.lock.Unlock()
return nil, ErrDisposed
}
var items []Item
// Remove references to popped items.
deleteItems := func(items []Item) {
for _, item := range items {
delete(pq... | go | {
"resource": ""
} |
q36160 | Peek | train | func (pq *PriorityQueue) Peek() Item {
pq.lock.Lock()
defer pq.lock.Unlock()
if len(pq.items) > 0 {
return pq.items[0]
}
return nil
} | go | {
"resource": ""
} |
q36161 | Empty | train | func (pq *PriorityQueue) Empty() bool {
pq.lock.Lock()
defer pq.lock.Unlock()
return len(pq.items) == 0
} | go | {
"resource": ""
} |
q36162 | Len | train | func (pq *PriorityQueue) Len() int {
pq.lock.Lock()
defer pq.lock.Unlock()
return len(pq.items)
} | go | {
"resource": ""
} |
q36163 | Disposed | train | func (pq *PriorityQueue) Disposed() bool {
pq.disposeLock.Lock()
defer pq.disposeLock.Unlock()
return pq.disposed
} | go | {
"resource": ""
} |
q36164 | NewPriorityQueue | train | func NewPriorityQueue(hint int, allowDuplicates bool) *PriorityQueue {
return &PriorityQueue{
items: make(priorityItems, 0, hint),
itemMap: make(map[Item]struct{}, hint),
allowDuplicates: allowDuplicates,
}
} | go | {
"resource": ""
} |
q36165 | contextOrCachedNode | train | func (t *Tr) contextOrCachedNode(id ID, cache bool) (*Node, error) {
if t.context != nil {
n := t.context.getNode(id)
if n != nil {
return n, nil
}
}
return t.cacher.getNode(t, id, cache)
} | go | {
"resource": ""
} |
q36166 | toBytes | train | func (t *Tr) toBytes() []byte {
buf, err := t.MarshalMsg(nil)
if err != nil {
panic(`unable to encode tree`)
}
return buf
} | go | {
"resource": ""
} |
q36167 | commit | train | func (t *Tr) commit() []*Payload {
items := make([]*Payload, 0, len(t.context.seenNodes))
for _, n := range t.context.seenNodes {
n.ChildValues, n.ChildKeys = n.flatten()
buf, err := n.MarshalMsg(nil)
if err != nil {
panic(`unable to encode node`)
}
n.ChildValues, n.ChildKeys = nil, nil
item := &Paylo... | go | {
"resource": ""
} |
q36168 | Load | train | func Load(p Persister, id []byte, comparator Comparator) (ReadableTree, error) {
items, err := p.Load(id)
if err != nil {
return nil, err
}
if len(items) == 0 || items[0] == nil {
return nil, ErrTreeNotFound
}
rt, err := treeFromBytes(p, items[0].Payload, comparator)
if err != nil {
return nil, err
}
... | go | {
"resource": ""
} |
q36169 | PopCount | train | func (b Bitmap32) PopCount() int {
// http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
b -= (b >> 1) & 0x55555555
b = (b>>2)&0x33333333 + b&0x33333333
b += b >> 4
b &= 0x0f0f0f0f
b *= 0x01010101
return int(byte(b >> 24))
} | go | {
"resource": ""
} |
q36170 | PopCount | train | func (b Bitmap64) PopCount() int {
// http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
b -= (b >> 1) & 0x5555555555555555
b = (b>>2)&0x3333333333333333 + b&0x3333333333333333
b += b >> 4
b &= 0x0f0f0f0f0f0f0f0f
b *= 0x0101010101010101
return int(byte(b >> 56))
} | go | {
"resource": ""
} |
q36171 | clear | train | func (c *cacher) clear() {
c.lock.Lock()
defer c.lock.Unlock()
c.cache = make(map[string]*futures.Future, 10)
} | go | {
"resource": ""
} |
q36172 | deleteFromCache | train | func (c *cacher) deleteFromCache(id ID) {
c.lock.Lock()
defer c.lock.Unlock()
delete(c.cache, string(id))
} | go | {
"resource": ""
} |
q36173 | getNode | train | func (c *cacher) getNode(t *Tr, key ID, useCache bool) (*Node, error) {
if !useCache {
return c.loadNode(t, key)
}
c.lock.Lock()
future, ok := c.cache[string(key)]
if ok {
c.lock.Unlock()
ifc, err := future.GetResult()
if err != nil {
return nil, err
}
return ifc.(*Node), nil
}
completer := mak... | go | {
"resource": ""
} |
q36174 | newCacher | train | func newCacher(persister Persister) *cacher {
return &cacher{
persister: persister,
cache: make(map[string]*futures.Future, 10),
}
} | go | {
"resource": ""
} |
q36175 | get | train | func get(n *node, keyHash uint32, key interface{}) Entry {
index := uint(mask(keyHash, n.level))
if n.dataMap.GetBit(index) {
return n.entries[index]
}
if n.nodeMap.GetBit(index) {
return get(n.entries[index].(*node), keyHash, key)
}
if n.level == 6 { // get from collisionNode
if n.entries[index] == nil {
... | go | {
"resource": ""
} |
q36176 | maxInt64 | train | func maxInt64(ints ...int64) int64 {
maxInt := ints[0]
for i := 1; i < len(ints); i++ {
if ints[i] > maxInt {
maxInt = ints[i]
}
}
return maxInt
} | go | {
"resource": ""
} |
q36177 | maxUint64 | train | func maxUint64(ints ...uint64) uint64 {
maxInt := ints[0]
for i := 1; i < len(ints); i++ {
if ints[i] > maxInt {
maxInt = ints[i]
}
}
return maxInt
} | go | {
"resource": ""
} |
q36178 | minUint64 | train | func minUint64(ints ...uint64) uint64 {
minInt := ints[0]
for i := 1; i < len(ints); i++ {
if ints[i] < minInt {
minInt = ints[i]
}
}
return minInt
} | go | {
"resource": ""
} |
q36179 | ToNums | train | func (ba *bitArray) ToNums() []uint64 {
nums := make([]uint64, 0, ba.highest-ba.lowest/4)
for i, block := range ba.blocks {
block.toNums(uint64(i)*s, &nums)
}
return nums
} | go | {
"resource": ""
} |
q36180 | SetBit | train | func (ba *bitArray) SetBit(k uint64) error {
if k >= ba.Capacity() {
return OutOfRangeError(k)
}
if !ba.anyset {
ba.lowest = k
ba.highest = k
ba.anyset = true
} else {
if k < ba.lowest {
ba.lowest = k
} else if k > ba.highest {
ba.highest = k
}
}
i, pos := getIndexAndRemainder(k)
ba.blocks[... | go | {
"resource": ""
} |
q36181 | GetBit | train | func (ba *bitArray) GetBit(k uint64) (bool, error) {
if k >= ba.Capacity() {
return false, OutOfRangeError(k)
}
i, pos := getIndexAndRemainder(k)
result := ba.blocks[i]&block(1<<pos) != 0
return result, nil
} | go | {
"resource": ""
} |
q36182 | ClearBit | train | func (ba *bitArray) ClearBit(k uint64) error {
if k >= ba.Capacity() {
return OutOfRangeError(k)
}
if !ba.anyset { // nothing is set, might as well bail
return nil
}
i, pos := getIndexAndRemainder(k)
ba.blocks[i] &^= block(1 << pos)
if k == ba.highest {
ba.setHighest()
} else if k == ba.lowest {
ba.s... | go | {
"resource": ""
} |
q36183 | Or | train | func (ba *bitArray) Or(other BitArray) BitArray {
if dba, ok := other.(*bitArray); ok {
return orDenseWithDenseBitArray(ba, dba)
}
return orSparseWithDenseBitArray(other.(*sparseBitArray), ba)
} | go | {
"resource": ""
} |
q36184 | And | train | func (ba *bitArray) And(other BitArray) BitArray {
if dba, ok := other.(*bitArray); ok {
return andDenseWithDenseBitArray(ba, dba)
}
return andSparseWithDenseBitArray(other.(*sparseBitArray), ba)
} | go | {
"resource": ""
} |
q36185 | Reset | train | func (ba *bitArray) Reset() {
for i := uint64(0); i < uint64(len(ba.blocks)); i++ {
ba.blocks[i] &= block(0)
}
ba.anyset = false
} | go | {
"resource": ""
} |
q36186 | Equals | train | func (ba *bitArray) Equals(other BitArray) bool {
if other.Capacity() == 0 && ba.highest > 0 {
return false
}
if other.Capacity() == 0 && !ba.anyset {
return true
}
var selfIndex uint64
for iter := other.Blocks(); iter.Next(); {
toIndex, otherBlock := iter.Value()
if toIndex > selfIndex {
for i := se... | go | {
"resource": ""
} |
q36187 | Intersects | train | func (ba *bitArray) Intersects(other BitArray) bool {
if other.Capacity() > ba.Capacity() {
return false
}
if sba, ok := other.(*sparseBitArray); ok {
return ba.intersectsSparseBitArray(sba)
}
return ba.intersectsDenseBitArray(other.(*bitArray))
} | go | {
"resource": ""
} |
q36188 | complement | train | func (ba *bitArray) complement() {
for i := uint64(0); i < uint64(len(ba.blocks)); i++ {
ba.blocks[i] = ^ba.blocks[i]
}
ba.setLowest()
if ba.anyset {
ba.setHighest()
}
} | go | {
"resource": ""
} |
q36189 | newBitArray | train | func newBitArray(size uint64, args ...bool) *bitArray {
i, r := getIndexAndRemainder(size)
if r > 0 {
i++
}
ba := &bitArray{
blocks: make([]block, i),
anyset: false,
}
if len(args) > 0 && args[0] == true {
for i := uint64(0); i < uint64(len(ba.blocks)); i++ {
ba.blocks[i] = maximumBlock
}
ba.low... | go | {
"resource": ""
} |
q36190 | exhaust | train | func (iter *iterator) exhaust() keys {
keys := make(keys, 0, 10)
for iter := iter; iter.Next(); {
keys = append(keys, iter.Value())
}
return keys
} | go | {
"resource": ""
} |
q36191 | setElementIfNotNil | train | func (c *cached) setElementIfNotNil(element *list.Element) {
if element != nil {
c.element = element
}
} | go | {
"resource": ""
} |
q36192 | EvictionPolicy | train | func EvictionPolicy(policy Policy) CacheOption {
return func(c *cache) {
switch policy {
case LeastRecentlyAdded:
c.recordAccess = c.noop
c.recordAdd = c.record
case LeastRecentlyUsed:
c.recordAccess = c.record
c.recordAdd = c.noop
}
}
} | go | {
"resource": ""
} |
q36193 | New | train | func New(capacity uint64, options ...CacheOption) Cache {
c := &cache{
cap: capacity,
keyList: list.New(),
items: map[string]*cached{},
}
// Default LRU eviction policy
EvictionPolicy(LeastRecentlyUsed)(c)
for _, option := range options {
option(c)
}
return c
} | go | {
"resource": ""
} |
q36194 | ensureCapacity | train | func (c *cache) ensureCapacity(toAdd uint64) {
mustRemove := int64(c.size+toAdd) - int64(c.cap)
for mustRemove > 0 {
key := c.keyList.Back().Value.(string)
mustRemove -= int64(c.items[key].item.Size())
c.remove(key)
}
} | go | {
"resource": ""
} |
q36195 | remove | train | func (c *cache) remove(key string) {
if cached, ok := c.items[key]; ok {
delete(c.items, key)
c.size -= cached.item.Size()
c.keyList.Remove(cached.element)
}
} | go | {
"resource": ""
} |
q36196 | record | train | func (c *cache) record(key string) *list.Element {
if item, ok := c.items[key]; ok {
c.keyList.MoveToFront(item.element)
return item.element
}
return c.keyList.PushFront(key)
} | go | {
"resource": ""
} |
q36197 | Add | train | func (set *Set) Add(items ...interface{}) {
set.lock.Lock()
defer set.lock.Unlock()
set.flattened = nil
for _, item := range items {
set.items[item] = struct{}{}
}
} | go | {
"resource": ""
} |
q36198 | Remove | train | func (set *Set) Remove(items ...interface{}) {
set.lock.Lock()
defer set.lock.Unlock()
set.flattened = nil
for _, item := range items {
delete(set.items, item)
}
} | go | {
"resource": ""
} |
q36199 | Exists | train | func (set *Set) Exists(item interface{}) bool {
set.lock.RLock()
_, ok := set.items[item]
set.lock.RUnlock()
return ok
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.