wasSharp – Diff between revs 22 and 23
?pathlinks?
Rev 22 | Rev 23 | |||
---|---|---|---|---|
1 | /////////////////////////////////////////////////////////////////////////// |
1 | /////////////////////////////////////////////////////////////////////////// |
|
2 | // Copyright (C) Wizardry and Steamworks 2016 - License: GNU GPLv3 // |
2 | // Copyright (C) Wizardry and Steamworks 2016 - License: GNU GPLv3 // |
|
3 | // Please see: http://www.gnu.org/licenses/gpl.html for legal details, // |
3 | // Please see: http://www.gnu.org/licenses/gpl.html for legal details, // |
|
4 | // rights of fair usage, the disclaimer and warranty conditions. // |
4 | // rights of fair usage, the disclaimer and warranty conditions. // |
|
5 | /////////////////////////////////////////////////////////////////////////// |
5 | /////////////////////////////////////////////////////////////////////////// |
|
6 | // Based on the work of Herman Schoenfeld |
6 | // Based on the work of Herman Schoenfeld |
|
7 | |
7 | |
|
8 | using System; |
8 | using System; |
|
9 | using System.Collections.Generic; |
9 | using System.Collections.Generic; |
|
10 | using System.Linq; |
10 | using System.Linq; |
|
11 | |
11 | |
|
12 | namespace wasSharp.Collections.Specialized |
12 | namespace wasSharp.Collections.Specialized |
|
13 | { |
13 | { |
|
14 | public class MultiKeyDictionary<K1, K2, V> : Dictionary<K1, Dictionary<K2, V>> |
14 | public class MultiKeyDictionary<K1, K2, V> : Dictionary<K1, Dictionary<K2, V>> |
|
15 | { |
15 | { |
|
16 | public V this[K1 key1, K2 key2] |
16 | public V this[K1 key1, K2 key2] |
|
17 | { |
17 | { |
|
18 | get |
18 | get |
|
19 | { |
19 | { |
|
20 | if (!ContainsKey(key1) || !this[key1].ContainsKey(key2)) |
20 | if (!ContainsKey(key1) || !this[key1].ContainsKey(key2)) |
|
21 | throw new ArgumentOutOfRangeException(); |
21 | throw new ArgumentOutOfRangeException(); |
|
22 | return base[key1][key2]; |
22 | return base[key1][key2]; |
|
23 | } |
23 | } |
|
24 | set |
24 | set |
|
25 | { |
25 | { |
|
26 | if (!ContainsKey(key1)) |
26 | if (!ContainsKey(key1)) |
|
27 | this[key1] = new Dictionary<K2, V>(); |
27 | this[key1] = new Dictionary<K2, V>(); |
|
28 | this[key1][key2] = value; |
28 | this[key1][key2] = value; |
|
29 | } |
29 | } |
|
30 | } |
30 | } |
|
31 | |
31 | |
|
32 | public new IEnumerable<V> Values |
- | ||
33 | { |
- | ||
34 | get |
- | ||
35 | { |
- | ||
36 | return from baseDict in base.Values |
- | ||
37 | from baseKey in baseDict.Keys |
32 | public new IEnumerable<V> Values => |
|
38 | select baseDict[baseKey]; |
- | ||
39 | } |
- | ||
40 | } |
33 | base.Values.SelectMany(baseDict => baseDict.Keys, (baseDict, baseKey) => baseDict[baseKey]); |
|
41 | |
34 | |
|
42 | public void Add(K1 key1, K2 key2, V value) |
35 | public void Add(K1 key1, K2 key2, V value) |
|
43 | { |
36 | { |
|
44 | if (!ContainsKey(key1)) |
37 | if (!ContainsKey(key1)) |
|
45 | this[key1] = new Dictionary<K2, V>(); |
38 | this[key1] = new Dictionary<K2, V>(); |
|
46 | this[key1][key2] = value; |
39 | this[key1][key2] = value; |
|
47 | } |
40 | } |
|
- | 41 | |
||
- | 42 | public void Remove(K1 key1, K2 key2) |
||
- | 43 | { |
||
- | 44 | if (!ContainsKey(key1) || !this[key1].ContainsKey(key2)) |
||
- | 45 | return; |
||
- | 46 | this[key1].Remove(key2); |
||
- | 47 | Remove(key1); |
||
- | 48 | } |
||
48 | |
49 | |
|
49 | public bool ContainsKey(K1 key1, K2 key2) |
50 | public bool ContainsKey(K1 key1, K2 key2) |
|
50 | { |
51 | { |
|
- | 52 | return ContainsKey(key1) && this[key1].ContainsKey(key2); |
||
- | 53 | } |
||
- | 54 | |
||
- | 55 | public bool TryGetValue(K1 key1, K2 key2, out V value) |
||
- | 56 | { |
||
- | 57 | if (!ContainsKey(key1) || !this[key1].ContainsKey(key2)) |
||
- | 58 | { |
||
- | 59 | value = default(V); |
||
- | 60 | return false; |
||
- | 61 | } |
||
- | 62 | value = base[key1][key2]; |
||
51 | return base.ContainsKey(key1) && this[key1].ContainsKey(key2); |
63 | return true; |
|
52 | } |
64 | } |
|
53 | } |
65 | } |
|
54 | |
66 | |
|
55 | public class MultiKeyDictionary<K1, K2, K3, V> : Dictionary<K1, MultiKeyDictionary<K2, K3, V>> |
67 | public class MultiKeyDictionary<K1, K2, K3, V> : Dictionary<K1, MultiKeyDictionary<K2, K3, V>> |
|
56 | { |
68 | { |
|
57 | public V this[K1 key1, K2 key2, K3 key3] |
69 | public V this[K1 key1, K2 key2, K3 key3] |
|
58 | { |
70 | { |
|
59 | get { return ContainsKey(key1) ? this[key1][key2, key3] : default(V); } |
71 | get { return ContainsKey(key1) ? this[key1][key2, key3] : default(V); } |
|
60 | set |
72 | set |
|
61 | { |
73 | { |
|
62 | if (!ContainsKey(key1)) |
74 | if (!ContainsKey(key1)) |
|
63 | this[key1] = new MultiKeyDictionary<K2, K3, V>(); |
75 | this[key1] = new MultiKeyDictionary<K2, K3, V>(); |
|
64 | this[key1][key2, key3] = value; |
76 | this[key1][key2, key3] = value; |
|
65 | } |
77 | } |
|
66 | } |
78 | } |
|
67 | |
79 | |
|
68 | public bool ContainsKey(K1 key1, K2 key2, K3 key3) |
80 | public bool ContainsKey(K1 key1, K2 key2, K3 key3) |
|
69 | { |
81 | { |
|
70 | return base.ContainsKey(key1) && this[key1].ContainsKey(key2, key3); |
82 | return ContainsKey(key1) && this[key1].ContainsKey(key2, key3); |
|
- | 83 | } |
||
- | 84 | |
||
- | 85 | public void Add(K1 key1, K2 key2, K3 key3, V value) |
||
- | 86 | { |
||
- | 87 | if (!ContainsKey(key1)) |
||
- | 88 | this[key1] = new MultiKeyDictionary<K2, K3, V>(); |
||
- | 89 | this[key1][key2, key3] = value; |
||
- | 90 | } |
||
- | 91 | |
||
- | 92 | public void Remove(K1 key1, K2 key2, K3 key3) |
||
- | 93 | { |
||
- | 94 | if (!ContainsKey(key1) || !this[key1].ContainsKey(key2, key3)) |
||
- | 95 | return; |
||
- | 96 | this[key1][key2].Remove(key3); |
||
- | 97 | this[key1].Remove(key2); |
||
- | 98 | Remove(key1); |
||
- | 99 | } |
||
- | 100 | |
||
- | 101 | public bool TryGetValue(K1 key1, K2 key2, K3 key3, out V value) |
||
- | 102 | { |
||
- | 103 | if (!ContainsKey(key1) || !this[key1].ContainsKey(key2, key3)) |
||
- | 104 | { |
||
- | 105 | value = default(V); |
||
- | 106 | return false; |
||
- | 107 | } |
||
- | 108 | value = base[key1][key2, key3]; |
||
- | 109 | return true; |
||
71 | } |
110 | } |
|
72 | } |
111 | } |
|
73 | |
112 | |
|
74 | public class MultiKeyDictionary<K1, K2, K3, K4, V> : Dictionary<K1, MultiKeyDictionary<K2, K3, K4, V>> |
113 | public class MultiKeyDictionary<K1, K2, K3, K4, V> : Dictionary<K1, MultiKeyDictionary<K2, K3, K4, V>> |
|
75 | { |
114 | { |
|
76 | public V this[K1 key1, K2 key2, K3 key3, K4 key4] |
115 | public V this[K1 key1, K2 key2, K3 key3, K4 key4] |
|
77 | { |
116 | { |
|
78 | get { return ContainsKey(key1) ? this[key1][key2, key3, key4] : default(V); } |
117 | get { return ContainsKey(key1) ? this[key1][key2, key3, key4] : default(V); } |
|
79 | set |
118 | set |
|
80 | { |
119 | { |
|
81 | if (!ContainsKey(key1)) |
120 | if (!ContainsKey(key1)) |
|
82 | this[key1] = new MultiKeyDictionary<K2, K3, K4, V>(); |
121 | this[key1] = new MultiKeyDictionary<K2, K3, K4, V>(); |
|
83 | this[key1][key2, key3, key4] = value; |
122 | this[key1][key2, key3, key4] = value; |
|
84 | } |
123 | } |
|
85 | } |
124 | } |
|
86 | |
125 | |
|
87 | public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4) |
126 | public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4) |
|
88 | { |
127 | { |
|
89 | return base.ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4); |
128 | return ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4); |
|
90 | } |
129 | } |
|
91 | } |
130 | } |
|
92 | |
131 | |
|
93 | public class MultiKeyDictionary<K1, K2, K3, K4, K5, V> : Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, V>> |
132 | public class MultiKeyDictionary<K1, K2, K3, K4, K5, V> : Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, V>> |
|
94 | { |
133 | { |
|
95 | public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5] |
134 | public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5] |
|
96 | { |
135 | { |
|
97 | get { return ContainsKey(key1) ? this[key1][key2, key3, key4, key5] : default(V); } |
136 | get { return ContainsKey(key1) ? this[key1][key2, key3, key4, key5] : default(V); } |
|
98 | set |
137 | set |
|
99 | { |
138 | { |
|
100 | if (!ContainsKey(key1)) |
139 | if (!ContainsKey(key1)) |
|
101 | this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, V>(); |
140 | this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, V>(); |
|
102 | this[key1][key2, key3, key4, key5] = value; |
141 | this[key1][key2, key3, key4, key5] = value; |
|
103 | } |
142 | } |
|
104 | } |
143 | } |
|
105 | |
144 | |
|
106 | public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5) |
145 | public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5) |
|
107 | { |
146 | { |
|
108 | return base.ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5); |
147 | return ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5); |
|
109 | } |
148 | } |
|
110 | } |
149 | } |
|
111 | |
150 | |
|
112 | public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, V> : |
151 | public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, V> : |
|
113 | Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, V>> |
152 | Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, V>> |
|
114 | { |
153 | { |
|
115 | public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6] |
154 | public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6] |
|
116 | { |
155 | { |
|
117 | get { return ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6] : default(V); } |
156 | get { return ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6] : default(V); } |
|
118 | set |
157 | set |
|
119 | { |
158 | { |
|
120 | if (!ContainsKey(key1)) |
159 | if (!ContainsKey(key1)) |
|
121 | this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, V>(); |
160 | this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, V>(); |
|
122 | this[key1][key2, key3, key4, key5, key6] = value; |
161 | this[key1][key2, key3, key4, key5, key6] = value; |
|
123 | } |
162 | } |
|
124 | } |
163 | } |
|
125 | |
164 | |
|
126 | public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6) |
165 | public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6) |
|
127 | { |
166 | { |
|
128 | return base.ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5, key6); |
167 | return ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5, key6); |
|
129 | } |
168 | } |
|
130 | } |
169 | } |
|
131 | |
170 | |
|
132 | public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, K7, V> : |
171 | public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, K7, V> : |
|
133 | Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, K7, V>> |
172 | Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, K7, V>> |
|
134 | { |
173 | { |
|
135 | public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7] |
174 | public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7] |
|
136 | { |
175 | { |
|
137 | get { return ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6, key7] : default(V); } |
176 | get { return ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6, key7] : default(V); } |
|
138 | set |
177 | set |
|
139 | { |
178 | { |
|
140 | if (!ContainsKey(key1)) |
179 | if (!ContainsKey(key1)) |
|
141 | this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, V>(); |
180 | this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, V>(); |
|
142 | this[key1][key2, key3, key4, key5, key6, key7] = value; |
181 | this[key1][key2, key3, key4, key5, key6, key7] = value; |
|
143 | } |
182 | } |
|
144 | } |
183 | } |
|
145 | |
184 | |
|
146 | public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7) |
185 | public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7) |
|
147 | { |
186 | { |
|
148 | return base.ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5, key6, key7); |
187 | return ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5, key6, key7); |
|
149 | } |
188 | } |
|
150 | } |
189 | } |
|
151 | |
190 | |
|
152 | public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, K7, K8, V> : |
191 | public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, K7, K8, V> : |
|
153 | Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, V>> |
192 | Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, V>> |
|
154 | { |
193 | { |
|
155 | public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8] |
194 | public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8] |
|
156 | { |
195 | { |
|
157 | get { return ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6, key7, key8] : default(V); } |
196 | get { return ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6, key7, key8] : default(V); } |
|
158 | set |
197 | set |
|
159 | { |
198 | { |
|
160 | if (!ContainsKey(key1)) |
199 | if (!ContainsKey(key1)) |
|
161 | this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, V>(); |
200 | this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, V>(); |
|
162 | this[key1][key2, key3, key4, key5, key6, key7, key8] = value; |
201 | this[key1][key2, key3, key4, key5, key6, key7, key8] = value; |
|
163 | } |
202 | } |
|
164 | } |
203 | } |
|
165 | |
204 | |
|
166 | public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8) |
205 | public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8) |
|
167 | { |
206 | { |
|
168 | return base.ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5, key6, key7, key8); |
207 | return ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5, key6, key7, key8); |
|
169 | } |
208 | } |
|
170 | } |
209 | } |
|
171 | |
210 | |
|
172 | public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, K7, K8, K9, V> : |
211 | public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, K7, K8, K9, V> : |
|
173 | Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, V>> |
212 | Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, V>> |
|
174 | { |
213 | { |
|
175 | public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9] |
214 | public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9] |
|
176 | { |
215 | { |
|
177 | get { return ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6, key7, key8, key9] : default(V); } |
216 | get { return ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6, key7, key8, key9] : default(V); } |
|
178 | set |
217 | set |
|
179 | { |
218 | { |
|
180 | if (!ContainsKey(key1)) |
219 | if (!ContainsKey(key1)) |
|
181 | this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, V>(); |
220 | this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, V>(); |
|
182 | this[key1][key2, key3, key4, key5, key6, key7, key8, key9] = value; |
221 | this[key1][key2, key3, key4, key5, key6, key7, key8, key9] = value; |
|
183 | } |
222 | } |
|
184 | } |
223 | } |
|
185 | |
224 | |
|
186 | public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9) |
225 | public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9) |
|
187 | { |
226 | { |
|
188 | return base.ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5, key6, key7, key8, key9); |
227 | return ContainsKey(key1) && this[key1].ContainsKey(key2, key3, key4, key5, key6, key7, key8, key9); |
|
189 | } |
228 | } |
|
190 | } |
229 | } |
|
191 | |
230 | |
|
192 | public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, V> : |
231 | public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, V> : |
|
193 | Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, K10, V>> |
232 | Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, K10, V>> |
|
194 | { |
233 | { |
|
195 | public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9, K10 key10] |
234 | public V this[K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9, K10 key10] |
|
196 | { |
235 | { |
|
197 | get |
236 | get |
|
198 | { |
237 | { |
|
199 | return ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6, key7, key8, key9, key10] : default(V); |
238 | return ContainsKey(key1) ? this[key1][key2, key3, key4, key5, key6, key7, key8, key9, key10] : default(V); |
|
200 | } |
239 | } |
|
201 | set |
240 | set |
|
202 | { |
241 | { |
|
203 | if (!ContainsKey(key1)) |
242 | if (!ContainsKey(key1)) |
|
204 | this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, K10, V>(); |
243 | this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, K10, V>(); |
|
205 | this[key1][key2, key3, key4, key5, key6, key7, key8, key9, key10] = value; |
244 | this[key1][key2, key3, key4, key5, key6, key7, key8, key9, key10] = value; |
|
206 | } |
245 | } |
|
207 | } |
246 | } |
|
208 | |
247 | |
|
209 | public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9, |
248 | public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9, |
|
210 | K10 key10) |
249 | K10 key10) |
|
211 | { |
250 | { |
|
212 | return base.ContainsKey(key1) && |
251 | return ContainsKey(key1) && |
|
213 | this[key1].ContainsKey(key2, key3, key4, key5, key6, key7, key8, key9, key10); |
252 | this[key1].ContainsKey(key2, key3, key4, key5, key6, key7, key8, key9, key10); |
|
214 | } |
253 | } |
|
215 | } |
254 | } |
|
216 | |
255 | |
|
217 | public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, V> : |
256 | public class MultiKeyDictionary<K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, V> : |
|
218 | Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, V>> |
257 | Dictionary<K1, MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, V>> |
|
219 | { |
258 | { |
|
220 | public V this[ |
259 | public V this[ |
|
221 | K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9, K10 key10, K11 key11] |
260 | K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9, K10 key10, K11 key11] |
|
222 | { |
261 | { |
|
223 | get |
262 | get |
|
224 | { |
263 | { |
|
225 | return ContainsKey(key1) |
264 | return ContainsKey(key1) |
|
226 | ? this[key1][key2, key3, key4, key5, key6, key7, key8, key9, key10, key11] |
265 | ? this[key1][key2, key3, key4, key5, key6, key7, key8, key9, key10, key11] |
|
227 | : default(V); |
266 | : default(V); |
|
228 | } |
267 | } |
|
229 | set |
268 | set |
|
230 | { |
269 | { |
|
231 | if (!ContainsKey(key1)) |
270 | if (!ContainsKey(key1)) |
|
232 | this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, V>(); |
271 | this[key1] = new MultiKeyDictionary<K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, V>(); |
|
233 | this[key1][key2, key3, key4, key5, key6, key7, key8, key9, key10, key11] = value; |
272 | this[key1][key2, key3, key4, key5, key6, key7, key8, key9, key10, key11] = value; |
|
234 | } |
273 | } |
|
235 | } |
274 | } |
|
236 | |
275 | |
|
237 | public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9, |
276 | public bool ContainsKey(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6, K7 key7, K8 key8, K9 key9, |
|
238 | K10 key10, K11 key11) |
277 | K10 key10, K11 key11) |
|
239 | { |
278 | { |
|
240 | return base.ContainsKey(key1) && |
279 | return ContainsKey(key1) && |
|
241 | this[key1].ContainsKey(key2, key3, key4, key5, key6, key7, key8, key9, key10, key11); |
280 | this[key1].ContainsKey(key2, key3, key4, key5, key6, key7, key8, key9, key10, key11); |
|
242 | } |
281 | } |
|
243 | } |
282 | } |
|
244 | } |
283 | } |
|
245 | |
284 | |
|
246 |
|
285 |
|
|
247 | |
286 | |
|
248 | |
287 | |
|
249 | |
288 | |