// Delete an object from the cache, if it's still there
void cache_delete(cache_t cache, key_type key){
item_t item_ptr = hash_table_find_item(cache->hash_table, key);
if (item_ptr!=NULL){
linked_list_delete(cache->linked_list, item_ptr->node_ptr);
hash_table_delete(cache->hash_table, item_ptr);
}
}
// Add a <key, value> pair to the cache.
// If key already exists, it will overwrite the old value.
// If maxmem capacity is exceeded, sufficient values will be removed
// from the cache to accomodate the new value.
void cache_set(cache_t cache, key_type key, val_type val, uint32_t val_size){
item_t item_to_set = hash_table_find_item(cache->hash_table, key);
// If key already exists, it will overwrite the old value.
if (item_to_set!=NULL){
item_to_set->val = val;
return;
}
//If maxmem capacity is exceeded, sufficient values will be removed
if (cache_space_used(cache)+val_size >= cache->maxmem){
cache_evict(cache);
}
//printf("\ncurrent_size:%u,hash_table_buckets_num:%u\n",cache->hash_table->current_size+1,(uint32_t) ((double) cache->hash_table->buckets_num*LOAD_FACTOR));
//Check if we need to resize hash table
if (cache->hash_table->current_size+1 > (uint32_t) ((double) cache->hash_table->buckets_num*LOAD_FACTOR)){
resize_hash_table(cache->hash_table);
}
item_t item = hash_table_set(cache->hash_table, key, val, val_size);
node_t node = linked_list_set(cache->linked_list);
// //connect the item in hash_table with its corresponding node in linked list
connect_node_and_item(item,node);
}
// Retrieve the value associated with key in the cache, or NULL if not found. It will move the item with key to the front of the linked_list
val_type cache_get(cache_t cache, key_type key, uint32_t * val_size){
item_t item_ptr = hash_table_find_item(cache->hash_table, key);
if (item_ptr!=NULL){
//move the newly used node to the front of the linked_list
linked_list_top(cache->linked_list,item_ptr->node_ptr);
*val_size = item_ptr->val_size;
return item_ptr->val;
}
//If key is not found, assign 0 to val_size
*val_size = 0;
return NULL;
}
/**
* Look up a key in the map and return the associated data pointer.
*/
const void *
util_keymap_lookup(const struct keymap *map, const void *key)
{
unsigned key_hash;
struct keymap_item *item;
assert(map);
if (!map)
return NULL;
key_hash = hash(key, map->key_size);
item = hash_table_find_item(map, key, key_hash);
if (!item)
return NULL;
return item->value;
}
/**
* Insert a new key + data pointer into the table.
* Note: we create a copy of the key, but not the data!
* If the key is already present in the table, replace the existing
* entry (calling the delete callback on the previous entry).
* If the maximum capacity of the map is reached an old entry
* will be deleted (the delete callback will be called).
*/
boolean
util_keymap_insert(struct keymap *map, const void *key,
const void *data, void *user)
{
unsigned key_hash;
struct keymap_item *item;
struct cso_hash_iter iter;
assert(map);
if (!map)
return FALSE;
key_hash = hash(key, map->key_size);
item = hash_table_find_item(map, key, key_hash);
if (item) {
/* call delete callback for old entry/item */
map->delete_func(map, item->key, item->value, user);
item->value = (void *) data;
return TRUE;
}
item = MALLOC_STRUCT(keymap_item);
if (!item)
return FALSE;
item->key = mem_dup(key, map->key_size);
item->value = (void *) data;
iter = cso_hash_insert(map->cso, key_hash, item);
if (cso_hash_iter_is_null(iter)) {
FREE(item);
return FALSE;
}
map->num_entries++;
return TRUE;
}