/
raw.go
129 lines (112 loc) · 2.29 KB
/
raw.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 feature
import (
"log"
"sort"
"github.com/Laughs-In-Flowers/xrr"
"gopkg.in/yaml.v2"
)
type RawFeature struct {
Group []string
Tag string
Apply string
Values []string
Constructor Constructor
}
func (r *RawFeature) MustGetValues() []string {
list := r.Values
if len(list) < 1 {
log.Fatalf("zero length list for %s", r.Tag)
}
return list
}
type Raw interface {
Queue([]byte) error
Dequeue(...string)
//DeqComponent([]*RawComponent) error
//DeqEntity([]*RawEntity) error
AddRaw(...*RawFeature) error
}
type raw struct {
e CEnv
has []*RawFeature
}
func NewRaw(e CEnv) *raw {
return &raw{
e: e,
has: make([]*RawFeature, 0),
}
}
func (r *raw) Len() int {
return len(r.has)
}
func (r *raw) Swap(i, j int) {
r.has[i], r.has[j] = r.has[j], r.has[i]
}
func (r *raw) Less(i, j int) bool {
return r.has[i].Constructor.Order() < r.has[j].Constructor.Order()
}
var NoConstructorError = xrr.Xrror("Constructor with tag %s does not exist.").Out
func applyConstructor(e CEnv, rf *RawFeature) error {
var c Constructor
var exists bool
if c, exists = e.GetConstructor(rf.Apply); !exists {
c, exists = e.GetConstructor("default")
if !exists {
return NoConstructorError(rf.Apply)
}
}
rf.Constructor = c
return nil
}
func (r *raw) AddRaw(rfs ...*RawFeature) error {
for _, rf := range rfs {
err := applyConstructor(r.e, rf)
if err != nil {
return err
}
r.has = append(r.has, rf)
}
return nil
}
func (r *raw) Queue(in []byte) error {
var rfs []*RawFeature
err := yaml.Unmarshal(in, &rfs)
if err != nil {
return err
}
return r.AddRaw(rfs...)
}
func (r *raw) Dequeue(groups ...string) {
sort.Sort(r)
for i, rf := range r.has {
rf.Group = append(rf.Group, groups...)
r.e.SetFeature(rf)
r.has[i] = nil
}
r.has = nil
}
func DeqComponent(e CEnv, rcs []*RawComponent) error {
for _, rc := range rcs {
var fs []*RawFeature
fs = append(fs, rc.Defines...)
fs = append(fs, rc.Features...)
err := e.AddRaw(fs...)
if err != nil {
return err
}
}
return e.SetRawComponent(rcs...)
}
func DeqEntity(e CEnv, res []*RawEntity) error {
for _, re := range res {
err := e.AddRaw(re.Defines...)
if err != nil {
return err
}
err = DeqComponent(e, re.Components)
if err != nil {
return err
}
}
return e.SetRawEntity(res...)
}