168 lines
3.2 KiB
C
168 lines
3.2 KiB
C
/*
|
|
*+SNOTICE
|
|
*
|
|
*
|
|
* $TOG: Dictionary.C /main/5 1997/12/22 16:32:11 bill $
|
|
*
|
|
* RESTRICTED CONFIDENTIAL INFORMATION:
|
|
*
|
|
* The information in this document is subject to special
|
|
* restrictions in a confidential disclosure agreement bertween
|
|
* HP, IBM, Sun, USL, SCO and Univel. Do not distribute this
|
|
* document outside HP, IBM, Sun, USL, SCO, or Univel wihtout
|
|
* Sun's specific written approval. This documment and all copies
|
|
* and derivative works thereof must be returned or destroyed at
|
|
* Sun's request.
|
|
*
|
|
* Copyright 1993 Sun Microsystems, Inc. All rights reserved.
|
|
*
|
|
*+ENOTICE
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <DtMail/Threads.hh>
|
|
#include <DtMail/Dictionary.hh>
|
|
|
|
DtMailDictionaryImpl::DtMailDictionaryImpl(int size)
|
|
{
|
|
_hash_size = size;
|
|
|
|
_hash_table = (HashTable_t *)malloc(sizeof(HashTable_t) * _hash_size);
|
|
|
|
for (int h = 0; h < _hash_size; h++) {
|
|
_hash_table[h] = NULL;
|
|
}
|
|
|
|
_obj_mutex = MutexInit();
|
|
}
|
|
|
|
DtMailDictionaryImpl::~DtMailDictionaryImpl(void)
|
|
{
|
|
MutexLock lock_scope(_obj_mutex);
|
|
|
|
if (_hash_table) {
|
|
for (int h = 0; h < _hash_size; h++) {
|
|
if (_hash_table[h]) {
|
|
delete _hash_table[h];
|
|
}
|
|
}
|
|
free(_hash_table);
|
|
_hash_table = NULL;
|
|
}
|
|
|
|
lock_scope.unlock_and_destroy();
|
|
}
|
|
|
|
void
|
|
DtMailDictionaryImpl::set(const char * key, const void * value)
|
|
{
|
|
MutexLock lock_scope(_obj_mutex);
|
|
|
|
int hash = hashValue(key);
|
|
|
|
// See if this key is already there. If so, simply update the value.
|
|
//
|
|
Entry * ent;
|
|
locate(hash, key, &ent);
|
|
|
|
if (ent) {
|
|
ent->value = value;
|
|
return;
|
|
}
|
|
|
|
// New key/value. Add it to the appropriate slot.
|
|
//
|
|
if (_hash_table[hash] == NULL) {
|
|
_hash_table[hash] = new DtVirtArray<Entry *>(16);
|
|
}
|
|
|
|
DtVirtArray<Entry *> * slot = _hash_table[hash];
|
|
|
|
ent = new Entry;
|
|
ent->key = strdup(key);
|
|
ent->value = value;
|
|
|
|
slot->append(ent);
|
|
return;
|
|
}
|
|
|
|
const void *
|
|
DtMailDictionaryImpl::lookup(const char * key)
|
|
{
|
|
MutexLock lock_scope(_obj_mutex);
|
|
|
|
int hash = hashValue(key);
|
|
|
|
Entry * ent;
|
|
locate(hash, key, &ent);
|
|
const void * value = NULL;
|
|
if (ent) {
|
|
value = ent->value;
|
|
}
|
|
|
|
return(value);
|
|
}
|
|
|
|
void
|
|
DtMailDictionaryImpl::remove(const char * key)
|
|
{
|
|
MutexLock lock_scope(_obj_mutex);
|
|
|
|
int hash = hashValue(key);
|
|
|
|
// Locate the entry. This approach will cause us to search
|
|
// the hash list twice, but that should be cheap enough that
|
|
// we can afford to do it.
|
|
//
|
|
Entry * ent;
|
|
locate(hash, key, &ent);
|
|
if (ent == NULL) {
|
|
// Not here, just return.
|
|
return;
|
|
}
|
|
|
|
DtVirtArray<Entry *> * slot = _hash_table[hash];
|
|
int loc = slot->indexof(ent);
|
|
slot->remove(loc);
|
|
|
|
return;
|
|
}
|
|
|
|
int
|
|
DtMailDictionaryImpl::hashValue(const char * key)
|
|
{
|
|
int hash = 0;
|
|
for (const char * cur = key; *cur; cur++) {
|
|
hash ^= *cur;
|
|
}
|
|
|
|
hash %= _hash_size;
|
|
|
|
return(hash);
|
|
}
|
|
|
|
void
|
|
DtMailDictionaryImpl::locate(int hash, const char * key, Entry ** ent)
|
|
{
|
|
*ent = NULL;
|
|
|
|
DtVirtArray<Entry *> * slot = _hash_table[hash];
|
|
|
|
if (slot == NULL) {
|
|
return;
|
|
}
|
|
|
|
for (int col = 0; col < slot->length(); col++) {
|
|
Entry * t_ent = (*slot)[col];
|
|
|
|
if (strcmp(t_ent->key, key) == 0) {
|
|
*ent = t_ent;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|