CFBag.c

/*
 * Copyright (c) 2008-2012 Brent Fulgham <bfulgham@gmail.org>. All rights reserved.
 *
 * This source code is a modified version of the CoreFoundation sources released by Apple Inc. under
 * the terms of the APSL version 2.0 (see below).
 *
 * For information about changes from the original Apple source release can be found by reviewing the
 * source control system for the project at https://sourceforge.net/svn/?group_id=246198.
 *
 * The original license information is as follows:
 *
 * Copyright (c) 2012 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */

/* CFBag.c
 Copyright (c) 1998-2011, Apple Inc. All rights reserved.
 Responsibility: Christopher Kane
 Machine generated from Notes/HashingCode.template
*/





#include<CoreFoundation/CFBag.h>
#include<CoreFoundation/CoreFoundation_Prefix.h>
#include"CFInternal.h"
#include"CFBasicHash.h"
#include<CoreFoundation/CFString.h>

#defineCFDictionary 0
#defineCFSet 0
#defineCFBag 0
#undef CFBag
#defineCFBag 1

#ifCFDictionary
constCFBagKeyCallBackskCFTypeBagKeyCallBacks= {0, __CFTypeCollectionRetain, __CFTypeCollectionRelease, CFCopyDescription, CFEqual, CFHash};
constCFBagKeyCallBackskCFCopyStringBagKeyCallBacks= {0, __CFStringCollectionCopy, __CFTypeCollectionRelease, CFCopyDescription, CFEqual, CFHash};
constCFBagValueCallBackskCFTypeBagValueCallBacks= {0, __CFTypeCollectionRetain, __CFTypeCollectionRelease, CFCopyDescription, CFEqual};
__private_extern__constCFBagValueCallBackskCFTypeBagValueCompactableCallBacks= {0, __CFTypeCollectionRetain, __CFTypeCollectionRelease, CFCopyDescription, CFEqual};
staticconstCFBagKeyCallBacks__kCFNullBagKeyCallBacks= {0, NULL, NULL, NULL, NULL, NULL};
staticconstCFBagValueCallBacks__kCFNullBagValueCallBacks= {0, NULL, NULL, NULL, NULL};

#defineCFHashRef CFDictionaryRef
#defineCFMutableHashRef CFMutableDictionaryRef
#defineCFHashKeyCallBacks CFBagKeyCallBacks
#defineCFHashValueCallBacks CFBagValueCallBacks
#endif

#ifCFSet
constCFBagCallBackskCFTypeBagCallBacks= {0, __CFTypeCollectionRetain, __CFTypeCollectionRelease, CFCopyDescription, CFEqual, CFHash};
constCFBagCallBackskCFCopyStringBagCallBacks= {0, __CFStringCollectionCopy, __CFTypeCollectionRelease, CFCopyDescription, CFEqual, CFHash};
staticconstCFBagCallBacks__kCFNullBagCallBacks= {0, NULL, NULL, NULL, NULL, NULL};

#defineCFBagKeyCallBacks CFBagCallBacks
#defineCFBagValueCallBacks CFBagCallBacks
#definekCFTypeBagKeyCallBacks kCFTypeBagCallBacks
#definekCFTypeBagValueCallBacks kCFTypeBagCallBacks
#define__kCFNullBagKeyCallBacks __kCFNullBagCallBacks
#define__kCFNullBagValueCallBacks __kCFNullBagCallBacks

#defineCFHashRef CFSetRef
#defineCFMutableHashRef CFMutableSetRef
#defineCFHashKeyCallBacks CFBagCallBacks
#defineCFHashValueCallBacks CFBagCallBacks
#endif

#ifCFBag
constCFBagCallBackskCFTypeBagCallBacks= {0, __CFTypeCollectionRetain, __CFTypeCollectionRelease, CFCopyDescription, CFEqual, CFHash};
constCFBagCallBackskCFCopyStringBagCallBacks= {0, __CFStringCollectionCopy, __CFTypeCollectionRelease, CFCopyDescription, CFEqual, CFHash};
staticconstCFBagCallBacks__kCFNullBagCallBacks= {0, NULL, NULL, NULL, NULL, NULL};

#defineCFBagKeyCallBacks CFBagCallBacks
#defineCFBagValueCallBacks CFBagCallBacks
#definekCFTypeBagKeyCallBacks kCFTypeBagCallBacks
#definekCFTypeBagValueCallBacks kCFTypeBagCallBacks
#define__kCFNullBagKeyCallBacks __kCFNullBagCallBacks
#define__kCFNullBagValueCallBacks __kCFNullBagCallBacks

#defineCFHashRef CFBagRef
#defineCFMutableHashRef CFMutableBagRef
#defineCFHashKeyCallBacks CFBagCallBacks
#defineCFHashValueCallBacks CFBagCallBacks
#endif


typedefuintptr_tany_t;
typedefconstvoid*const_any_pointer_t;
typedefvoid*any_pointer_t;

staticBoolean__CFBagEqual(CFTypeRefcf1, CFTypeRefcf2) {
return__CFBasicHashEqual((CFBasicHashRef)cf1, (CFBasicHashRef)cf2);
}

staticCFHashCode__CFBagHash(CFTypeRefcf) {
return__CFBasicHashHash((CFBasicHashRef)cf);
}

staticCFStringRef__CFBagCopyDescription(CFTypeRefcf) {
return__CFBasicHashCopyDescription((CFBasicHashRef)cf);
}

staticvoid__CFBagDeallocate(CFTypeRefcf) {
__CFBasicHashDeallocate((CFBasicHashRef)cf);
}

staticCFTypeID__kCFBagTypeID=_kCFRuntimeNotATypeID;

staticconstCFRuntimeClass__CFBagClass= {
_kCFRuntimeScannedObject,
"CFBag",
NULL, // init
NULL, // copy
__CFBagDeallocate,
__CFBagEqual,
__CFBagHash,
NULL, //
__CFBagCopyDescription
};

CFTypeIDCFBagGetTypeID(void) {
if (_kCFRuntimeNotATypeID==__kCFBagTypeID) __kCFBagTypeID=_CFRuntimeRegisterClass(&__CFBagClass);
return__kCFBagTypeID;
}

#defineGCRETAIN(A, B) kCFTypeSetCallBacks.retain(A, B)
#defineGCRELEASE(A, B) kCFTypeSetCallBacks.release(A, B)

staticuintptr_t__CFBagStandardRetainValue(CFConstBasicHashRefht, uintptr_tstack_value) {
if (CFBasicHashGetSpecialBits(ht) &0x0100) returnstack_value;
return (CFBasicHashHasStrongValues(ht)) ? (uintptr_t)GCRETAIN(kCFAllocatorSystemDefault, (CFTypeRef)stack_value) : (uintptr_t)CFRetain((CFTypeRef)stack_value);
}

