init

vendor/github.com/anacrolix/missinggo/orderedmap/google_btree.go

@@ -0,0 +1,100 @@
+package orderedmap
+
+import (
+	"github.com/google/btree"
+
+	"github.com/anacrolix/missinggo/iter"
+)
+
+type GoogleBTree struct {
+	bt     *btree.BTree
+	lesser func(l, r interface{}) bool
+}
+
+type googleBTreeItem struct {
+	less  func(l, r interface{}) bool
+	key   interface{}
+	value interface{}
+}
+
+func (me googleBTreeItem) Less(right btree.Item) bool {
+	return me.less(me.key, right.(*googleBTreeItem).key)
+}
+
+func NewGoogleBTree(lesser func(l, r interface{}) bool) *GoogleBTree {
+	return &GoogleBTree{
+		bt:     btree.New(32),
+		lesser: lesser,
+	}
+}
+
+func (me *GoogleBTree) Set(key interface{}, value interface{}) {
+	me.bt.ReplaceOrInsert(&googleBTreeItem{me.lesser, key, value})
+}
+
+func (me *GoogleBTree) Get(key interface{}) interface{} {
+	ret, _ := me.GetOk(key)
+	return ret
+}
+
+func (me *GoogleBTree) GetOk(key interface{}) (interface{}, bool) {
+	item := me.bt.Get(&googleBTreeItem{me.lesser, key, nil})
+	if item == nil {
+		return nil, false
+	}
+	return item.(*googleBTreeItem).value, true
+}
+
+type googleBTreeIter struct {
+	i  btree.Item
+	bt *btree.BTree
+}
+
+func (me *googleBTreeIter) Next() bool {
+	if me.bt == nil {
+		return false
+	}
+	if me.i == nil {
+		me.bt.Ascend(func(i btree.Item) bool {
+			me.i = i
+			return false
+		})
+	} else {
+		var n int
+		me.bt.AscendGreaterOrEqual(me.i, func(i btree.Item) bool {
+			n++
+			if n == 1 {
+				return true
+			}
+			me.i = i
+			return false
+		})
+		if n != 2 {
+			me.i = nil
+		}
+	}
+	return me.i != nil
+}
+
+func (me *googleBTreeIter) Value() interface{} {
+	return me.i.(*googleBTreeItem).value
+}
+
+func (me *googleBTreeIter) Stop() {
+	me.bt = nil
+	me.i = nil
+}
+
+func (me *GoogleBTree) Iter(f iter.Callback) {
+	me.bt.Ascend(func(i btree.Item) bool {
+		return f(i.(*googleBTreeItem).value)
+	})
+}
+
+func (me *GoogleBTree) Unset(key interface{}) {
+	me.bt.Delete(&googleBTreeItem{me.lesser, key, nil})
+}
+
+func (me *GoogleBTree) Len() int {
+	return me.bt.Len()
+}

vendor/github.com/anacrolix/missinggo/orderedmap/orderedmap.go

@@ -0,0 +1,16 @@
+package orderedmap
+
+import "github.com/anacrolix/missinggo/iter"
+
+func New(lesser func(l, r interface{}) bool) OrderedMap {
+	return NewGoogleBTree(lesser)
+}
+
+type OrderedMap interface {
+	Get(key interface{}) interface{}
+	GetOk(key interface{}) (interface{}, bool)
+	iter.Iterable
+	Set(key, value interface{})
+	Unset(key interface{})
+	Len() int
+}

vendor/github.com/anacrolix/missinggo/orderedmap/skiplist.go

@@ -0,0 +1,66 @@
+package orderedmap
+
+import "github.com/ryszard/goskiplist/skiplist"
+
+type skiplistOrderedMap struct {
+	sl *skiplist.SkipList
+}
+
+func NewSkipList(lesser func(l, r interface{}) bool) *skiplistOrderedMap {
+	return &skiplistOrderedMap{skiplist.NewCustomMap(lesser)}
+}
+
+func (me *skiplistOrderedMap) Set(key interface{}, value interface{}) {
+	me.sl.Set(key, value)
+}
+
+func (me *skiplistOrderedMap) Get(key interface{}) interface{} {
+	if me == nil {
+		return nil
+	}
+	ret, _ := me.sl.Get(key)
+	return ret
+}
+
+func (me *skiplistOrderedMap) GetOk(key interface{}) (interface{}, bool) {
+	if me == nil {
+		return nil, false
+	}
+	return me.sl.Get(key)
+}
+
+type Iter struct {
+	it skiplist.Iterator
+}
+
+func (me *Iter) Next() bool {
+	if me == nil {
+		return false
+	}
+	return me.it.Next()
+}
+
+func (me *Iter) Value() interface{} {
+	return me.it.Value()
+}
+
+func (me *skiplistOrderedMap) Iter() *Iter {
+	if me == nil {
+		return nil
+	}
+	return &Iter{me.sl.Iterator()}
+}
+
+func (me *skiplistOrderedMap) Unset(key interface{}) {
+	if me == nil {
+		return
+	}
+	me.sl.Delete(key)
+}
+
+func (me *skiplistOrderedMap) Len() int {
+	if me.sl == nil {
+		return 0
+	}
+	return me.sl.Len()
+}