PARCHashMap *
parcHashMap_Put(PARCHashMap *hashMap, const PARCObject *key, const PARCObject *value)
{
// When expanded by 2 the load factor goes from .75 (3/4) to .375 (3/8), if
// we compress by 2 when the load factor is .25 (1/4) the load
// factor becomes .5 (1/2).
double loadFactor = (double)hashMap->size/(double)hashMap->capacity;
if (loadFactor >= hashMap->maxLoadFactor) {
_parcHashMap_Resize(hashMap, hashMap->capacity * 2);
}
_PARCHashMapEntry *entry = _parcHashMap_GetEntry(hashMap, key);
if (entry != NULL) {
if (entry->value != value) {
parcObject_Release(&entry->value);
entry->value = parcObject_Acquire(value);
}
} else {
entry = _parcHashMapEntry_Create(key, value);
PARCHashCode keyHash = parcObject_HashCode(key);
int bucket = keyHash % hashMap->capacity;
if (hashMap->buckets[bucket] == NULL) {
hashMap->buckets[bucket] = parcLinkedList_Create();
}
parcLinkedList_Append(hashMap->buckets[bucket], entry);
hashMap->size++;
_parcHashMapEntry_Release(&entry);
}
return hashMap;
}
PARCKeyStore *
parcKeyStore_Create(PARCObject *instance, const PARCKeyStoreInterface *interface)
{
PARCKeyStore *keyStore = parcObject_CreateInstance(PARCKeyStore);
if (keyStore != NULL) {
keyStore->instance = parcObject_Acquire(instance);
keyStore->interface = interface;
}
return keyStore;
}
PARCChunker *
parcChunker_Create(PARCObject *instance, PARCChunkerInterface *interface)
{
PARCChunker *chunker = parcObject_CreateInstance(PARCChunker);
if (chunker != NULL) {
chunker->instance = parcObject_Acquire(instance);
chunker->interface = interface;
}
return chunker;
}
static _PARCHashMapEntry *
_parcHashMapEntry_Create(const PARCObject *key, const PARCObject *value)
{
parcObject_OptionalAssertValid(key);
parcObject_OptionalAssertValid(value);
_PARCHashMapEntry *result = parcObject_CreateInstance(_PARCHashMapEntry);
result->key = parcObject_Copy(key);
result->value = parcObject_Acquire(value);
return result;
}
void
parcObjectTesting_AssertAcquireReleaseImpl(const PARCObject *instance)
{
PARCReferenceCount originalReferences = parcObject_GetReferenceCount(instance);
PARCObject *newReference = parcObject_Acquire(instance);
assertTrue(newReference == instance, "Expected the acquire function to return the same instance pointer.");
PARCReferenceCount currentReferences = parcObject_GetReferenceCount(instance);
assertTrue(currentReferences == (originalReferences + 1),
"Expected references to be %" PRIu64 ", actual %" PRIu64, (originalReferences + 1), currentReferences);
parcObject_Release(&newReference);
currentReferences = parcObject_GetReferenceCount(instance);
assertTrue(currentReferences == originalReferences,
"Expected references to be %" PRIu64 ", actual %" PRIu64, originalReferences, currentReferences);
}
PARCLogReporter *
parcLogReporterFile_Acquire(const PARCLogReporter *reporter)
{
return parcObject_Acquire(reporter);
}
PARCLogReporter *
parcLogReporterTextStdout_Acquire(const PARCLogReporter *instance)
{
return parcObject_Acquire(instance);
}