staticuintptr_t__CFBagStandardRetainKey(CFConstBasicHashRefht, uintptr_tstack_key) {
if (CFBasicHashGetSpecialBits(ht) &0x0001) returnstack_key;
return (CFBasicHashHasStrongKeys(ht)) ? (uintptr_t)GCRETAIN(kCFAllocatorSystemDefault, (CFTypeRef)stack_key) : (uintptr_t)CFRetain((CFTypeRef)stack_key);
}

staticvoid__CFBagStandardReleaseValue(CFConstBasicHashRefht, uintptr_tstack_value) {
if (CFBasicHashGetSpecialBits(ht) &0x0200) return;
if (CFBasicHashHasStrongValues(ht)) GCRELEASE(kCFAllocatorSystemDefault, (CFTypeRef)stack_value); elseCFRelease((CFTypeRef)stack_value);
}

staticvoid__CFBagStandardReleaseKey(CFConstBasicHashRefht, uintptr_tstack_key) {
if (CFBasicHashGetSpecialBits(ht) &0x0002) return;
if (CFBasicHashHasStrongKeys(ht)) GCRELEASE(kCFAllocatorSystemDefault, (CFTypeRef)stack_key); elseCFRelease((CFTypeRef)stack_key);
}

staticBoolean__CFBagStandardEquateValues(CFConstBasicHashRefht, uintptr_tcoll_value1, uintptr_tstack_value2) {
if (CFBasicHashGetSpecialBits(ht) &0x0400) returncoll_value1==stack_value2;
returnCFEqual((CFTypeRef)coll_value1, (CFTypeRef)stack_value2);
}

staticBoolean__CFBagStandardEquateKeys(CFConstBasicHashRefht, uintptr_tcoll_key1, uintptr_tstack_key2) {
if (CFBasicHashGetSpecialBits(ht) &0x0004) returncoll_key1==stack_key2;
returnCFEqual((CFTypeRef)coll_key1, (CFTypeRef)stack_key2);
}

staticuintptr_t__CFBagStandardHashKey(CFConstBasicHashRefht, uintptr_tstack_key) {
if (CFBasicHashGetSpecialBits(ht) &0x0008) returnstack_key;
return (uintptr_t)CFHash((CFTypeRef)stack_key);
}

staticuintptr_t__CFBagStandardGetIndirectKey(CFConstBasicHashRefht, uintptr_tcoll_value) {
return0;
}

staticCFStringRef__CFBagStandardCopyValueDescription(CFConstBasicHashRefht, uintptr_tstack_value) {
if (CFBasicHashGetSpecialBits(ht) &0x0800) returnCFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("<%p>"), (void*)stack_value);
returnCFCopyDescription((CFTypeRef)stack_value);
}

staticCFStringRef__CFBagStandardCopyKeyDescription(CFConstBasicHashRefht, uintptr_tstack_key) {
if (CFBasicHashGetSpecialBits(ht) &0x0010) returnCFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("<%p>"), (void*)stack_key);
returnCFCopyDescription((CFTypeRef)stack_key);
}

staticCFBasicHashCallbacks*__CFBagStandardCopyCallbacks(CFConstBasicHashRefht, CFAllocatorRefallocator, CFBasicHashCallbacks*cb);
staticvoid__CFBagStandardFreeCallbacks(CFConstBasicHashRefht, CFAllocatorRefallocator, CFBasicHashCallbacks*cb);

staticconstCFBasicHashCallbacksCFBagStandardCallbacks= {
__CFBagStandardCopyCallbacks,
__CFBagStandardFreeCallbacks,
__CFBagStandardRetainValue,
__CFBagStandardRetainKey,
__CFBagStandardReleaseValue,
__CFBagStandardReleaseKey,
__CFBagStandardEquateValues,
__CFBagStandardEquateKeys,
__CFBagStandardHashKey,
__CFBagStandardGetIndirectKey,
__CFBagStandardCopyValueDescription,
__CFBagStandardCopyKeyDescription
};

staticCFBasicHashCallbacks*__CFBagStandardCopyCallbacks(CFConstBasicHashRefht, CFAllocatorRefallocator, CFBasicHashCallbacks*cb) {
return (CFBasicHashCallbacks*)&CFBagStandardCallbacks;
}

staticvoid__CFBagStandardFreeCallbacks(CFConstBasicHashRefht, CFAllocatorRefallocator, CFBasicHashCallbacks*cb) {
}


staticCFBasicHashCallbacks*__CFBagCopyCallbacks(CFConstBasicHashRefht, CFAllocatorRefallocator, CFBasicHashCallbacks*cb) {
CFBasicHashCallbacks*newcb=NULL;
if (CF_IS_COLLECTABLE_ALLOCATOR(allocator)) {
newcb= (CFBasicHashCallbacks*)auto_zone_allocate_object(objc_collectableZone(), sizeof(CFBasicHashCallbacks) +10*sizeof(void*), AUTO_MEMORY_UNSCANNED, false, false);
 } else {
newcb= (CFBasicHashCallbacks*)CFAllocatorAllocate(allocator, sizeof(CFBasicHashCallbacks) +10*sizeof(void*), 0);
 }
if (!newcb) HALT;
memmove(newcb, (void*)cb, sizeof(CFBasicHashCallbacks) +10*sizeof(void*));
returnnewcb;
}

staticvoid__CFBagFreeCallbacks(CFConstBasicHashRefht, CFAllocatorRefallocator, CFBasicHashCallbacks*cb) {
if (CF_IS_COLLECTABLE_ALLOCATOR(allocator)) {
 } else {
CFAllocatorDeallocate(allocator, cb);
 }
}

staticuintptr_t__CFBagRetainValue(CFConstBasicHashRefht, uintptr_tstack_value) {
constCFBasicHashCallbacks*cb=CFBasicHashGetCallbacks(ht);
const_any_pointer_t (*value_retain)(CFAllocatorRef, const_any_pointer_t) = (const_any_pointer_t (*)(CFAllocatorRef, const_any_pointer_t))cb->context[0];
if (NULL==value_retain) returnstack_value;
return (uintptr_t)INVOKE_CALLBACK2(value_retain, CFGetAllocator(ht), (const_any_pointer_t)stack_value);
}

staticuintptr_t__CFBagRetainKey(CFConstBasicHashRefht, uintptr_tstack_key) {
constCFBasicHashCallbacks*cb=CFBasicHashGetCallbacks(ht);
const_any_pointer_t (*key_retain)(CFAllocatorRef, const_any_pointer_t) = (const_any_pointer_t (*)(CFAllocatorRef, const_any_pointer_t))cb->context[1];
if (NULL==key_retain) returnstack_key;
return (uintptr_t)INVOKE_CALLBACK2(key_retain, CFGetAllocator(ht), (const_any_pointer_t)stack_key);
}

staticvoid__CFBagReleaseValue(CFConstBasicHashRefht, uintptr_tstack_value) {
constCFBasicHashCallbacks*cb=CFBasicHashGetCallbacks(ht);
void (*value_release)(CFAllocatorRef, const_any_pointer_t) = (void (*)(CFAllocatorRef, const_any_pointer_t))cb->context[2];
if (NULL!=value_release) INVOKE_CALLBACK2(value_release, CFGetAllocator(ht), (const_any_pointer_t) stack_value);
}

