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