Merge pull request #1 from panapol-p/feat/add-data-into-event-struct

feat(core): add data into event struct

Author: panapol-p

README.md

@@ -12,7 +12,7 @@ package main
 import (
 	"fmt"
 
-	listener "go-slice-struct-listener"
+	listener "github.com/panapol-p/go-slice-struct-listener"
 )
 
 type FeedData struct {
@@ -30,27 +30,27 @@ func main() {
 	l := listener.NewListener[FeedData]()
 
 	// set callback func if you need
-	f := func(e []listener.Events) {
+	f := func(e []listener.Events[FeedData]) {
 		fmt.Println("[callback func]", "receive new event!!", e)
 	}
 	l.SetCallback(f)
 
 	events := l.AddNewValue(fs)
-	fmt.Println(events) // [{added 1} {added 2}]
+	fmt.Println(events) // [{1 added {1 Bob 98.5}} {2 added {2 Joe 92.5}}]
 
 	fs = []FeedData{
 		{ID: "1", Name: "Bob", Score: 96.50},
 		{ID: "2", Name: "Joe", Score: 92.50},
 		{ID: "3", Name: "Micky", Score: 89.70},
 	}
 	events = l.AddNewValue(fs)
-	fmt.Println(events) // [{updated 1} {added 3}]
+	fmt.Println(events) // [{1 updated {1 Bob 96.5}} {3 added {3 Micky 89.7}}]
 
 	fs = []FeedData{
 		{ID: "1", Name: "Bob", Score: 96.50},
 	}
 	events = l.AddNewValue(fs)
-	fmt.Println(events) // [{deleted 2} {deleted 3}]
+	fmt.Println(events) // [{2 deleted {  0}} {3 deleted {  0}}]
 }
 ```
 

go.mod

@@ -1,4 +1,4 @@
-module go-slice-struct-listener
+module github.com/panapol-p/go-slice-struct-listener
 
 go 1.19
 

listener.go

@@ -7,44 +7,49 @@ import (
 )
 
 type Listener[T any] struct {
-	CurrentValue  map[string]string
-	NewValue      map[string]string
-	EventCallback func([]Events)
-	CurrentEvent  []Events
+	CurrentValue  map[string]Value[T]
+	NewValue      map[string]Value[T]
+	EventCallback func([]Events[T])
+	CurrentEvent  []Events[T]
 	mu            sync.Mutex
 }
 
 type EventState string
 
 type DataStruct interface{}
+type Value[T any] struct {
+	Hash string
+	Data T
+}
 
 var EventStateAdded EventState = "added"
 var EventStateUpdated EventState = "updated"
 var EventStateDeleted EventState = "deleted"
 
-type Events struct {
-	State EventState
+type Events[T any] struct {
 	ID    string
+	State EventState
+	Data  T
 }
 
 func NewListener[T any]() *Listener[T] {
 	return &Listener[T]{}
 }
 
-func (l *Listener[T]) SetCallback(f func([]Events)) {
+func (l *Listener[T]) SetCallback(f func([]Events[T])) {
 	l.EventCallback = f
 }
 
-func (l *Listener[T]) AddNewValue(a []T) []Events {
+func (l *Listener[T]) AddNewValue(a []T) []Events[T] {
 	l.mu.Lock()
 	defer l.mu.Unlock()
 
 	l.NewValue = l.convertToMap(a)
 	return l.compareMap()
 }
 
-func (l *Listener[T]) convertToMap(s []T) map[string]string {
-	m := make(map[string]string)
+func (l *Listener[T]) convertToMap(s []T) map[string]Value[T] {
+	m := make(map[string]Value[T])
 
 	var uniqueField []string
 	for ii := range s {
@@ -68,31 +73,36 @@ func (l *Listener[T]) convertToMap(s []T) map[string]string {
 		}
 
 		b, _ := json.Marshal(s[ii])
-		m[uniqueID] = string(b)
+		m[uniqueID] = Value[T]{
+			Hash: string(b),
+			Data: s[ii],
+		}
 	}
 	return m
 }
 
-func (l *Listener[T]) compareMap() []Events {
-	var es []Events
+func (l *Listener[T]) compareMap() []Events[T] {
+	var es []Events[T]
 
 	for key := range l.NewValue {
-		var e Events
+		var e Events[T]
 		if value, ok := l.CurrentValue[key]; ok {
-			if value != l.NewValue[key] {
+			if value.Hash != l.NewValue[key].Hash {
 				e.ID = key
 				e.State = EventStateUpdated
+				e.Data = l.NewValue[key].Data
 				es = append(es, e)
 			}
 		} else {
 			e.ID = key
 			e.State = EventStateAdded
+			e.Data = l.NewValue[key].Data
 			es = append(es, e)
 		}
 	}
 
 	for key := range l.CurrentValue {
-		var e Events
+		var e Events[T]
 		if _, ok := l.NewValue[key]; !ok {
 			e.ID = key
 			e.State = EventStateDeleted

listener_test.go

@@ -19,7 +19,7 @@ func TestNewListener(t *testing.T) {
 
 func TestListener_SetCallback(t *testing.T) {
 	l := NewListener[S]()
-	f := func(e []Events) {}
+	f := func(e []Events[S]) {}
 	l.SetCallback(f)
 	assert.NotNil(t, l.EventCallback)
 }
@@ -32,10 +32,15 @@ func TestListener_AddNewValue(t *testing.T) {
 		{F0: "2", F1: "test2", F2: ""},
 	}
 	l.AddNewValue(s)
-	expected := map[string]string{
-		"1": "{\"F0\":\"1\",\"F1\":\"test2\",\"F2\":\"\"}",
-		"2": "{\"F0\":\"2\",\"F1\":\"test2\",\"F2\":\"\"}",
-	}
+	expected := map[string]Value[S]{
+		"1": {
+			Hash: "{\"F0\":\"1\",\"F1\":\"test2\",\"F2\":\"\"}",
+			Data: S{F0: "1", F1: "test2", F2: ""},
+		},
+		"2": {
+			Hash: "{\"F0\":\"2\",\"F1\":\"test2\",\"F2\":\"\"}",
+			Data: S{F0: "2", F1: "test2", F2: ""},
+		}}
 	assert.Equal(t, expected, l.NewValue)
 }
 
@@ -47,38 +52,43 @@ func TestListener_convertToMap(t *testing.T) {
 		{F0: "2", F1: "test2", F2: ""},
 	}
 	actual := l.convertToMap(s)
-	expected := map[string]string{
-		"1": "{\"F0\":\"1\",\"F1\":\"test2\",\"F2\":\"\"}",
-		"2": "{\"F0\":\"2\",\"F1\":\"test2\",\"F2\":\"\"}",
-	}
+	expected := map[string]Value[S]{
+		"1": {
+			Hash: "{\"F0\":\"1\",\"F1\":\"test2\",\"F2\":\"\"}",
+			Data: S{F0: "1", F1: "test2", F2: ""},
+		},
+		"2": {
+			Hash: "{\"F0\":\"2\",\"F1\":\"test2\",\"F2\":\"\"}",
+			Data: S{F0: "2", F1: "test2", F2: ""},
+		}}
 	assert.Equal(t, expected, actual)
 }
 
 func TestListener_compareMap(t *testing.T) {
 	l := new(Listener[S])
-	l.CurrentValue = map[string]string{
-		"2": "2",
-		"3": "6",
-		"4": "4",
-		"5": "5",
+	l.CurrentValue = map[string]Value[S]{
+		"2": {"{\"F0\":\"2\"}", S{F0: "2"}},
+		"3": {"{\"F0\":\"3\"}", S{F0: "3"}},
+		"4": {"{\"F0\":\"4\"}", S{F0: "4"}},
+		"5": {"{\"F0\":\"5\"}", S{F0: "5"}},
 	}
-	l.NewValue = map[string]string{
-		"1": "1",
-		"2": "2",
-		"3": "3",
-		"4": "4",
+	l.NewValue = map[string]Value[S]{
+		"1": {"{\"F0\":\"1\"}", S{F0: "1"}},
+		"2": {"{\"F0\":\"2\"}", S{F0: "2"}},
+		"3": {"{\"F0\":\"3\",\"F2\": \"4\"}}", S{F0: "3", F2: "4"}},
+		"4": {"{\"F0\":\"4\"}", S{F0: "4"}},
 	}
 
 	e := l.compareMap()
-	expected := []Events{
-		{State: EventStateAdded, ID: "1"},
-		{State: EventStateUpdated, ID: "3"},
-		{State: EventStateDeleted, ID: "5"},
+	expected := []Events[S]{
+		{State: EventStateAdded, ID: "1", Data: S{F0: "1"}},
+		{State: EventStateUpdated, ID: "3", Data: S{F0: "3", F2: "4"}},
+		{State: EventStateDeleted, ID: "5", Data: S{}},
 	}
 	assert.Equal(t, expected, e)
 
 	// test compare with callback
-	f := func(e []Events) {}
+	f := func(e []Events[S]) {}
 	l.SetCallback(f)
 	e = l.compareMap()
 	//no change event