staticvoid__CFBagReleaseKey(CFConstBasicHashRefht, uintptr_tstack_key) {
constCFBasicHashCallbacks*cb=CFBasicHashGetCallbacks(ht);
void (*key_release)(CFAllocatorRef, const_any_pointer_t) = (void (*)(CFAllocatorRef, const_any_pointer_t))cb->context[3];
if (NULL!=key_release) INVOKE_CALLBACK2(key_release, CFGetAllocator(ht), (const_any_pointer_t) stack_key);
}

staticBoolean__CFBagEquateValues(CFConstBasicHashRefht, uintptr_tcoll_value1, uintptr_tstack_value2) {
constCFBasicHashCallbacks*cb=CFBasicHashGetCallbacks(ht);
Boolean (*value_equal)(const_any_pointer_t, const_any_pointer_t) = (Boolean (*)(const_any_pointer_t, const_any_pointer_t))cb->context[4];
if (NULL==value_equal) return (coll_value1==stack_value2);
returnINVOKE_CALLBACK2(value_equal, (const_any_pointer_t) coll_value1, (const_any_pointer_t) stack_value2) ? 1 : 0;
}

staticBoolean__CFBagEquateKeys(CFConstBasicHashRefht, uintptr_tcoll_key1, uintptr_tstack_key2) {
constCFBasicHashCallbacks*cb=CFBasicHashGetCallbacks(ht);
Boolean (*key_equal)(const_any_pointer_t, const_any_pointer_t) = (Boolean (*)(const_any_pointer_t, const_any_pointer_t))cb->context[5];
if (NULL==key_equal) return (coll_key1==stack_key2);
returnINVOKE_CALLBACK2(key_equal, (const_any_pointer_t) coll_key1, (const_any_pointer_t) stack_key2) ? 1 : 0;
}

staticuintptr_t__CFBagHashKey(CFConstBasicHashRefht, uintptr_tstack_key) {
constCFBasicHashCallbacks*cb=CFBasicHashGetCallbacks(ht);
CFHashCode (*hash)(const_any_pointer_t) = (CFHashCode (*)(const_any_pointer_t))cb->context[6];
if (NULL==hash) returnstack_key;
return (uintptr_t)INVOKE_CALLBACK1(hash, (const_any_pointer_t) stack_key);
}

staticuintptr_t__CFBagGetIndirectKey(CFConstBasicHashRefht, uintptr_tcoll_value) {
return0;
}

staticCFStringRef__CFBagCopyValueDescription(CFConstBasicHashRefht, uintptr_tstack_value) {
constCFBasicHashCallbacks*cb=CFBasicHashGetCallbacks(ht);
CFStringRef (*value_describe)(const_any_pointer_t) = (CFStringRef (*)(const_any_pointer_t))cb->context[8];
if (NULL==value_describe) returnCFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("<%p>"), (const_any_pointer_t) stack_value);
return (CFStringRef)INVOKE_CALLBACK1(value_describe, (const_any_pointer_t) stack_value);
}

staticCFStringRef__CFBagCopyKeyDescription(CFConstBasicHashRefht, uintptr_tstack_key) {
constCFBasicHashCallbacks*cb=CFBasicHashGetCallbacks(ht);
CFStringRef (*key_describe)(const_any_pointer_t) = (CFStringRef (*)(const_any_pointer_t))cb->context[9];
if (NULL==key_describe) returnCFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("<%p>"), (const_any_pointer_t) stack_key);
return (CFStringRef)INVOKE_CALLBACK1(key_describe, (const_any_pointer_t) stack_key);
}

