1/*
2Copyright 2019 The Kubernetes Authors.
3
4Licensed under the Apache License, Version 2.0 (the "License");
5you may not use this file except in compliance with the License.
6You may obtain a copy of the License at
7
8    http://www.apache.org/licenses/LICENSE-2.0
9
10Unless required by applicable law or agreed to in writing, software
11distributed under the License is distributed on an "AS IS" BASIS,
12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13See the License for the specific language governing permissions and
14limitations under the License.
15*/
16
17package value
18
19type mapUnstructuredInterface map[interface{}]interface{}
20
21func (m mapUnstructuredInterface) Set(key string, val Value) {
22	m[key] = val.Unstructured()
23}
24
25func (m mapUnstructuredInterface) Get(key string) (Value, bool) {
26	return m.GetUsing(HeapAllocator, key)
27}
28
29func (m mapUnstructuredInterface) GetUsing(a Allocator, key string) (Value, bool) {
30	if v, ok := m[key]; !ok {
31		return nil, false
32	} else {
33		return a.allocValueUnstructured().reuse(v), true
34	}
35}
36
37func (m mapUnstructuredInterface) Has(key string) bool {
38	_, ok := m[key]
39	return ok
40}
41
42func (m mapUnstructuredInterface) Delete(key string) {
43	delete(m, key)
44}
45
46func (m mapUnstructuredInterface) Iterate(fn func(key string, value Value) bool) bool {
47	return m.IterateUsing(HeapAllocator, fn)
48}
49
50func (m mapUnstructuredInterface) IterateUsing(a Allocator, fn func(key string, value Value) bool) bool {
51	if len(m) == 0 {
52		return true
53	}
54	vv := a.allocValueUnstructured()
55	defer a.Free(vv)
56	for k, v := range m {
57		if ks, ok := k.(string); !ok {
58			continue
59		} else {
60			if !fn(ks, vv.reuse(v)) {
61				return false
62			}
63		}
64	}
65	return true
66}
67
68func (m mapUnstructuredInterface) Length() int {
69	return len(m)
70}
71
72func (m mapUnstructuredInterface) Empty() bool {
73	return len(m) == 0
74}
75
76func (m mapUnstructuredInterface) Equals(other Map) bool {
77	return m.EqualsUsing(HeapAllocator, other)
78}
79
80func (m mapUnstructuredInterface) EqualsUsing(a Allocator, other Map) bool {
81	lhsLength := m.Length()
82	rhsLength := other.Length()
83	if lhsLength != rhsLength {
84		return false
85	}
86	if lhsLength == 0 {
87		return true
88	}
89	vv := a.allocValueUnstructured()
90	defer a.Free(vv)
91	return other.Iterate(func(key string, value Value) bool {
92		lhsVal, ok := m[key]
93		if !ok {
94			return false
95		}
96		return Equals(vv.reuse(lhsVal), value)
97	})
98}
99
100func (m mapUnstructuredInterface) Zip(other Map, order MapTraverseOrder, fn func(key string, lhs, rhs Value) bool) bool {
101	return m.ZipUsing(HeapAllocator, other, order, fn)
102}
103
104func (m mapUnstructuredInterface) ZipUsing(a Allocator, other Map, order MapTraverseOrder, fn func(key string, lhs, rhs Value) bool) bool {
105	return defaultMapZip(a, m, other, order, fn)
106}
107
108type mapUnstructuredString map[string]interface{}
109
110func (m mapUnstructuredString) Set(key string, val Value) {
111	m[key] = val.Unstructured()
112}
113
114func (m mapUnstructuredString) Get(key string) (Value, bool) {
115	return m.GetUsing(HeapAllocator, key)
116}
117func (m mapUnstructuredString) GetUsing(a Allocator, key string) (Value, bool) {
118	if v, ok := m[key]; !ok {
119		return nil, false
120	} else {
121		return a.allocValueUnstructured().reuse(v), true
122	}
123}
124
125func (m mapUnstructuredString) Has(key string) bool {
126	_, ok := m[key]
127	return ok
128}
129
130func (m mapUnstructuredString) Delete(key string) {
131	delete(m, key)
132}
133
134func (m mapUnstructuredString) Iterate(fn func(key string, value Value) bool) bool {
135	return m.IterateUsing(HeapAllocator, fn)
136}
137
138func (m mapUnstructuredString) IterateUsing(a Allocator, fn func(key string, value Value) bool) bool {
139	if len(m) == 0 {
140		return true
141	}
142	vv := a.allocValueUnstructured()
143	defer a.Free(vv)
144	for k, v := range m {
145		if !fn(k, vv.reuse(v)) {
146			return false
147		}
148	}
149	return true
150}
151
152func (m mapUnstructuredString) Length() int {
153	return len(m)
154}
155
156func (m mapUnstructuredString) Equals(other Map) bool {
157	return m.EqualsUsing(HeapAllocator, other)
158}
159
160func (m mapUnstructuredString) EqualsUsing(a Allocator, other Map) bool {
161	lhsLength := m.Length()
162	rhsLength := other.Length()
163	if lhsLength != rhsLength {
164		return false
165	}
166	if lhsLength == 0 {
167		return true
168	}
169	vv := a.allocValueUnstructured()
170	defer a.Free(vv)
171	return other.Iterate(func(key string, value Value) bool {
172		lhsVal, ok := m[key]
173		if !ok {
174			return false
175		}
176		return Equals(vv.reuse(lhsVal), value)
177	})
178}
179
180func (m mapUnstructuredString) Zip(other Map, order MapTraverseOrder, fn func(key string, lhs, rhs Value) bool) bool {
181	return m.ZipUsing(HeapAllocator, other, order, fn)
182}
183
184func (m mapUnstructuredString) ZipUsing(a Allocator, other Map, order MapTraverseOrder, fn func(key string, lhs, rhs Value) bool) bool {
185	return defaultMapZip(a, m, other, order, fn)
186}
187
188func (m mapUnstructuredString) Empty() bool {
189	return len(m) == 0
190}
191