20060303a

1 files changed, 202 insertions, 0 deletions

diff --git a/include/freetype/cache/ftlru.h b/include/freetype/cache/ftlru.h
new file mode 100644
index 00000000..9e4507ef
--- /dev/null
+++ b/include/freetype/cache/ftlru.h
@@ -0,0 +1,202 @@
+/***************************************************************************/
+/*                                                                         */
+/*  ftlru.h                                                                */
+/*                                                                         */
+/*    Simple LRU list-cache (specification).                               */
+/*                                                                         */
+/*  Copyright 2000-2001 by                                                 */
+/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+/*                                                                         */
+/*  This file is part of the FreeType project, and may only be used,       */
+/*  modified, and distributed under the terms of the FreeType project      */
+/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+/*  this file you indicate that you have read the license and              */
+/*  understand and accept it fully.                                        */
+/*                                                                         */
+/***************************************************************************/
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* An LRU is a list that cannot hold more than a certain number of       */
+  /* elements (`max_elements').  All elements in the list are sorted in    */
+  /* least-recently-used order, i.e., the `oldest' element is at the tail  */
+  /* of the list.                                                          */
+  /*                                                                       */
+  /* When doing a lookup (either through `Lookup()' or `Lookup_Node()'),   */
+  /* the list is searched for an element with the corresponding key.  If   */
+  /* it is found, the element is moved to the head of the list and is      */
+  /* returned.                                                             */
+  /*                                                                       */
+  /* If no corresponding element is found, the lookup routine will try to  */
+  /* obtain a new element with the relevant key.  If the list is already   */
+  /* full, the oldest element from the list is discarded and replaced by a */
+  /* new one; a new element is added to the list otherwise.                */
+  /*                                                                       */
+  /* Note that it is possible to pre-allocate the element list nodes.      */
+  /* This is handy if `max_elements' is sufficiently small, as it saves    */
+  /* allocations/releases during the lookup process.                       */
+  /*                                                                       */
+  /*************************************************************************/
+
+
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*********                                                       *********/
+  /*********             WARNING, THIS IS BETA CODE.               *********/
+  /*********                                                       *********/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+  /*************************************************************************/
+
+
+#ifndef __FTLRU_H__
+#define __FTLRU_H__
+
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+
+FT_BEGIN_HEADER
+
+
+  /* generic list key type */
+  typedef FT_Pointer  FT_LruKey;
+
+  /* a list list handle */
+  typedef struct FT_LruListRec_*  FT_LruList;
+
+  /* a list class handle */
+  typedef const struct FT_LruList_ClassRec_*  FT_LruList_Class;
+
+  /* a list node handle */
+  typedef struct FT_LruNodeRec_*  FT_LruNode;
+
+  /* the list node structure */
+  typedef struct  FT_LruNodeRec_
+  {
+    FT_LruNode  next;
+    FT_LruKey   key;
+
+  } FT_LruNodeRec;
+
+
+  /* the list structure */
+  typedef struct  FT_LruListRec_
+  {
+    FT_Memory         memory;
+    FT_LruList_Class  clazz;
+    FT_LruNode        nodes;
+    FT_UInt           max_nodes;
+    FT_UInt           num_nodes;
+    FT_Pointer        data;
+
+  } FT_LruListRec;
+
+
+  /* initialize a list list */
+  typedef FT_Error
+  (*FT_LruList_InitFunc)( FT_LruList  list );
+
+  /* finalize a list list */
+  typedef void
+  (*FT_LruList_DoneFunc)( FT_LruList  list );
+
+  /* this method is used to initialize a new list element node */
+  typedef FT_Error
+  (*FT_LruNode_InitFunc)( FT_LruNode  node,
+                          FT_LruKey   key,
+                          FT_Pointer  data );
+
+  /* this method is used to finalize a given list element node */
+  typedef void
+  (*FT_LruNode_DoneFunc)( FT_LruNode  node,
+                          FT_Pointer  data );
+
+  /* If defined, this method is called when the list if full        */
+  /* during the lookup process -- it is used to change the contents */
+  /* of a list element node instead of calling `done_element()',    */
+  /* then `init_element()'.  Set it to 0 for default behaviour.     */
+  typedef FT_Error
+  (*FT_LruNode_FlushFunc)( FT_LruNode  node,
+                           FT_LruKey   new_key,
+                           FT_Pointer  data );
+
+  /* If defined, this method is used to compare a list element node */
+  /* with a given key during a lookup.  If set to 0, the `key'      */
+  /* fields will be directly compared instead.                      */
+  typedef FT_Bool
+  (*FT_LruNode_CompareFunc)( FT_LruNode  node,
+                             FT_LruKey   key,
+                             FT_Pointer  data );
+
+  /* A selector is used to indicate whether a given list element node */
+  /* is part of a selection for FT_LruList_Remove_Selection().  The   */
+  /* functrion must return true (i.e., non-null) to indicate that the */
+  /* node is part of it.                                              */
+  typedef FT_Bool
+  (*FT_LruNode_SelectFunc)( FT_LruNode  node,
+                            FT_Pointer  data,
+                            FT_Pointer  list_data );
+
+  /* LRU class */
+  typedef struct  FT_LruList_ClassRec_
+  {
+    FT_UInt                 list_size;
+    FT_LruList_InitFunc     list_init;      /* optional */
+    FT_LruList_DoneFunc     list_done;      /* optional */
+
+    FT_UInt                 node_size;
+    FT_LruNode_InitFunc     node_init;     /* MANDATORY */
+    FT_LruNode_DoneFunc     node_done;     /* optional  */
+    FT_LruNode_FlushFunc    node_flush;    /* optional  */
+    FT_LruNode_CompareFunc  node_compare;  /* optional  */
+
+  } FT_LruList_ClassRec;
+
+
+  /* The following functions must be exported in the case where */
+  /* applications would want to write their own cache classes.  */
+
+  FT_EXPORT( FT_Error )
+  FT_LruList_New( FT_LruList_Class  clazz,
+                  FT_UInt           max_elements,
+                  FT_Pointer        user_data,
+                  FT_Memory         memory,
+                  FT_LruList       *alist );
+
+  FT_EXPORT( void )
+  FT_LruList_Reset( FT_LruList  list );
+
+  FT_EXPORT( void )
+  FT_LruList_Destroy ( FT_LruList  list );
+
+  FT_EXPORT( FT_Error )
+  FT_LruList_Lookup( FT_LruList  list,
+                     FT_LruKey   key,
+                     FT_LruNode *anode );
+
+  FT_EXPORT( void )
+  FT_LruList_Remove( FT_LruList  list,
+                     FT_LruNode  node );
+
+  FT_EXPORT( void )
+  FT_LruList_Remove_Selection( FT_LruList             list,
+                               FT_LruNode_SelectFunc  select_func,
+                               FT_Pointer             select_data );
+
+ /* */
+
+FT_END_HEADER
+
+
+#endif /* __FTLRU_H__ */
+
+
+/* END */