]>
Commit | Line | Data |
---|---|---|
bae9f6d2 JC |
1 | package schema |
2 | ||
3 | import ( | |
4 | "bytes" | |
5 | "fmt" | |
6 | "reflect" | |
7 | "sort" | |
8 | "strconv" | |
9 | "sync" | |
10 | ||
11 | "github.com/hashicorp/terraform/helper/hashcode" | |
12 | ) | |
13 | ||
14 | // HashString hashes strings. If you want a Set of strings, this is the | |
15 | // SchemaSetFunc you want. | |
16 | func HashString(v interface{}) int { | |
17 | return hashcode.String(v.(string)) | |
18 | } | |
19 | ||
15c0b25d AP |
20 | // HashInt hashes integers. If you want a Set of integers, this is the |
21 | // SchemaSetFunc you want. | |
22 | func HashInt(v interface{}) int { | |
23 | return hashcode.String(strconv.Itoa(v.(int))) | |
24 | } | |
25 | ||
bae9f6d2 JC |
26 | // HashResource hashes complex structures that are described using |
27 | // a *Resource. This is the default set implementation used when a set's | |
28 | // element type is a full resource. | |
29 | func HashResource(resource *Resource) SchemaSetFunc { | |
30 | return func(v interface{}) int { | |
31 | var buf bytes.Buffer | |
32 | SerializeResourceForHash(&buf, v, resource) | |
33 | return hashcode.String(buf.String()) | |
34 | } | |
35 | } | |
36 | ||
37 | // HashSchema hashes values that are described using a *Schema. This is the | |
38 | // default set implementation used when a set's element type is a single | |
39 | // schema. | |
40 | func HashSchema(schema *Schema) SchemaSetFunc { | |
41 | return func(v interface{}) int { | |
42 | var buf bytes.Buffer | |
43 | SerializeValueForHash(&buf, v, schema) | |
44 | return hashcode.String(buf.String()) | |
45 | } | |
46 | } | |
47 | ||
48 | // Set is a set data structure that is returned for elements of type | |
49 | // TypeSet. | |
50 | type Set struct { | |
51 | F SchemaSetFunc | |
52 | ||
53 | m map[string]interface{} | |
54 | once sync.Once | |
55 | } | |
56 | ||
57 | // NewSet is a convenience method for creating a new set with the given | |
58 | // items. | |
59 | func NewSet(f SchemaSetFunc, items []interface{}) *Set { | |
60 | s := &Set{F: f} | |
61 | for _, i := range items { | |
62 | s.Add(i) | |
63 | } | |
64 | ||
65 | return s | |
66 | } | |
67 | ||
68 | // CopySet returns a copy of another set. | |
69 | func CopySet(otherSet *Set) *Set { | |
70 | return NewSet(otherSet.F, otherSet.List()) | |
71 | } | |
72 | ||
73 | // Add adds an item to the set if it isn't already in the set. | |
74 | func (s *Set) Add(item interface{}) { | |
75 | s.add(item, false) | |
76 | } | |
77 | ||
78 | // Remove removes an item if it's already in the set. Idempotent. | |
79 | func (s *Set) Remove(item interface{}) { | |
80 | s.remove(item) | |
81 | } | |
82 | ||
83 | // Contains checks if the set has the given item. | |
84 | func (s *Set) Contains(item interface{}) bool { | |
85 | _, ok := s.m[s.hash(item)] | |
86 | return ok | |
87 | } | |
88 | ||
89 | // Len returns the amount of items in the set. | |
90 | func (s *Set) Len() int { | |
91 | return len(s.m) | |
92 | } | |
93 | ||
94 | // List returns the elements of this set in slice format. | |
95 | // | |
96 | // The order of the returned elements is deterministic. Given the same | |
97 | // set, the order of this will always be the same. | |
98 | func (s *Set) List() []interface{} { | |
99 | result := make([]interface{}, len(s.m)) | |
100 | for i, k := range s.listCode() { | |
101 | result[i] = s.m[k] | |
102 | } | |
103 | ||
104 | return result | |
105 | } | |
106 | ||
107 | // Difference performs a set difference of the two sets, returning | |
108 | // a new third set that has only the elements unique to this set. | |
109 | func (s *Set) Difference(other *Set) *Set { | |
110 | result := &Set{F: s.F} | |
111 | result.once.Do(result.init) | |
112 | ||
113 | for k, v := range s.m { | |
114 | if _, ok := other.m[k]; !ok { | |
115 | result.m[k] = v | |
116 | } | |
117 | } | |
118 | ||
119 | return result | |
120 | } | |
121 | ||
122 | // Intersection performs the set intersection of the two sets | |
123 | // and returns a new third set. | |
124 | func (s *Set) Intersection(other *Set) *Set { | |
125 | result := &Set{F: s.F} | |
126 | result.once.Do(result.init) | |
127 | ||
128 | for k, v := range s.m { | |
129 | if _, ok := other.m[k]; ok { | |
130 | result.m[k] = v | |
131 | } | |
132 | } | |
133 | ||
134 | return result | |
135 | } | |
136 | ||
137 | // Union performs the set union of the two sets and returns a new third | |
138 | // set. | |
139 | func (s *Set) Union(other *Set) *Set { | |
140 | result := &Set{F: s.F} | |
141 | result.once.Do(result.init) | |
142 | ||
143 | for k, v := range s.m { | |
144 | result.m[k] = v | |
145 | } | |
146 | for k, v := range other.m { | |
147 | result.m[k] = v | |
148 | } | |
149 | ||
150 | return result | |
151 | } | |
152 | ||
153 | func (s *Set) Equal(raw interface{}) bool { | |
154 | other, ok := raw.(*Set) | |
155 | if !ok { | |
156 | return false | |
157 | } | |
158 | ||
159 | return reflect.DeepEqual(s.m, other.m) | |
160 | } | |
161 | ||
15c0b25d AP |
162 | // HashEqual simply checks to the keys the top-level map to the keys in the |
163 | // other set's top-level map to see if they are equal. This obviously assumes | |
164 | // you have a properly working hash function - use HashResource if in doubt. | |
165 | func (s *Set) HashEqual(raw interface{}) bool { | |
166 | other, ok := raw.(*Set) | |
167 | if !ok { | |
168 | return false | |
169 | } | |
170 | ||
171 | ks1 := make([]string, 0) | |
172 | ks2 := make([]string, 0) | |
173 | ||
174 | for k := range s.m { | |
175 | ks1 = append(ks1, k) | |
176 | } | |
177 | for k := range other.m { | |
178 | ks2 = append(ks2, k) | |
179 | } | |
180 | ||
181 | sort.Strings(ks1) | |
182 | sort.Strings(ks2) | |
183 | ||
184 | return reflect.DeepEqual(ks1, ks2) | |
185 | } | |
186 | ||
bae9f6d2 JC |
187 | func (s *Set) GoString() string { |
188 | return fmt.Sprintf("*Set(%#v)", s.m) | |
189 | } | |
190 | ||
191 | func (s *Set) init() { | |
192 | s.m = make(map[string]interface{}) | |
193 | } | |
194 | ||
195 | func (s *Set) add(item interface{}, computed bool) string { | |
196 | s.once.Do(s.init) | |
197 | ||
198 | code := s.hash(item) | |
199 | if computed { | |
200 | code = "~" + code | |
107c1cdb ND |
201 | |
202 | if isProto5() { | |
203 | tmpCode := code | |
204 | count := 0 | |
205 | for _, exists := s.m[tmpCode]; exists; _, exists = s.m[tmpCode] { | |
206 | count++ | |
207 | tmpCode = fmt.Sprintf("%s%d", code, count) | |
208 | } | |
209 | code = tmpCode | |
210 | } | |
bae9f6d2 JC |
211 | } |
212 | ||
213 | if _, ok := s.m[code]; !ok { | |
214 | s.m[code] = item | |
215 | } | |
216 | ||
217 | return code | |
218 | } | |
219 | ||
220 | func (s *Set) hash(item interface{}) string { | |
221 | code := s.F(item) | |
222 | // Always return a nonnegative hashcode. | |
223 | if code < 0 { | |
224 | code = -code | |
225 | } | |
226 | return strconv.Itoa(code) | |
227 | } | |
228 | ||
229 | func (s *Set) remove(item interface{}) string { | |
230 | s.once.Do(s.init) | |
231 | ||
232 | code := s.hash(item) | |
233 | delete(s.m, code) | |
234 | ||
235 | return code | |
236 | } | |
237 | ||
238 | func (s *Set) index(item interface{}) int { | |
239 | return sort.SearchStrings(s.listCode(), s.hash(item)) | |
240 | } | |
241 | ||
242 | func (s *Set) listCode() []string { | |
243 | // Sort the hash codes so the order of the list is deterministic | |
244 | keys := make([]string, 0, len(s.m)) | |
245 | for k := range s.m { | |
246 | keys = append(keys, k) | |
247 | } | |
248 | sort.Sort(sort.StringSlice(keys)) | |
249 | return keys | |
250 | } |