-
Notifications
You must be signed in to change notification settings - Fork 0
/
message.go
135 lines (119 loc) · 2.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
130
131
132
133
134
135
package adversarylab
import (
"github.com/ugorji/go/codec"
)
type TrainPacket struct {
Dataset string
AllowBlock bool
Incoming bool
Payload []byte
}
type TestPacket struct {
Dataset string
Incoming bool
Payload []byte
}
type RuleRequest struct {
Dataset string
Incoming bool
}
type Rule struct {
Dataset string
RequireForbid bool
Incoming bool
Sequence []byte
}
type ResultStatus int
const (
Success ResultStatus = iota
Error
)
func TrainPacketFromMap(data map[interface{}]interface{}) TrainPacket {
packet := TrainPacket{}
packet.Dataset = data["Dataset"].(string)
packet.AllowBlock = data["AllowBlock"].(bool)
packet.Incoming = data["Incoming"].(bool)
packet.Payload = data["Payload"].([]byte)
return packet
}
func TestPacketFromMap(data map[interface{}]interface{}) TestPacket {
packet := TestPacket{}
packet.Dataset = data["Dataset"].(string)
packet.Incoming = data["Incoming"].(bool)
packet.Payload = data["Payload"].([]byte)
return packet
}
func RuleFromMap(data map[interface{}]interface{}) Rule {
rule := Rule{}
rule.Dataset = data["Dataset"].(string)
rule.RequireForbid = data["RequireForbid"].(bool)
rule.Incoming = data["Incoming"].(bool)
rule.Sequence = data["Sequence"].([]byte)
return rule
}
func encodeString(value string) ([]byte, error) {
var b []byte = make([]byte, 0, 64)
var h codec.Handle = new(codec.CborHandle)
var enc *codec.Encoder = codec.NewEncoderBytes(&b, h)
var err error = enc.Encode(value)
if err == nil {
return nil, err
} else {
return b, nil
}
}
func decodeString(b []byte) (string, error) {
var value string
var h codec.Handle = new(codec.CborHandle)
var dec *codec.Decoder = codec.NewDecoderBytes(b, h)
var err error = dec.Decode(&value)
if err == nil {
return "", err
} else {
return value, nil
}
}
func encodeUint16(value uint16) ([]byte, error) {
var b []byte = make([]byte, 0, 64)
var h codec.Handle = new(codec.CborHandle)
var enc *codec.Encoder = codec.NewEncoderBytes(&b, h)
var err error = enc.Encode(value)
if err == nil {
return nil, err
} else {
return b, nil
}
}
func decodeUint16(b []byte) (uint16, error) {
var value uint16
var h codec.Handle = new(codec.CborHandle)
var dec *codec.Decoder = codec.NewDecoderBytes(b, h)
var err error = dec.Decode(&value)
if err == nil {
return 0, err
} else {
return value, nil
}
}
func encodeUint16Slice(value []uint16) ([]byte, error) {
var b []byte = make([]byte, 0, 64)
var h codec.Handle = new(codec.CborHandle)
var enc *codec.Encoder = codec.NewEncoderBytes(&b, h)
var err error = enc.Encode(value)
if err == nil {
return nil, err
} else {
return b, nil
}
}
func decodeUint16Slice(b []byte) ([]uint16, error) {
var value []uint16
var h codec.Handle = new(codec.CborHandle)
var dec *codec.Decoder = codec.NewDecoderBytes(b, h)
var err error = dec.Decode(&value)
if err == nil {
return nil, err
} else {
return value, nil
}
}