RemoveListener support closure function; fix: #9

listener.go

@@ -1,7 +1,6 @@
 package event
 
 import (
-	"fmt"
 	"sort"
 )
 
@@ -88,11 +87,11 @@ func (lq *ListenerQueue) Remove(listener Listener) {
 	}
 
 	// unsafe.Pointer(listener)
-	ptrVal := fmt.Sprintf("%p", listener)
+	ptrVal := getListenCompareKey(listener)
 
 	var newItems []*ListenerItem
 	for _, li := range lq.items {
-		liPtrVal := fmt.Sprintf("%p", li.Listener)
+		liPtrVal := getListenCompareKey(li.Listener)
 		if liPtrVal == ptrVal {
 			continue
 		}

listener_key.go

@@ -0,0 +1,40 @@
+// Package event is lightweight event manager and dispatcher implements by Go.
+package event
+
+import (
+	"fmt"
+	"reflect"
+	"unsafe"
+	_ "unsafe" // go linkname
+)
+
+func getReflectRawPointer(v reflect.Value) uintptr {
+	switch v.Kind() {
+	case reflect.Func:
+		return uintptr(getNativePointerLink(&v))
+	case reflect.Pointer, reflect.Chan, reflect.Map, reflect.UnsafePointer:
+		return v.Pointer()
+	default:
+		return 0
+	}
+}
+
+// only validate in reflect.Pointer, reflect.Chan, reflect.Map, reflect.UnsafePointer, reflect.Func
+//go:linkname getNativePointerLink  reflect.(*Value).pointer
+func getNativePointerLink(*reflect.Value) unsafe.Pointer
+
+type listenerCompareKey struct {
+	strData string
+	ptrData uintptr
+}
+
+func getListenCompareKey(src Listener) listenerCompareKey {
+	ret := listenerCompareKey{
+		ptrData: getReflectRawPointer(reflect.ValueOf(src)),
+	}
+	if ret.ptrData == 0 {
+		//ret.strData = fmt.Sprintf("%v", src)
+		ret.strData = fmt.Sprintf("%p", any(src))
+	}
+	return ret
+}

listener_key_test.go

@@ -0,0 +1,77 @@
+package event
+
+import (
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+func Test_getListenCompareKey(t *testing.T) {
+	t.Run("ptr", func(t *testing.T) {
+		makeFn := func(a int) ListenerFunc {
+			return func(e Event) error {
+				_ = a
+				return nil
+			}
+		}
+
+		f1 := makeFn(11)
+		f2 := makeFn(22)
+		f2same := makeFn(22)
+		f2copy := f2
+		require.NotEqual(t, getListenCompareKey(f1), getListenCompareKey(f2))
+		require.NotEqual(t, getListenCompareKey(f2), getListenCompareKey(f2same))
+		require.NotEqual(t, getListenCompareKey(f2same), getListenCompareKey(f2copy))
+		require.Equal(t, getListenCompareKey(f2copy), getListenCompareKey(f2))
+
+		f3ptr := &testListener{userData: "3"}
+		ptr4 := &testListener{userData: "4"}
+		ptr4Same := &testListener{userData: "4"}
+		ptr4Copy := ptr4
+
+		require.NotEqual(t, getListenCompareKey(f3ptr), getListenCompareKey(ptr4))
+		require.NotEqual(t, getListenCompareKey(ptr4), getListenCompareKey(ptr4Same))
+		require.NotEqual(t, getListenCompareKey(ptr4Same), getListenCompareKey(ptr4Copy))
+		require.Equal(t, getListenCompareKey(ptr4Copy), getListenCompareKey(ptr4Copy))
+
+	})
+
+	t.Run("same value", func(t *testing.T) {
+
+		f5struct := testListenerReadOnly{userData: "5"}
+		struct6 := testListenerReadOnly{userData: "6"}
+		struct6same := testListenerReadOnly{userData: "6"}
+		struct6copy := struct6
+
+		require.NotEqual(t, getListenCompareKey(f5struct), getListenCompareKey(struct6))
+		require.Equal(t, getListenCompareKey(struct6), getListenCompareKey(struct6same))     // equal when struct data
+		require.Equal(t, getListenCompareKey(struct6same), getListenCompareKey(struct6copy)) // equal when struct data
+		require.Equal(t, getListenCompareKey(struct6copy), getListenCompareKey(struct6))
+
+		f7func := ListenerFunc(testEmptyFunc1)
+		func8 := ListenerFunc(testEmptyFunc2)
+		func8same := ListenerFunc(testEmptyFunc2)
+		func8copy := func8
+
+		require.NotEqual(t, getListenCompareKey(f7func), getListenCompareKey(func8))
+		require.Equal(t, getListenCompareKey(func8), getListenCompareKey(func8same))     // equal when struct data
+		require.Equal(t, getListenCompareKey(func8same), getListenCompareKey(func8copy)) // equal when struct data
+		require.Equal(t, getListenCompareKey(func8copy), getListenCompareKey(func8))
+
+	})
+
+}
+
+func testEmptyFunc1(e Event) error {
+	return nil
+}
+func testEmptyFunc2(e Event) error {
+	return nil
+}
+
+type testListenerReadOnly struct {
+	userData string
+}
+
+func (l testListenerReadOnly) Handle(e Event) error {
+	return nil
+}

listener_remove_test.go

@@ -0,0 +1,145 @@
+package event
+
+import (
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+type globalTestVal struct {
+	n   int
+	sum int
+}
+type testListenerCalc struct {
+	bind  int
+	owner *globalTestVal
+}
+
+func (l testListenerCalc) Handle(e Event) error {
+	l.owner.n++
+	l.owner.sum += l.bind
+	return nil
+}
+
+func Test_RemoveListener(t *testing.T) {
+	t.Run("", func(t *testing.T) {
+		global := &globalTestVal{}
+		makeFn := func(a int) ListenerFunc {
+			return func(e Event) error {
+				global.n++
+				global.sum += a
+				return nil
+			}
+		}
+
+		evBus := NewManager("")
+		const evName = "ev1"
+
+		f1 := makeFn(11)
+		f2 := makeFn(22)
+		f3 := makeFn(33)
+		p4 := &testListenerCalc{bind: 44, owner: global}
+		p5 := &testListenerCalc{bind: 55, owner: global}
+		p6 := &testListenerCalc{bind: 66, owner: global}
+
+		evBus.On(evName, f1)
+		evBus.On(evName, f2)
+		evBus.On(evName, f3)
+		evBus.On(evName, p4)
+		evBus.On(evName, p5)
+		evBus.On(evName, p6)
+
+		evBus.MustFire(evName, nil)
+		require.Equal(t, global.n, 6)
+		require.Equal(t, global.sum, 231) //11+22+33+44+55+66=231
+
+		evBus.RemoveListener(evName, f2)
+		evBus.RemoveListener(evName, p5)
+		evBus.MustFire(evName, nil)
+		require.Equal(t, global.n, 6+4)
+		require.Equal(t, global.sum, 385) // 231+11+33+44+66=385
+
+		evBus.RemoveListener(evName, f1)
+		evBus.RemoveListener(evName, f1) // not exist function.
+		evBus.MustFire(evName, nil)
+		require.Equal(t, global.n, 6+4+3)
+		require.Equal(t, global.sum, 528) // 385+33+44+66=528
+
+		evBus.RemoveListener(evName, p6)
+		evBus.RemoveListener(evName, p6) // not exist function.
+		evBus.MustFire(evName, nil)
+		require.Equal(t, global.n, 6+4+3+2)
+		require.Equal(t, global.sum, 605) // 528+33+44=605
+	})
+	t.Run("same value struct", func(t *testing.T) {
+		global := &globalTestVal{}
+		f1 := testListenerCalc{bind: 11, owner: global}
+		f2 := testListenerCalc{bind: 22, owner: global}
+		f2same := testListenerCalc{bind: 22, owner: global}
+		f2copy := f2 // testListenerCalc{bind: 22, owner: global}
+
+		evBus := NewManager("")
+		const evName = "ev1"
+		evBus.On(evName, f1)
+		evBus.On(evName, f2)
+		evBus.On(evName, f2same)
+		evBus.On(evName, f2copy)
+
+		evBus.MustFire(evName, nil)
+		require.Equal(t, global.n, 4)
+		require.Equal(t, global.sum, 77) //11+22+22+22=77
+
+		evBus.RemoveListener(evName, f1)
+		evBus.MustFire(evName, nil)
+		require.Equal(t, global.n, 7)
+		require.Equal(t, global.sum, 143) // 77+22+22+22=143
+
+		evBus.RemoveListener(evName, f2)
+		evBus.MustFire(evName, nil)
+		require.Equal(t, global.n, 7)
+		require.Equal(t, global.sum, 143) //
+	})
+	t.Run("same func", func(t *testing.T) {
+		global := &globalStatic
+
+		f1 := ListenerFunc(testFuncCalc1)
+		f2 := ListenerFunc(testFuncCalc2)
+		f2same := ListenerFunc(testFuncCalc2)
+		f2copy := f2
+
+		evBus := NewManager("")
+		const evName = "ev1"
+		evBus.On(evName, f1)
+		evBus.On(evName, f2)
+		evBus.On(evName, f2same)
+		evBus.On(evName, f2copy)
+
+		evBus.MustFire(evName, nil)
+		require.Equal(t, global.n, 4)
+		require.Equal(t, global.sum, 77) //11+22+22+22=77
+
+		evBus.RemoveListener(evName, f1)
+		evBus.MustFire(evName, nil)
+		require.Equal(t, global.n, 7)
+		require.Equal(t, global.sum, 143) // 77+22+22+22=143
+
+		evBus.RemoveListener(evName, f2)
+		evBus.MustFire(evName, nil)
+		require.Equal(t, global.n, 7)
+		require.Equal(t, global.sum, 143) //
+	})
+}
+
+var globalStatic = globalTestVal{}
+
+func testFuncCalc1(e Event) error {
+	globalStatic.n++
+	globalStatic.sum += 11
+	return nil
+}
+func testFuncCalc2(e Event) error {
+	globalStatic.n++
+	globalStatic.sum += 22
+	return nil
+}
+
+///