void CFArraySetValueAtIndex(CFMutableArrayRef array, CFIndex idx, const void *value) {
CF_OBJC_FUNCDISPATCHV(__kCFArrayTypeID, void, (NSMutableArray *)array, setObject:(id)value atIndex:(NSUInteger)idx);
__CFGenericValidateType(array, __kCFArrayTypeID);
CFAssert1(__CFArrayGetType(array) != __kCFArrayImmutable, __kCFLogAssertion, "%s(): array is immutable", __PRETTY_FUNCTION__);
CFAssert2(0 <= idx && idx <= __CFArrayGetCount(array), __kCFLogAssertion, "%s(): index (%d) out of bounds", __PRETTY_FUNCTION__, idx);
CHECK_FOR_MUTATION(array);
if (idx == __CFArrayGetCount(array)) {
_CFArrayReplaceValues(array, CFRangeMake(idx, 0), &value, 1);
} else {
BEGIN_MUTATION(array);
const void *old_value;
const CFArrayCallBacks *cb = __CFArrayGetCallBacks(array);
CFAllocatorRef allocator = __CFGetAllocator(array);
struct __CFArrayBucket *bucket = __CFArrayGetBucketAtIndex(array, idx);
if (NULL != cb->retain && !hasBeenFinalized(array)) {
value = (void *)INVOKE_CALLBACK2(cb->retain, allocator, value);
}
old_value = bucket->_item;
__CFAssignWithWriteBarrier((void **)&bucket->_item, (void *)value); // GC: handles deque/CFStorage cases.
if (NULL != cb->release && !hasBeenFinalized(array)) {
INVOKE_CALLBACK2(cb->release, allocator, old_value);
}
array->_mutations++;
END_MUTATION(array);
}
}
void CFArrayAppendValue(CFMutableArrayRef array, const void *value) {
CF_OBJC_FUNCDISPATCH1(__kCFArrayTypeID, void, array, "addObject:", value);
__CFGenericValidateType(array, __kCFArrayTypeID);
CFAssert1(__CFArrayGetType(array) != __kCFArrayImmutable, __kCFLogAssertion, "%s(): array is immutable", __PRETTY_FUNCTION__);
CHECK_FOR_MUTATION(array);
_CFArrayReplaceValues(array, CFRangeMake(__CFArrayGetCount(array), 0), &value, 1);
}
CF_EXPORT unsigned long _CFArrayFastEnumeration(CFArrayRef array, struct __objcFastEnumerationStateEquivalent *state, void *stackbuffer, unsigned long count) {
CHECK_FOR_MUTATION(array);
if (array->_count == 0) return 0;
enum { ATSTART = 0, ATEND = 1 };
switch (__CFArrayGetType(array)) {
case __kCFArrayImmutable:
if (state->state == ATSTART) { /* first time */
static const unsigned long const_mu = 1;
state->state = ATEND;
state->mutationsPtr = (unsigned long *)&const_mu;
state->itemsPtr = (unsigned long *)__CFArrayGetBucketsPtr(array);
return array->_count;
}
return 0;
case __kCFArrayDeque:
if (state->state == ATSTART) { /* first time */
state->state = ATEND;
state->mutationsPtr = (unsigned long *)&array->_mutations;
state->itemsPtr = (unsigned long *)__CFArrayGetBucketsPtr(array);
return array->_count;
}
return 0;
}
return 0;
}
static CFStringRef __CFArrayCopyDescription(CFTypeRef cf) {
CFArrayRef array = (CFArrayRef)cf;
CFMutableStringRef result;
const CFArrayCallBacks *cb;
CFAllocatorRef allocator;
CFIndex idx, cnt;
cnt = __CFArrayGetCount(array);
allocator = CFGetAllocator(array);
result = CFStringCreateMutable(allocator, 0);
switch (__CFArrayGetType(array)) {
case __kCFArrayImmutable:
CFStringAppendFormat(result, NULL, CFSTR("<CFArray %p [%p]>{type = immutable, count = %lu, values = (%s"), cf, allocator, (unsigned long)cnt, cnt ? "\n" : "");
break;
case __kCFArrayDeque:
CFStringAppendFormat(result, NULL, CFSTR("<CFArray %p [%p]>{type = mutable-small, count = %lu, values = (%s"), cf, allocator, (unsigned long)cnt, cnt ? "\n" : "");
break;
}
cb = __CFArrayGetCallBacks(array);
for (idx = 0; idx < cnt; idx++) {
CFStringRef desc = NULL;
const void *val = __CFArrayGetBucketAtIndex(array, idx)->_item;
if (NULL != cb->copyDescription) {
desc = (CFStringRef)INVOKE_CALLBACK1(cb->copyDescription, val);
}
if (NULL != desc) {
CFStringAppendFormat(result, NULL, CFSTR("\t%lu : %@\n"), (unsigned long)idx, desc);
CFRelease(desc);
} else {
CFStringAppendFormat(result, NULL, CFSTR("\t%lu : <%p>\n"), (unsigned long)idx, val);
}
}
CFStringAppend(result, CFSTR(")}"));
return result;
}
void CFArrayInsertValueAtIndex(CFMutableArrayRef array, CFIndex idx, const void *value) {
CF_OBJC_FUNCDISPATCH2(__kCFArrayTypeID, void, array, "insertObject:atIndex:", value, idx);
__CFGenericValidateType(array, __kCFArrayTypeID);
CFAssert1(__CFArrayGetType(array) != __kCFArrayImmutable, __kCFLogAssertion, "%s(): array is immutable", __PRETTY_FUNCTION__);
CFAssert2(0 <= idx && idx <= __CFArrayGetCount(array), __kCFLogAssertion, "%s(): index (%d) out of bounds", __PRETTY_FUNCTION__, idx);
CHECK_FOR_MUTATION(array);
_CFArrayReplaceValues(array, CFRangeMake(idx, 0), &value, 1);
}
void CFArrayRemoveValueAtIndex(CFMutableArrayRef array, CFIndex idx) {
CF_OBJC_FUNCDISPATCHV(__kCFArrayTypeID, void, (NSMutableArray *)array, removeObjectAtIndex:(NSUInteger)idx);
__CFGenericValidateType(array, __kCFArrayTypeID);
CFAssert1(__CFArrayGetType(array) != __kCFArrayImmutable, __kCFLogAssertion, "%s(): array is immutable", __PRETTY_FUNCTION__);
CFAssert2(0 <= idx && idx < __CFArrayGetCount(array), __kCFLogAssertion, "%s(): index (%d) out of bounds", __PRETTY_FUNCTION__, idx);
CHECK_FOR_MUTATION(array);
_CFArrayReplaceValues(array, CFRangeMake(idx, 1), NULL, 0);
}
/* This shouldn't be called if the array count is 0. */
CF_INLINE struct __CFArrayBucket *__CFArrayGetBucketAtIndex(CFArrayRef array, CFIndex idx) {
switch (__CFArrayGetType(array)) {
case __kCFArrayImmutable:
case __kCFArrayDeque:
return __CFArrayGetBucketsPtr(array) + idx;
}
return NULL;
}
void CFArrayReplaceValues(CFMutableArrayRef array, CFRange range, const void **newValues, CFIndex newCount) {
CF_OBJC_FUNCDISPATCHV(__kCFArrayTypeID, void, (NSMutableArray *)array, replaceObjectsInRange:NSMakeRange(range.location, range.length) withObjects:(id *)newValues count:(NSUInteger)newCount);
__CFGenericValidateType(array, __kCFArrayTypeID);
__CFArrayValidateRange(array, range, __PRETTY_FUNCTION__);
CFAssert1(__CFArrayGetType(array) != __kCFArrayImmutable, __kCFLogAssertion, "%s(): array is immutable", __PRETTY_FUNCTION__);
CFAssert2(0 <= newCount, __kCFLogAssertion, "%s(): newCount (%d) cannot be less than zero", __PRETTY_FUNCTION__, newCount);
CHECK_FOR_MUTATION(array);
return _CFArrayReplaceValues(array, range, newValues, newCount);
}
/* Only applies to immutable and mutable-deque-using arrays;
* Returns the bucket holding the left-most real value in the latter case. */
CF_INLINE struct __CFArrayBucket *__CFArrayGetBucketsPtr(CFArrayRef array) {
switch (__CFArrayGetType(array)) {
case __kCFArrayImmutable:
return (struct __CFArrayBucket *)((uint8_t *)array + __CFArrayGetSizeOfType(((CFRuntimeBase *)array)->_cfinfo[CF_INFO_BITS]));
case __kCFArrayDeque: {
struct __CFArrayDeque *deque = (struct __CFArrayDeque *)array->_store;
return (struct __CFArrayBucket *)((uint8_t *)deque + sizeof(struct __CFArrayDeque) + deque->_leftIdx * sizeof(struct __CFArrayBucket));
}
}
return NULL;
}
void CFArrayRemoveAllValues(CFMutableArrayRef array) {
CF_OBJC_FUNCDISPATCHV(__kCFArrayTypeID, void, (NSMutableArray *)array, removeAllObjects);
__CFGenericValidateType(array, __kCFArrayTypeID);
CFAssert1(__CFArrayGetType(array) != __kCFArrayImmutable, __kCFLogAssertion, "%s(): array is immutable", __PRETTY_FUNCTION__);
CHECK_FOR_MUTATION(array);
BEGIN_MUTATION(array);
__CFArrayReleaseValues(array, CFRangeMake(0, __CFArrayGetCount(array)), true);
__CFArraySetCount(array, 0);
array->_mutations++;
END_MUTATION(array);
}
// This function is for Foundation's benefit; no one else should use it.
void _CFArraySetCapacity(CFMutableArrayRef array, CFIndex cap) {
if (CF_IS_OBJC(__kCFArrayTypeID, array)) return;
__CFGenericValidateType(array, __kCFArrayTypeID);
CFAssert1(__CFArrayGetType(array) != __kCFArrayImmutable, __kCFLogAssertion, "%s(): array is immutable", __PRETTY_FUNCTION__);
CFAssert3(__CFArrayGetCount(array) <= cap, __kCFLogAssertion, "%s(): desired capacity (%d) is less than count (%d)", __PRETTY_FUNCTION__, cap, __CFArrayGetCount(array));
CHECK_FOR_MUTATION(array);
BEGIN_MUTATION(array);
// Currently, attempting to set the capacity of an array which is the CFStorage
// variant, or set the capacity larger than __CF_MAX_BUCKETS_PER_DEQUE, has no
// effect. The primary purpose of this API is to help avoid a bunch of the
// resizes at the small capacities 4, 8, 16, etc.
if (__CFArrayGetType(array) == __kCFArrayDeque) {
struct __CFArrayDeque *deque = (struct __CFArrayDeque *)array->_store;
CFIndex capacity = __CFArrayDequeRoundUpCapacity(cap);
CFIndex size = sizeof(struct __CFArrayDeque) + capacity * sizeof(struct __CFArrayBucket);
CFAllocatorRef allocator = __CFGetAllocator(array);
allocator = _CFConvertAllocatorToGCRefZeroEquivalent(allocator);
Boolean collectableMemory = CF_IS_COLLECTABLE_ALLOCATOR(allocator);
if (NULL == deque) {
deque = (struct __CFArrayDeque *)CFAllocatorAllocate(allocator, size, isStrongMemory(array) ? __kCFAllocatorGCScannedMemory : 0);
if (NULL == deque) __CFArrayHandleOutOfMemory(array, size);
if (__CFOASafe) __CFSetLastAllocationEventName(deque, "CFArray (store-deque)");
deque->_leftIdx = capacity / 2;
} else {
struct __CFArrayDeque *olddeque = deque;
CFIndex oldcap = deque->_capacity;
deque = (struct __CFArrayDeque *)CFAllocatorAllocate(allocator, size, isStrongMemory(array) ? __kCFAllocatorGCScannedMemory : 0);
if (NULL == deque) __CFArrayHandleOutOfMemory(array, size);
objc_memmove_collectable(deque, olddeque, sizeof(struct __CFArrayDeque) + oldcap * sizeof(struct __CFArrayBucket));
if (!collectableMemory) CFAllocatorDeallocate(allocator, olddeque);
if (__CFOASafe) __CFSetLastAllocationEventName(deque, "CFArray (store-deque)");
}
deque->_capacity = capacity;
__CFAssignWithWriteBarrier((void **)&array->_store, (void *)deque);
}
END_MUTATION(array);
}
void CFArrayGetValues(CFArrayRef array, CFRange range, const void **values) {
CF_OBJC_FUNCDISPATCHV(__kCFArrayTypeID, void, (NSArray *)array, getObjects:(id *)values range:NSMakeRange(range.location, range.length));
__CFGenericValidateType(array, __kCFArrayTypeID);
__CFArrayValidateRange(array, range, __PRETTY_FUNCTION__);
CFAssert1(NULL != values, __kCFLogAssertion, "%s(): pointer to values may not be NULL", __PRETTY_FUNCTION__);
CHECK_FOR_MUTATION(array);
if (0 < range.length) {
switch (__CFArrayGetType(array)) {
case __kCFArrayImmutable:
case __kCFArrayDeque:
objc_memmove_collectable(values, __CFArrayGetBucketsPtr(array) + range.location, range.length * sizeof(struct __CFArrayBucket));
break;
}
}
}
static void __CFArrayReleaseValues(CFArrayRef array, CFRange range, bool releaseStorageIfPossible) {
const CFArrayCallBacks *cb = __CFArrayGetCallBacks(array);
CFAllocatorRef allocator;
CFIndex idx;
switch (__CFArrayGetType(array)) {
case __kCFArrayImmutable:
if (NULL != cb->release && 0 < range.length && !hasBeenFinalized(array)) {
// if we've been finalized then we know that
// 1) we're using the standard callback on GC memory
// 2) the slots don't' need to be zeroed
struct __CFArrayBucket *buckets = __CFArrayGetBucketsPtr(array);
allocator = __CFGetAllocator(array);
for (idx = 0; idx < range.length; idx++) {
INVOKE_CALLBACK2(cb->release, allocator, buckets[idx + range.location]._item);
buckets[idx + range.location]._item = NULL; // GC: break strong reference.
}
}
break;
case __kCFArrayDeque: {
struct __CFArrayDeque *deque = (struct __CFArrayDeque *)array->_store;
if (0 < range.length && NULL != deque && !hasBeenFinalized(array)) {
struct __CFArrayBucket *buckets = __CFArrayGetBucketsPtr(array);
if (NULL != cb->release) {
allocator = __CFGetAllocator(array);
for (idx = 0; idx < range.length; idx++) {
INVOKE_CALLBACK2(cb->release, allocator, buckets[idx + range.location]._item);
buckets[idx + range.location]._item = NULL; // GC: break strong reference.
}
} else {
for (idx = 0; idx < range.length; idx++) {
buckets[idx + range.location]._item = NULL; // GC: break strong reference.
}
}
}
if (releaseStorageIfPossible && 0 == range.location && __CFArrayGetCount(array) == range.length) {
allocator = __CFGetAllocator(array);
if (NULL != deque) if (!CF_IS_COLLECTABLE_ALLOCATOR(allocator)) CFAllocatorDeallocate(allocator, deque);
__CFArraySetCount(array, 0); // GC: _count == 0 ==> _store == NULL.
((struct __CFArray *)array)->_store = NULL;
}
break;
}
}
}
// NB: AddressBook on the Phone is a fragile flower, so this function cannot do anything
// that causes the values to be retained or released.
void CFArrayExchangeValuesAtIndices(CFMutableArrayRef array, CFIndex idx1, CFIndex idx2) {
const void *tmp;
struct __CFArrayBucket *bucket1, *bucket2;
CF_OBJC_FUNCDISPATCHV(__kCFArrayTypeID, void, (NSMutableArray *)array, exchangeObjectAtIndex:(NSUInteger)idx1 withObjectAtIndex:(NSUInteger)idx2);
__CFGenericValidateType(array, __kCFArrayTypeID);
CFAssert2(0 <= idx1 && idx1 < __CFArrayGetCount(array), __kCFLogAssertion, "%s(): index #1 (%d) out of bounds", __PRETTY_FUNCTION__, idx1);
CFAssert2(0 <= idx2 && idx2 < __CFArrayGetCount(array), __kCFLogAssertion, "%s(): index #2 (%d) out of bounds", __PRETTY_FUNCTION__, idx2);
CFAssert1(__CFArrayGetType(array) != __kCFArrayImmutable, __kCFLogAssertion, "%s(): array is immutable", __PRETTY_FUNCTION__);
CHECK_FOR_MUTATION(array);
BEGIN_MUTATION(array);
bucket1 = __CFArrayGetBucketAtIndex(array, idx1);
bucket2 = __CFArrayGetBucketAtIndex(array, idx2);
tmp = bucket1->_item;
// XXX these aren't needed.
__CFAssignWithWriteBarrier((void **)&bucket1->_item, (void *)bucket2->_item);
__CFAssignWithWriteBarrier((void **)&bucket2->_item, (void *)tmp);
array->_mutations++;
END_MUTATION(array);
}
CF_PRIVATE CFArrayCallBacks *__CFArrayGetCallBacks(CFArrayRef array) {
CFArrayCallBacks *result = NULL;
switch (__CFBitfieldGetValue(((const CFRuntimeBase *)array)->_cfinfo[CF_INFO_BITS], 3, 2)) {
case __kCFArrayHasNullCallBacks:
return (CFArrayCallBacks *)&__kCFNullArrayCallBacks;
case __kCFArrayHasCFTypeCallBacks:
return (CFArrayCallBacks *)&kCFTypeArrayCallBacks;
case __kCFArrayHasCustomCallBacks:
break;
}
switch (__CFArrayGetType(array)) {
case __kCFArrayImmutable:
result = (CFArrayCallBacks *)((uint8_t *)array + sizeof(struct __CFArray));
break;
case __kCFArrayDeque:
result = (CFArrayCallBacks *)((uint8_t *)array + sizeof(struct __CFArray));
break;
}
return result;
}
static void __CFArrayReleaseValues(CFArrayRef array, CFRange range, bool releaseStorageIfPossible) {
const CFArrayCallBacks *cb = __CFArrayGetCallBacks(array);
CFAllocatorRef allocator;
CFIndex idx;
switch (__CFArrayGetType(array)) {
case __kCFArrayImmutable:
if (NULL != cb->release && 0 < range.length) {
struct __CFArrayBucket *buckets = __CFArrayGetBucketsPtr(array);
allocator = __CFGetAllocator(array);
for (idx = 0; idx < range.length; idx++) {
INVOKE_CALLBACK2(cb->release, allocator, buckets[idx + range.location]._item);
}
memset(buckets + range.location, 0, sizeof(struct __CFArrayBucket) * range.length);
}
break;
case __kCFArrayDeque: {
struct __CFArrayDeque *deque = (struct __CFArrayDeque *)array->_store;
if (0 < range.length && NULL != deque) {
struct __CFArrayBucket *buckets = __CFArrayGetBucketsPtr(array);
if (NULL != cb->release) {
allocator = __CFGetAllocator(array);
for (idx = 0; idx < range.length; idx++) {
INVOKE_CALLBACK2(cb->release, allocator, buckets[idx + range.location]._item);
}
}
memset(buckets + range.location, 0, sizeof(struct __CFArrayBucket) * range.length);
}
if (releaseStorageIfPossible && 0 == range.location && __CFArrayGetCount(array) == range.length) {
allocator = __CFGetAllocator(array);
if (NULL != deque) CFAllocatorDeallocate(allocator, deque);
__CFArraySetCount(array, 0);
((struct __CFArray *)array)->_store = NULL;
}
break;
}
}
}
void CFArraySortValues(CFMutableArrayRef array, CFRange range, CFComparatorFunction comparator, void *context) {
FAULT_CALLBACK((void **)&(comparator));
__CFArrayValidateRange(array, range, __PRETTY_FUNCTION__);
CFAssert1(NULL != comparator, __kCFLogAssertion, "%s(): pointer to comparator function may not be NULL", __PRETTY_FUNCTION__);
Boolean immutable = false;
if (CF_IS_OBJC(__kCFArrayTypeID, array)) {
BOOL result;
CF_OBJC_CALL1(BOOL, result, array, "isKindOfClass:", objc_lookUpClass("NSMutableArray"));
immutable = !result;
} else if (__kCFArrayImmutable == __CFArrayGetType(array)) {
immutable = true;
}
const CFArrayCallBacks *cb = NULL;
if (CF_IS_OBJC(__kCFArrayTypeID, array)) {
cb = &kCFTypeArrayCallBacks;
} else {
cb = __CFArrayGetCallBacks(array);
}
if (!immutable && ((cb->retain && !cb->release) || (!cb->retain && cb->release))) {
__CFZSort(array, range, comparator, context);
return;
}
if (range.length < 2) {
return;
}
// implemented abstractly, careful!
const void **values, *buffer[256];
values = (range.length <= 256) ? (const void **)buffer : (const void **)CFAllocatorAllocate(kCFAllocatorSystemDefault, range.length * sizeof(void *), 0); // GC OK
CFArrayGetValues(array, range, values);
struct _acompareContext ctx;
ctx.func = comparator;
ctx.context = context;
CFQSortArray(values, range.length, sizeof(void *), (CFComparatorFunction)__CFArrayCompareValues, &ctx);
if (!immutable) CFArrayReplaceValues(array, range, values, range.length);
if (values != buffer) CFAllocatorDeallocate(kCFAllocatorSystemDefault, values);
}