1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
/**
*
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version. The Blender
* Foundation also sells licenses for use in proprietary software under
* the Blender License. See http://www.blender.org/BL/ for information
* about this.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* Contributor(s): Peter Schlaile <peter@schlaile.de> 2005
*
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
#ifndef __MEM_cache_limiter_c_api_h_included__
#define __MEM_cache_limiter_c_api_h_included__ 1
#ifdef __cplusplus
extern "C" {
#endif
struct MEM_CacheLimiter_s;
struct MEM_CacheLimiterHandle_s;
typedef struct MEM_CacheLimiter_s MEM_CacheLimiterC;
typedef struct MEM_CacheLimiterHandle_s MEM_CacheLimiterHandleC;
#ifndef __MEM_cache_limiter_h_included__
extern void MEM_CacheLimiter_set_maximum(int m);
extern int MEM_CacheLimiter_get_maximum();
#endif
/**
* Create new MEM_CacheLimiter object
* managed objects are destructed with the data_destructor
*
* @param data_destructor
* @return A new MEM_CacheLimter object
*/
extern MEM_CacheLimiterC * new_MEM_CacheLimiter(
void (*data_destructor) (void * data));
/**
* Delete MEM_CacheLimiter
*
* Frees the memory of the CacheLimiter but does not touch managed objects!
*
* @param This "This" pointer
*/
extern void delete_MEM_CacheLimiter(MEM_CacheLimiterC * This);
/**
* Manage object
*
* @param This "This" pointer, data data object to manage
* @return CacheLimiterHandle to ref, unref, touch the managed object
*/
extern MEM_CacheLimiterHandleC * MEM_CacheLimiter_insert(
MEM_CacheLimiterC * This, void * data);
/**
* Free objects until memory constraints are satisfied
*
* @param This "This" pointer
*/
extern void MEM_CacheLimiter_enforce_limits(MEM_CacheLimiterC * This);
/**
* Unmanage object previously inserted object.
* Does _not_ delete managed object!
*
* @param This "This" pointer, handle of object
*/
extern void MEM_CacheLimiter_unmanage(MEM_CacheLimiterHandleC * handle);
/**
* Raise priority of object (put it at the tail of the deletion chain)
*
* @param handle of object
*/
extern void MEM_CacheLimiter_touch(MEM_CacheLimiterHandleC * handle);
/**
* Increment reference counter. Objects with reference counter != 0 are _not_
* deleted.
*
* @param handle of object
*/
extern void MEM_CacheLimiter_ref(MEM_CacheLimiterHandleC * handle);
/**
* Decrement reference counter. Objects with reference counter != 0 are _not_
* deleted.
*
* @param handle of object
*/
extern void MEM_CacheLimiter_unref(MEM_CacheLimiterHandleC * handle);
/**
* Get reference counter.
*
* @param This "This" pointer, handle of object
*/
extern int MEM_CacheLimiter_get_refcount(MEM_CacheLimiterHandleC * handle);
/**
* Get pointer to managed object
*
* @param handle of object
*/
extern void * MEM_CacheLimiter_get(MEM_CacheLimiterHandleC * handle);
#ifdef __cplusplus
}
#endif
#endif
|