staticCFBasicHashRef__CFBagCreateGeneric(CFAllocatorRefallocator, constCFHashKeyCallBacks*keyCallBacks, constCFHashValueCallBacks*valueCallBacks, BooleanuseValueCB) {
CFOptionFlagsflags=kCFBasicHashLinearHashing; // kCFBasicHashExponentialHashing
flags |= (CFDictionary ? kCFBasicHashHasKeys : 0) | (CFBag ? kCFBasicHashHasCounts : 0);

CFBasicHashCallbacks*cb=NULL;
Booleanstd_cb= false;
uint16_tspecialBits=0;
const_any_pointer_t (*key_retain)(CFAllocatorRef, const_any_pointer_t) =NULL;
void (*key_release)(CFAllocatorRef, const_any_pointer_t) =NULL;
const_any_pointer_t (*value_retain)(CFAllocatorRef, const_any_pointer_t) =NULL;
void (*value_release)(CFAllocatorRef, const_any_pointer_t) =NULL;

if ((NULL==keyCallBacks||0==keyCallBacks->version) && (!useValueCB||NULL==valueCallBacks||0==valueCallBacks->version)) {
BooleankeyRetainNull=NULL==keyCallBacks||NULL==keyCallBacks->retain;
BooleankeyReleaseNull=NULL==keyCallBacks||NULL==keyCallBacks->release;
BooleankeyEquateNull=NULL==keyCallBacks||NULL==keyCallBacks->equal;
BooleankeyHashNull=NULL==keyCallBacks||NULL==keyCallBacks->hash;
BooleankeyDescribeNull=NULL==keyCallBacks||NULL==keyCallBacks->copyDescription;

BooleanvalueRetainNull= (useValueCB&& (NULL==valueCallBacks||NULL==valueCallBacks->retain)) || (!useValueCB&&keyRetainNull);
BooleanvalueReleaseNull= (useValueCB&& (NULL==valueCallBacks||NULL==valueCallBacks->release)) || (!useValueCB&&keyReleaseNull);
BooleanvalueEquateNull= (useValueCB&& (NULL==valueCallBacks||NULL==valueCallBacks->equal)) || (!useValueCB&&keyEquateNull);
BooleanvalueDescribeNull= (useValueCB&& (NULL==valueCallBacks||NULL==valueCallBacks->copyDescription)) || (!useValueCB&&keyDescribeNull);

BooleankeyRetainStd=keyRetainNull||__CFTypeCollectionRetain==keyCallBacks->retain;
BooleankeyReleaseStd=keyReleaseNull||__CFTypeCollectionRelease==keyCallBacks->release;
BooleankeyEquateStd=keyEquateNull||CFEqual==keyCallBacks->equal;
BooleankeyHashStd=keyHashNull||CFHash==keyCallBacks->hash;
BooleankeyDescribeStd=keyDescribeNull||CFCopyDescription==keyCallBacks->copyDescription;

BooleanvalueRetainStd= (useValueCB&& (valueRetainNull||__CFTypeCollectionRetain==valueCallBacks->retain)) || (!useValueCB&&keyRetainStd);
BooleanvalueReleaseStd= (useValueCB&& (valueReleaseNull||__CFTypeCollectionRelease==valueCallBacks->release)) || (!useValueCB&&keyReleaseStd);
BooleanvalueEquateStd= (useValueCB&& (valueEquateNull||CFEqual==valueCallBacks->equal)) || (!useValueCB&&keyEquateStd);
BooleanvalueDescribeStd= (useValueCB&& (valueDescribeNull||CFCopyDescription==valueCallBacks->copyDescription)) || (!useValueCB&&keyDescribeStd);

if (keyRetainStd&&keyReleaseStd&&keyEquateStd&&keyHashStd&&keyDescribeStd&&valueRetainStd&&valueReleaseStd&&valueEquateStd&&valueDescribeStd) {
cb= (CFBasicHashCallbacks*)&CFBagStandardCallbacks;
if (!(keyRetainNull||keyReleaseNull||keyEquateNull||keyHashNull||keyDescribeNull||valueRetainNull||valueReleaseNull||valueEquateNull||valueDescribeNull)) {
std_cb= true;
 } else {
// just set these to tickle the GC Strong logic below in a way that mimics past practice
key_retain=keyCallBacks ? keyCallBacks->retain : NULL;
key_release=keyCallBacks ? keyCallBacks->release : NULL;
if (useValueCB) {
value_retain=valueCallBacks ? valueCallBacks->retain : NULL;
value_release=valueCallBacks ? valueCallBacks->release : NULL;
 } else {
value_retain=key_retain;
value_release=key_release;
 }
 }
if (keyRetainNull) specialBits |= 0x0001;
if (keyReleaseNull) specialBits |= 0x0002;
if (keyEquateNull) specialBits |= 0x0004;
if (keyHashNull) specialBits |= 0x0008;
if (keyDescribeNull) specialBits |= 0x0010;
if (valueRetainNull) specialBits |= 0x0100;
if (valueReleaseNull) specialBits |= 0x0200;
if (valueEquateNull) specialBits |= 0x0400;
if (valueDescribeNull) specialBits |= 0x0800;
 }
 }

if (!cb) {
Boolean (*key_equal)(const_any_pointer_t, const_any_pointer_t) =NULL;
Boolean (*value_equal)(const_any_pointer_t, const_any_pointer_t) =NULL;
CFStringRef (*key_describe)(const_any_pointer_t) =NULL;
CFStringRef (*value_describe)(const_any_pointer_t) =NULL;
CFHashCode (*hash_key)(const_any_pointer_t) =NULL;
key_retain=keyCallBacks ? keyCallBacks->retain : NULL;
key_release=keyCallBacks ? keyCallBacks->release : NULL;
key_equal=keyCallBacks ? keyCallBacks->equal : NULL;
key_describe=keyCallBacks ? keyCallBacks->copyDescription : NULL;
if (useValueCB) {
value_retain=valueCallBacks ? valueCallBacks->retain : NULL;
value_release=valueCallBacks ? valueCallBacks->release : NULL;
value_equal=valueCallBacks ? valueCallBacks->equal : NULL;
value_describe=valueCallBacks ? valueCallBacks->copyDescription : NULL;
 } else {
value_retain=key_retain;
value_release=key_release;
value_equal=key_equal;
value_describe=key_describe;
 }
hash_key=keyCallBacks ? keyCallBacks->hash : NULL;

CFBasicHashCallbacks*newcb=NULL;
if (CF_IS_COLLECTABLE_ALLOCATOR(allocator)) {
newcb= (CFBasicHashCallbacks*)auto_zone_allocate_object(objc_collectableZone(), sizeof(CFBasicHashCallbacks) +10*sizeof(void*), AUTO_MEMORY_UNSCANNED, false, false);
 } else {
newcb= (CFBasicHashCallbacks*)CFAllocatorAllocate(allocator, sizeof(CFBasicHashCallbacks) +10*sizeof(void*), 0);
 }
if (!newcb) HALT;
newcb->copyCallbacks=__CFBagCopyCallbacks;
newcb->freeCallbacks=__CFBagFreeCallbacks;
newcb->retainValue=__CFBagRetainValue;
newcb->retainKey=__CFBagRetainKey;
newcb->releaseValue=__CFBagReleaseValue;
newcb->releaseKey=__CFBagReleaseKey;
newcb->equateValues=__CFBagEquateValues;
newcb->equateKeys=__CFBagEquateKeys;
newcb->hashKey=__CFBagHashKey;
newcb->getIndirectKey=__CFBagGetIndirectKey;
newcb->copyValueDescription=__CFBagCopyValueDescription;
newcb->copyKeyDescription=__CFBagCopyKeyDescription;
newcb->context[0] = (uintptr_t)value_retain;
newcb->context[1] = (uintptr_t)key_retain;
newcb->context[2] = (uintptr_t)value_release;
newcb->context[3] = (uintptr_t)key_release;
newcb->context[4] = (uintptr_t)value_equal;
newcb->context[5] = (uintptr_t)key_equal;
newcb->context[6] = (uintptr_t)hash_key;
newcb->context[8] = (uintptr_t)value_describe;
newcb->context[9] = (uintptr_t)key_describe;
cb=newcb;
 }

if (CF_IS_COLLECTABLE_ALLOCATOR(allocator)) {
if (std_cb||value_retain!=NULL||value_release!=NULL) {
flags |= kCFBasicHashStrongValues;
 }
if (std_cb||key_retain!=NULL||key_release!=NULL) {
flags |= kCFBasicHashStrongKeys;
 }
#ifCFDictionary
if (valueCallBacks==&kCFTypeDictionaryValueCompactableCallBacks) {
// Foundation allocated collections will have compactable values
flags |= kCFBasicHashCompactableValues;
 }
#endif
 }

CFBasicHashRefht=CFBasicHashCreate(allocator, flags, cb);
CFBasicHashSetSpecialBits(ht, specialBits);
returnht;
}

