Return to gdcache.h CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / gd

Annotation of embedaddon/php/ext/gd/gdcache.h, revision 1.1.1.2

1.1       misho       1: /*
1.1.1.2 ! misho       2:  * $Id$
1.1       misho       3:  *
                      4:  * Caches of pointers to user structs in which the least-recently-used
                      5:  * element is replaced in the event of a cache miss after the cache has
                      6:  * reached a given size.
                      7:  *
                      8:  * John Ellson  (ellson@lucent.com)  Oct 31, 1997
                      9:  *
                     10:  * Test this with:
                     11:  *              gcc -o gdcache -g -Wall -DTEST gdcache.c
                     12:  *
                     13:  * The cache is implemented by a singly-linked list of elements
                     14:  * each containing a pointer to a user struct that is being managed by
                     15:  * the cache.
                     16:  *
                     17:  * The head structure has a pointer to the most-recently-used
                     18:  * element, and elements are moved to this position in the list each
                     19:  * time they are used.  The head also contains pointers to three
                     20:  * user defined functions:
                     21:  *             - a function to test if a cached userdata matches some keydata
                     22:  *             - a function to provide a new userdata struct to the cache
                     23:  *          if there has been a cache miss.
                     24:  *             - a function to release a userdata struct when it is
                     25:  *          no longer being managed by the cache
                     26:  *
                     27:  * In the event of a cache miss the cache is allowed to grow up to
                     28:  * a specified maximum size.  After the maximum size is reached then
                     29:  * the least-recently-used element is discarded to make room for the
                     30:  * new.  The most-recently-returned value is always left at the
                     31:  * beginning of the list after retrieval.
                     32:  *
                     33:  * In the current implementation the cache is traversed by a linear
                     34:  * search from most-recent to least-recent.  This linear search
                     35:  * probably limits the usefulness of this implementation to cache
                     36:  * sizes of a few tens of elements.
                     37:  */
                     38: 
                     39: /*********************************************************/
                     40: /* header                                                */
                     41: /*********************************************************/
                     42: 
                     43: #if (!defined(_OSD_POSIX) && !defined(__FreeBSD__)) && HAVE_MALLOC_H
                     44: #include <malloc.h>
                     45: #else
                     46: #include <stdlib.h> /* BS2000/OSD defines malloc() & friends in stdlib.h */
                     47: #endif
                     48: #ifndef NULL
                     49: #define NULL (void *)0
                     50: #endif
                     51: 
                     52: /* user defined function templates */
                     53: typedef int (*gdCacheTestFn_t)(void *userdata, void *keydata);
                     54: typedef void *(*gdCacheFetchFn_t)(char **error, void *keydata);
                     55: typedef void (*gdCacheReleaseFn_t)(void *userdata);
                     56: 
                     57: /* element structure */
                     58: typedef struct gdCache_element_s gdCache_element_t;
                     59: struct gdCache_element_s {
                     60:        gdCache_element_t       *next;
                     61:        void                    *userdata;
                     62: };
                     63: 
                     64: /* head structure */
                     65: typedef struct gdCache_head_s gdCache_head_t;
                     66: struct gdCache_head_s {
                     67:        gdCache_element_t       *mru;
                     68:        int                                     size;
                     69:        char                            *error;
                     70:        gdCacheTestFn_t         gdCacheTest;
                     71:        gdCacheFetchFn_t        gdCacheFetch;
                     72:        gdCacheReleaseFn_t      gdCacheRelease;
                     73: };
                     74: 
                     75: /* function templates */
                     76: gdCache_head_t *
                     77: gdCacheCreate(
                     78:        int                                     size,
                     79:        gdCacheTestFn_t         gdCacheTest,
                     80:        gdCacheFetchFn_t        gdCacheFetch,
                     81:        gdCacheReleaseFn_t      gdCacheRelease );
                     82: 
                     83: void
                     84: gdCacheDelete( gdCache_head_t *head );
                     85: 
                     86: void *
                     87: gdCacheGet( gdCache_head_t *head, void *keydata );