Main Page | Class List | Directories | File List | Class Members | File Members

gcache.c File Reference

#include "glib.h"

Go to the source code of this file.

Classes

struct  _GCacheNode
struct  _GRealCache

Typedefs

typedef _GCacheNode GCacheNode
typedef _GRealCache GRealCache

Functions

static GCacheNode * g_cache_node_new (gpointer value)
static void g_cache_node_destroy (GCacheNode *node)
 G_LOCK_DEFINE_STATIC (node_mem_chunk)
GCache * g_cache_new (GCacheNewFunc value_new_func, GCacheDestroyFunc value_destroy_func, GCacheDupFunc key_dup_func, GCacheDestroyFunc key_destroy_func, GHashFunc hash_key_func, GHashFunc hash_value_func, GCompareFunc key_compare_func)
void g_cache_destroy (GCache *cache)
gpointer g_cache_insert (GCache *cache, gpointer key)
void g_cache_remove (GCache *cache, gpointer value)
void g_cache_key_foreach (GCache *cache, GHFunc func, gpointer user_data)
void g_cache_value_foreach (GCache *cache, GHFunc func, gpointer user_data)

Variables

static GMemChunk * node_mem_chunk = NULL

Typedef Documentation

typedef struct _GCacheNode GCacheNode
 

Definition at line 34 of file gcache.c.

typedef struct _GRealCache GRealCache
 

Definition at line 35 of file gcache.c.

Function Documentation

void g_cache_destroy (  GCache *  cache  ) 
 

Definition at line 104 of file gcache.c.

References g_free(), g_hash_table_destroy(), g_return_if_fail, _GRealCache::key_table, NULL, and _GRealCache::value_table.

00105 {
00106   GRealCache *rcache;
00107 
00108   g_return_if_fail (cache != NULL);
00109 
00110   rcache = (GRealCache*) cache;
00111   g_hash_table_destroy (rcache->key_table);
00112   g_hash_table_destroy (rcache->value_table);
00113   g_free (rcache);
00114 }

gpointer g_cache_insert (  GCache *  cache,
gpointer  key
) 
 

Definition at line 117 of file gcache.c.

References g_cache_node_new(), g_hash_table_insert(), g_hash_table_lookup(), g_return_val_if_fail, _GRealCache::key_dup_func, _GRealCache::key_table, NULL, _GCacheNode::ref_count, _GCacheNode::value, _GRealCache::value_new_func, and _GRealCache::value_table.

00119 {
00120   GRealCache *rcache;
00121   GCacheNode *node;
00122   gpointer value;
00123 
00124   g_return_val_if_fail (cache != NULL, NULL);
00125 
00126   rcache = (GRealCache*) cache;
00127 
00128   node = g_hash_table_lookup (rcache->key_table, key);
00129   if (node)
00130     {
00131       node->ref_count += 1;
00132       return node->value;
00133     }
00134 
00135   key = (* rcache->key_dup_func) (key);
00136   value = (* rcache->value_new_func) (key);
00137   node = g_cache_node_new (value);
00138 
00139   g_hash_table_insert (rcache->key_table, key, node);
00140   g_hash_table_insert (rcache->value_table, value, key);
00141 
00142   return node->value;
00143 }

void g_cache_key_foreach (  GCache *  cache,
GHFunc  func,
gpointer  user_data
) 
 

Definition at line 175 of file gcache.c.

References g_hash_table_foreach(), g_return_if_fail, NULL, and _GRealCache::value_table.

00178 {
00179   GRealCache *rcache;
00180 
00181   g_return_if_fail (cache != NULL);
00182   g_return_if_fail (func != NULL);
00183 
00184   rcache = (GRealCache*) cache;
00185 
00186   g_hash_table_foreach (rcache->value_table, func, user_data);
00187 }

GCache* g_cache_new (  GCacheNewFunc  value_new_func,
GCacheDestroyFunc  value_destroy_func,
GCacheDupFunc  key_dup_func,
GCacheDestroyFunc  key_destroy_func,
GHashFunc  hash_key_func,
GHashFunc  hash_value_func,
GCompareFunc  key_compare_func
) 
 

Definition at line 74 of file gcache.c.

References g_hash_table_new(), g_new, g_return_val_if_fail, _GRealCache::key_destroy_func, _GRealCache::key_dup_func, _GRealCache::key_table, NULL, _GRealCache::value_destroy_func, _GRealCache::value_new_func, and _GRealCache::value_table.

