8b3af63b89
A lot of comments in LLDB are surrounded by an ASCII line to delimit the begging and end of the comment. Its use is not really consistent across the code base, sometimes the lines are longer, sometimes they are shorter and sometimes they are omitted. Furthermore, it looks kind of weird with the 80 column limit, where the comment actually extends past the line, but not by much. Furthermore, when /// is used for Doxygen comments, it looks particularly odd. And when // is used, it incorrectly gives the impression that it's actually a Doxygen comment. I assume these lines were added to improve distinguishing between comments and code. However, given that todays editors and IDEs do a great job at highlighting comments, I think it's worth to drop this for the sake of consistency. The alternative is fixing all the inconsistencies, which would create a lot more churn. Differential revision: https://reviews.llvm.org/D60508 llvm-svn: 358135
457 lines
15 KiB
C++
457 lines
15 KiB
C++
//===-- CFCMutableDictionary.cpp --------------------------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#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);
|
|
}
|