/
message.go
129 lines (99 loc) · 1.89 KB
/
message.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
123
124
125
126
127
128
129
package gilmour
import (
"encoding/json"
"sync"
"gopkg.in/gilmour-libs/gilmour-e-go.v5/proto"
)
type pubMsg struct {
Data interface{} `json:"data"`
Code int `json:"code"`
Sender string `json:"sender"`
}
type Message struct {
data interface{}
code int
sender string
sync.RWMutex
}
func (m *Message) Bytes() ([]byte, error) {
m.RLock()
defer m.RUnlock()
return json.Marshal(m.data)
}
func (m *Message) SetData(data interface{}) *Message {
m.Lock()
defer m.Unlock()
if m.data != nil {
panic("Cannot rewrite data for Message.")
}
m.data = data
return m
}
func (m *Message) rawData() interface{} {
m.RLock()
defer m.RUnlock()
return m.data
}
func (m *Message) GetData(t interface{}) error {
m.RLock()
defer m.RUnlock()
if byts, err := m.Bytes(); err != nil {
return err
} else {
return json.Unmarshal(byts, t)
}
}
func (m *Message) GetCode() int {
m.RLock()
defer m.RUnlock()
return m.code
}
func (m *Message) SetCode(code int) *Message {
m.Lock()
defer m.Unlock()
m.code = code
return m
}
func (m *Message) GetSender() string {
m.RLock()
defer m.RUnlock()
return m.sender
}
func (m *Message) setSender(sender string) *Message {
m.Lock()
defer m.Unlock()
m.sender = sender
return m
}
func (m *Message) Marshal() ([]byte, error) {
m.RLock()
defer m.RUnlock()
return json.Marshal(pubMsg{m.data, m.code, m.sender})
}
func parseMessage(data interface{}) (*Message, error) {
resp := &Message{}
var err error
if data == nil {
return resp, err
}
var msg []byte
switch t := data.(type) {
case string:
msg = []byte(t)
case []byte:
msg = t
case json.RawMessage:
msg = t
}
_msg := new(pubMsg)
err = json.Unmarshal(msg, _msg)
if err == nil {
resp = &Message{data: _msg.Data, code: _msg.Code, sender: _msg.Sender}
}
return resp, err
}
func NewMessage() *Message {
x := &Message{}
x.setSender(proto.SenderId())
return x
}