00081 {
00082   GRealCache *cache;
00083 
00084   g_return_val_if_fail (value_new_func != NULL, NULL);
00085   g_return_val_if_fail (value_destroy_func != NULL, NULL);
00086   g_return_val_if_fail (key_dup_func != NULL, NULL);
00087   g_return_val_if_fail (key_destroy_func != NULL, NULL);
00088   g_return_val_if_fail (hash_key_func != NULL, NULL);
00089   g_return_val_if_fail (hash_value_func != NULL, NULL);
00090   g_return_val_if_fail (key_compare_func != NULL, NULL);
00091 
00092   cache = g_new (GRealCache, 1);
00093   cache->value_new_func = value_new_func;
00094   cache->value_destroy_func = value_destroy_func;
00095   cache->key_dup_func = key_dup_func;
00096   cache->key_destroy_func = key_destroy_func;
00097   cache->key_table = g_hash_table_new (hash_key_func, key_compare_func);
00098   cache->value_table = g_hash_table_new (hash_value_func, NULL);
00099 
00100   return (GCache*) cache;
00101 }

static void g_cache_node_destroy (  GCacheNode *  node  )  [static]
 

Definition at line 225 of file gcache.c.

References G_LOCK, g_mem_chunk_free(), G_UNLOCK, and node_mem_chunk.

Referenced by g_cache_remove().

00226 {
00227   G_LOCK (node_mem_chunk);
00228   g_mem_chunk_free (node_mem_chunk, node);
00229   G_UNLOCK (node_mem_chunk);
00230 }

static GCacheNode * g_cache_node_new (  gpointer  value  )  [static]
 

Definition at line 206 of file gcache.c.

References G_ALLOC_AND_FREE, g_chunk_new, G_LOCK, g_mem_chunk_new(), G_UNLOCK, node_mem_chunk, _GCacheNode::ref_count, and _GCacheNode::value.

Referenced by g_cache_insert().

00207 {
00208   GCacheNode *node;
00209 
00210   G_LOCK (node_mem_chunk);
00211   if (!node_mem_chunk)
00212     node_mem_chunk = g_mem_chunk_new ("cache node mem chunk", sizeof (GCacheNode),
00213                                       1024, G_ALLOC_AND_FREE);
00214 
00215   node = g_chunk_new (GCacheNode, node_mem_chunk);
00216   G_UNLOCK (node_mem_chunk);
00217 
00218   node->value = value;
00219   node->ref_count = 1;
00220 
00221   return node;
00222 }

void g_cache_remove (  GCache *  cache,
gpointer  value
) 
 

Definition at line 146 of file gcache.c.

References g_cache_node_destroy(), g_hash_table_lookup(), g_hash_table_remove(), g_return_if_fail, _GRealCache::key_destroy_func, _GRealCache::key_table, NULL, _GCacheNode::ref_count, _GCacheNode::value, _GRealCache::value_destroy_func, and _GRealCache::value_table.

00148 {
00149   GRealCache *rcache;
00150   GCacheNode *node;
00151   gpointer key;
00152 
00153   g_return_if_fail (cache != NULL);
00154 
00155   rcache = (GRealCache*) cache;
00156 
00157   key = g_hash_table_lookup (rcache->value_table, value);
00158   node = g_hash_table_lookup (rcache->key_table, key);
00159 
00160   g_return_if_fail (node != NULL);
00161 
00162   node->ref_count -= 1;
00163   if (node->ref_count == 0)
00164     {
00165       g_hash_table_remove (rcache->value_table, value);
00166       g_hash_table_remove (rcache->key_table, key);
00167 
00168       (* rcache->key_destroy_func) (key);
00169       (* rcache->value_destroy_func) (node->value);
00170       g_cache_node_destroy (node);
00171     }
00172 }

void g_cache_value_foreach (  GCache *  cache,
GHFunc  func,
gpointer  user_data
) 
 

Definition at line 190 of file gcache.c.

References g_hash_table_foreach(), g_return_if_fail, _GRealCache::key_table, and NULL.

00193 {
00194   GRealCache *rcache;
00195 
00196   g_return_if_fail (cache != NULL);
00197   g_return_if_fail (func != NULL);
00198 
00199   rcache = (GRealCache*) cache;
00200 
00201   g_hash_table_foreach (rcache->key_table, func, user_data);
00202 }

G_LOCK_DEFINE_STATIC (  node_mem_chunk   ) 
 

Variable Documentation

GMemChunk* node_mem_chunk = NULL [static]
 

Definition at line 70 of file gcache.c.

Referenced by g_cache_node_destroy(), g_cache_node_new(), g_hash_node_new(), and g_tree_node_new().

© sourcejam.com 2005-2008