-
Notifications
You must be signed in to change notification settings - Fork 3
/
observer.go
108 lines (89 loc) · 2.72 KB
/
observer.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
package events
// An observer is a special type of receiver that is used to monitor events
// related to a observer. When the simulation pops an event, all registered
// observers are notified. Registering an observer has priority over processing
// events, thus allowing registration at any moment.
type Observer interface {
Receiver
}
// A passive observer keeps all the events that were received by it in a
// a channel. Moreover, it allows proxying the receival of an event by using
// using the Decorable interface. This means that the event can be processed
// before being put into the Recv channel.
type PassiveObserver interface {
Decorable
Observer
Recv() <-chan interface{}
}
// An active observer is an observer which allows for a proxy. It's intent for
// usage is allowing for calling a Proxy at a higher level.
type ActiveObserver interface {
Decorable
Observer
}
// An active event observer calls the proxy on receival of an event.
type ActiveEventObserver struct {
*Decorator
receiver Receiver
}
func NewActiveEventObserver(receiver Receiver) *ActiveEventObserver {
return &ActiveEventObserver{
Decorator: NewDecorator(),
receiver: receiver,
}
}
func (o *ActiveEventObserver) Receive(e *Event) *Event {
if e.Receiver() == o.receiver {
o.Proxy(e)
}
return nil
}
const maxGlobalObserverQueue int = 1000000
const maxObserverQueue int = 1000
// A passive event observer is a PassiveObserver that calls a proxy function
// before delivering a message to the Recv channel.
type PassiveEventObserver struct {
*Decorator
receiver Receiver
observer chan interface{}
}
func NewPassiveEventObserver(receiver Receiver) *PassiveEventObserver {
return &PassiveEventObserver{
Decorator: NewDecorator(),
observer: make(chan interface{}, maxObserverQueue),
receiver: receiver,
}
}
func (o *PassiveEventObserver) Recv() <-chan interface{} {
return o.observer
}
func (o *PassiveEventObserver) Receive(e *Event) *Event {
if e.Receiver() == o.receiver {
// Call the proxy on the received message before delivering it.
// The Proxy can be set by upper layers via SetProxy(Proxy).
deliver := o.Proxy(e)
if deliver != nil {
o.observer <- deliver
}
}
return nil
}
// GlobalEventObserver is a passive observer which monitors all events. These
// events can be used for monitoring and logging purposes.
type GlobalEventObserver struct {
*Decorator
observer chan interface{}
}
func NewGlobalEventObserver() *GlobalEventObserver {
return &GlobalEventObserver{
Decorator: NewDecorator(),
observer: make(chan interface{}, maxObserverQueue),
}
}
func (o *GlobalEventObserver) Recv() <-chan interface{} {
return o.observer
}
func (o *GlobalEventObserver) Receive(e *Event) *Event {
o.observer <- o.Proxy(e)
return nil
}