#ifCFDictionary
__private_extern__CFHashRef__CFBagCreateTransfer(CFAllocatorRefallocator, const_any_pointer_t*klist, const_any_pointer_t*vlist, CFIndexnumValues) {
#endif
#ifCFSet||CFBag
__private_extern__CFHashRef__CFBagCreateTransfer(CFAllocatorRefallocator, const_any_pointer_t*klist, CFIndexnumValues) {
const_any_pointer_t*vlist=klist;
#endif
CFTypeIDtypeID=CFBagGetTypeID();
CFAssert2(0 <= numValues, __kCFLogAssertion, "%s(): numValues (%ld) cannot be less than zero", __PRETTY_FUNCTION__, numValues);
CFOptionFlagsflags=kCFBasicHashLinearHashing; // kCFBasicHashExponentialHashing
flags |= (CFDictionary ? kCFBasicHashHasKeys : 0) | (CFBag ? kCFBasicHashHasCounts : 0);
CFBasicHashCallbacks*cb= (CFBasicHashCallbacks*)&CFBagStandardCallbacks;
CFBasicHashRefht=CFBasicHashCreate(allocator, flags, cb);
CFBasicHashSetSpecialBits(ht, 0x0303);
if (0<numValues) CFBasicHashSetCapacity(ht, numValues);
for (CFIndexidx=0; idx<numValues; idx++) {
CFBasicHashAddValue(ht, (uintptr_t)klist[idx], (uintptr_t)vlist[idx]);
 }
CFBasicHashSetSpecialBits(ht, 0x0000);
CFBasicHashMakeImmutable(ht);
*(uintptr_t*)ht=__CFISAForTypeID(typeID);
_CFRuntimeSetInstanceTypeID(ht, typeID);
if (__CFOASafe) __CFSetLastAllocationEventName(ht, "CFBag (immutable)");
return (CFHashRef)ht;
}

#ifCFDictionary
CFHashRefCFBagCreate(CFAllocatorRefallocator, const_any_pointer_t*klist, const_any_pointer_t*vlist, CFIndexnumValues, constCFBagKeyCallBacks*keyCallBacks, constCFBagValueCallBacks*valueCallBacks) {
#endif
#ifCFSet||CFBag
CFHashRefCFBagCreate(CFAllocatorRefallocator, const_any_pointer_t*klist, CFIndexnumValues, constCFBagKeyCallBacks*keyCallBacks) {
const_any_pointer_t*vlist=klist;
constCFBagValueCallBacks*valueCallBacks=0;
#endif
CFTypeIDtypeID=CFBagGetTypeID();
CFAssert2(0 <= numValues, __kCFLogAssertion, "%s(): numValues (%ld) cannot be less than zero", __PRETTY_FUNCTION__, numValues);
CFBasicHashRefht=__CFBagCreateGeneric(allocator, keyCallBacks, valueCallBacks, CFDictionary);
if (0<numValues) CFBasicHashSetCapacity(ht, numValues);
for (CFIndexidx=0; idx<numValues; idx++) {
CFBasicHashAddValue(ht, (uintptr_t)klist[idx], (uintptr_t)vlist[idx]);
 }
CFBasicHashMakeImmutable(ht);
*(uintptr_t*)ht=__CFISAForTypeID(typeID);
_CFRuntimeSetInstanceTypeID(ht, typeID);
if (__CFOASafe) __CFSetLastAllocationEventName(ht, "CFBag (immutable)");
return (CFHashRef)ht;
}

#ifCFDictionary
CFMutableHashRefCFBagCreateMutable(CFAllocatorRefallocator, CFIndexcapacity, constCFBagKeyCallBacks*keyCallBacks, constCFBagValueCallBacks*valueCallBacks) {
#endif
#ifCFSet||CFBag
CFMutableHashRefCFBagCreateMutable(CFAllocatorRefallocator, CFIndexcapacity, constCFBagKeyCallBacks*keyCallBacks) {
constCFBagValueCallBacks*valueCallBacks=0;
#endif
CFTypeIDtypeID=CFBagGetTypeID();
CFAssert2(0 <= capacity, __kCFLogAssertion, "%s(): capacity (%ld) cannot be less than zero", __PRETTY_FUNCTION__, capacity);
CFBasicHashRefht=__CFBagCreateGeneric(allocator, keyCallBacks, valueCallBacks, CFDictionary);
*(uintptr_t*)ht=__CFISAForTypeID(typeID);
_CFRuntimeSetInstanceTypeID(ht, typeID);
if (__CFOASafe) __CFSetLastAllocationEventName(ht, "CFBag (mutable)");
return (CFMutableHashRef)ht;
}

CFHashRefCFBagCreateCopy(CFAllocatorRefallocator, CFHashRefother) {
CFTypeIDtypeID=CFBagGetTypeID();
CFAssert1(other, __kCFLogAssertion, "%s(): other CFBag cannot be NULL", __PRETTY_FUNCTION__);
__CFGenericValidateType(other, typeID);
CFBasicHashRefht=NULL;
if (CF_IS_OBJC(typeID, other)) {
CFIndexnumValues=CFBagGetCount(other);
const_any_pointer_tvbuffer[256], kbuffer[256];
const_any_pointer_t*vlist= (numValues <= 256) ? vbuffer : (const_any_pointer_t*)CFAllocatorAllocate(kCFAllocatorSystemDefault, numValues*sizeof(const_any_pointer_t), 0);
#ifCFSet||CFBag
const_any_pointer_t*klist=vlist;
CFBagGetValues(other, vlist);
#endif
#ifCFDictionary
const_any_pointer_t*klist= (numValues <= 256) ? kbuffer : (const_any_pointer_t*)CFAllocatorAllocate(kCFAllocatorSystemDefault, numValues*sizeof(const_any_pointer_t), 0);
CFDictionaryGetKeysAndValues(other, klist, vlist);
#endif
ht=__CFBagCreateGeneric(allocator, &kCFTypeBagKeyCallBacks, CFDictionary ? &kCFTypeBagValueCallBacks : NULL, CFDictionary);
if (0<numValues) CFBasicHashSetCapacity(ht, numValues);
for (CFIndexidx=0; idx<numValues; idx++) {
CFBasicHashAddValue(ht, (uintptr_t)klist[idx], (uintptr_t)vlist[idx]);
 }
if (klist!=kbuffer&&klist!=vlist) CFAllocatorDeallocate(kCFAllocatorSystemDefault, klist);
if (vlist!=vbuffer) CFAllocatorDeallocate(kCFAllocatorSystemDefault, vlist);
 } else {
ht=CFBasicHashCreateCopy(allocator, (CFBasicHashRef)other);
 }
CFBasicHashMakeImmutable(ht);
*(uintptr_t*)ht=__CFISAForTypeID(typeID);
_CFRuntimeSetInstanceTypeID(ht, typeID);
if (__CFOASafe) __CFSetLastAllocationEventName(ht, "CFBag (immutable)");
return (CFHashRef)ht;
}

CFMutableHashRefCFBagCreateMutableCopy(CFAllocatorRefallocator, CFIndexcapacity, CFHashRefother) {
CFTypeIDtypeID=CFBagGetTypeID();
CFAssert1(other, __kCFLogAssertion, "%s(): other CFBag cannot be NULL", __PRETTY_FUNCTION__);
__CFGenericValidateType(other, typeID);
CFAssert2(0 <= capacity, __kCFLogAssertion, "%s(): capacity (%ld) cannot be less than zero", __PRETTY_FUNCTION__, capacity);
CFBasicHashRefht=NULL;
if (CF_IS_OBJC(typeID, other)) {
CFIndexnumValues=CFBagGetCount(other);
const_any_pointer_tvbuffer[256], kbuffer[256];
const_any_pointer_t*vlist= (numValues <= 256) ? vbuffer : (const_any_pointer_t*)CFAllocatorAllocate(kCFAllocatorSystemDefault, numValues*sizeof(const_any_pointer_t), 0);
#ifCFSet||CFBag
const_any_pointer_t*klist=vlist;
CFBagGetValues(other, vlist);
#endif
#ifCFDictionary
const_any_pointer_t*klist= (numValues <= 256) ? kbuffer : (const_any_pointer_t*)CFAllocatorAllocate(kCFAllocatorSystemDefault, numValues*sizeof(const_any_pointer_t), 0);
CFDictionaryGetKeysAndValues(other, klist, vlist);
#endif
ht=__CFBagCreateGeneric(allocator, &kCFTypeBagKeyCallBacks, CFDictionary ? &kCFTypeBagValueCallBacks : NULL, CFDictionary);
if (0<numValues) CFBasicHashSetCapacity(ht, numValues);
for (CFIndexidx=0; idx<numValues; idx++) {
CFBasicHashAddValue(ht, (uintptr_t)klist[idx], (uintptr_t)vlist[idx]);
 }
if (klist!=kbuffer&&klist!=vlist) CFAllocatorDeallocate(kCFAllocatorSystemDefault, klist);
if (vlist!=vbuffer) CFAllocatorDeallocate(kCFAllocatorSystemDefault, vlist);
 } else {
ht=CFBasicHashCreateCopy(allocator, (CFBasicHashRef)other);
 }
*(uintptr_t*)ht=__CFISAForTypeID(typeID);
_CFRuntimeSetInstanceTypeID(ht, typeID);
if (__CFOASafe) __CFSetLastAllocationEventName(ht, "CFBag (mutable)");
return (CFMutableHashRef)ht;
}

CFIndexCFBagGetCount(CFHashRefhc) {
if (CFDictionary) CF_OBJC_FUNCDISPATCH0(__kCFBagTypeID, CFIndex, hc, "count");
if (CFSet) CF_OBJC_FUNCDISPATCH0(__kCFBagTypeID, CFIndex, hc, "count");
__CFGenericValidateType(hc, __kCFBagTypeID);
returnCFBasicHashGetCount((CFBasicHashRef)hc);
}

#ifCFDictionary
CFIndexCFBagGetCountOfKey(CFHashRefhc, const_any_pointer_tkey) {
#endif
#ifCFSet||CFBag
CFIndexCFBagGetCountOfValue(CFHashRefhc, const_any_pointer_tkey) {
#endif
if (CFDictionary) CF_OBJC_FUNCDISPATCH1(__kCFBagTypeID, CFIndex, hc, "countForKey:", key);
if (CFSet) CF_OBJC_FUNCDISPATCH1(__kCFBagTypeID, CFIndex, hc, "countForObject:", key);
__CFGenericValidateType(hc, __kCFBagTypeID);
returnCFBasicHashGetCountOfKey((CFBasicHashRef)hc, (uintptr_t)key);
}

#ifCFDictionary
BooleanCFBagContainsKey(CFHashRefhc, const_any_pointer_tkey) {
#endif
#ifCFSet||CFBag
BooleanCFBagContainsValue(CFHashRefhc, const_any_pointer_tkey) {
#endif
if (CFDictionary) CF_OBJC_FUNCDISPATCH1(__kCFBagTypeID, char, hc, "containsKey:", key);
if (CFSet) CF_OBJC_FUNCDISPATCH1(__kCFBagTypeID, char, hc, "containsObject:", key);
__CFGenericValidateType(hc, __kCFBagTypeID);
return (0<CFBasicHashGetCountOfKey((CFBasicHashRef)hc, (uintptr_t)key));
}

const_any_pointer_tCFBagGetValue(CFHashRefhc, const_any_pointer_tkey) {
if (CFDictionary) CF_OBJC_FUNCDISPATCH1(__kCFBagTypeID, const_any_pointer_t, hc, "objectForKey:", key);
if (CFSet) CF_OBJC_FUNCDISPATCH1(__kCFBagTypeID, const_any_pointer_t, hc, "member:", key);
__CFGenericValidateType(hc, __kCFBagTypeID);
CFBasicHashBucketbkt=CFBasicHashFindBucket((CFBasicHashRef)hc, (uintptr_t)key);
return (0<bkt.count ? (const_any_pointer_t)bkt.weak_value : 0);
}

BooleanCFBagGetValueIfPresent(CFHashRefhc, const_any_pointer_tkey, const_any_pointer_t*value) {
if (CFDictionary) CF_OBJC_FUNCDISPATCH2(__kCFBagTypeID, Boolean, hc, "__getValue:forKey:", (any_t*)value, key);
if (CFSet) CF_OBJC_FUNCDISPATCH2(__kCFBagTypeID, Boolean, hc, "__getValue:forObj:", (any_t*)value, key);
__CFGenericValidateType(hc, __kCFBagTypeID);
CFBasicHashBucketbkt=CFBasicHashFindBucket((CFBasicHashRef)hc, (uintptr_t)key);
if (0<bkt.count) {
if (value) {
if (kCFUseCollectableAllocator&& (CFBasicHashGetFlags((CFBasicHashRef)hc) &kCFBasicHashStrongValues)) {
__CFAssignWithWriteBarrier((void**)value, (void*)bkt.weak_value);
 } else {
*value= (const_any_pointer_t)bkt.weak_value;
 }
 }
return true;
 }
return false;
}

#ifCFDictionary
CFIndexCFDictionaryGetCountOfValue(CFHashRefhc, const_any_pointer_tvalue) {
CF_OBJC_FUNCDISPATCH1(__kCFBagTypeID, CFIndex, hc, "countForObject:", value);
__CFGenericValidateType(hc, __kCFBagTypeID);
returnCFBasicHashGetCountOfValue((CFBasicHashRef)hc, (uintptr_t)value);
}

BooleanCFDictionaryContainsValue(CFHashRefhc, const_any_pointer_tvalue) {
CF_OBJC_FUNCDISPATCH1(__kCFBagTypeID, char, hc, "containsObject:", value);
__CFGenericValidateType(hc, __kCFBagTypeID);
return (0<CFBasicHashGetCountOfValue((CFBasicHashRef)hc, (uintptr_t)value));
}

CF_EXPORTBooleanCFDictionaryGetKeyIfPresent(CFHashRefhc, const_any_pointer_tkey, const_any_pointer_t*actualkey) {
CF_OBJC_FUNCDISPATCH2(__kCFBagTypeID, Boolean, hc, "getActualKey:forKey:", actualkey, key);
__CFGenericValidateType(hc, __kCFBagTypeID);
CFBasicHashBucketbkt=CFBasicHashFindBucket((CFBasicHashRef)hc, (uintptr_t)key);
if (0<bkt.count) {
if (actualkey) {
if (kCFUseCollectableAllocator&& (CFBasicHashGetFlags((CFBasicHashRef)hc) &kCFBasicHashStrongKeys)) {
__CFAssignWithWriteBarrier((void**)actualkey, (void*)bkt.weak_key);
 } else {
*actualkey= (const_any_pointer_t)bkt.weak_key;
 }
 }
return true;
 }
return false;
}
#endif

#ifCFDictionary
voidCFBagGetKeysAndValues(CFHashRefhc, const_any_pointer_t*keybuf, const_any_pointer_t*valuebuf) {
#endif
#ifCFSet||CFBag
voidCFBagGetValues(CFHashRefhc, const_any_pointer_t*keybuf) {
const_any_pointer_t*valuebuf=0;
#endif
if (CFDictionary) CF_OBJC_FUNCDISPATCH2(__kCFBagTypeID, void, hc, "getObjects:andKeys:", (any_t*)valuebuf, (any_t*)keybuf);
if (CFSet) CF_OBJC_FUNCDISPATCH1(__kCFBagTypeID, void, hc, "getObjects:", (any_t*)keybuf);
__CFGenericValidateType(hc, __kCFBagTypeID);
#if__BLOCKS__
if (kCFUseCollectableAllocator) {
CFOptionFlagsflags=CFBasicHashGetFlags((CFBasicHashRef)hc);
__blockconst_any_pointer_t*keys=keybuf;
__blockconst_any_pointer_t*values=valuebuf;
CFBasicHashApply((CFBasicHashRef)hc, ^(CFBasicHashBucketbkt) {
for (CFIndexcnt=bkt.count; cnt--;) {
if (keybuf&& (flags&kCFBasicHashStrongKeys)) { __CFAssignWithWriteBarrier((void**)keys, (void*)bkt.weak_key); keys++; }
if (keybuf&& !(flags&kCFBasicHashStrongKeys)) { *keys++= (const_any_pointer_t)bkt.weak_key; }
if (valuebuf&& (flags&kCFBasicHashStrongValues)) { __CFAssignWithWriteBarrier((void**)values, (void*)bkt.weak_value); values++; }
if (valuebuf&& !(flags&kCFBasicHashStrongValues)) { *values++= (const_any_pointer_t)bkt.weak_value; }
 }
return (Boolean)true;
 });
 } else {
#else
 {
#endif
CFBasicHashGetElements((CFBasicHashRef)hc, CFBagGetCount(hc), (uintptr_t*)valuebuf, (uintptr_t*)keybuf);
 }
}

voidCFBagApplyFunction(CFHashRefhc, CFBagApplierFunctionapplier, any_pointer_tcontext) {
FAULT_CALLBACK((void**)&(applier));
if (CFDictionary) CF_OBJC_FUNCDISPATCH2(__kCFBagTypeID, void, hc, "__apply:context:", applier, context);
if (CFSet) CF_OBJC_FUNCDISPATCH2(__kCFBagTypeID, void, hc, "__applyValues:context:", applier, context);
__CFGenericValidateType(hc, __kCFBagTypeID);
#if__BLOCKS__
CFBasicHashApply((CFBasicHashRef)hc, ^(CFBasicHashBucketbkt) {
#ifCFDictionary
INVOKE_CALLBACK3(applier, (const_any_pointer_t)bkt.weak_key, (const_any_pointer_t)bkt.weak_value, context);
#endif
#ifCFSet
INVOKE_CALLBACK2(applier, (const_any_pointer_t)bkt.weak_value, context);
#endif
#ifCFBag
for (CFIndexcnt=bkt.count; cnt--;) {
INVOKE_CALLBACK2(applier, (const_any_pointer_t)bkt.weak_value, context);
 }
#endif
return (Boolean)true;
 });
#else// blockless!

#ifCFDictionary
CFIndexcnt=CFDictionaryGetCount(hc);
STACK_BUFFER_DECL(any_t, keys, cnt);
STACK_BUFFER_DECL(any_t, values, cnt);
CFDictionaryGetKeysAndValues(hc, (constvoid**)keys, (constvoid**)values);
#elifCFSet
CFIndexcnt=CFSetGetCount(hc);
STACK_BUFFER_DECL(any_t, values, cnt);
CFSetGetValues(hc, (constvoid**)values);
#elifCFBag
CFIndexcnt=CFBagGetCount(hc);
STACK_BUFFER_DECL(any_t, values, cnt);
CFBagGetValues(hc, (constvoid**)values);
#endif

for (CFIndexidx=0; idx<cnt; idx++) {
#ifCFDictionary
INVOKE_CALLBACK3(applier, (const_any_pointer_t)keys[idx], (const_any_pointer_t)values[idx], context);
#endif
#ifCFSet
INVOKE_CALLBACK2(applier, (const_any_pointer_t)values[idx], context);
#elifCFBag
for (CFIndexcntVal=CFBagGetCountOfValue(hc, (constvoid*)values[idx]); cntVal--;) {
INVOKE_CALLBACK2(applier, (const_any_pointer_t)values[idx], context);
 }
#endif
 }
#endif
}

// This function is for Foundation's benefit; no one else should use it.
CF_EXPORT unsigned long_CFBagFastEnumeration(CFHashRefhc, struct__objcFastEnumerationStateEquivalent*state, void*stackbuffer, unsigned longcount) {
if (CF_IS_OBJC(__kCFBagTypeID, hc)) return0;
__CFGenericValidateType(hc, __kCFBagTypeID);
return__CFBasicHashFastEnumeration((CFBasicHashRef)hc, (struct__objcFastEnumerationStateEquivalent2*)state, stackbuffer, count);
}

// This function is for Foundation's benefit; no one else should use it.
CF_EXPORTBoolean_CFBagIsMutable(CFHashRefhc) {
if (CF_IS_OBJC(__kCFBagTypeID, hc)) return false;
__CFGenericValidateType(hc, __kCFBagTypeID);
returnCFBasicHashIsMutable((CFBasicHashRef)hc);
}

// This function is for Foundation's benefit; no one else should use it.
CF_EXPORTvoid_CFBagSetCapacity(CFMutableHashRefhc, CFIndexcap) {
if (CF_IS_OBJC(__kCFBagTypeID, hc)) return;
__CFGenericValidateType(hc, __kCFBagTypeID);
CFAssert2(CFBasicHashIsMutable((CFBasicHashRef)hc), __kCFLogAssertion, "%s(): immutable collection %p passed to mutating operation", __PRETTY_FUNCTION__, hc);
CFAssert3(CFBagGetCount(hc) <= cap, __kCFLogAssertion, "%s(): desired capacity (%ld) is less than count (%ld)", __PRETTY_FUNCTION__, cap, CFBagGetCount(hc));
CFBasicHashSetCapacity((CFBasicHashRef)hc, cap);
}

CF_INLINECFIndex__CFBagGetKVOBit(CFHashRefhc) {
return__CFBitfieldGetValue(((CFRuntimeBase*)hc)->_cfinfo[CF_INFO_BITS], 0, 0);
}

CF_INLINEvoid__CFBagSetKVOBit(CFHashRefhc, CFIndexbit) {
__CFBitfieldSetValue(((CFRuntimeBase*)hc)->_cfinfo[CF_INFO_BITS], 0, 0, ((uintptr_t)bit&0x1));
}

// This function is for Foundation's benefit; no one else should use it.
CF_EXPORTCFIndex_CFBagGetKVOBit(CFHashRefhc) {
return__CFBagGetKVOBit(hc);
}

// This function is for Foundation's benefit; no one else should use it.
CF_EXPORTvoid_CFBagSetKVOBit(CFHashRefhc, CFIndexbit) {
__CFBagSetKVOBit(hc, bit);
}


#if !defined(CF_OBJC_KVO_WILLCHANGE)
#defineCF_OBJC_KVO_WILLCHANGE(obj, key)
#defineCF_OBJC_KVO_DIDCHANGE(obj, key)
#defineCF_OBJC_KVO_WILLCHANGEALL(obj)
#defineCF_OBJC_KVO_DIDCHANGEALL(obj)
#endif

#ifCFDictionary
voidCFBagAddValue(CFMutableHashRefhc, const_any_pointer_tkey, const_any_pointer_tvalue) {
#endif
#ifCFSet||CFBag
voidCFBagAddValue(CFMutableHashRefhc, const_any_pointer_tkey) {
const_any_pointer_tvalue=key;
#endif
if (CFDictionary) CF_OBJC_FUNCDISPATCH2(__kCFBagTypeID, void, hc, "addObject:forKey:", value, key);
if (CFSet) CF_OBJC_FUNCDISPATCH1(__kCFBagTypeID, void, hc, "addObject:", key);
__CFGenericValidateType(hc, __kCFBagTypeID);
CFAssert2(CFBasicHashIsMutable((CFBasicHashRef)hc), __kCFLogAssertion, "%s(): immutable collection %p passed to mutating operation", __PRETTY_FUNCTION__, hc);
if (!CFBasicHashIsMutable((CFBasicHashRef)hc)) {
CFLog(kCFLogLevelError, CFSTR("%s(): immutable collection %p given to mutating function"), __PRETTY_FUNCTION__, hc);
 }
CF_OBJC_KVO_WILLCHANGE(hc, key);
CFBasicHashAddValue((CFBasicHashRef)hc, (uintptr_t)key, (uintptr_t)value);
CF_OBJC_KVO_DIDCHANGE(hc, key);
}

#ifCFDictionary
voidCFBagReplaceValue(CFMutableHashRefhc, const_any_pointer_tkey, const_any_pointer_tvalue) {
#endif
#ifCFSet||CFBag
voidCFBagReplaceValue(CFMutableHashRefhc, const_any_pointer_tkey) {
const_any_pointer_tvalue=key;
#endif
if (CFDictionary) CF_OBJC_FUNCDISPATCH2(__kCFBagTypeID, void, hc, "replaceObject:forKey:", value, key);
if (CFSet) CF_OBJC_FUNCDISPATCH1(__kCFBagTypeID, void, hc, "replaceObject:", key);
__CFGenericValidateType(hc, __kCFBagTypeID);
CFAssert2(CFBasicHashIsMutable((CFBasicHashRef)hc), __kCFLogAssertion, "%s(): immutable collection %p passed to mutating operation", __PRETTY_FUNCTION__, hc);
if (!CFBasicHashIsMutable((CFBasicHashRef)hc)) {
CFLog(kCFLogLevelError, CFSTR("%s(): immutable collection %p given to mutating function"), __PRETTY_FUNCTION__, hc);
 }
CF_OBJC_KVO_WILLCHANGE(hc, key);
CFBasicHashReplaceValue((CFBasicHashRef)hc, (uintptr_t)key, (uintptr_t)value);
CF_OBJC_KVO_DIDCHANGE(hc, key);
}

#ifCFDictionary
voidCFBagSetValue(CFMutableHashRefhc, const_any_pointer_tkey, const_any_pointer_tvalue) {
#endif
#ifCFSet||CFBag
voidCFBagSetValue(CFMutableHashRefhc, const_any_pointer_tkey) {
const_any_pointer_tvalue=key;
#endif
if (CFDictionary) CF_OBJC_FUNCDISPATCH2(__kCFBagTypeID, void, hc, "setObject:forKey:", value, key);
if (CFSet) CF_OBJC_FUNCDISPATCH1(__kCFBagTypeID, void, hc, "setObject:", key);
__CFGenericValidateType(hc, __kCFBagTypeID);
CFAssert2(CFBasicHashIsMutable((CFBasicHashRef)hc), __kCFLogAssertion, "%s(): immutable collection %p passed to mutating operation", __PRETTY_FUNCTION__, hc);
if (!CFBasicHashIsMutable((CFBasicHashRef)hc)) {
CFLog(kCFLogLevelError, CFSTR("%s(): immutable collection %p given to mutating function"), __PRETTY_FUNCTION__, hc);
 }
CF_OBJC_KVO_WILLCHANGE(hc, key);
//#warning this for a dictionary used to not replace the key
CFBasicHashSetValue((CFBasicHashRef)hc, (uintptr_t)key, (uintptr_t)value);
CF_OBJC_KVO_DIDCHANGE(hc, key);
}

voidCFBagRemoveValue(CFMutableHashRefhc, const_any_pointer_tkey) {
if (CFDictionary) CF_OBJC_FUNCDISPATCH1(__kCFBagTypeID, void, hc, "removeObjectForKey:", key);
if (CFSet) CF_OBJC_FUNCDISPATCH1(__kCFBagTypeID, void, hc, "removeObject:", key);
__CFGenericValidateType(hc, __kCFBagTypeID);
CFAssert2(CFBasicHashIsMutable((CFBasicHashRef)hc), __kCFLogAssertion, "%s(): immutable collection %p passed to mutating operation", __PRETTY_FUNCTION__, hc);
if (!CFBasicHashIsMutable((CFBasicHashRef)hc)) {
CFLog(kCFLogLevelError, CFSTR("%s(): immutable collection %p given to mutating function"), __PRETTY_FUNCTION__, hc);
 }
CF_OBJC_KVO_WILLCHANGE(hc, key);
CFBasicHashRemoveValue((CFBasicHashRef)hc, (uintptr_t)key);
CF_OBJC_KVO_DIDCHANGE(hc, key);
}

voidCFBagRemoveAllValues(CFMutableHashRefhc) {
if (CFDictionary) CF_OBJC_FUNCDISPATCH0(__kCFBagTypeID, void, hc, "removeAllObjects");
if (CFSet) CF_OBJC_FUNCDISPATCH0(__kCFBagTypeID, void, hc, "removeAllObjects");
__CFGenericValidateType(hc, __kCFBagTypeID);
CFAssert2(CFBasicHashIsMutable((CFBasicHashRef)hc), __kCFLogAssertion, "%s(): immutable collection %p passed to mutating operation", __PRETTY_FUNCTION__, hc);
if (!CFBasicHashIsMutable((CFBasicHashRef)hc)) {
CFLog(kCFLogLevelError, CFSTR("%s(): immutable collection %p given to mutating function"), __PRETTY_FUNCTION__, hc);
 }
CF_OBJC_KVO_WILLCHANGEALL(hc);
CFBasicHashRemoveAllValues((CFBasicHashRef)hc);
CF_OBJC_KVO_DIDCHANGEALL(hc);
}

#undef CF_OBJC_KVO_WILLCHANGE
#undef CF_OBJC_KVO_DIDCHANGE
#undef CF_OBJC_KVO_WILLCHANGEALL
#undef CF_OBJC_KVO_DIDCHANGEALL