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.1     ! misho       1: /*
        !             2:  * $Id: gdcache.h 242949 2007-09-26 15:44:16Z cvs2svn $
        !             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 );