/***************************************************************************/ /* */ /* ftccache.h */ /* */ /* FreeType internal cache interface (specification). */ /* */ /* Copyright 2000-2001, 2002 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. */ /* */ /***************************************************************************/ #ifndef __FTCCACHE_H__ #define __FTCCACHE_H__ /* define to allow cache lookup inlining */ #define FTC_CACHE_USE_INLINE FT_BEGIN_HEADER /* handle to cache object */ typedef struct FTC_CacheRec_* FTC_Cache; /* handle to cache class */ typedef const struct FTC_Cache_ClassRec_* FTC_Cache_Class; /* handle to cache node family */ typedef struct FTC_FamilyRec_* FTC_Family; /* handle to cache root query */ typedef struct FTC_QueryRec_* FTC_Query; /*************************************************************************/ /*************************************************************************/ /***** *****/ /***** CACHE NODE DEFINITIONS *****/ /***** *****/ /*************************************************************************/ /*************************************************************************/ /*************************************************************************/ /* */ /* Each cache controls one or more cache nodes. Each node is part of */ /* the global_lru list of the manager. Its `data' field however is used */ /* as a reference count for now. */ /* */ /* A node can be anything, depending on the type of information held by */ /* the cache. It can be an individual glyph image, a set of bitmaps */ /* glyphs for a given size, some metrics, etc. */ /* */ /*************************************************************************/ /* structure size should be 20 bytes on 32-bits machines */ typedef struct FTC_NodeRec_ { FTC_Node mru_next; /* circular mru list pointer */ FTC_Node mru_prev; /* circular mru list pointer */ FTC_Node link; /* used for hashing */ FT_UInt32 hash; /* used for hashing too */ FT_UShort fam_index; /* index of family the node belongs to */ FT_Short ref_count; /* reference count for this node */ } FTC_NodeRec; #define FTC_NODE( x ) ( (FTC_Node)(x) ) #define FTC_NODE_P( x ) ( (FTC_Node*)(x) ) /*************************************************************************/ /* */ /* These functions are exported so that they can be called from */ /* user-provided cache classes; otherwise, they are really part of the */ /* cache sub-system internals. */ /* */ /* can be used as a FTC_Node_DoneFunc */ FT_EXPORT( void ) ftc_node_done( FTC_Node node, FTC_Cache cache ); /* reserved for manager's use */ FT_EXPORT( void ) ftc_node_destroy( FTC_Node node, FTC_Manager manager ); /*************************************************************************/ /*************************************************************************/ /***** *****/ /***** CACHE QUERY DEFINITIONS *****/ /***** *****/ /*************************************************************************/ /*************************************************************************/ /* A structure modelling a cache node query. The following fields must */ /* all be set by the @FTC_Family_CompareFunc method of a cache's family */ /* list. */ /* */ typedef struct FTC_QueryRec_ { FTC_Family family; FT_UFast hash; } FTC_QueryRec; #define FTC_QUERY( x ) ( (FTC_Query)(x) ) #define FTC_QUERY_P( x ) ( (FTC_Query*)(x) ) /*************************************************************************/ /*************************************************************************/ /***** *****/ /***** CACHE FAMILY DEFINITIONS *****/ /***** *****/ /*************************************************************************/ /*************************************************************************/ typedef struct FTC_FamilyRec_ { FT_LruNodeRec lru; FTC_Cache cache; FT_UInt num_nodes; FT_UInt fam_index; } FTC_FamilyRec; #define FTC_FAMILY( x ) ( (FTC_Family)(x) ) #define FTC_FAMILY_P( x ) ( (FTC_Family*)(x) ) /*************************************************************************/ /* */ /* These functions are exported so that they can be called from */ /* user-provided cache classes; otherwise, they are really part of the */ /* cache sub-system internals. */ /* */ /* must be called by any FTC_Node_InitFunc routine */ FT_EXPORT( FT_Error ) ftc_family_init( FTC_Family family, FTC_Query query, FTC_Cache cache ); /* can be used as a FTC_Family_DoneFunc; otherwise, must be called */ /* by any family finalizer function */ FT_EXPORT( void ) ftc_family_done( FTC_Family family ); /*************************************************************************/ /*************************************************************************/ /***** *****/ /***** CACHE DEFINITIONS *****/ /***** *****/ /*************************************************************************/ /*************************************************************************/ /* each cache really implements a dynamic hash table to manage its nodes */ typedef struct FTC_CacheRec_ { FTC_Manager manager; FT_Memory memory; FTC_Cache_Class clazz; FT_UInt cache_index; /* in manager's table */ FT_Pointer cache_data; /* used by cache node methods */ FT_UFast p; FT_UFast mask; FT_Long slack; FTC_Node* buckets; FT_LruList_ClassRec family_class; FT_LruList families; } FTC_CacheRec; #define FTC_CACHE( x ) ( (FTC_Cache)(x) ) #define FTC_CACHE_P( x ) ( (FTC_Cache*)(x) ) /* initialize a given cache */ typedef FT_Error (*FTC_Cache_InitFunc)( FTC_Cache cache ); /* clear a cache */ typedef void (*FTC_Cache_ClearFunc)( FTC_Cache cache ); /* finalize a given cache */ typedef void (*FTC_Cache_DoneFunc)( FTC_Cache cache ); typedef FT_Error (*FTC_Family_InitFunc)( FTC_Family family, FTC_Query query, FTC_Cache cache ); typedef FT_Int (*FTC_Family_CompareFunc)( FTC_Family family, FTC_Query query ); typedef void (*FTC_Family_DoneFunc)( FTC_Family family, FTC_Cache cache ); /* initialize a new cache node */ typedef FT_Error (*FTC_Node_InitFunc)( FTC_Node node, FT_Pointer type, FTC_Cache cache ); /* compute the weight of a given cache node */ typedef FT_ULong (*FTC_Node_WeightFunc)( FTC_Node node, FTC_Cache cache ); /* compare a node to a given key pair */ typedef FT_Bool (*FTC_Node_CompareFunc)( FTC_Node node, FT_Pointer key, FTC_Cache cache ); /* finalize a given cache node */ typedef void (*FTC_Node_DoneFunc)( FTC_Node node, FTC_Cache cache ); typedef struct FTC_Cache_ClassRec_ { FT_UInt cache_size; FTC_Cache_InitFunc cache_init; FTC_Cache_ClearFunc cache_clear; FTC_Cache_DoneFunc cache_done; FT_UInt family_size; FTC_Family_InitFunc family_init; FTC_Family_CompareFunc family_compare; FTC_Family_DoneFunc family_done; FT_UInt node_size; FTC_Node_InitFunc node_init; FTC_Node_WeightFunc node_weight; FTC_Node_CompareFunc node_compare; FTC_Node_DoneFunc node_done; } FTC_Cache_ClassRec; /* */ /*************************************************************************/ /* */ /* These functions are exported so that they can be called from */ /* user-provided cache classes; otherwise, they are really part of the */ /* cache sub-system internals. */ /* */ /* can be used directly as FTC_Cache_DoneFunc(), or called by custom */ /* cache finalizers */ FT_EXPORT( void ) ftc_cache_done( FTC_Cache cache ); /* can be used directly as FTC_Cache_ClearFunc(), or called by custom */ /* cache clear routines */ FT_EXPORT( void ) ftc_cache_clear( FTC_Cache cache ); /* initalize the hash table within the cache */ FT_EXPORT( FT_Error ) ftc_cache_init( FTC_Cache cache ); /* can be called when the key's hash value has been computed */ FT_EXPORT( FT_Error ) ftc_cache_lookup( FTC_Cache cache, FTC_Query query, FTC_Node *anode ); /* */ FT_END_HEADER #endif /* __FTCCACHE_H__ */ /* END */