observer_generator_patteren.go

package main

import (
	"fmt"
	"sync"
	"time"
)

type (
	Event struct {
		data int
	}

	Observer interface {
		NotifyCallBack(Event)
	}

	Subject interface {
		AddListener(Observer)
		RemoveListener(Observer)
		Notify(Event)
	}
	eventObserver struct {
		id   int
		time time.Time
	}

	eventSubject struct {
		observers sync.Map
	}
)

func (e *eventObserver) NotifyCallBack(event Event) {
	fmt.Printf("observer id: %d, Received %d , after %v \n", e.id, event.data, time.Since(e.time))
}

func (s *eventSubject) AddListener(obs Observer) {
	s.observers.Store(obs, struct{}{})
}

func (s *eventSubject) RemoveListener(obs Observer) {
	s.observers.Delete(obs)
}

func (s *eventSubject) Notify(event Event) {
	s.observers.Range(func(key, value interface{}) bool {
		if key == nil || value == nil {
			return false
		}
		key.(Observer).NotifyCallBack(event)
		return true
	})

}

// fib generator concept
func fib(n int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)
		for i, j := 0, 1; i < n; i, j = i+j, i {
			out <- i
		}

	}()
	return out
}

func main() {

	event_sub := eventSubject{
		observers: sync.Map{},
	}
	obs_1 := eventObserver{id: 1, time: time.Now()}
	obs_2 := eventObserver{id: 2, time: time.Now()}
	event_sub.AddListener(&obs_1)
	event_sub.AddListener(&obs_2)

	go func() {
		select {
		case <-time.After(time.Microsecond * 10):
			event_sub.RemoveListener(&obs_1)
		}
	}()

	for x := range fib(1000) {
		event_sub.Notify(Event{data: x})
	}
}