1 //===-- CFCMutableDictionary.cpp --------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "CFCMutableDictionary.h"
10 #include "CFCString.h"
11 // CFCString constructor
12 CFCMutableDictionary::CFCMutableDictionary(CFMutableDictionaryRef s)
13     : CFCReleaser<CFMutableDictionaryRef>(s) {}
14 
15 // CFCMutableDictionary copy constructor
16 CFCMutableDictionary::CFCMutableDictionary(const CFCMutableDictionary &rhs)
17     : CFCReleaser<CFMutableDictionaryRef>(rhs) {}
18 
19 // CFCMutableDictionary copy constructor
20 const CFCMutableDictionary &CFCMutableDictionary::
21 operator=(const CFCMutableDictionary &rhs) {
22   if (this != &rhs)
23     *this = rhs;
24   return *this;
25 }
26 
27 // Destructor
28 CFCMutableDictionary::~CFCMutableDictionary() {}
29 
30 CFIndex CFCMutableDictionary::GetCount() const {
31   CFMutableDictionaryRef dict = get();
32   if (dict)
33     return ::CFDictionaryGetCount(dict);
34   return 0;
35 }
36 
37 CFIndex CFCMutableDictionary::GetCountOfKey(const void *key) const
38 
39 {
40   CFMutableDictionaryRef dict = get();
41   if (dict)
42     return ::CFDictionaryGetCountOfKey(dict, key);
43   return 0;
44 }
45 
46 CFIndex CFCMutableDictionary::GetCountOfValue(const void *value) const
47 
48 {
49   CFMutableDictionaryRef dict = get();
50   if (dict)
51     return ::CFDictionaryGetCountOfValue(dict, value);
52   return 0;
53 }
54 
55 void CFCMutableDictionary::GetKeysAndValues(const void **keys,
56                                             const void **values) const {
57   CFMutableDictionaryRef dict = get();
58   if (dict)
59     ::CFDictionaryGetKeysAndValues(dict, keys, values);
60 }
61 
62 const void *CFCMutableDictionary::GetValue(const void *key) const
63 
64 {
65   CFMutableDictionaryRef dict = get();
66   if (dict)
67     return ::CFDictionaryGetValue(dict, key);
68   return NULL;
69 }
70 
71 Boolean
72 CFCMutableDictionary::GetValueIfPresent(const void *key,
73                                         const void **value_handle) const {
74   CFMutableDictionaryRef dict = get();
75   if (dict)
76     return ::CFDictionaryGetValueIfPresent(dict, key, value_handle);
77   return false;
78 }
79 
80 CFMutableDictionaryRef CFCMutableDictionary::Dictionary(bool can_create) {
81   CFMutableDictionaryRef dict = get();
82   if (can_create && dict == NULL) {
83     dict = ::CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
84                                        &kCFTypeDictionaryKeyCallBacks,
85                                        &kCFTypeDictionaryValueCallBacks);
86     reset(dict);
87   }
88   return dict;
89 }
90 
91 bool CFCMutableDictionary::AddValue(CFStringRef key, const void *value,
92                                     bool can_create) {
93   CFMutableDictionaryRef dict = Dictionary(can_create);
94   if (dict != NULL) {
95     // Let the dictionary own the CFNumber
96     ::CFDictionaryAddValue(dict, key, value);
97     return true;
98   }
99   return false;
100 }
101 
102 bool CFCMutableDictionary::SetValue(CFStringRef key, const void *value,
103                                     bool can_create) {
104   CFMutableDictionaryRef dict = Dictionary(can_create);
105   if (dict != NULL) {
106     // Let the dictionary own the CFNumber
107     ::CFDictionarySetValue(dict, key, value);
108     return true;
109   }
110   return false;
111 }
112 
113 bool CFCMutableDictionary::AddValueSInt8(CFStringRef key, int8_t value,
114                                          bool can_create) {
115   CFMutableDictionaryRef dict = Dictionary(can_create);
116   if (dict != NULL) {
117     CFCReleaser<CFNumberRef> cf_number(
118         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt8Type, &value));
119     if (cf_number.get()) {
120       // Let the dictionary own the CFNumber
121       ::CFDictionaryAddValue(dict, key, cf_number.get());
122       return true;
123     }
124   }
125   return false;
126 }
127 
128 bool CFCMutableDictionary::SetValueSInt8(CFStringRef key, int8_t value,
129                                          bool can_create) {
130   CFMutableDictionaryRef dict = Dictionary(can_create);
131   if (dict != NULL) {
132     CFCReleaser<CFNumberRef> cf_number(
133         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt8Type, &value));
134     if (cf_number.get()) {
135       // Let the dictionary own the CFNumber
136       ::CFDictionarySetValue(dict, key, cf_number.get());
137       return true;
138     }
139   }
140   return false;
141 }
142 
143 bool CFCMutableDictionary::AddValueSInt16(CFStringRef key, int16_t value,
144                                           bool can_create) {
145   CFMutableDictionaryRef dict = Dictionary(can_create);
146   if (dict != NULL) {
147     CFCReleaser<CFNumberRef> cf_number(
148         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt16Type, &value));
149     if (cf_number.get()) {
150       // Let the dictionary own the CFNumber
151       ::CFDictionaryAddValue(dict, key, cf_number.get());
152       return true;
153     }
154   }
155   return false;
156 }
157 
158 bool CFCMutableDictionary::SetValueSInt16(CFStringRef key, int16_t value,
159                                           bool can_create) {
160   CFMutableDictionaryRef dict = Dictionary(can_create);
161   if (dict != NULL) {
162     CFCReleaser<CFNumberRef> cf_number(
163         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt16Type, &value));
164     if (cf_number.get()) {
165       // Let the dictionary own the CFNumber
166       ::CFDictionarySetValue(dict, key, cf_number.get());
167       return true;
168     }
169   }
170   return false;
171 }
172 
173 bool CFCMutableDictionary::AddValueSInt32(CFStringRef key, int32_t value,
174                                           bool can_create) {
175   CFMutableDictionaryRef dict = Dictionary(can_create);
176   if (dict != NULL) {
177     CFCReleaser<CFNumberRef> cf_number(
178         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &value));
179     if (cf_number.get()) {
180       // Let the dictionary own the CFNumber
181       ::CFDictionaryAddValue(dict, key, cf_number.get());
182       return true;
183     }
184   }
185   return false;
186 }
187 
188 bool CFCMutableDictionary::SetValueSInt32(CFStringRef key, int32_t value,
189                                           bool can_create) {
190   CFMutableDictionaryRef dict = Dictionary(can_create);
191   if (dict != NULL) {
192     CFCReleaser<CFNumberRef> cf_number(
193         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &value));
194     if (cf_number.get()) {
195       // Let the dictionary own the CFNumber
196       ::CFDictionarySetValue(dict, key, cf_number.get());
197       return true;
198     }
199   }
200   return false;
201 }
202 
203 bool CFCMutableDictionary::AddValueSInt64(CFStringRef key, int64_t value,
204                                           bool can_create) {
205   CFMutableDictionaryRef dict = Dictionary(can_create);
206   if (dict != NULL) {
207     CFCReleaser<CFNumberRef> cf_number(
208         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &value));
209     if (cf_number.get()) {
210       // Let the dictionary own the CFNumber
211       ::CFDictionaryAddValue(dict, key, cf_number.get());
212       return true;
213     }
214   }
215   return false;
216 }
217 
218 bool CFCMutableDictionary::SetValueSInt64(CFStringRef key, int64_t value,
219                                           bool can_create) {
220   CFMutableDictionaryRef dict = Dictionary(can_create);
221   if (dict != NULL) {
222     CFCReleaser<CFNumberRef> cf_number(
223         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &value));
224     if (cf_number.get()) {
225       // Let the dictionary own the CFNumber
226       ::CFDictionarySetValue(dict, key, cf_number.get());
227       return true;
228     }
229   }
230   return false;
231 }
232 
233 bool CFCMutableDictionary::AddValueUInt8(CFStringRef key, uint8_t value,
234                                          bool can_create) {
235   CFMutableDictionaryRef dict = Dictionary(can_create);
236   if (dict != NULL) {
237     // Have to promote to the next size type so things don't appear negative of
238     // the MSBit is set...
239     int16_t sval = value;
240     CFCReleaser<CFNumberRef> cf_number(
241         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt16Type, &sval));
242     if (cf_number.get()) {
243       // Let the dictionary own the CFNumber
244       ::CFDictionaryAddValue(dict, key, cf_number.get());
245       return true;
246     }
247   }
248   return false;
249 }
250 
251 bool CFCMutableDictionary::SetValueUInt8(CFStringRef key, uint8_t value,
252                                          bool can_create) {
253   CFMutableDictionaryRef dict = Dictionary(can_create);
254   if (dict != NULL) {
255     // Have to promote to the next size type so things don't appear negative of
256     // the MSBit is set...
257     int16_t sval = value;
258     CFCReleaser<CFNumberRef> cf_number(
259         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt16Type, &sval));
260     if (cf_number.get()) {
261       // Let the dictionary own the CFNumber
262       ::CFDictionarySetValue(dict, key, cf_number.get());
263       return true;
264     }
265   }
266   return false;
267 }
268 
269 bool CFCMutableDictionary::AddValueUInt16(CFStringRef key, uint16_t value,
270                                           bool can_create) {
271   CFMutableDictionaryRef dict = Dictionary(can_create);
272   if (dict != NULL) {
273     // Have to promote to the next size type so things don't appear negative of
274     // the MSBit is set...
275     int32_t sval = value;
276     CFCReleaser<CFNumberRef> cf_number(
277         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &sval));
278     if (cf_number.get()) {
279       // Let the dictionary own the CFNumber
280       ::CFDictionaryAddValue(dict, key, cf_number.get());
281       return true;
282     }
283   }
284   return false;
285 }
286 
287 bool CFCMutableDictionary::SetValueUInt16(CFStringRef key, uint16_t value,
288                                           bool can_create) {
289   CFMutableDictionaryRef dict = Dictionary(can_create);
290   if (dict != NULL) {
291     // Have to promote to the next size type so things don't appear negative of
292     // the MSBit is set...
293     int32_t sval = value;
294     CFCReleaser<CFNumberRef> cf_number(
295         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &sval));
296     if (cf_number.get()) {
297       // Let the dictionary own the CFNumber
298       ::CFDictionarySetValue(dict, key, cf_number.get());
299       return true;
300     }
301   }
302   return false;
303 }
304 
305 bool CFCMutableDictionary::AddValueUInt32(CFStringRef key, uint32_t value,
306                                           bool can_create) {
307   CFMutableDictionaryRef dict = Dictionary(can_create);
308   if (dict != NULL) {
309     // Have to promote to the next size type so things don't appear negative of
310     // the MSBit is set...
311     int64_t sval = value;
312     CFCReleaser<CFNumberRef> cf_number(
313         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &sval));
314     if (cf_number.get()) {
315       // Let the dictionary own the CFNumber
316       ::CFDictionaryAddValue(dict, key, cf_number.get());
317       return true;
318     }
319   }
320   return false;
321 }
322 
323 bool CFCMutableDictionary::SetValueUInt32(CFStringRef key, uint32_t value,
324                                           bool can_create) {
325   CFMutableDictionaryRef dict = Dictionary(can_create);
326   if (dict != NULL) {
327     // Have to promote to the next size type so things don't appear negative of
328     // the MSBit is set...
329     int64_t sval = value;
330     CFCReleaser<CFNumberRef> cf_number(
331         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &sval));
332     if (cf_number.get()) {
333       // Let the dictionary own the CFNumber
334       ::CFDictionarySetValue(dict, key, cf_number.get());
335       return true;
336     }
337   }
338   return false;
339 }
340 
341 bool CFCMutableDictionary::AddValueUInt64(CFStringRef key, uint64_t value,
342                                           bool can_create) {
343   CFMutableDictionaryRef dict = Dictionary(can_create);
344   if (dict != NULL) {
345     // The number may appear negative if the MSBit is set in "value". Due to a
346     // limitation of CFNumber, there isn't a way to have it show up otherwise
347     // as of this writing.
348     CFCReleaser<CFNumberRef> cf_number(
349         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &value));
350     if (cf_number.get()) {
351       // Let the dictionary own the CFNumber
352       ::CFDictionaryAddValue(dict, key, cf_number.get());
353       return true;
354     }
355   }
356   return false;
357 }
358 
359 bool CFCMutableDictionary::SetValueUInt64(CFStringRef key, uint64_t value,
360                                           bool can_create) {
361   CFMutableDictionaryRef dict = Dictionary(can_create);
362   if (dict != NULL) {
363     // The number may appear negative if the MSBit is set in "value". Due to a
364     // limitation of CFNumber, there isn't a way to have it show up otherwise
365     // as of this writing.
366     CFCReleaser<CFNumberRef> cf_number(
367         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &value));
368     if (cf_number.get()) {
369       // Let the dictionary own the CFNumber
370       ::CFDictionarySetValue(dict, key, cf_number.get());
371       return true;
372     }
373   }
374   return false;
375 }
376 
377 bool CFCMutableDictionary::AddValueDouble(CFStringRef key, double value,
378                                           bool can_create) {
379   CFMutableDictionaryRef dict = Dictionary(can_create);
380   if (dict != NULL) {
381     // The number may appear negative if the MSBit is set in "value". Due to a
382     // limitation of CFNumber, there isn't a way to have it show up otherwise
383     // as of this writing.
384     CFCReleaser<CFNumberRef> cf_number(
385         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &value));
386     if (cf_number.get()) {
387       // Let the dictionary own the CFNumber
388       ::CFDictionaryAddValue(dict, key, cf_number.get());
389       return true;
390     }
391   }
392   return false;
393 }
394 
395 bool CFCMutableDictionary::SetValueDouble(CFStringRef key, double value,
396                                           bool can_create) {
397   CFMutableDictionaryRef dict = Dictionary(can_create);
398   if (dict != NULL) {
399     // The number may appear negative if the MSBit is set in "value". Due to a
400     // limitation of CFNumber, there isn't a way to have it show up otherwise
401     // as of this writing.
402     CFCReleaser<CFNumberRef> cf_number(
403         ::CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &value));
404     if (cf_number.get()) {
405       // Let the dictionary own the CFNumber
406       ::CFDictionarySetValue(dict, key, cf_number.get());
407       return true;
408     }
409   }
410   return false;
411 }
412 
413 bool CFCMutableDictionary::AddValueCString(CFStringRef key, const char *cstr,
414                                            bool can_create) {
415   CFMutableDictionaryRef dict = Dictionary(can_create);
416   if (dict != NULL) {
417     CFCString cf_str(cstr, kCFStringEncodingUTF8);
418     if (cf_str.get()) {
419       // Let the dictionary own the CFNumber
420       ::CFDictionaryAddValue(dict, key, cf_str.get());
421       return true;
422     }
423   }
424   return false;
425 }
426 
427 bool CFCMutableDictionary::SetValueCString(CFStringRef key, const char *cstr,
428                                            bool can_create) {
429   CFMutableDictionaryRef dict = Dictionary(can_create);
430   if (dict != NULL) {
431     CFCString cf_str(cstr, kCFStringEncodingUTF8);
432     if (cf_str.get()) {
433       // Let the dictionary own the CFNumber
434       ::CFDictionarySetValue(dict, key, cf_str.get());
435       return true;
436     }
437   }
438   return false;
439 }
440 
441 void CFCMutableDictionary::RemoveAllValues() {
442   CFMutableDictionaryRef dict = get();
443   if (dict)
444     ::CFDictionaryRemoveAllValues(dict);
445 }
446 
447 void CFCMutableDictionary::RemoveValue(const void *value) {
448   CFMutableDictionaryRef dict = get();
449   if (dict)
450     ::CFDictionaryRemoveValue(dict, value);
451 }
452 void CFCMutableDictionary::ReplaceValue(const void *key, const void *value) {
453   CFMutableDictionaryRef dict = get();
454   if (dict)
455     ::CFDictionaryReplaceValue(dict, key, value);
456 }
457