# lv_cache_private.h (/api/misc/cache/lv_cache_private_h)
Enums [#enums]
lv_cache_reserve_cond_res_t [#lv_cache_reserve_cond_res_t]
The result of the cache reserve condition callback
| Name | Description |
| ----------------------------------- | ------------------------------------------------------------- |
| `LV_CACHE_RESERVE_COND_OK` | The condition is met and no entries need to be evicted |
| `LV_CACHE_RESERVE_COND_TOO_LARGE` | The condition is not met and the reserve size is too large |
| `LV_CACHE_RESERVE_COND_NEED_VICTIM` | The condition is not met and a victim is needed to be evicted |
| `LV_CACHE_RESERVE_COND_ERROR` | An error occurred while checking the condition |
Structs [#structs]
\_lv_cache_ops_t [#_lv_cache_ops_t]
The cache operations struct
| Member | Type | Description |
| ------------ | ---------------------------------------- | ------------------------- |
| `compare_cb` | | Compare function for keys |
| `create_cb` | | Create function for nodes |
| `free_cb` | | Free function for nodes |
\_lv_cache_t [#_lv_cache_t]
The cache entry struct
| Member | Type | Description |
| ----------- | ---------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `clz` | | Cache class. There are two built-in classes:
- lv\_cache\_class\_lru\_rb\_count for LRU-based cache with count-based eviction policy.
- lv\_cache\_class\_lru\_rb\_size for LRU-based cache with size-based eviction policy. |
| `node_size` | | Size of a node |
| `max_size` | | Maximum size of the cache |
| `size` | | Current size of the cache |
| `ops` | | Cache operations struct |
| `lock` | `lv_mutex_t` | Cache lock used to protect the cache in multithreading environments |
| `name` | `const char *` | Name of the cache |
\_lv_cache_class_t [#_lv_cache_class_t]
Cache class struct for building custom cache classes
Examples:
* lv\_cache\_class\_lru\_rb\_count for LRU-based cache with count-based eviction policy.
* lv\_cache\_class\_lru\_rb\_size for LRU-based cache with size-based eviction policy.
| Member | Type | Description |
| ----------------- | ------------------------------------------- | ------------------------------------------------ |
| `alloc_cb` | | The allocation function for cache entries |
| `init_cb` | | The initialization function for cache entries |
| `destroy_cb` | | The destruction function for cache entries |
| `get_cb` | | The get function for cache entries |
| `add_cb` | | The add function for cache entries |
| `remove_cb` | | The remove function for cache entries |
| `drop_cb` | | The drop function for cache entries |
| `drop_all_cb` | | The drop all function for cache entries |
| `get_victim_cb` | | The get victim function for cache entries |
| `reserve_cond_cb` | | The reserve condition function for cache entries |
| `iter_create_cb` | | The iterator creation function for cache entries |
\_lv_cache_slot_size_t [#_lv_cache_slot_size_t]
Cache entry slot struct
To add new fields to the cache entry, add them to a new struct and add it to the first field of the cache data struct. And this one is a size slot for the cache entry.
| Member | Type | Description |
| ------ | ------------------------- | ----------- |
| `size` | | |
Typedefs [#typedefs]
lv_cache_ops_t [#lv_cache_ops_t]
```c title=" " lineNumbers=1
typedef struct _lv_cache_ops_t lv_cache_ops_t
```
* `lv_cache_create` — param `ops`
lv_cache_class_t [#lv_cache_class_t]
```c title=" " lineNumbers=1
typedef struct _lv_cache_class_t lv_cache_class_t
```
* `lv_cache_create` — param `cache_class`
lv_cache_compare_res_t [#lv_cache_compare_res_t]
```c title=" " lineNumbers=1
typedef int32_t lv_cache_compare_res_t
```
lv_cache_create_cb_t [#lv_cache_create_cb_t]
```c title=" " lineNumbers=1
typedef bool(* lv_cache_create_cb_t) (void *node, void *user_data)
```
* `lv_cache_set_create_cb` — param `alloc_cb`
lv_cache_free_cb_t [#lv_cache_free_cb_t]
```c title=" " lineNumbers=1
typedef void(* lv_cache_free_cb_t) (void *node, void *user_data)
```
* `lv_cache_set_free_cb` — param `free_cb`
lv_cache_compare_cb_t [#lv_cache_compare_cb_t]
```c title=" " lineNumbers=1
typedef lv_cache_compare_res_t(* lv_cache_compare_cb_t) (const void *a, const void *b)
```
* `lv_cache_set_compare_cb` — param `compare_cb`
lv_cache_alloc_cb_t [#lv_cache_alloc_cb_t]
```c title=" " lineNumbers=1
typedef void *(* lv_cache_alloc_cb_t) (void)
```
The cache instance allocation function, used by the cache class to allocate memory for cache instances.
lv_cache_init_cb_t [#lv_cache_init_cb_t]
```c title=" " lineNumbers=1
typedef bool(* lv_cache_init_cb_t) (lv_cache_t *cache)
```
The cache instance initialization function, used by the cache class to initialize the cache instance.
lv_cache_destroy_cb_t [#lv_cache_destroy_cb_t]
```c title=" " lineNumbers=1
typedef void(* lv_cache_destroy_cb_t) (lv_cache_t *cache, void *user_data)
```
The cache instance destruction function, used by the cache class to destroy the cache instance.
lv_cache_get_cb_t [#lv_cache_get_cb_t]
```c title=" " lineNumbers=1
typedef lv_cache_entry_t *(* lv_cache_get_cb_t) (lv_cache_t *cache, const void *key, void *user_data)
```
The cache get function, used by the cache class to get a cache entry by its key.
lv_cache_add_cb_t [#lv_cache_add_cb_t]
```c title=" " lineNumbers=1
typedef lv_cache_entry_t *(* lv_cache_add_cb_t) (lv_cache_t *cache, const void *key, void *user_data)
```
The cache add function, used by the cache class to add a cache entry with a given key. This function only cares about how to add the entry, it doesn't check if the entry already exists and doesn't care about is it a victim or not.
lv_cache_remove_cb_t [#lv_cache_remove_cb_t]
```c title=" " lineNumbers=1
typedef void(* lv_cache_remove_cb_t) (lv_cache_t *cache, lv_cache_entry_t *entry, void *user_data)
```
The cache remove function, used by the cache class to remove a cache entry from the cache but doesn't free the memory.. This function only cares about how to remove the entry, it doesn't care about is it a victim or not.
lv_cache_drop_cb_t [#lv_cache_drop_cb_t]
```c title=" " lineNumbers=1
typedef void(* lv_cache_drop_cb_t) (lv_cache_t *cache, const void *key, void *user_data)
```
The cache drop function, used by the cache class to remove a cache entry from the cache and free the memory.
lv_cache_drop_all_cb_t [#lv_cache_drop_all_cb_t]
```c title=" " lineNumbers=1
typedef void(* lv_cache_drop_all_cb_t) (lv_cache_t *cache, void *user_data)
```
The cache drop all function, used by the cache class to remove all cache entries from the cache and free the memory.
lv_cache_get_victim_cb [#lv_cache_get_victim_cb]
```c title=" " lineNumbers=1
typedef lv_cache_entry_t *(* lv_cache_get_victim_cb) (lv_cache_t *cache, void *user_data)
```
The cache get victim function, used by the cache class to get a victim entry to be evicted.
lv_cache_reserve_cond_cb [#lv_cache_reserve_cond_cb]
```c title=" " lineNumbers=1
typedef lv_cache_reserve_cond_res_t(* lv_cache_reserve_cond_cb) (lv_cache_t *cache, const void *key, size_t size, void *user_data)
```
The cache reserve condition function, used by the cache class to check if a new entry can be added to the cache without exceeding its maximum size. See lv\_cache\_reserve\_cond\_res\_t for the possible results.
lv_cache_iter_create_cb [#lv_cache_iter_create_cb]
```c title=" " lineNumbers=1
typedef lv_iter_t *(* lv_cache_iter_create_cb) (lv_cache_t *cache)
```
The cache iterator creation function, used by the cache class to create an iterator for the cache.
lv_cache_slot_size_t [#lv_cache_slot_size_t]
```c title=" " lineNumbers=1
typedef struct _lv_cache_slot_size_t lv_cache_slot_size_t
```
Dependencies [#dependencies]