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//----------------------------------------------------------------------
15CFCMutableDictionary::CFCMutableDictionary(CFMutableDictionaryRef s) :
16    CFCReleaser<CFMutableDictionaryRef> (s)
17{
18}
19
20//----------------------------------------------------------------------
21// CFCMutableDictionary copy constructor
22//----------------------------------------------------------------------
23CFCMutableDictionary::CFCMutableDictionary(const CFCMutableDictionary& rhs) :
24    CFCReleaser<CFMutableDictionaryRef> (rhs)
25{
26}
27
28//----------------------------------------------------------------------
29// CFCMutableDictionary copy constructor
30//----------------------------------------------------------------------
31const CFCMutableDictionary&
32CFCMutableDictionary::operator=(const CFCMutableDictionary& rhs)
33{
34    if (this != &rhs)
35        *this = rhs;
36    return *this;
37}
38
39//----------------------------------------------------------------------
40// Destructor
41//----------------------------------------------------------------------
42CFCMutableDictionary::~CFCMutableDictionary()
43{
44}
45
46
47CFIndex
48CFCMutableDictionary::GetCount() const
49{
50    CFMutableDictionaryRef dict = get();
51    if (dict)
52        return ::CFDictionaryGetCount (dict);
53    return 0;
54}
55
56CFIndex
57CFCMutableDictionary::GetCountOfKey(const void *key) const
58
59{
60    CFMutableDictionaryRef dict = get();
61    if (dict)
62        return ::CFDictionaryGetCountOfKey (dict, key);
63    return 0;
64}
65
66CFIndex
67CFCMutableDictionary::GetCountOfValue(const void *value) const
68
69{
70    CFMutableDictionaryRef dict = get();
71    if (dict)
72        return ::CFDictionaryGetCountOfValue (dict, value);
73    return 0;
74}
75
76void
77CFCMutableDictionary::GetKeysAndValues(const void **keys, const void **values) const
78{
79    CFMutableDictionaryRef dict = get();
80    if (dict)
81        ::CFDictionaryGetKeysAndValues (dict, keys, values);
82}
83
84
85const void *
86CFCMutableDictionary::GetValue(const void *key) const
87
88{
89    CFMutableDictionaryRef dict = get();
90    if (dict)
91        return ::CFDictionaryGetValue (dict, key);
92    return NULL;
93}
94
95Boolean
96CFCMutableDictionary::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
105CFMutableDictionaryRef
106CFCMutableDictionary::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
117bool
118CFCMutableDictionary::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
130bool
131CFCMutableDictionary::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
143bool
144CFCMutableDictionary::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
160bool
161CFCMutableDictionary::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
177bool
178CFCMutableDictionary::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
194bool
195CFCMutableDictionary::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
211bool
212CFCMutableDictionary::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
228bool
229CFCMutableDictionary::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
245bool
246CFCMutableDictionary::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
262bool
263CFCMutableDictionary::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
279bool
280CFCMutableDictionary::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
298bool
299CFCMutableDictionary::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
318bool
319CFCMutableDictionary::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
337bool
338CFCMutableDictionary::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
356bool
357CFCMutableDictionary::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
375bool
376CFCMutableDictionary::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
395bool
396CFCMutableDictionary::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
415bool
416CFCMutableDictionary::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
434bool
435CFCMutableDictionary::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
453bool
454CFCMutableDictionary::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
472bool
473CFCMutableDictionary::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
489bool
490CFCMutableDictionary::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
507void
508CFCMutableDictionary::RemoveAllValues()
509{
510    CFMutableDictionaryRef dict = get();
511    if (dict)
512        ::CFDictionaryRemoveAllValues(dict);
513}
514
515void
516CFCMutableDictionary::RemoveValue(const void *value)
517{
518    CFMutableDictionaryRef dict = get();
519    if (dict)
520        ::CFDictionaryRemoveValue(dict, value);
521}
522void
523CFCMutableDictionary::ReplaceValue(const void *key, const void *value)
524{
525    CFMutableDictionaryRef dict = get();
526    if (dict)
527        ::CFDictionaryReplaceValue (dict, key, value);
528}
529
530