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 //----------------------------------------------------------------------
CFCMutableDictionary(CFMutableDictionaryRef s)15 CFCMutableDictionary::CFCMutableDictionary(CFMutableDictionaryRef s) :
16 CFCReleaser<CFMutableDictionaryRef> (s)
17 {
18 }
19
20 //----------------------------------------------------------------------
21 // CFCMutableDictionary copy constructor
22 //----------------------------------------------------------------------
CFCMutableDictionary(const CFCMutableDictionary & rhs)23 CFCMutableDictionary::CFCMutableDictionary(const CFCMutableDictionary& rhs) :
24 CFCReleaser<CFMutableDictionaryRef> (rhs)
25 {
26 }
27
28 //----------------------------------------------------------------------
29 // CFCMutableDictionary copy constructor
30 //----------------------------------------------------------------------
31 const CFCMutableDictionary&
operator =(const CFCMutableDictionary & rhs)32 CFCMutableDictionary::operator=(const CFCMutableDictionary& rhs)
33 {
34 if (this != &rhs)
35 *this = rhs;
36 return *this;
37 }
38
39 //----------------------------------------------------------------------
40 // Destructor
41 //----------------------------------------------------------------------
~CFCMutableDictionary()42 CFCMutableDictionary::~CFCMutableDictionary()
43 {
44 }
45
46
47 CFIndex
GetCount() const48 CFCMutableDictionary::GetCount() const
49 {
50 CFMutableDictionaryRef dict = get();
51 if (dict)
52 return ::CFDictionaryGetCount (dict);
53 return 0;
54 }
55
56 CFIndex
GetCountOfKey(const void * key) const57 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
GetCountOfValue(const void * value) const67 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
GetKeysAndValues(const void ** keys,const void ** values) const77 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 *
GetValue(const void * key) const86 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
GetValueIfPresent(const void * key,const void ** value_handle) const96 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
Dictionary(bool can_create)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
AddValue(CFStringRef key,const void * value,bool can_create)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
SetValue(CFStringRef key,const void * value,bool can_create)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
AddValueSInt8(CFStringRef key,int8_t value,bool can_create)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
SetValueSInt8(CFStringRef key,int8_t value,bool can_create)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
AddValueSInt16(CFStringRef key,int16_t value,bool can_create)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
SetValueSInt16(CFStringRef key,int16_t value,bool can_create)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
AddValueSInt32(CFStringRef key,int32_t value,bool can_create)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
SetValueSInt32(CFStringRef key,int32_t value,bool can_create)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
AddValueSInt64(CFStringRef key,int64_t value,bool can_create)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
SetValueSInt64(CFStringRef key,int64_t value,bool can_create)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
AddValueUInt8(CFStringRef key,uint8_t value,bool can_create)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
SetValueUInt8(CFStringRef key,uint8_t value,bool can_create)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
AddValueUInt16(CFStringRef key,uint16_t value,bool can_create)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
SetValueUInt16(CFStringRef key,uint16_t value,bool can_create)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
AddValueUInt32(CFStringRef key,uint32_t value,bool can_create)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
SetValueUInt32(CFStringRef key,uint32_t value,bool can_create)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
AddValueUInt64(CFStringRef key,uint64_t value,bool can_create)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
SetValueUInt64(CFStringRef key,uint64_t value,bool can_create)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
AddValueDouble(CFStringRef key,double value,bool can_create)435 CFCMutableDictionary::AddValueDouble(CFStringRef key, double value, bool can_create)
436 {
437 CFMutableDictionaryRef dict = Dictionary(can_create);
438 if (dict != NULL)
439 {
440 // The number may appear negative if the MSBit is set in "value". Due to a limitation of
441 // CFNumber, there isn't a way to have it show up otherwise as of this writing.
442 CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberDoubleType, &value));
443 if (cf_number.get())
444 {
445 // Let the dictionary own the CFNumber
446 ::CFDictionaryAddValue (dict, key, cf_number.get());
447 return true;
448 }
449 }
450 return false;
451 }
452
453 bool
SetValueDouble(CFStringRef key,double value,bool can_create)454 CFCMutableDictionary::SetValueDouble(CFStringRef key, double value, bool can_create)
455 {
456 CFMutableDictionaryRef dict = Dictionary(can_create);
457 if (dict != NULL)
458 {
459 // The number may appear negative if the MSBit is set in "value". Due to a limitation of
460 // CFNumber, there isn't a way to have it show up otherwise as of this writing.
461 CFCReleaser<CFNumberRef> cf_number(::CFNumberCreate (kCFAllocatorDefault, kCFNumberDoubleType, &value));
462 if (cf_number.get())
463 {
464 // Let the dictionary own the CFNumber
465 ::CFDictionarySetValue (dict, key, cf_number.get());
466 return true;
467 }
468 }
469 return false;
470 }
471
472 bool
AddValueCString(CFStringRef key,const char * cstr,bool can_create)473 CFCMutableDictionary::AddValueCString(CFStringRef key, const char *cstr, bool can_create)
474 {
475 CFMutableDictionaryRef dict = Dictionary(can_create);
476 if (dict != NULL)
477 {
478 CFCString cf_str(cstr, kCFStringEncodingUTF8);
479 if (cf_str.get())
480 {
481 // Let the dictionary own the CFNumber
482 ::CFDictionaryAddValue (dict, key, cf_str.get());
483 return true;
484 }
485 }
486 return false;
487 }
488
489 bool
SetValueCString(CFStringRef key,const char * cstr,bool can_create)490 CFCMutableDictionary::SetValueCString(CFStringRef key, const char *cstr, bool can_create)
491 {
492 CFMutableDictionaryRef dict = Dictionary(can_create);
493 if (dict != NULL)
494 {
495 CFCString cf_str(cstr, kCFStringEncodingUTF8);
496 if (cf_str.get())
497 {
498 // Let the dictionary own the CFNumber
499 ::CFDictionarySetValue (dict, key, cf_str.get());
500 return true;
501 }
502 }
503 return false;
504 }
505
506
507 void
RemoveAllValues()508 CFCMutableDictionary::RemoveAllValues()
509 {
510 CFMutableDictionaryRef dict = get();
511 if (dict)
512 ::CFDictionaryRemoveAllValues(dict);
513 }
514
515 void
RemoveValue(const void * value)516 CFCMutableDictionary::RemoveValue(const void *value)
517 {
518 CFMutableDictionaryRef dict = get();
519 if (dict)
520 ::CFDictionaryRemoveValue(dict, value);
521 }
522 void
ReplaceValue(const void * key,const void * value)523 CFCMutableDictionary::ReplaceValue(const void *key, const void *value)
524 {
525 CFMutableDictionaryRef dict = get();
526 if (dict)
527 ::CFDictionaryReplaceValue (dict, key, value);
528 }
529
530