mirror of
https://github.com/willnorris/imageproxy.git
synced 2024-12-23 22:27:38 -05:00
116 lines
2.9 KiB
Go
116 lines
2.9 KiB
Go
package diskv
|
|
|
|
import (
|
|
"sync"
|
|
|
|
"github.com/petar/GoLLRB/llrb"
|
|
)
|
|
|
|
// Index is a generic interface for things that can
|
|
// provide an ordered list of keys.
|
|
type Index interface {
|
|
Initialize(less LessFunction, keys <-chan string)
|
|
Insert(key string)
|
|
Delete(key string)
|
|
Keys(from string, n int) []string
|
|
}
|
|
|
|
// LessFunction is used to initialize an Index of keys in a specific order.
|
|
type LessFunction func(string, string) bool
|
|
|
|
// llrbString is a custom data type that satisfies the LLRB Less interface,
|
|
// making the strings it wraps sortable by the LLRB package.
|
|
type llrbString struct {
|
|
s string
|
|
l LessFunction
|
|
}
|
|
|
|
// Less satisfies the llrb.Less interface using the llrbString's LessFunction.
|
|
func (s llrbString) Less(i llrb.Item) bool {
|
|
return s.l(s.s, i.(llrbString).s)
|
|
}
|
|
|
|
// LLRBIndex is an implementation of the Index interface
|
|
// using Petar Maymounkov's LLRB tree.
|
|
type LLRBIndex struct {
|
|
sync.RWMutex
|
|
LessFunction
|
|
*llrb.LLRB
|
|
}
|
|
|
|
// Initialize populates the LLRB tree with data from the keys channel,
|
|
// according to the passed less function. It's destructive to the LLRBIndex.
|
|
func (i *LLRBIndex) Initialize(less LessFunction, keys <-chan string) {
|
|
i.Lock()
|
|
defer i.Unlock()
|
|
i.LessFunction = less
|
|
i.LLRB = rebuild(less, keys)
|
|
}
|
|
|
|
// Insert inserts the given key (only) into the LLRB tree.
|
|
func (i *LLRBIndex) Insert(key string) {
|
|
i.Lock()
|
|
defer i.Unlock()
|
|
if i.LLRB == nil || i.LessFunction == nil {
|
|
panic("uninitialized index")
|
|
}
|
|
i.LLRB.ReplaceOrInsert(llrbString{s: key, l: i.LessFunction})
|
|
}
|
|
|
|
// Delete removes the given key (only) from the LLRB tree.
|
|
func (i *LLRBIndex) Delete(key string) {
|
|
i.Lock()
|
|
defer i.Unlock()
|
|
if i.LLRB == nil || i.LessFunction == nil {
|
|
panic("uninitialized index")
|
|
}
|
|
i.LLRB.Delete(llrbString{s: key, l: i.LessFunction})
|
|
}
|
|
|
|
// Keys yields a maximum of n keys in order. If the passed 'from' key is empty,
|
|
// Keys will return the first n keys. If the passed 'from' key is non-empty, the
|
|
// first key in the returned slice will be the key that immediately follows the
|
|
// passed key, in key order.
|
|
func (i *LLRBIndex) Keys(from string, n int) []string {
|
|
i.RLock()
|
|
defer i.RUnlock()
|
|
|
|
if i.LLRB == nil || i.LessFunction == nil {
|
|
panic("uninitialized index")
|
|
}
|
|
|
|
if i.LLRB.Len() <= 0 {
|
|
return []string{}
|
|
}
|
|
|
|
llrbFrom := llrbString{s: from, l: i.LessFunction}
|
|
skipFirst := true
|
|
if len(from) <= 0 || !i.LLRB.Has(llrbFrom) {
|
|
// no such key, so start at the top
|
|
llrbFrom = i.LLRB.Min().(llrbString)
|
|
skipFirst = false
|
|
}
|
|
|
|
keys := []string{}
|
|
iterator := func(i llrb.Item) bool {
|
|
keys = append(keys, i.(llrbString).s)
|
|
return len(keys) < n
|
|
}
|
|
i.LLRB.AscendGreaterOrEqual(llrbFrom, iterator)
|
|
|
|
if skipFirst && len(keys) > 0 {
|
|
keys = keys[1:]
|
|
}
|
|
|
|
return keys
|
|
}
|
|
|
|
// rebuildIndex does the work of regenerating the index
|
|
// with the given keys.
|
|
func rebuild(less LessFunction, keys <-chan string) *llrb.LLRB {
|
|
tree := llrb.New()
|
|
for key := range keys {
|
|
tree.ReplaceOrInsert(llrbString{s: key, l: less})
|
|
}
|
|
return tree
|
|
}
|