From 13645ca7ea7854d1078bac84443d2d40b508d800 Mon Sep 17 00:00:00 2001 From: Inhere Date: Fri, 16 Dec 2022 13:14:53 +0800 Subject: [PATCH] :necktie: up: replace all interface{} to any --- event.go | 47 +++++++++++++++++++++--------------------- event_all_test.go | 14 ++++++------- global.go | 2 +- listener.go | 7 ++++--- manager.go | 17 ++++++++------- simpleevent/data.go | 6 +++--- simpleevent/default.go | 6 +++--- simpleevent/manager.go | 6 +++--- 8 files changed, 54 insertions(+), 51 deletions(-) diff --git a/event.go b/event.go index cc820f0..042b5e0 100644 --- a/event.go +++ b/event.go @@ -1,14 +1,13 @@ // Package event is lightweight event manager and dispatcher implements by Go. -// package event // Event interface type Event interface { Name() string - Get(key string) interface{} - Set(key string, val interface{}) - Add(key string, val interface{}) - Data() map[string]interface{} + Get(key string) any + Set(key string, val any) + Add(key string, val any) + Data() map[string]any SetData(M) Event Abort(bool) IsAborted() bool @@ -19,32 +18,32 @@ type BasicEvent struct { // event name name string // user data. - data map[string]interface{} + data map[string]any // target - target interface{} + target any // mark is aborted aborted bool } // NewBasic new a basic event instance -func NewBasic(name string, data M) BasicEvent { +func NewBasic(name string, data M) *BasicEvent { if data == nil { - data = make(map[string]interface{}) + data = make(map[string]any) } - return BasicEvent{ + return &BasicEvent{ name: name, data: data, } } // Abort event loop exec -func (e BasicEvent) Abort(abort bool) { +func (e *BasicEvent) Abort(abort bool) { e.aborted = abort } // Fill event data -func (e BasicEvent) Fill(target interface{}, data M) BasicEvent { +func (e *BasicEvent) Fill(target any, data M) *BasicEvent { if data != nil { e.data = data } @@ -54,12 +53,12 @@ func (e BasicEvent) Fill(target interface{}, data M) BasicEvent { } // AttachTo add current event to the event manager. -func (e BasicEvent) AttachTo(em ManagerFace) { +func (e *BasicEvent) AttachTo(em ManagerFace) { em.AddEvent(e) } // Get data by index -func (e BasicEvent) Get(key string) interface{} { +func (e *BasicEvent) Get(key string) any { if v, ok := e.data[key]; ok { return v } @@ -68,49 +67,49 @@ func (e BasicEvent) Get(key string) interface{} { } // Add value by key -func (e BasicEvent) Add(key string, val interface{}) { +func (e *BasicEvent) Add(key string, val any) { if _, ok := e.data[key]; !ok { e.Set(key, val) } } // Set value by key -func (e BasicEvent) Set(key string, val interface{}) { +func (e *BasicEvent) Set(key string, val any) { if e.data == nil { - e.data = make(map[string]interface{}) + e.data = make(map[string]any) } e.data[key] = val } // Name get event name -func (e BasicEvent) Name() string { +func (e *BasicEvent) Name() string { return e.name } // Data get all data -func (e BasicEvent) Data() map[string]interface{} { +func (e *BasicEvent) Data() map[string]any { return e.data } // IsAborted check. -func (e BasicEvent) IsAborted() bool { +func (e *BasicEvent) IsAborted() bool { return e.aborted } // Target get target -func (e BasicEvent) Target() interface{} { +func (e *BasicEvent) Target() any { return e.target } // SetName set event name -func (e BasicEvent) SetName(name string) BasicEvent { +func (e *BasicEvent) SetName(name string) *BasicEvent { e.name = name return e } // SetData set data to the event -func (e BasicEvent) SetData(data M) Event { +func (e *BasicEvent) SetData(data M) Event { if data != nil { e.data = data } @@ -118,7 +117,7 @@ func (e BasicEvent) SetData(data M) Event { } // SetTarget set event target -func (e BasicEvent) SetTarget(target interface{}) BasicEvent { +func (e *BasicEvent) SetTarget(target any) *BasicEvent { e.target = target return e } diff --git a/event_all_test.go b/event_all_test.go index 0c5f45d..def7324 100644 --- a/event_all_test.go +++ b/event_all_test.go @@ -146,7 +146,7 @@ func TestFire(t *testing.T) { err, e = Trigger("evt2", M{"k": "v"}) assert.NoError(t, err) assert.Equal(t, "evt2", e.Name()) - assert.Equal(t, map[string]interface{}{"k": "v"}, e.Data()) + assert.Equal(t, map[string]any{"k": "v"}, e.Data()) // clear all Reset() @@ -361,7 +361,7 @@ func TestListenGroupEvent(t *testing.T) { func TestManager_AsyncFire(t *testing.T) { em := NewManager("test") em.On("e1", ListenerFunc(func(e Event) error { - assert.Equal(t, map[string]interface{}{"k": "v"}, e.Data()) + assert.Equal(t, map[string]any{"k": "v"}, e.Data()) e.Set("nk", "nv") return nil })) @@ -388,7 +388,7 @@ func TestManager_AsyncFire(t *testing.T) { func TestManager_AwaitFire(t *testing.T) { em := NewManager("test") em.On("e1", ListenerFunc(func(e Event) error { - assert.Equal(t, map[string]interface{}{"k": "v"}, e.Data()) + assert.Equal(t, map[string]any{"k": "v"}, e.Data()) e.Set("nk", "nv") return nil })) @@ -405,8 +405,8 @@ type testSubscriber struct { // ooo } -func (s *testSubscriber) SubscribedEvents() map[string]interface{} { - return map[string]interface{}{ +func (s *testSubscriber) SubscribedEvents() map[string]any { + return map[string]any{ "e1": ListenerFunc(s.e1Handler), "e2": ListenerItem{ Priority: AboveNormal, @@ -425,8 +425,8 @@ func (s *testSubscriber) e1Handler(e Event) error { type testSubscriber2 struct{} -func (s testSubscriber2) SubscribedEvents() map[string]interface{} { - return map[string]interface{}{ +func (s testSubscriber2) SubscribedEvents() map[string]any { + return map[string]any{ "e1": "invalid", } } diff --git a/global.go b/global.go index 0c26d07..3c96e3a 100644 --- a/global.go +++ b/global.go @@ -66,7 +66,7 @@ func MustTrigger(name string, params M) Event { } // FireBatch fire multi event at once. -func FireBatch(es ...interface{}) []error { +func FireBatch(es ...any) []error { return DefaultEM.FireBatch(es...) } diff --git a/listener.go b/listener.go index 0618a40..6a28f32 100644 --- a/listener.go +++ b/listener.go @@ -24,7 +24,7 @@ type Subscriber interface { // SubscribedEvents register event listeners // key: is event name // value: can be Listener or ListenerItem interface - SubscribedEvents() map[string]interface{} + SubscribedEvents() map[string]any } // ListenerItem storage a event listener and it's priority value. @@ -60,7 +60,8 @@ func (lq *ListenerQueue) Push(li *ListenerItem) *ListenerQueue { // Sort the queue items by ListenerItem's priority. // Priority: -// High > Low +// +// High > Low func (lq *ListenerQueue) Sort() *ListenerQueue { // if lq.IsEmpty() { // return lq @@ -102,7 +103,7 @@ func (lq *ListenerQueue) Remove(listener Listener) { lq.items = newItems } -// Clear clear all listeners +// Clear all listeners func (lq *ListenerQueue) Clear() { lq.items = lq.items[:0] } diff --git a/manager.go b/manager.go index bff0484..4e2974d 100644 --- a/manager.go +++ b/manager.go @@ -13,7 +13,7 @@ const Wildcard = "*" var goodNameReg = regexp.MustCompile(`^[a-zA-Z][\w-.*]*$`) // M is short name for map[string]... -type M = map[string]interface{} +type M = map[string]any // ManagerFace event manager interface type ManagerFace interface { @@ -74,8 +74,9 @@ func (em *Manager) Listen(name string, listener Listener, priority ...int) { // On register a event handler/listener. can setting priority. // // Usage: -// On("evt0", listener) -// On("evt0", listener, High) +// +// On("evt0", listener) +// On("evt0", listener, High) func (em *Manager) On(name string, listener Listener, priority ...int) { pv := Normal if len(priority) > 0 { @@ -208,8 +209,9 @@ func (em *Manager) AwaitFire(e Event) (err error) { // FireBatch fire multi event at once. // Usage: -// FireBatch("name1", "name2", &MyEvent{}) -func (em *Manager) FireBatch(es ...interface{}) (ers []error) { +// +// FireBatch("name1", "name2", &MyEvent{}) +func (em *Manager) FireBatch(es ...any) (ers []error) { var err error for _, e := range es { if name, ok := e.(string); ok { @@ -355,8 +357,9 @@ func (em *Manager) ListenedNames() map[string]int { // RemoveListener remove a given listener, you can limit event name. // // Usage: -// RemoveListener("", listener) -// RemoveListener("name", listener) // limit event name. +// +// RemoveListener("", listener) +// RemoveListener("name", listener) // limit event name. func (em *Manager) RemoveListener(name string, listener Listener) { if name != "" { if lq, ok := em.listeners[name]; ok { diff --git a/simpleevent/data.go b/simpleevent/data.go index be02f5e..63816da 100644 --- a/simpleevent/data.go +++ b/simpleevent/data.go @@ -10,7 +10,7 @@ type EventData struct { // event name name string // user data. - Data []interface{} + Data []any } // Name get @@ -28,13 +28,13 @@ func (e *EventData) IsAborted() bool { return e.aborted } -func (e *EventData) init(name string, data []interface{}) { +func (e *EventData) init(name string, data []any) { e.name = name e.Data = data } func (e *EventData) reset() { e.name = "" - e.Data = make([]interface{}, 0) + e.Data = make([]any, 0) e.aborted = false } diff --git a/simpleevent/default.go b/simpleevent/default.go index 61e611d..c9961e2 100644 --- a/simpleevent/default.go +++ b/simpleevent/default.go @@ -19,15 +19,15 @@ func Has(name string) bool { } // Fire fire handlers by name. -func Fire(name string, args ...interface{}) error { +func Fire(name string, args ...any) error { return DefaultEM.Fire(name, args) } // MustFire fire event by name. will panic on error -func MustFire(name string, args ...interface{}) { +func MustFire(name string, args ...any) { DefaultEM.MustFire(name, args) } -func funcName(f interface{}) string { +func funcName(f any) string { return runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name() } diff --git a/simpleevent/manager.go b/simpleevent/manager.go index 795ecc0..957eae1 100644 --- a/simpleevent/manager.go +++ b/simpleevent/manager.go @@ -32,7 +32,7 @@ func NewEventManager() *EventManager { } // set pool creator - em.pool.New = func() interface{} { + em.pool.New = func() any { return &EventData{} } @@ -56,7 +56,7 @@ func (em *EventManager) On(name string, handler HandlerFunc) { } // MustFire fire handlers by name. will panic on error -func (em *EventManager) MustFire(name string, args ...interface{}) { +func (em *EventManager) MustFire(name string, args ...any) { err := em.Fire(name, args...) if err != nil { panic(err) @@ -64,7 +64,7 @@ func (em *EventManager) MustFire(name string, args ...interface{}) { } // Fire handlers by name -func (em *EventManager) Fire(name string, args ...interface{}) (err error) { +func (em *EventManager) Fire(name string, args ...any) (err error) { handlers, ok := em.handlers[name] if !ok { return