74 lines
1.4 KiB
Go
74 lines
1.4 KiB
Go
package cuckoo
|
|
|
|
type entry[K, V any] struct {
|
|
key K
|
|
value V
|
|
}
|
|
|
|
type slot[K, V any] struct {
|
|
entry[K, V]
|
|
occupied bool
|
|
}
|
|
|
|
type bucket[K, V any] struct {
|
|
hash Hash[K]
|
|
slots []slot[K, V]
|
|
capacity, size uint64
|
|
compare EqualFunc[K]
|
|
}
|
|
|
|
func (b bucket[K, V]) location(key K) uint64 {
|
|
return b.hash(key) % b.capacity
|
|
}
|
|
|
|
func (b bucket[K, V]) get(key K) (value V, found bool) {
|
|
slot := b.slots[b.location(key)]
|
|
return slot.value, slot.occupied && b.compare(slot.key, key)
|
|
}
|
|
|
|
func (b *bucket[K, V]) resize(capacity uint64) {
|
|
b.slots = make([]slot[K, V], capacity)
|
|
b.capacity = capacity
|
|
b.size = 0
|
|
}
|
|
|
|
func (b bucket[K, V]) update(key K, value V) (updated bool) {
|
|
slot := &b.slots[b.location(key)]
|
|
|
|
if slot.occupied && b.compare(slot.key, key) {
|
|
slot.value = value
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
func (b *bucket[K, V]) evict(insertion entry[K, V]) (evicted entry[K, V], eviction bool) {
|
|
slot := &b.slots[b.location(insertion.key)]
|
|
|
|
if !slot.occupied {
|
|
slot.entry = insertion
|
|
slot.occupied = true
|
|
b.size++
|
|
return
|
|
}
|
|
|
|
if b.compare(slot.key, insertion.key) {
|
|
slot.value = insertion.value
|
|
return
|
|
}
|
|
|
|
insertion, slot.entry = slot.entry, insertion
|
|
return insertion, true
|
|
}
|
|
|
|
func newBucket[K, V any](capacity uint64, hash Hash[K], compare EqualFunc[K]) bucket[K, V] {
|
|
return bucket[K, V]{
|
|
hash: hash,
|
|
capacity: capacity,
|
|
compare: compare,
|
|
size: 0,
|
|
slots: make([]slot[K, V], capacity),
|
|
}
|
|
}
|