-
Notifications
You must be signed in to change notification settings - Fork 1
/
handler.go
122 lines (101 loc) · 2.16 KB
/
handler.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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
package miruken
import (
"fmt"
"github.com/miruken-go/miruken/internal"
)
type (
// Handler is the uniform metaphor for processing.
Handler interface {
Handle(
callback any,
greedy bool,
composer Handler,
) HandleResult
}
// HandleContext allows inspection of the current Callback.
HandleContext struct {
Handler any
Callback Callback
Binding Binding
Composer Handler
Greedy bool
}
// NotHandledError reports a failed callback.
NotHandledError struct {
Callback any
}
// RejectedError reports a rejected callback.
RejectedError struct {
Callback any
}
// CanceledError reports a canceled operation.
CanceledError struct {
Message string
Cause error
}
// handlerAdapter adapts an ordinary type to a Handler.
handlerAdapter struct {
handler any
}
)
// HandleContext
func (c HandleContext) Handle(
callback any,
greedy bool,
composer Handler,
) HandleResult {
return c.Composer.Handle(callback, greedy, composer)
}
// handlerAdapter
func (h handlerAdapter) Handle(
callback any,
greedy bool,
composer Handler,
) HandleResult {
return DispatchCallback(h.handler, callback, greedy, composer)
}
func ToHandler(handler any) Handler {
switch h := handler.(type) {
case Handler:
return h
default:
return handlerAdapter{handler}
}
}
// NotHandledError
func (e *NotHandledError) Error() string {
return fmt.Sprintf("unhandled \"%T\"", e.Callback)
}
// RejectedError
func (e *RejectedError) Error() string {
return fmt.Sprintf("callback \"%T\" was rejected", e.Callback)
}
// CanceledError
func (e *CanceledError) Error() string {
if internal.IsNil(e.Cause) {
return e.Message
}
return fmt.Sprintf("%v: %s", e.Message, e.Cause.Error())
}
func (e *CanceledError) Unwrap() error {
return e.Cause
}
func DispatchCallback(
handler any,
callback any,
greedy bool,
composer Handler,
) HandleResult {
if internal.IsNil(handler) {
return NotHandled
}
switch d := callback.(type) {
case customizeDispatch:
return d.Dispatch(handler, greedy, composer)
case suppressDispatch:
return NotHandled
}
var builder HandlesBuilder
return builder.WithCallback(callback).New().
Dispatch(handler, greedy, composer)
}