| //===-- CFCMutableDictionary.cpp --------------------------------*- C++ -*-===// | |
| // | |
| // The LLVM Compiler Infrastructure | |
| // | |
| // This file is distributed under the University of Illinois Open Source | |
| // License. See LICENSE.TXT for details. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "CFCMutableDictionary.h" | |
| #include "CFCString.h" | |
| //---------------------------------------------------------------------- | |
| // CFCString constructor | |
| //---------------------------------------------------------------------- | |
| CFCMutableDictionary::CFCMutableDictionary(CFMutableDictionaryRef s) | |
| : CFCReleaser<CFMutableDictionaryRef>(s) {} | |
| //---------------------------------------------------------------------- | |
| // CFCMutableDictionary copy constructor | |
| //---------------------------------------------------------------------- | |
| CFCMutableDictionary::CFCMutableDictionary(const CFCMutableDictionary &rhs) | |
| : CFCReleaser<CFMutableDictionaryRef>(rhs) {} | |
| //---------------------------------------------------------------------- | |
| // CFCMutableDictionary copy constructor | |
| //---------------------------------------------------------------------- | |
| const CFCMutableDictionary &CFCMutableDictionary:: | |
| operator=(const CFCMutableDictionary &rhs) { | |
| if (this != &rhs) | |
| *this = rhs; | |
| return *this; | |
| } | |
| //---------------------------------------------------------------------- | |
| // Destructor | |
| //---------------------------------------------------------------------- | |
| CFCMutableDictionary::~CFCMutableDictionary() {} | |
| CFIndex CFCMutableDictionary::GetCount() const { | |
| CFMutableDictionaryRef dict = get(); | |
| if (dict) | |
| return ::CFDictionaryGetCount(dict); | |
| return 0; | |
| } | |
| CFIndex CFCMutableDictionary::GetCountOfKey(const void *key) const | |
| { | |
| CFMutableDictionaryRef dict = get(); | |
| if (dict) | |
| return ::CFDictionaryGetCountOfKey(dict, key); | |
| return 0; | |
| } | |
| CFIndex CFCMutableDictionary::GetCountOfValue(const void *value) const | |
| { | |
| CFMutableDictionaryRef dict = get(); | |
| if (dict) | |
| return ::CFDictionaryGetCountOfValue(dict, value); | |
| return 0; | |
| } | |
| void CFCMutableDictionary::GetKeysAndValues(const void **keys, | |
| const void **values) const { | |
| CFMutableDictionaryRef dict = get(); | |
| if (dict) | |
| ::CFDictionaryGetKeysAndValues(dict, keys, values); | |
| } | |
| const void *CFCMutableDictionary::GetValue(const void *key) const | |
| { | |
| CFMutableDictionaryRef dict = get(); | |
| if (dict) | |
| return ::CFDictionaryGetValue(dict, key); | |
| return NULL; | |
| } | |
| Boolean | |
| CFCMutableDictionary::GetValueIfPresent(const void *key, | |
| const void **value_handle) const { | |
| CFMutableDictionaryRef dict = get(); | |
| if (dict) | |
| return ::CFDictionaryGetValueIfPresent(dict, key, value_handle); | |
| return false; | |
| } | |
| CFMutableDictionaryRef CFCMutableDictionary::Dictionary(bool can_create) { | |
| CFMutableDictionaryRef dict = get(); | |
| if (can_create && dict == NULL) { | |
| dict = ::CFDictionaryCreateMutable(kCFAllocatorDefault, 0, | |
| &kCFTypeDictionaryKeyCallBacks, | |
| &kCFTypeDictionaryValueCallBacks); | |
| reset(dict); | |
| } | |
| return dict; | |
| } | |
| bool CFCMutableDictionary::AddValue(CFStringRef key, const void *value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionaryAddValue(dict, key, value); | |
| return true; | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::SetValue(CFStringRef key, const void *value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionarySetValue(dict, key, value); | |
| return true; | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::AddValueSInt8(CFStringRef key, int8_t value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt8Type, &value)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionaryAddValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::SetValueSInt8(CFStringRef key, int8_t value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt8Type, &value)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionarySetValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::AddValueSInt16(CFStringRef key, int16_t value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt16Type, &value)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionaryAddValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::SetValueSInt16(CFStringRef key, int16_t value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt16Type, &value)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionarySetValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::AddValueSInt32(CFStringRef key, int32_t value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &value)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionaryAddValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::SetValueSInt32(CFStringRef key, int32_t value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &value)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionarySetValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::AddValueSInt64(CFStringRef key, int64_t value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &value)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionaryAddValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::SetValueSInt64(CFStringRef key, int64_t value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &value)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionarySetValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::AddValueUInt8(CFStringRef key, uint8_t value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| // Have to promote to the next size type so things don't appear negative of | |
| // the MSBit is set... | |
| int16_t sval = value; | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt16Type, &sval)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionaryAddValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::SetValueUInt8(CFStringRef key, uint8_t value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| // Have to promote to the next size type so things don't appear negative of | |
| // the MSBit is set... | |
| int16_t sval = value; | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt16Type, &sval)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionarySetValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::AddValueUInt16(CFStringRef key, uint16_t value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| // Have to promote to the next size type so things don't appear negative of | |
| // the MSBit is set... | |
| int32_t sval = value; | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &sval)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionaryAddValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::SetValueUInt16(CFStringRef key, uint16_t value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| // Have to promote to the next size type so things don't appear negative of | |
| // the MSBit is set... | |
| int32_t sval = value; | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &sval)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionarySetValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::AddValueUInt32(CFStringRef key, uint32_t value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| // Have to promote to the next size type so things don't appear negative of | |
| // the MSBit is set... | |
| int64_t sval = value; | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &sval)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionaryAddValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::SetValueUInt32(CFStringRef key, uint32_t value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| // Have to promote to the next size type so things don't appear negative of | |
| // the MSBit is set... | |
| int64_t sval = value; | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &sval)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionarySetValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::AddValueUInt64(CFStringRef key, uint64_t value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| // The number may appear negative if the MSBit is set in "value". Due to a | |
| // limitation of CFNumber, there isn't a way to have it show up otherwise | |
| // as of this writing. | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &value)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionaryAddValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::SetValueUInt64(CFStringRef key, uint64_t value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| // The number may appear negative if the MSBit is set in "value". Due to a | |
| // limitation of CFNumber, there isn't a way to have it show up otherwise | |
| // as of this writing. | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &value)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionarySetValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::AddValueDouble(CFStringRef key, double value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| // The number may appear negative if the MSBit is set in "value". Due to a | |
| // limitation of CFNumber, there isn't a way to have it show up otherwise | |
| // as of this writing. | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &value)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionaryAddValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::SetValueDouble(CFStringRef key, double value, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| // The number may appear negative if the MSBit is set in "value". Due to a | |
| // limitation of CFNumber, there isn't a way to have it show up otherwise | |
| // as of this writing. | |
| CFCReleaser<CFNumberRef> cf_number( | |
| ::CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &value)); | |
| if (cf_number.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionarySetValue(dict, key, cf_number.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::AddValueCString(CFStringRef key, const char *cstr, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| CFCString cf_str(cstr, kCFStringEncodingUTF8); | |
| if (cf_str.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionaryAddValue(dict, key, cf_str.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| bool CFCMutableDictionary::SetValueCString(CFStringRef key, const char *cstr, | |
| bool can_create) { | |
| CFMutableDictionaryRef dict = Dictionary(can_create); | |
| if (dict != NULL) { | |
| CFCString cf_str(cstr, kCFStringEncodingUTF8); | |
| if (cf_str.get()) { | |
| // Let the dictionary own the CFNumber | |
| ::CFDictionarySetValue(dict, key, cf_str.get()); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| void CFCMutableDictionary::RemoveAllValues() { | |
| CFMutableDictionaryRef dict = get(); | |
| if (dict) | |
| ::CFDictionaryRemoveAllValues(dict); | |
| } | |
| void CFCMutableDictionary::RemoveValue(const void *value) { | |
| CFMutableDictionaryRef dict = get(); | |
| if (dict) | |
| ::CFDictionaryRemoveValue(dict, value); | |
| } | |
| void CFCMutableDictionary::ReplaceValue(const void *key, const void *value) { | |
| CFMutableDictionaryRef dict = get(); | |
| if (dict) | |
| ::CFDictionaryReplaceValue(dict, key, value); | |
| } |