go/zodb/btree: Add KeyRange type

KeyRange represents [lo,hi) key range. It simplifies working with ranges
of keys. We will use it in the next commit.

KeyRange originated in WCFS and was copied from there:

https://lab.nexedi.com/kirr/wendelin.core/blob/57be0126/wcfs/internal/xbtree/blib/keyrange.go

go/zodb/btree/btree.go.in

@@ -102,6 +102,12 @@ type BucketEntry struct {
 	value interface{}
 }
 
+// KeyRange represents [lo,hi) key range.
+type KeyRange struct {
+	Lo  KEY
+	Hi_ KEY // NOTE _not_ hi) to avoid overflow at ∞;  hi = hi_ + 1
+}
+
 const _KeyMin KEY = math.Min<Key>
 const _KeyMax KEY = math.Max<Key>
 
@@ -641,3 +647,44 @@ func init() {
 	zodb.RegisterClass("BTrees.BTree.BTree",  t(BTree{}),  t(btreeState{}))
 	zodb.RegisterClass("BTrees.BTree.Bucket", t(Bucket{}), t(bucketState{}))
 }
+
+
+// ---- misc ----
+
+// Has returns whether key k belongs to the range.
+func (r *KeyRange) Has(k KEY) bool {
+	return (r.Lo <= k && k <= r.Hi_)
+}
+
+// Empty returns whether key range is empty.
+func (r *KeyRange) Empty() bool {
+	hi := r.Hi_
+	if hi == _KeyMax {
+		// [x,∞] cannot be empty because max x is ∞ and [∞,∞] has one element: ∞
+		return false
+	}
+	hi++ // no overflow
+	return r.Lo >= hi
+}
+
+func (r KeyRange) String() string {
+	var shi string
+	if r.Hi_ == _KeyMax {
+		shi = kstr(r.Hi_) // ∞
+	} else {
+		shi = fmt.Sprintf("%d", r.Hi_+1)
+	}
+	return fmt.Sprintf("[%s,%s)", kstr(r.Lo), shi)
+}
+
+
+// kstr formats key as string.
+func kstr(k KEY) string {
+	if k == _KeyMin {
+		return "-∞"
+	}
+	if k == _KeyMax {
+		return "∞"
+	}
+	return fmt.Sprintf("%d", k)
+}

go/zodb/btree/gen-btree

@@ -29,6 +29,7 @@ kind=${KIND,,}	# IO -> io
 Key=${KEY^}
 
 KEYKIND=${KIND:0:1}	# IO -> I
+keykind=${KEYKIND,,}	# I -> i
 
 input=$(dirname $0)/btree.go.in
 
@@ -49,4 +50,6 @@ sed	\
 	-e "s/\bbucketState\b/${kind}bucketState/g"	\
 	-e "s/\b_KeyMin\b/_${KEYKIND}KeyMin/g"		\
 	-e "s/\b_KeyMax\b/_${KEYKIND}KeyMax/g"		\
+	-e "s/\bKeyRange\b/${KEYKIND}KeyRange/g"	\
+	-e "s/\bkstr\b/${keykind}kstr/g"		\
 	$input >>$out

go/zodb/btree/ziobtree.go

@@ -104,6 +104,12 @@ type IOBucketEntry struct {
 	value interface{}
 }
 
+// IKeyRange represents [lo,hi) key range.
+type IKeyRange struct {
+	Lo  int32
+	Hi_ int32 // NOTE _not_ hi) to avoid overflow at ∞;  hi = hi_ + 1
+}
+
 const _IKeyMin int32 = math.MinInt32
 const _IKeyMax int32 = math.MaxInt32
 
@@ -643,3 +649,44 @@ func init() {
 	zodb.RegisterClass("BTrees.IOBTree.IOBTree",  t(IOBTree{}),  t(iobtreeState{}))
 	zodb.RegisterClass("BTrees.IOBTree.IOBucket", t(IOBucket{}), t(iobucketState{}))
 }
+
+
+// ---- misc ----
+
+// Has returns whether key k belongs to the range.
+func (r *IKeyRange) Has(k int32) bool {
+	return (r.Lo <= k && k <= r.Hi_)
+}
+
+// Empty returns whether key range is empty.
+func (r *IKeyRange) Empty() bool {
+	hi := r.Hi_
+	if hi == _IKeyMax {
+		// [x,∞] cannot be empty because max x is ∞ and [∞,∞] has one element: ∞
+		return false
+	}
+	hi++ // no overflow
+	return r.Lo >= hi
+}
+
+func (r IKeyRange) String() string {
+	var shi string
+	if r.Hi_ == _IKeyMax {
+		shi = ikstr(r.Hi_) // ∞
+	} else {
+		shi = fmt.Sprintf("%d", r.Hi_+1)
+	}
+	return fmt.Sprintf("[%s,%s)", ikstr(r.Lo), shi)
+}
+
+
+// ikstr formats key as string.
+func ikstr(k int32) string {
+	if k == _IKeyMin {
+		return "-∞"
+	}
+	if k == _IKeyMax {
+		return "∞"
+	}
+	return fmt.Sprintf("%d", k)
+}

go/zodb/btree/zlobtree.go

@@ -104,6 +104,12 @@ type LOBucketEntry struct {
 	value interface{}
 }
 
+// LKeyRange represents [lo,hi) key range.
+type LKeyRange struct {
+	Lo  int64
+	Hi_ int64 // NOTE _not_ hi) to avoid overflow at ∞;  hi = hi_ + 1
+}
+
 const _LKeyMin int64 = math.MinInt64
 const _LKeyMax int64 = math.MaxInt64
 
@@ -643,3 +649,44 @@ func init() {
 	zodb.RegisterClass("BTrees.LOBTree.LOBTree",  t(LOBTree{}),  t(lobtreeState{}))
 	zodb.RegisterClass("BTrees.LOBTree.LOBucket", t(LOBucket{}), t(lobucketState{}))
 }
+
+
+// ---- misc ----
+
+// Has returns whether key k belongs to the range.
+func (r *LKeyRange) Has(k int64) bool {
+	return (r.Lo <= k && k <= r.Hi_)
+}
+
+// Empty returns whether key range is empty.
+func (r *LKeyRange) Empty() bool {
+	hi := r.Hi_
+	if hi == _LKeyMax {
+		// [x,∞] cannot be empty because max x is ∞ and [∞,∞] has one element: ∞
+		return false
+	}
+	hi++ // no overflow
+	return r.Lo >= hi
+}
+
+func (r LKeyRange) String() string {
+	var shi string
+	if r.Hi_ == _LKeyMax {
+		shi = lkstr(r.Hi_) // ∞
+	} else {
+		shi = fmt.Sprintf("%d", r.Hi_+1)
+	}
+	return fmt.Sprintf("[%s,%s)", lkstr(r.Lo), shi)
+}
+
+
+// lkstr formats key as string.
+func lkstr(k int64) string {
+	if k == _LKeyMin {
+		return "-∞"
+	}
+	if k == _LKeyMax {
+		return "∞"
+	}
+	return fmt.Sprintf("%d", k)
+}