refactor internal code

Author: gaissmai

bartmethodsgenerated.go

@@ -25,11 +25,9 @@
 package bart
 
 import (
-	"fmt"
 	"net/netip"
 
 	"github.com/gaissmai/bart/internal/nodes"
-	"github.com/gaissmai/bart/internal/value"
 
 	// inlining hint, see also the TestInlineBitSet256Functions.
 	// without this silent import the BitSet256 functions are not inlined
@@ -40,58 +38,10 @@ import (
 // internal/nodes. Aliased to keep the code readable.
 type stridePath = nodes.StridePath
 
-// Equaler is a generic interface for types that can decide their own
-// equality logic. It can be used to override the potentially expensive
-// default comparison with [reflect.DeepEqual].
-type Equaler[V any] interface {
-	Equal(other V) bool
-}
-
-// Cloner is an interface that enables deep cloning of values of type V.
-// If a value implements Cloner[V], Table methods such as InsertPersist,
-// ModifyPersist, DeletePersist, UnionPersist, Union and Clone will use
-// its Clone method to perform deep copies.
-type Cloner[V any] interface {
-	Clone() V
-}
-
 // DumpListNode contains CIDR, Value and Subnets, representing the trie
 // in a sorted, recursive representation, especially useful for serialization.
 type DumpListNode[V any] struct {
 	CIDR    netip.Prefix      `json:"cidr"`
 	Value   V                 `json:"value"`
 	Subnets []DumpListNode[V] `json:"subnets,omitempty"`
 }
-
-// cloneFnFactory returns a CloneFunc.
-// If V implements Cloner[V], the returned function should perform
-// a deep copy using Clone(), otherwise it returns nil.
-func cloneFnFactory[V any]() nodes.CloneFunc[V] {
-	var zero V
-	// you can't assert directly on a type parameter
-	if _, ok := any(zero).(Cloner[V]); ok {
-		return cloneVal[V]
-	}
-	return nil
-}
-
-// cloneVal returns a deep clone of val by calling Clone when
-// val implements Cloner[V]. If val does not implement
-// Cloner[V] or the Cloner receiver is nil (val is a nil pointer),
-// cloneVal returns val unchanged.
-func cloneVal[V any](val V) V {
-	// you can't assert directly on a type parameter
-	c, ok := any(val).(Cloner[V])
-	if !ok || c == nil {
-		return val
-	}
-	return c.Clone()
-}
-
-// panicOnZST panics if V is a zero sized type.
-// bart.Fast must reject zero-sized types as payload.
-func panicOnZST[V any]() {
-	if value.IsZST[V]() {
-		panic(fmt.Errorf("%T is a zero-sized type, not allowed as payload for bart.Fast", *new(V)))
-	}
-}

common.go

@@ -23,6 +23,7 @@ import (
 	"strings"
 
 	"github.com/gaissmai/bart/internal/nodes"
+	"github.com/gaissmai/bart/internal/value"
 )
 
 type _NODE_TYPE[V any] struct{}
@@ -140,7 +141,7 @@ func (t *_TABLE_TYPE[V]) insertPersist(pfx netip.Prefix, val V) *_TABLE_TYPE[V]
 
 	// Create a cloning function for deep copying values;
 	// returns nil if V does not implement the Cloner interface.
-	cloneFn := cloneFnFactory[V]()
+	cloneFn := value.CloneFnFactory[V]()
 
 	// Clone root node corresponding to the IP version, for copy-on-write.
 	n := &pt.root4
@@ -243,7 +244,7 @@ func (t *_TABLE_TYPE[V]) DeletePersist(pfx netip.Prefix) *_TABLE_TYPE[V] {
 
 	// Create a cloning function for deep copying values;
 	// returns nil if V does not implement the Cloner interface.
-	cloneFn := cloneFnFactory[V]()
+	cloneFn := value.CloneFnFactory[V]()
 
 	// Clone root node corresponding to the IP version, for copy-on-write.
 	if is4 {
@@ -317,7 +318,7 @@ func (t *_TABLE_TYPE[V]) ModifyPersist(pfx netip.Prefix, cb func(_ V, ok bool) (
 	val := oldVal
 
 	// to clone or not to clone ...
-	cloneFn := cloneFnFactory[V]()
+	cloneFn := value.CloneFnFactory[V]()
 	if cloneFn != nil && ok {
 		val = cloneFn(oldVal)
 	}
@@ -483,7 +484,7 @@ func (t *_TABLE_TYPE[V]) Union(o *_TABLE_TYPE[V]) {
 
 	// Create a cloning function for deep copying values;
 	// returns nil if V does not implement the Cloner interface.
-	cloneFn := cloneFnFactory[V]()
+	cloneFn := value.CloneFnFactory[V]()
 
 	dup4 := t.root4.UnionRec(cloneFn, &o.root4, 0)
 	dup6 := t.root6.UnionRec(cloneFn, &o.root6, 0)
@@ -504,7 +505,7 @@ func (t *_TABLE_TYPE[V]) UnionPersist(o *_TABLE_TYPE[V]) *_TABLE_TYPE[V] {
 
 	// Create a cloning function for deep copying values;
 	// returns nil if V does not implement the Cloner interface.
-	cloneFn := cloneFnFactory[V]()
+	cloneFn := value.CloneFnFactory[V]()
 
 	// new _TABLE_TYPE with root nodes just copied.
 	pt := &_TABLE_TYPE[V]{
@@ -560,7 +561,7 @@ func (t *_TABLE_TYPE[V]) Clone() *_TABLE_TYPE[V] {
 
 	c := new(_TABLE_TYPE[V])
 
-	cloneFn := cloneFnFactory[V]()
+	cloneFn := value.CloneFnFactory[V]()
 
 	c.root4 = *t.root4.CloneRec(cloneFn)
 	c.root6 = *t.root6.CloneRec(cloneFn)

commonmethods_tmpl.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/gaissmai/bart/internal/art"
 	"github.com/gaissmai/bart/internal/nodes"
+	"github.com/gaissmai/bart/internal/value"
 )
 
 // Fast follows the ART design by Knuth in using fixed arrays at each level
@@ -64,7 +65,7 @@ func (f *Fast[V]) rootNodeByVersion(is4 bool) *nodes.FastNode[V] {
 // The prefix is automatically canonicalized using pfx.Masked() to ensure
 // consistent behavior regardless of host bits in the input.
 func (t *Fast[V]) Insert(pfx netip.Prefix, val V) {
-	t.once.Do(panicOnZST[V])
+	t.once.Do(value.PanicOnZST[V])
 	t.insert(pfx, val)
 }
 
@@ -80,7 +81,7 @@ func (t *Fast[V]) Insert(pfx netip.Prefix, val V) {
 // Due to cloning overhead this is significantly slower than Insert,
 // typically taking μsec instead of nsec.
 func (t *Fast[V]) InsertPersist(pfx netip.Prefix, val V) *Fast[V] {
-	t.once.Do(panicOnZST[V])
+	t.once.Do(value.PanicOnZST[V])
 	return t.insertPersist(pfx, val)
 }
 

fast.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/gaissmai/bart/internal/lpm"
 	"github.com/gaissmai/bart/internal/sparse"
+	"github.com/gaissmai/bart/internal/value"
 )
 
 // BartNode is a trie level BartNode in the multibit routing table.
@@ -191,7 +192,7 @@ func (n *BartNode[V]) Lookup(idx uint8) (val V, ok bool) {
 //
 // Note: The returned node is a new instance with copied slices but only shallow copies of nested nodes,
 // except for LeafNode and FringeNode children which are cloned according to cloneFn.
-func (n *BartNode[V]) CloneFlat(cloneFn CloneFunc[V]) *BartNode[V] {
+func (n *BartNode[V]) CloneFlat(cloneFn value.CloneFunc[V]) *BartNode[V] {
 	if n == nil {
 		return nil
 	}
@@ -248,7 +249,7 @@ func (n *BartNode[V]) CloneFlat(cloneFn CloneFunc[V]) *BartNode[V] {
 //
 // Returns a new instance of BartNode[V] which is a complete deep clone of the
 // receiver node with all descendants.
-func (n *BartNode[V]) CloneRec(cloneFn CloneFunc[V]) *BartNode[V] {
+func (n *BartNode[V]) CloneRec(cloneFn value.CloneFunc[V]) *BartNode[V] {
 	if n == nil {
 		return nil
 	}