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