File Coverage

Shared.xs

Criterion	Covered	Total	%
statement	1100	2116	51.9
branch	777	3890	19.9
condition			n/a
subroutine			n/a
pod			n/a
total	1877	6006	31.2

line	stmt	bran	code
1			#define PERL_NO_GET_CONTEXT
2			#include "EXTERN.h"
3			#include "perl.h"
4			#include "XSUB.h"
5
6			#include "ppport.h"
7
8			#include "shm_i16.h"
9			#include "shm_i32.h"
10			#include "shm_ii.h"
11			#include "shm_i16s.h"
12			#include "shm_i32s.h"
13			#include "shm_is.h"
14			#include "shm_si16.h"
15			#include "shm_si32.h"
16			#include "shm_si.h"
17			#include "shm_ss.h"
18
19			#include "XSParseKeyword.h"
20
21			/* ---- Exception-safe lock guard for rdlock held across Perl API calls ---- */
22
23	18		static void shm_rdunlock_cleanup(pTHX_ void *ptr) {
24	18		ShmHeader hdr = (ShmHeader )ptr;
25	18		shm_rwlock_rdunlock(hdr);
26	18		}
27
28			#define RDLOCK_GUARD(hdr) \
29			shm_rwlock_rdlock(hdr); \
30			SAVEDESTRUCTOR_X(shm_rdunlock_cleanup, (void*)(hdr))
31
32			/* ---- Helper macros ---- */
33
34			#define EXTRACT_MAP(classname, sv) \
35			if (!sv_isobject(sv) \|\| !sv_derived_from(sv, classname)) \
36			croak("Expected a %s object", classname); \
37			ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(sv))); \
38			if (!h) croak("Attempted to use a destroyed %s object", classname)
39
40			#define EXTRACT_STR_KEY(sv) \
41			STRLEN _klen; \
42			const char* _kstr = SvPV(sv, _klen); \
43			if (_klen > SHM_MAX_STR_LEN) croak("key too long (max 2GB)"); \
44			bool _kutf8 = SvUTF8(sv) ? true : false
45
46			#define EXTRACT_STR_VAL(sv) \
47			STRLEN _vlen; \
48			const char* _vstr = SvPV(sv, _vlen); \
49			if (_vlen > SHM_MAX_STR_LEN) croak("value too long (max 2GB)"); \
50			bool _vutf8 = SvUTF8(sv) ? true : false
51
52			#define REQUIRE_TTL(h) \
53			if (!(h)->expires_at) croak("put_ttl requires a TTL-enabled map (pass ttl > 0 to constructor)")
54
55			#define EXTRACT_CURSOR(classname, sv) \
56			if (!sv_isobject(sv) \|\| !sv_derived_from(sv, classname)) \
57			croak("Expected a %s object", classname); \
58			ShmCursor* c = INT2PTR(ShmCursor*, SvIV(SvRV(sv))); \
59			if (!c) croak("Attempted to use a destroyed %s cursor", classname)
60
61			/* ---- Generic keyword build functions ---- */
62
63	116		static int build_kw_1arg(pTHX_ OP *out, XSParseKeywordPiece args[], size_t nargs, void *hookdata) {
64			(void)nargs;
65	116		const char func = (const char )hookdata;
66	116		OP *map_op = args[0]->op;
67	116		OP *cvref = newCVREF(0, newGVOP(OP_GV, 0, gv_fetchpv(func, GV_ADD, SVt_PVCV)));
68	116		OP *arglist = op_append_elem(OP_LIST, map_op, cvref);
69	116		*out = op_convert_list(OP_ENTERSUB, OPf_STACKED, arglist);
70	116		return KEYWORD_PLUGIN_EXPR;
71			}
72
73	179		static int build_kw_2arg(pTHX_ OP *out, XSParseKeywordPiece args[], size_t nargs, void *hookdata) {
74			(void)nargs;
75	179		const char func = (const char )hookdata;
76	179		OP *map_op = args[0]->op;
77	179		OP *key_op = args[1]->op;
78	179		OP *cvref = newCVREF(0, newGVOP(OP_GV, 0, gv_fetchpv(func, GV_ADD, SVt_PVCV)));
79	179		OP *arglist = op_append_elem(OP_LIST, map_op, key_op);
80	179		arglist = op_append_elem(OP_LIST, arglist, cvref);
81	179		*out = op_convert_list(OP_ENTERSUB, OPf_STACKED, arglist);
82	179		return KEYWORD_PLUGIN_EXPR;
83			}
84
85	204		static int build_kw_3arg(pTHX_ OP *out, XSParseKeywordPiece args[], size_t nargs, void *hookdata) {
86			(void)nargs;
87	204		const char func = (const char )hookdata;
88	204		OP *map_op = args[0]->op;
89	204		OP *key_op = args[1]->op;
90	204		OP *val_op = args[2]->op;
91	204		OP *cvref = newCVREF(0, newGVOP(OP_GV, 0, gv_fetchpv(func, GV_ADD, SVt_PVCV)));
92	204		OP *arglist = op_append_elem(OP_LIST, map_op, key_op);
93	204		arglist = op_append_elem(OP_LIST, arglist, val_op);
94	204		arglist = op_append_elem(OP_LIST, arglist, cvref);
95	204		*out = op_convert_list(OP_ENTERSUB, OPf_STACKED, arglist);
96	204		return KEYWORD_PLUGIN_EXPR;
97			}
98
99	13		static int build_kw_4arg(pTHX_ OP *out, XSParseKeywordPiece args[], size_t nargs, void *hookdata) {
100			(void)nargs;
101	13		const char func = (const char )hookdata;
102	13		OP *map_op = args[0]->op;
103	13		OP *key_op = args[1]->op;
104	13		OP *val_op = args[2]->op;
105	13		OP *ttl_op = args[3]->op;
106	13		OP *cvref = newCVREF(0, newGVOP(OP_GV, 0, gv_fetchpv(func, GV_ADD, SVt_PVCV)));
107	13		OP *arglist = op_append_elem(OP_LIST, map_op, key_op);
108	13		arglist = op_append_elem(OP_LIST, arglist, val_op);
109	13		arglist = op_append_elem(OP_LIST, arglist, ttl_op);
110	13		arglist = op_append_elem(OP_LIST, arglist, cvref);
111	13		*out = op_convert_list(OP_ENTERSUB, OPf_STACKED, arglist);
112	13		return KEYWORD_PLUGIN_EXPR;
113			}
114
115	36		static int build_kw_1arg_list(pTHX_ OP *out, XSParseKeywordPiece args[], size_t nargs, void *hookdata) {
116			(void)nargs;
117	36		const char func = (const char )hookdata;
118	36		OP *map_op = args[0]->op;
119	36		OP *cvref = newCVREF(0, newGVOP(OP_GV, 0, gv_fetchpv(func, GV_ADD, SVt_PVCV)));
120	36		OP *arglist = op_append_elem(OP_LIST, map_op, cvref);
121	36		*out = op_convert_list(OP_ENTERSUB, OPf_STACKED \| OPf_WANT_LIST, arglist);
122	36		return KEYWORD_PLUGIN_EXPR;
123			}
124
125			/* ---- Keyword pieces ---- */
126
127			static const struct XSParseKeywordPieceType pieces_1expr[] = {
128			XPK_TERMEXPR, {0}
129			};
130
131			static const struct XSParseKeywordPieceType pieces_2expr[] = {
132			XPK_TERMEXPR, XPK_COMMA, XPK_TERMEXPR, {0}
133			};
134
135			static const struct XSParseKeywordPieceType pieces_3expr[] = {
136			XPK_TERMEXPR, XPK_COMMA, XPK_TERMEXPR, XPK_COMMA, XPK_TERMEXPR, {0}
137			};
138
139			static const struct XSParseKeywordPieceType pieces_4expr[] = {
140			XPK_TERMEXPR, XPK_COMMA, XPK_TERMEXPR, XPK_COMMA, XPK_TERMEXPR, XPK_COMMA, XPK_TERMEXPR, {0}
141			};
142
143			/* ---- Keyword hook definitions ---- */
144
145			#define DEFINE_KW_HOOK(variant, PKG, kw, nargs, builder) \
146			static const struct XSParseKeywordHooks hooks_shm_##variant##_##kw = { \
147			.flags = XPK_FLAG_EXPR, \
148			.permit_hintkey = "Data::HashMap::Shared::" PKG "/shm_" #variant "_" #kw, \
149			.pieces = pieces_##nargs##expr, \
150			.build = builder, \
151			};
152
153			/* I16 (int16 -> int16, counters) */
154			DEFINE_KW_HOOK(i16, "I16", put, 3, build_kw_3arg)
155			DEFINE_KW_HOOK(i16, "I16", get, 2, build_kw_2arg)
156			DEFINE_KW_HOOK(i16, "I16", remove, 2, build_kw_2arg)
157			DEFINE_KW_HOOK(i16, "I16", exists, 2, build_kw_2arg)
158			DEFINE_KW_HOOK(i16, "I16", incr, 2, build_kw_2arg)
159			DEFINE_KW_HOOK(i16, "I16", decr, 2, build_kw_2arg)
160			DEFINE_KW_HOOK(i16, "I16", incr_by, 3, build_kw_3arg)
161			DEFINE_KW_HOOK(i16, "I16", size, 1, build_kw_1arg)
162			DEFINE_KW_HOOK(i16, "I16", keys, 1, build_kw_1arg_list)
163			DEFINE_KW_HOOK(i16, "I16", values, 1, build_kw_1arg_list)
164			DEFINE_KW_HOOK(i16, "I16", items, 1, build_kw_1arg_list)
165			DEFINE_KW_HOOK(i16, "I16", each, 1, build_kw_1arg_list)
166			DEFINE_KW_HOOK(i16, "I16", iter_reset, 1, build_kw_1arg)
167			DEFINE_KW_HOOK(i16, "I16", clear, 1, build_kw_1arg)
168			DEFINE_KW_HOOK(i16, "I16", to_hash, 1, build_kw_1arg)
169			DEFINE_KW_HOOK(i16, "I16", max_entries, 1, build_kw_1arg)
170			DEFINE_KW_HOOK(i16, "I16", get_or_set, 3, build_kw_3arg)
171			DEFINE_KW_HOOK(i16, "I16", put_ttl, 4, build_kw_4arg)
172			DEFINE_KW_HOOK(i16, "I16", max_size, 1, build_kw_1arg)
173			DEFINE_KW_HOOK(i16, "I16", ttl, 1, build_kw_1arg)
174			DEFINE_KW_HOOK(i16, "I16", cursor, 1, build_kw_1arg)
175			DEFINE_KW_HOOK(i16, "I16", cursor_next, 1, build_kw_1arg_list)
176			DEFINE_KW_HOOK(i16, "I16", cursor_reset, 1, build_kw_1arg)
177			DEFINE_KW_HOOK(i16, "I16", cursor_seek, 2, build_kw_2arg)
178			DEFINE_KW_HOOK(i16, "I16", ttl_remaining, 2, build_kw_2arg)
179			DEFINE_KW_HOOK(i16, "I16", capacity, 1, build_kw_1arg)
180			DEFINE_KW_HOOK(i16, "I16", tombstones, 1, build_kw_1arg)
181			DEFINE_KW_HOOK(i16, "I16", take, 2, build_kw_2arg)
182			DEFINE_KW_HOOK(i16, "I16", flush_expired, 1, build_kw_1arg)
183			DEFINE_KW_HOOK(i16, "I16", flush_expired_partial, 2, build_kw_2arg)
184			DEFINE_KW_HOOK(i16, "I16", mmap_size, 1, build_kw_1arg)
185			DEFINE_KW_HOOK(i16, "I16", touch, 2, build_kw_2arg)
186			DEFINE_KW_HOOK(i16, "I16", reserve, 2, build_kw_2arg)
187			DEFINE_KW_HOOK(i16, "I16", stat_evictions, 1, build_kw_1arg)
188			DEFINE_KW_HOOK(i16, "I16", stat_expired, 1, build_kw_1arg)
189			DEFINE_KW_HOOK(i16, "I16", stat_recoveries, 1, build_kw_1arg)
190
191			/* I32 (int32 -> int32, counters) */
192			DEFINE_KW_HOOK(i32, "I32", put, 3, build_kw_3arg)
193			DEFINE_KW_HOOK(i32, "I32", get, 2, build_kw_2arg)
194			DEFINE_KW_HOOK(i32, "I32", remove, 2, build_kw_2arg)
195			DEFINE_KW_HOOK(i32, "I32", exists, 2, build_kw_2arg)
196			DEFINE_KW_HOOK(i32, "I32", incr, 2, build_kw_2arg)
197			DEFINE_KW_HOOK(i32, "I32", decr, 2, build_kw_2arg)
198			DEFINE_KW_HOOK(i32, "I32", incr_by, 3, build_kw_3arg)
199			DEFINE_KW_HOOK(i32, "I32", size, 1, build_kw_1arg)
200			DEFINE_KW_HOOK(i32, "I32", keys, 1, build_kw_1arg_list)
201			DEFINE_KW_HOOK(i32, "I32", values, 1, build_kw_1arg_list)
202			DEFINE_KW_HOOK(i32, "I32", items, 1, build_kw_1arg_list)
203			DEFINE_KW_HOOK(i32, "I32", each, 1, build_kw_1arg_list)
204			DEFINE_KW_HOOK(i32, "I32", iter_reset, 1, build_kw_1arg)
205			DEFINE_KW_HOOK(i32, "I32", clear, 1, build_kw_1arg)
206			DEFINE_KW_HOOK(i32, "I32", to_hash, 1, build_kw_1arg)
207			DEFINE_KW_HOOK(i32, "I32", max_entries, 1, build_kw_1arg)
208			DEFINE_KW_HOOK(i32, "I32", get_or_set, 3, build_kw_3arg)
209			DEFINE_KW_HOOK(i32, "I32", put_ttl, 4, build_kw_4arg)
210			DEFINE_KW_HOOK(i32, "I32", max_size, 1, build_kw_1arg)
211			DEFINE_KW_HOOK(i32, "I32", ttl, 1, build_kw_1arg)
212			DEFINE_KW_HOOK(i32, "I32", cursor, 1, build_kw_1arg)
213			DEFINE_KW_HOOK(i32, "I32", cursor_next, 1, build_kw_1arg_list)
214			DEFINE_KW_HOOK(i32, "I32", cursor_reset, 1, build_kw_1arg)
215			DEFINE_KW_HOOK(i32, "I32", cursor_seek, 2, build_kw_2arg)
216			DEFINE_KW_HOOK(i32, "I32", ttl_remaining, 2, build_kw_2arg)
217			DEFINE_KW_HOOK(i32, "I32", capacity, 1, build_kw_1arg)
218			DEFINE_KW_HOOK(i32, "I32", tombstones, 1, build_kw_1arg)
219			DEFINE_KW_HOOK(i32, "I32", take, 2, build_kw_2arg)
220			DEFINE_KW_HOOK(i32, "I32", flush_expired, 1, build_kw_1arg)
221			DEFINE_KW_HOOK(i32, "I32", flush_expired_partial, 2, build_kw_2arg)
222			DEFINE_KW_HOOK(i32, "I32", mmap_size, 1, build_kw_1arg)
223			DEFINE_KW_HOOK(i32, "I32", touch, 2, build_kw_2arg)
224			DEFINE_KW_HOOK(i32, "I32", reserve, 2, build_kw_2arg)
225			DEFINE_KW_HOOK(i32, "I32", stat_evictions, 1, build_kw_1arg)
226			DEFINE_KW_HOOK(i32, "I32", stat_expired, 1, build_kw_1arg)
227			DEFINE_KW_HOOK(i32, "I32", stat_recoveries, 1, build_kw_1arg)
228
229			/* II (int64 -> int64, counters) */
230			DEFINE_KW_HOOK(ii, "II", put, 3, build_kw_3arg)
231			DEFINE_KW_HOOK(ii, "II", get, 2, build_kw_2arg)
232			DEFINE_KW_HOOK(ii, "II", remove, 2, build_kw_2arg)
233			DEFINE_KW_HOOK(ii, "II", exists, 2, build_kw_2arg)
234			DEFINE_KW_HOOK(ii, "II", incr, 2, build_kw_2arg)
235			DEFINE_KW_HOOK(ii, "II", decr, 2, build_kw_2arg)
236			DEFINE_KW_HOOK(ii, "II", incr_by, 3, build_kw_3arg)
237			DEFINE_KW_HOOK(ii, "II", size, 1, build_kw_1arg)
238			DEFINE_KW_HOOK(ii, "II", keys, 1, build_kw_1arg_list)
239			DEFINE_KW_HOOK(ii, "II", values, 1, build_kw_1arg_list)
240			DEFINE_KW_HOOK(ii, "II", items, 1, build_kw_1arg_list)
241			DEFINE_KW_HOOK(ii, "II", each, 1, build_kw_1arg_list)
242			DEFINE_KW_HOOK(ii, "II", iter_reset, 1, build_kw_1arg)
243			DEFINE_KW_HOOK(ii, "II", clear, 1, build_kw_1arg)
244			DEFINE_KW_HOOK(ii, "II", to_hash, 1, build_kw_1arg)
245			DEFINE_KW_HOOK(ii, "II", max_entries, 1, build_kw_1arg)
246			DEFINE_KW_HOOK(ii, "II", get_or_set, 3, build_kw_3arg)
247			DEFINE_KW_HOOK(ii, "II", put_ttl, 4, build_kw_4arg)
248			DEFINE_KW_HOOK(ii, "II", max_size, 1, build_kw_1arg)
249			DEFINE_KW_HOOK(ii, "II", ttl, 1, build_kw_1arg)
250			DEFINE_KW_HOOK(ii, "II", cursor, 1, build_kw_1arg)
251			DEFINE_KW_HOOK(ii, "II", cursor_next, 1, build_kw_1arg_list)
252			DEFINE_KW_HOOK(ii, "II", cursor_reset, 1, build_kw_1arg)
253			DEFINE_KW_HOOK(ii, "II", cursor_seek, 2, build_kw_2arg)
254			DEFINE_KW_HOOK(ii, "II", ttl_remaining, 2, build_kw_2arg)
255			DEFINE_KW_HOOK(ii, "II", capacity, 1, build_kw_1arg)
256			DEFINE_KW_HOOK(ii, "II", tombstones, 1, build_kw_1arg)
257			DEFINE_KW_HOOK(ii, "II", take, 2, build_kw_2arg)
258			DEFINE_KW_HOOK(ii, "II", flush_expired, 1, build_kw_1arg)
259			DEFINE_KW_HOOK(ii, "II", flush_expired_partial, 2, build_kw_2arg)
260			DEFINE_KW_HOOK(ii, "II", mmap_size, 1, build_kw_1arg)
261			DEFINE_KW_HOOK(ii, "II", touch, 2, build_kw_2arg)
262			DEFINE_KW_HOOK(ii, "II", reserve, 2, build_kw_2arg)
263			DEFINE_KW_HOOK(ii, "II", stat_evictions, 1, build_kw_1arg)
264			DEFINE_KW_HOOK(ii, "II", stat_expired, 1, build_kw_1arg)
265			DEFINE_KW_HOOK(ii, "II", stat_recoveries, 1, build_kw_1arg)
266
267			/* I16S (int16 -> string, no counters) */
268			DEFINE_KW_HOOK(i16s, "I16S", put, 3, build_kw_3arg)
269			DEFINE_KW_HOOK(i16s, "I16S", get, 2, build_kw_2arg)
270			DEFINE_KW_HOOK(i16s, "I16S", remove, 2, build_kw_2arg)
271			DEFINE_KW_HOOK(i16s, "I16S", exists, 2, build_kw_2arg)
272			DEFINE_KW_HOOK(i16s, "I16S", size, 1, build_kw_1arg)
273			DEFINE_KW_HOOK(i16s, "I16S", keys, 1, build_kw_1arg_list)
274			DEFINE_KW_HOOK(i16s, "I16S", values, 1, build_kw_1arg_list)
275			DEFINE_KW_HOOK(i16s, "I16S", items, 1, build_kw_1arg_list)
276			DEFINE_KW_HOOK(i16s, "I16S", each, 1, build_kw_1arg_list)
277			DEFINE_KW_HOOK(i16s, "I16S", iter_reset, 1, build_kw_1arg)
278			DEFINE_KW_HOOK(i16s, "I16S", clear, 1, build_kw_1arg)
279			DEFINE_KW_HOOK(i16s, "I16S", to_hash, 1, build_kw_1arg)
280			DEFINE_KW_HOOK(i16s, "I16S", max_entries, 1, build_kw_1arg)
281			DEFINE_KW_HOOK(i16s, "I16S", get_or_set, 3, build_kw_3arg)
282			DEFINE_KW_HOOK(i16s, "I16S", put_ttl, 4, build_kw_4arg)
283			DEFINE_KW_HOOK(i16s, "I16S", max_size, 1, build_kw_1arg)
284			DEFINE_KW_HOOK(i16s, "I16S", ttl, 1, build_kw_1arg)
285			DEFINE_KW_HOOK(i16s, "I16S", cursor, 1, build_kw_1arg)
286			DEFINE_KW_HOOK(i16s, "I16S", cursor_next, 1, build_kw_1arg_list)
287			DEFINE_KW_HOOK(i16s, "I16S", cursor_reset, 1, build_kw_1arg)
288			DEFINE_KW_HOOK(i16s, "I16S", cursor_seek, 2, build_kw_2arg)
289			DEFINE_KW_HOOK(i16s, "I16S", ttl_remaining, 2, build_kw_2arg)
290			DEFINE_KW_HOOK(i16s, "I16S", capacity, 1, build_kw_1arg)
291			DEFINE_KW_HOOK(i16s, "I16S", tombstones, 1, build_kw_1arg)
292			DEFINE_KW_HOOK(i16s, "I16S", take, 2, build_kw_2arg)
293			DEFINE_KW_HOOK(i16s, "I16S", flush_expired, 1, build_kw_1arg)
294			DEFINE_KW_HOOK(i16s, "I16S", flush_expired_partial, 2, build_kw_2arg)
295			DEFINE_KW_HOOK(i16s, "I16S", mmap_size, 1, build_kw_1arg)
296			DEFINE_KW_HOOK(i16s, "I16S", touch, 2, build_kw_2arg)
297			DEFINE_KW_HOOK(i16s, "I16S", reserve, 2, build_kw_2arg)
298			DEFINE_KW_HOOK(i16s, "I16S", stat_evictions, 1, build_kw_1arg)
299			DEFINE_KW_HOOK(i16s, "I16S", stat_expired, 1, build_kw_1arg)
300			DEFINE_KW_HOOK(i16s, "I16S", stat_recoveries, 1, build_kw_1arg)
301
302			/* I32S (int32 -> string, no counters) */
303			DEFINE_KW_HOOK(i32s, "I32S", put, 3, build_kw_3arg)
304			DEFINE_KW_HOOK(i32s, "I32S", get, 2, build_kw_2arg)
305			DEFINE_KW_HOOK(i32s, "I32S", remove, 2, build_kw_2arg)
306			DEFINE_KW_HOOK(i32s, "I32S", exists, 2, build_kw_2arg)
307			DEFINE_KW_HOOK(i32s, "I32S", size, 1, build_kw_1arg)
308			DEFINE_KW_HOOK(i32s, "I32S", keys, 1, build_kw_1arg_list)
309			DEFINE_KW_HOOK(i32s, "I32S", values, 1, build_kw_1arg_list)
310			DEFINE_KW_HOOK(i32s, "I32S", items, 1, build_kw_1arg_list)
311			DEFINE_KW_HOOK(i32s, "I32S", each, 1, build_kw_1arg_list)
312			DEFINE_KW_HOOK(i32s, "I32S", iter_reset, 1, build_kw_1arg)
313			DEFINE_KW_HOOK(i32s, "I32S", clear, 1, build_kw_1arg)
314			DEFINE_KW_HOOK(i32s, "I32S", to_hash, 1, build_kw_1arg)
315			DEFINE_KW_HOOK(i32s, "I32S", max_entries, 1, build_kw_1arg)
316			DEFINE_KW_HOOK(i32s, "I32S", get_or_set, 3, build_kw_3arg)
317			DEFINE_KW_HOOK(i32s, "I32S", put_ttl, 4, build_kw_4arg)
318			DEFINE_KW_HOOK(i32s, "I32S", max_size, 1, build_kw_1arg)
319			DEFINE_KW_HOOK(i32s, "I32S", ttl, 1, build_kw_1arg)
320			DEFINE_KW_HOOK(i32s, "I32S", cursor, 1, build_kw_1arg)
321			DEFINE_KW_HOOK(i32s, "I32S", cursor_next, 1, build_kw_1arg_list)
322			DEFINE_KW_HOOK(i32s, "I32S", cursor_reset, 1, build_kw_1arg)
323			DEFINE_KW_HOOK(i32s, "I32S", cursor_seek, 2, build_kw_2arg)
324			DEFINE_KW_HOOK(i32s, "I32S", ttl_remaining, 2, build_kw_2arg)
325			DEFINE_KW_HOOK(i32s, "I32S", capacity, 1, build_kw_1arg)
326			DEFINE_KW_HOOK(i32s, "I32S", tombstones, 1, build_kw_1arg)
327			DEFINE_KW_HOOK(i32s, "I32S", take, 2, build_kw_2arg)
328			DEFINE_KW_HOOK(i32s, "I32S", flush_expired, 1, build_kw_1arg)
329			DEFINE_KW_HOOK(i32s, "I32S", flush_expired_partial, 2, build_kw_2arg)
330			DEFINE_KW_HOOK(i32s, "I32S", mmap_size, 1, build_kw_1arg)
331			DEFINE_KW_HOOK(i32s, "I32S", touch, 2, build_kw_2arg)
332			DEFINE_KW_HOOK(i32s, "I32S", reserve, 2, build_kw_2arg)
333			DEFINE_KW_HOOK(i32s, "I32S", stat_evictions, 1, build_kw_1arg)
334			DEFINE_KW_HOOK(i32s, "I32S", stat_expired, 1, build_kw_1arg)
335			DEFINE_KW_HOOK(i32s, "I32S", stat_recoveries, 1, build_kw_1arg)
336
337			/* IS (int64 -> string, no counters) */
338			DEFINE_KW_HOOK(is, "IS", put, 3, build_kw_3arg)
339			DEFINE_KW_HOOK(is, "IS", get, 2, build_kw_2arg)
340			DEFINE_KW_HOOK(is, "IS", remove, 2, build_kw_2arg)
341			DEFINE_KW_HOOK(is, "IS", exists, 2, build_kw_2arg)
342			DEFINE_KW_HOOK(is, "IS", size, 1, build_kw_1arg)
343			DEFINE_KW_HOOK(is, "IS", keys, 1, build_kw_1arg_list)
344			DEFINE_KW_HOOK(is, "IS", values, 1, build_kw_1arg_list)
345			DEFINE_KW_HOOK(is, "IS", items, 1, build_kw_1arg_list)
346			DEFINE_KW_HOOK(is, "IS", each, 1, build_kw_1arg_list)
347			DEFINE_KW_HOOK(is, "IS", iter_reset, 1, build_kw_1arg)
348			DEFINE_KW_HOOK(is, "IS", clear, 1, build_kw_1arg)
349			DEFINE_KW_HOOK(is, "IS", to_hash, 1, build_kw_1arg)
350			DEFINE_KW_HOOK(is, "IS", max_entries, 1, build_kw_1arg)
351			DEFINE_KW_HOOK(is, "IS", get_or_set, 3, build_kw_3arg)
352			DEFINE_KW_HOOK(is, "IS", put_ttl, 4, build_kw_4arg)
353			DEFINE_KW_HOOK(is, "IS", max_size, 1, build_kw_1arg)
354			DEFINE_KW_HOOK(is, "IS", ttl, 1, build_kw_1arg)
355			DEFINE_KW_HOOK(is, "IS", cursor, 1, build_kw_1arg)
356			DEFINE_KW_HOOK(is, "IS", cursor_next, 1, build_kw_1arg_list)
357			DEFINE_KW_HOOK(is, "IS", cursor_reset, 1, build_kw_1arg)
358			DEFINE_KW_HOOK(is, "IS", cursor_seek, 2, build_kw_2arg)
359			DEFINE_KW_HOOK(is, "IS", ttl_remaining, 2, build_kw_2arg)
360			DEFINE_KW_HOOK(is, "IS", capacity, 1, build_kw_1arg)
361			DEFINE_KW_HOOK(is, "IS", tombstones, 1, build_kw_1arg)
362			DEFINE_KW_HOOK(is, "IS", take, 2, build_kw_2arg)
363			DEFINE_KW_HOOK(is, "IS", flush_expired, 1, build_kw_1arg)
364			DEFINE_KW_HOOK(is, "IS", flush_expired_partial, 2, build_kw_2arg)
365			DEFINE_KW_HOOK(is, "IS", mmap_size, 1, build_kw_1arg)
366			DEFINE_KW_HOOK(is, "IS", touch, 2, build_kw_2arg)
367			DEFINE_KW_HOOK(is, "IS", reserve, 2, build_kw_2arg)
368			DEFINE_KW_HOOK(is, "IS", stat_evictions, 1, build_kw_1arg)
369			DEFINE_KW_HOOK(is, "IS", stat_expired, 1, build_kw_1arg)
370			DEFINE_KW_HOOK(is, "IS", stat_recoveries, 1, build_kw_1arg)
371
372			/* SI16 (string -> int16, counters) */
373			DEFINE_KW_HOOK(si16, "SI16", put, 3, build_kw_3arg)
374			DEFINE_KW_HOOK(si16, "SI16", get, 2, build_kw_2arg)
375			DEFINE_KW_HOOK(si16, "SI16", remove, 2, build_kw_2arg)
376			DEFINE_KW_HOOK(si16, "SI16", exists, 2, build_kw_2arg)
377			DEFINE_KW_HOOK(si16, "SI16", incr, 2, build_kw_2arg)
378			DEFINE_KW_HOOK(si16, "SI16", decr, 2, build_kw_2arg)
379			DEFINE_KW_HOOK(si16, "SI16", incr_by, 3, build_kw_3arg)
380			DEFINE_KW_HOOK(si16, "SI16", size, 1, build_kw_1arg)
381			DEFINE_KW_HOOK(si16, "SI16", keys, 1, build_kw_1arg_list)
382			DEFINE_KW_HOOK(si16, "SI16", values, 1, build_kw_1arg_list)
383			DEFINE_KW_HOOK(si16, "SI16", items, 1, build_kw_1arg_list)
384			DEFINE_KW_HOOK(si16, "SI16", each, 1, build_kw_1arg_list)
385			DEFINE_KW_HOOK(si16, "SI16", iter_reset, 1, build_kw_1arg)
386			DEFINE_KW_HOOK(si16, "SI16", clear, 1, build_kw_1arg)
387			DEFINE_KW_HOOK(si16, "SI16", to_hash, 1, build_kw_1arg)
388			DEFINE_KW_HOOK(si16, "SI16", max_entries, 1, build_kw_1arg)
389			DEFINE_KW_HOOK(si16, "SI16", get_or_set, 3, build_kw_3arg)
390			DEFINE_KW_HOOK(si16, "SI16", put_ttl, 4, build_kw_4arg)
391			DEFINE_KW_HOOK(si16, "SI16", max_size, 1, build_kw_1arg)
392			DEFINE_KW_HOOK(si16, "SI16", ttl, 1, build_kw_1arg)
393			DEFINE_KW_HOOK(si16, "SI16", cursor, 1, build_kw_1arg)
394			DEFINE_KW_HOOK(si16, "SI16", cursor_next, 1, build_kw_1arg_list)
395			DEFINE_KW_HOOK(si16, "SI16", cursor_reset, 1, build_kw_1arg)
396			DEFINE_KW_HOOK(si16, "SI16", cursor_seek, 2, build_kw_2arg)
397			DEFINE_KW_HOOK(si16, "SI16", ttl_remaining, 2, build_kw_2arg)
398			DEFINE_KW_HOOK(si16, "SI16", capacity, 1, build_kw_1arg)
399			DEFINE_KW_HOOK(si16, "SI16", tombstones, 1, build_kw_1arg)
400			DEFINE_KW_HOOK(si16, "SI16", take, 2, build_kw_2arg)
401			DEFINE_KW_HOOK(si16, "SI16", flush_expired, 1, build_kw_1arg)
402			DEFINE_KW_HOOK(si16, "SI16", flush_expired_partial, 2, build_kw_2arg)
403			DEFINE_KW_HOOK(si16, "SI16", mmap_size, 1, build_kw_1arg)
404			DEFINE_KW_HOOK(si16, "SI16", touch, 2, build_kw_2arg)
405			DEFINE_KW_HOOK(si16, "SI16", reserve, 2, build_kw_2arg)
406			DEFINE_KW_HOOK(si16, "SI16", stat_evictions, 1, build_kw_1arg)
407			DEFINE_KW_HOOK(si16, "SI16", stat_expired, 1, build_kw_1arg)
408			DEFINE_KW_HOOK(si16, "SI16", stat_recoveries, 1, build_kw_1arg)
409
410			/* SI32 (string -> int32, counters) */
411			DEFINE_KW_HOOK(si32, "SI32", put, 3, build_kw_3arg)
412			DEFINE_KW_HOOK(si32, "SI32", get, 2, build_kw_2arg)
413			DEFINE_KW_HOOK(si32, "SI32", remove, 2, build_kw_2arg)
414			DEFINE_KW_HOOK(si32, "SI32", exists, 2, build_kw_2arg)
415			DEFINE_KW_HOOK(si32, "SI32", incr, 2, build_kw_2arg)
416			DEFINE_KW_HOOK(si32, "SI32", decr, 2, build_kw_2arg)
417			DEFINE_KW_HOOK(si32, "SI32", incr_by, 3, build_kw_3arg)
418			DEFINE_KW_HOOK(si32, "SI32", size, 1, build_kw_1arg)
419			DEFINE_KW_HOOK(si32, "SI32", keys, 1, build_kw_1arg_list)
420			DEFINE_KW_HOOK(si32, "SI32", values, 1, build_kw_1arg_list)
421			DEFINE_KW_HOOK(si32, "SI32", items, 1, build_kw_1arg_list)
422			DEFINE_KW_HOOK(si32, "SI32", each, 1, build_kw_1arg_list)
423			DEFINE_KW_HOOK(si32, "SI32", iter_reset, 1, build_kw_1arg)
424			DEFINE_KW_HOOK(si32, "SI32", clear, 1, build_kw_1arg)
425			DEFINE_KW_HOOK(si32, "SI32", to_hash, 1, build_kw_1arg)
426			DEFINE_KW_HOOK(si32, "SI32", max_entries, 1, build_kw_1arg)
427			DEFINE_KW_HOOK(si32, "SI32", get_or_set, 3, build_kw_3arg)
428			DEFINE_KW_HOOK(si32, "SI32", put_ttl, 4, build_kw_4arg)
429			DEFINE_KW_HOOK(si32, "SI32", max_size, 1, build_kw_1arg)
430			DEFINE_KW_HOOK(si32, "SI32", ttl, 1, build_kw_1arg)
431			DEFINE_KW_HOOK(si32, "SI32", cursor, 1, build_kw_1arg)
432			DEFINE_KW_HOOK(si32, "SI32", cursor_next, 1, build_kw_1arg_list)
433			DEFINE_KW_HOOK(si32, "SI32", cursor_reset, 1, build_kw_1arg)
434			DEFINE_KW_HOOK(si32, "SI32", cursor_seek, 2, build_kw_2arg)
435			DEFINE_KW_HOOK(si32, "SI32", ttl_remaining, 2, build_kw_2arg)
436			DEFINE_KW_HOOK(si32, "SI32", capacity, 1, build_kw_1arg)
437			DEFINE_KW_HOOK(si32, "SI32", tombstones, 1, build_kw_1arg)
438			DEFINE_KW_HOOK(si32, "SI32", take, 2, build_kw_2arg)
439			DEFINE_KW_HOOK(si32, "SI32", flush_expired, 1, build_kw_1arg)
440			DEFINE_KW_HOOK(si32, "SI32", flush_expired_partial, 2, build_kw_2arg)
441			DEFINE_KW_HOOK(si32, "SI32", mmap_size, 1, build_kw_1arg)
442			DEFINE_KW_HOOK(si32, "SI32", touch, 2, build_kw_2arg)
443			DEFINE_KW_HOOK(si32, "SI32", reserve, 2, build_kw_2arg)
444			DEFINE_KW_HOOK(si32, "SI32", stat_evictions, 1, build_kw_1arg)
445			DEFINE_KW_HOOK(si32, "SI32", stat_expired, 1, build_kw_1arg)
446			DEFINE_KW_HOOK(si32, "SI32", stat_recoveries, 1, build_kw_1arg)
447
448			/* SI (string -> int64, counters) */
449			DEFINE_KW_HOOK(si, "SI", put, 3, build_kw_3arg)
450			DEFINE_KW_HOOK(si, "SI", get, 2, build_kw_2arg)
451			DEFINE_KW_HOOK(si, "SI", remove, 2, build_kw_2arg)
452			DEFINE_KW_HOOK(si, "SI", exists, 2, build_kw_2arg)
453			DEFINE_KW_HOOK(si, "SI", incr, 2, build_kw_2arg)
454			DEFINE_KW_HOOK(si, "SI", decr, 2, build_kw_2arg)
455			DEFINE_KW_HOOK(si, "SI", incr_by, 3, build_kw_3arg)
456			DEFINE_KW_HOOK(si, "SI", size, 1, build_kw_1arg)
457			DEFINE_KW_HOOK(si, "SI", keys, 1, build_kw_1arg_list)
458			DEFINE_KW_HOOK(si, "SI", values, 1, build_kw_1arg_list)
459			DEFINE_KW_HOOK(si, "SI", items, 1, build_kw_1arg_list)
460			DEFINE_KW_HOOK(si, "SI", each, 1, build_kw_1arg_list)
461			DEFINE_KW_HOOK(si, "SI", iter_reset, 1, build_kw_1arg)
462			DEFINE_KW_HOOK(si, "SI", clear, 1, build_kw_1arg)
463			DEFINE_KW_HOOK(si, "SI", to_hash, 1, build_kw_1arg)
464			DEFINE_KW_HOOK(si, "SI", max_entries, 1, build_kw_1arg)
465			DEFINE_KW_HOOK(si, "SI", get_or_set, 3, build_kw_3arg)
466			DEFINE_KW_HOOK(si, "SI", put_ttl, 4, build_kw_4arg)
467			DEFINE_KW_HOOK(si, "SI", max_size, 1, build_kw_1arg)
468			DEFINE_KW_HOOK(si, "SI", ttl, 1, build_kw_1arg)
469			DEFINE_KW_HOOK(si, "SI", cursor, 1, build_kw_1arg)
470			DEFINE_KW_HOOK(si, "SI", cursor_next, 1, build_kw_1arg_list)
471			DEFINE_KW_HOOK(si, "SI", cursor_reset, 1, build_kw_1arg)
472			DEFINE_KW_HOOK(si, "SI", cursor_seek, 2, build_kw_2arg)
473			DEFINE_KW_HOOK(si, "SI", ttl_remaining, 2, build_kw_2arg)
474			DEFINE_KW_HOOK(si, "SI", capacity, 1, build_kw_1arg)
475			DEFINE_KW_HOOK(si, "SI", tombstones, 1, build_kw_1arg)
476			DEFINE_KW_HOOK(si, "SI", take, 2, build_kw_2arg)
477			DEFINE_KW_HOOK(si, "SI", flush_expired, 1, build_kw_1arg)
478			DEFINE_KW_HOOK(si, "SI", flush_expired_partial, 2, build_kw_2arg)
479			DEFINE_KW_HOOK(si, "SI", mmap_size, 1, build_kw_1arg)
480			DEFINE_KW_HOOK(si, "SI", touch, 2, build_kw_2arg)
481			DEFINE_KW_HOOK(si, "SI", reserve, 2, build_kw_2arg)
482			DEFINE_KW_HOOK(si, "SI", stat_evictions, 1, build_kw_1arg)
483			DEFINE_KW_HOOK(si, "SI", stat_expired, 1, build_kw_1arg)
484			DEFINE_KW_HOOK(si, "SI", stat_recoveries, 1, build_kw_1arg)
485
486			/* SS (string -> string, no counters) */
487			DEFINE_KW_HOOK(ss, "SS", put, 3, build_kw_3arg)
488			DEFINE_KW_HOOK(ss, "SS", get, 2, build_kw_2arg)
489			DEFINE_KW_HOOK(ss, "SS", remove, 2, build_kw_2arg)
490			DEFINE_KW_HOOK(ss, "SS", exists, 2, build_kw_2arg)
491			DEFINE_KW_HOOK(ss, "SS", size, 1, build_kw_1arg)
492			DEFINE_KW_HOOK(ss, "SS", keys, 1, build_kw_1arg_list)
493			DEFINE_KW_HOOK(ss, "SS", values, 1, build_kw_1arg_list)
494			DEFINE_KW_HOOK(ss, "SS", items, 1, build_kw_1arg_list)
495			DEFINE_KW_HOOK(ss, "SS", each, 1, build_kw_1arg_list)
496			DEFINE_KW_HOOK(ss, "SS", iter_reset, 1, build_kw_1arg)
497			DEFINE_KW_HOOK(ss, "SS", clear, 1, build_kw_1arg)
498			DEFINE_KW_HOOK(ss, "SS", to_hash, 1, build_kw_1arg)
499			DEFINE_KW_HOOK(ss, "SS", max_entries, 1, build_kw_1arg)
500			DEFINE_KW_HOOK(ss, "SS", get_or_set, 3, build_kw_3arg)
501			DEFINE_KW_HOOK(ss, "SS", put_ttl, 4, build_kw_4arg)
502			DEFINE_KW_HOOK(ss, "SS", max_size, 1, build_kw_1arg)
503			DEFINE_KW_HOOK(ss, "SS", ttl, 1, build_kw_1arg)
504			DEFINE_KW_HOOK(ss, "SS", cursor, 1, build_kw_1arg)
505			DEFINE_KW_HOOK(ss, "SS", cursor_next, 1, build_kw_1arg_list)
506			DEFINE_KW_HOOK(ss, "SS", cursor_reset, 1, build_kw_1arg)
507			DEFINE_KW_HOOK(ss, "SS", cursor_seek, 2, build_kw_2arg)
508			DEFINE_KW_HOOK(ss, "SS", ttl_remaining, 2, build_kw_2arg)
509			DEFINE_KW_HOOK(ss, "SS", capacity, 1, build_kw_1arg)
510			DEFINE_KW_HOOK(ss, "SS", tombstones, 1, build_kw_1arg)
511			DEFINE_KW_HOOK(ss, "SS", take, 2, build_kw_2arg)
512			DEFINE_KW_HOOK(ss, "SS", flush_expired, 1, build_kw_1arg)
513			DEFINE_KW_HOOK(ss, "SS", flush_expired_partial, 2, build_kw_2arg)
514			DEFINE_KW_HOOK(ss, "SS", mmap_size, 1, build_kw_1arg)
515			DEFINE_KW_HOOK(ss, "SS", touch, 2, build_kw_2arg)
516			DEFINE_KW_HOOK(ss, "SS", reserve, 2, build_kw_2arg)
517			DEFINE_KW_HOOK(ss, "SS", stat_evictions, 1, build_kw_1arg)
518			DEFINE_KW_HOOK(ss, "SS", stat_expired, 1, build_kw_1arg)
519			DEFINE_KW_HOOK(ss, "SS", stat_recoveries, 1, build_kw_1arg)
520
521			/* ---- Register keyword macro ---- */
522
523			#define REGISTER_KW(variant, kw, func_name) \
524			register_xs_parse_keyword("shm_" #variant "_" #kw, \
525			&hooks_shm_##variant##_##kw, (void*)func_name)
526
527
528			/* ============================================================
529			* MODULE/PACKAGE sections
530			* ============================================================ */
531
532			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::I16
533			PROTOTYPES: DISABLE
534
535			BOOT:
536	10		boot_xs_parse_keyword(0.40);
537			/* I16 */
538	10		REGISTER_KW(i16, put, "Data::HashMap::Shared::I16::put");
539	10		REGISTER_KW(i16, get, "Data::HashMap::Shared::I16::get");
540	10		REGISTER_KW(i16, remove, "Data::HashMap::Shared::I16::remove");
541	10		REGISTER_KW(i16, exists, "Data::HashMap::Shared::I16::exists");
542	10		REGISTER_KW(i16, incr, "Data::HashMap::Shared::I16::incr");
543	10		REGISTER_KW(i16, decr, "Data::HashMap::Shared::I16::decr");
544	10		REGISTER_KW(i16, incr_by, "Data::HashMap::Shared::I16::incr_by");
545	10		REGISTER_KW(i16, size, "Data::HashMap::Shared::I16::size");
546	10		REGISTER_KW(i16, keys, "Data::HashMap::Shared::I16::keys");
547	10		REGISTER_KW(i16, values, "Data::HashMap::Shared::I16::values");
548	10		REGISTER_KW(i16, items, "Data::HashMap::Shared::I16::items");
549	10		REGISTER_KW(i16, each, "Data::HashMap::Shared::I16::each");
550	10		REGISTER_KW(i16, iter_reset, "Data::HashMap::Shared::I16::iter_reset");
551	10		REGISTER_KW(i16, clear, "Data::HashMap::Shared::I16::clear");
552	10		REGISTER_KW(i16, to_hash, "Data::HashMap::Shared::I16::to_hash");
553	10		REGISTER_KW(i16, max_entries, "Data::HashMap::Shared::I16::max_entries");
554	10		REGISTER_KW(i16, get_or_set, "Data::HashMap::Shared::I16::get_or_set");
555	10		REGISTER_KW(i16, put_ttl, "Data::HashMap::Shared::I16::put_ttl");
556	10		REGISTER_KW(i16, max_size, "Data::HashMap::Shared::I16::max_size");
557	10		REGISTER_KW(i16, ttl, "Data::HashMap::Shared::I16::ttl");
558	10		REGISTER_KW(i16, cursor, "Data::HashMap::Shared::I16::cursor");
559	10		REGISTER_KW(i16, cursor_next, "Data::HashMap::Shared::I16::Cursor::next");
560	10		REGISTER_KW(i16, cursor_reset, "Data::HashMap::Shared::I16::Cursor::reset");
561	10		REGISTER_KW(i16, cursor_seek, "Data::HashMap::Shared::I16::Cursor::seek");
562	10		REGISTER_KW(i16, ttl_remaining, "Data::HashMap::Shared::I16::ttl_remaining");
563	10		REGISTER_KW(i16, capacity, "Data::HashMap::Shared::I16::capacity");
564	10		REGISTER_KW(i16, tombstones, "Data::HashMap::Shared::I16::tombstones");
565	10		REGISTER_KW(i16, take, "Data::HashMap::Shared::I16::take");
566	10		REGISTER_KW(i16, flush_expired, "Data::HashMap::Shared::I16::flush_expired");
567	10		REGISTER_KW(i16, flush_expired_partial, "Data::HashMap::Shared::I16::flush_expired_partial");
568	10		REGISTER_KW(i16, mmap_size, "Data::HashMap::Shared::I16::mmap_size");
569	10		REGISTER_KW(i16, touch, "Data::HashMap::Shared::I16::touch");
570	10		REGISTER_KW(i16, reserve, "Data::HashMap::Shared::I16::reserve");
571	10		REGISTER_KW(i16, stat_evictions, "Data::HashMap::Shared::I16::stat_evictions");
572	10		REGISTER_KW(i16, stat_expired, "Data::HashMap::Shared::I16::stat_expired");
573	10		REGISTER_KW(i16, stat_recoveries, "Data::HashMap::Shared::I16::stat_recoveries");
574	10		REGISTER_KW(i32, put, "Data::HashMap::Shared::I32::put");
575	10		REGISTER_KW(i32, get, "Data::HashMap::Shared::I32::get");
576	10		REGISTER_KW(i32, remove, "Data::HashMap::Shared::I32::remove");
577	10		REGISTER_KW(i32, exists, "Data::HashMap::Shared::I32::exists");
578	10		REGISTER_KW(i32, incr, "Data::HashMap::Shared::I32::incr");
579	10		REGISTER_KW(i32, decr, "Data::HashMap::Shared::I32::decr");
580	10		REGISTER_KW(i32, incr_by, "Data::HashMap::Shared::I32::incr_by");
581	10		REGISTER_KW(i32, size, "Data::HashMap::Shared::I32::size");
582	10		REGISTER_KW(i32, keys, "Data::HashMap::Shared::I32::keys");
583	10		REGISTER_KW(i32, values, "Data::HashMap::Shared::I32::values");
584	10		REGISTER_KW(i32, items, "Data::HashMap::Shared::I32::items");
585	10		REGISTER_KW(i32, each, "Data::HashMap::Shared::I32::each");
586	10		REGISTER_KW(i32, iter_reset, "Data::HashMap::Shared::I32::iter_reset");
587	10		REGISTER_KW(i32, clear, "Data::HashMap::Shared::I32::clear");
588	10		REGISTER_KW(i32, to_hash, "Data::HashMap::Shared::I32::to_hash");
589	10		REGISTER_KW(i32, max_entries, "Data::HashMap::Shared::I32::max_entries");
590	10		REGISTER_KW(i32, get_or_set, "Data::HashMap::Shared::I32::get_or_set");
591	10		REGISTER_KW(i32, put_ttl, "Data::HashMap::Shared::I32::put_ttl");
592	10		REGISTER_KW(i32, max_size, "Data::HashMap::Shared::I32::max_size");
593	10		REGISTER_KW(i32, ttl, "Data::HashMap::Shared::I32::ttl");
594	10		REGISTER_KW(i32, cursor, "Data::HashMap::Shared::I32::cursor");
595	10		REGISTER_KW(i32, cursor_next, "Data::HashMap::Shared::I32::Cursor::next");
596	10		REGISTER_KW(i32, cursor_reset, "Data::HashMap::Shared::I32::Cursor::reset");
597	10		REGISTER_KW(i32, cursor_seek, "Data::HashMap::Shared::I32::Cursor::seek");
598	10		REGISTER_KW(i32, ttl_remaining, "Data::HashMap::Shared::I32::ttl_remaining");
599	10		REGISTER_KW(i32, capacity, "Data::HashMap::Shared::I32::capacity");
600	10		REGISTER_KW(i32, tombstones, "Data::HashMap::Shared::I32::tombstones");
601	10		REGISTER_KW(i32, take, "Data::HashMap::Shared::I32::take");
602	10		REGISTER_KW(i32, flush_expired, "Data::HashMap::Shared::I32::flush_expired");
603	10		REGISTER_KW(i32, flush_expired_partial, "Data::HashMap::Shared::I32::flush_expired_partial");
604	10		REGISTER_KW(i32, mmap_size, "Data::HashMap::Shared::I32::mmap_size");
605	10		REGISTER_KW(i32, touch, "Data::HashMap::Shared::I32::touch");
606	10		REGISTER_KW(i32, reserve, "Data::HashMap::Shared::I32::reserve");
607	10		REGISTER_KW(i32, stat_evictions, "Data::HashMap::Shared::I32::stat_evictions");
608	10		REGISTER_KW(i32, stat_expired, "Data::HashMap::Shared::I32::stat_expired");
609	10		REGISTER_KW(i32, stat_recoveries, "Data::HashMap::Shared::I32::stat_recoveries");
610	10		REGISTER_KW(ii, put, "Data::HashMap::Shared::II::put");
611	10		REGISTER_KW(ii, get, "Data::HashMap::Shared::II::get");
612	10		REGISTER_KW(ii, remove, "Data::HashMap::Shared::II::remove");
613	10		REGISTER_KW(ii, exists, "Data::HashMap::Shared::II::exists");
614	10		REGISTER_KW(ii, incr, "Data::HashMap::Shared::II::incr");
615	10		REGISTER_KW(ii, decr, "Data::HashMap::Shared::II::decr");
616	10		REGISTER_KW(ii, incr_by, "Data::HashMap::Shared::II::incr_by");
617	10		REGISTER_KW(ii, size, "Data::HashMap::Shared::II::size");
618	10		REGISTER_KW(ii, keys, "Data::HashMap::Shared::II::keys");
619	10		REGISTER_KW(ii, values, "Data::HashMap::Shared::II::values");
620	10		REGISTER_KW(ii, items, "Data::HashMap::Shared::II::items");
621	10		REGISTER_KW(ii, each, "Data::HashMap::Shared::II::each");
622	10		REGISTER_KW(ii, iter_reset, "Data::HashMap::Shared::II::iter_reset");
623	10		REGISTER_KW(ii, clear, "Data::HashMap::Shared::II::clear");
624	10		REGISTER_KW(ii, to_hash, "Data::HashMap::Shared::II::to_hash");
625	10		REGISTER_KW(ii, max_entries, "Data::HashMap::Shared::II::max_entries");
626	10		REGISTER_KW(ii, get_or_set, "Data::HashMap::Shared::II::get_or_set");
627	10		REGISTER_KW(ii, put_ttl, "Data::HashMap::Shared::II::put_ttl");
628	10		REGISTER_KW(ii, max_size, "Data::HashMap::Shared::II::max_size");
629	10		REGISTER_KW(ii, ttl, "Data::HashMap::Shared::II::ttl");
630	10		REGISTER_KW(ii, cursor, "Data::HashMap::Shared::II::cursor");
631	10		REGISTER_KW(ii, cursor_next, "Data::HashMap::Shared::II::Cursor::next");
632	10		REGISTER_KW(ii, cursor_reset, "Data::HashMap::Shared::II::Cursor::reset");
633	10		REGISTER_KW(ii, cursor_seek, "Data::HashMap::Shared::II::Cursor::seek");
634	10		REGISTER_KW(ii, ttl_remaining, "Data::HashMap::Shared::II::ttl_remaining");
635	10		REGISTER_KW(ii, capacity, "Data::HashMap::Shared::II::capacity");
636	10		REGISTER_KW(ii, tombstones, "Data::HashMap::Shared::II::tombstones");
637	10		REGISTER_KW(ii, take, "Data::HashMap::Shared::II::take");
638	10		REGISTER_KW(ii, flush_expired, "Data::HashMap::Shared::II::flush_expired");
639	10		REGISTER_KW(ii, flush_expired_partial, "Data::HashMap::Shared::II::flush_expired_partial");
640	10		REGISTER_KW(ii, mmap_size, "Data::HashMap::Shared::II::mmap_size");
641	10		REGISTER_KW(ii, touch, "Data::HashMap::Shared::II::touch");
642	10		REGISTER_KW(ii, reserve, "Data::HashMap::Shared::II::reserve");
643	10		REGISTER_KW(ii, stat_evictions, "Data::HashMap::Shared::II::stat_evictions");
644	10		REGISTER_KW(ii, stat_expired, "Data::HashMap::Shared::II::stat_expired");
645	10		REGISTER_KW(ii, stat_recoveries, "Data::HashMap::Shared::II::stat_recoveries");
646	10		REGISTER_KW(i16s, put, "Data::HashMap::Shared::I16S::put");
647	10		REGISTER_KW(i16s, get, "Data::HashMap::Shared::I16S::get");
648	10		REGISTER_KW(i16s, remove, "Data::HashMap::Shared::I16S::remove");
649	10		REGISTER_KW(i16s, exists, "Data::HashMap::Shared::I16S::exists");
650	10		REGISTER_KW(i16s, size, "Data::HashMap::Shared::I16S::size");
651	10		REGISTER_KW(i16s, keys, "Data::HashMap::Shared::I16S::keys");
652	10		REGISTER_KW(i16s, values, "Data::HashMap::Shared::I16S::values");
653	10		REGISTER_KW(i16s, items, "Data::HashMap::Shared::I16S::items");
654	10		REGISTER_KW(i16s, each, "Data::HashMap::Shared::I16S::each");
655	10		REGISTER_KW(i16s, iter_reset, "Data::HashMap::Shared::I16S::iter_reset");
656	10		REGISTER_KW(i16s, clear, "Data::HashMap::Shared::I16S::clear");
657	10		REGISTER_KW(i16s, to_hash, "Data::HashMap::Shared::I16S::to_hash");
658	10		REGISTER_KW(i16s, max_entries, "Data::HashMap::Shared::I16S::max_entries");
659	10		REGISTER_KW(i16s, get_or_set, "Data::HashMap::Shared::I16S::get_or_set");
660	10		REGISTER_KW(i16s, put_ttl, "Data::HashMap::Shared::I16S::put_ttl");
661	10		REGISTER_KW(i16s, max_size, "Data::HashMap::Shared::I16S::max_size");
662	10		REGISTER_KW(i16s, ttl, "Data::HashMap::Shared::I16S::ttl");
663	10		REGISTER_KW(i16s, cursor, "Data::HashMap::Shared::I16S::cursor");
664	10		REGISTER_KW(i16s, cursor_next, "Data::HashMap::Shared::I16S::Cursor::next");
665	10		REGISTER_KW(i16s, cursor_reset, "Data::HashMap::Shared::I16S::Cursor::reset");
666	10		REGISTER_KW(i16s, cursor_seek, "Data::HashMap::Shared::I16S::Cursor::seek");
667	10		REGISTER_KW(i16s, ttl_remaining, "Data::HashMap::Shared::I16S::ttl_remaining");
668	10		REGISTER_KW(i16s, capacity, "Data::HashMap::Shared::I16S::capacity");
669	10		REGISTER_KW(i16s, tombstones, "Data::HashMap::Shared::I16S::tombstones");
670	10		REGISTER_KW(i16s, take, "Data::HashMap::Shared::I16S::take");
671	10		REGISTER_KW(i16s, flush_expired, "Data::HashMap::Shared::I16S::flush_expired");
672	10		REGISTER_KW(i16s, flush_expired_partial, "Data::HashMap::Shared::I16S::flush_expired_partial");
673	10		REGISTER_KW(i16s, mmap_size, "Data::HashMap::Shared::I16S::mmap_size");
674	10		REGISTER_KW(i16s, touch, "Data::HashMap::Shared::I16S::touch");
675	10		REGISTER_KW(i16s, reserve, "Data::HashMap::Shared::I16S::reserve");
676	10		REGISTER_KW(i16s, stat_evictions, "Data::HashMap::Shared::I16S::stat_evictions");
677	10		REGISTER_KW(i16s, stat_expired, "Data::HashMap::Shared::I16S::stat_expired");
678	10		REGISTER_KW(i16s, stat_recoveries, "Data::HashMap::Shared::I16S::stat_recoveries");
679	10		REGISTER_KW(i32s, put, "Data::HashMap::Shared::I32S::put");
680	10		REGISTER_KW(i32s, get, "Data::HashMap::Shared::I32S::get");
681	10		REGISTER_KW(i32s, remove, "Data::HashMap::Shared::I32S::remove");
682	10		REGISTER_KW(i32s, exists, "Data::HashMap::Shared::I32S::exists");
683	10		REGISTER_KW(i32s, size, "Data::HashMap::Shared::I32S::size");
684	10		REGISTER_KW(i32s, keys, "Data::HashMap::Shared::I32S::keys");
685	10		REGISTER_KW(i32s, values, "Data::HashMap::Shared::I32S::values");
686	10		REGISTER_KW(i32s, items, "Data::HashMap::Shared::I32S::items");
687	10		REGISTER_KW(i32s, each, "Data::HashMap::Shared::I32S::each");
688	10		REGISTER_KW(i32s, iter_reset, "Data::HashMap::Shared::I32S::iter_reset");
689	10		REGISTER_KW(i32s, clear, "Data::HashMap::Shared::I32S::clear");
690	10		REGISTER_KW(i32s, to_hash, "Data::HashMap::Shared::I32S::to_hash");
691	10		REGISTER_KW(i32s, max_entries, "Data::HashMap::Shared::I32S::max_entries");
692	10		REGISTER_KW(i32s, get_or_set, "Data::HashMap::Shared::I32S::get_or_set");
693	10		REGISTER_KW(i32s, put_ttl, "Data::HashMap::Shared::I32S::put_ttl");
694	10		REGISTER_KW(i32s, max_size, "Data::HashMap::Shared::I32S::max_size");
695	10		REGISTER_KW(i32s, ttl, "Data::HashMap::Shared::I32S::ttl");
696	10		REGISTER_KW(i32s, cursor, "Data::HashMap::Shared::I32S::cursor");
697	10		REGISTER_KW(i32s, cursor_next, "Data::HashMap::Shared::I32S::Cursor::next");
698	10		REGISTER_KW(i32s, cursor_reset, "Data::HashMap::Shared::I32S::Cursor::reset");
699	10		REGISTER_KW(i32s, cursor_seek, "Data::HashMap::Shared::I32S::Cursor::seek");
700	10		REGISTER_KW(i32s, ttl_remaining, "Data::HashMap::Shared::I32S::ttl_remaining");
701	10		REGISTER_KW(i32s, capacity, "Data::HashMap::Shared::I32S::capacity");
702	10		REGISTER_KW(i32s, tombstones, "Data::HashMap::Shared::I32S::tombstones");
703	10		REGISTER_KW(i32s, take, "Data::HashMap::Shared::I32S::take");
704	10		REGISTER_KW(i32s, flush_expired, "Data::HashMap::Shared::I32S::flush_expired");
705	10		REGISTER_KW(i32s, flush_expired_partial, "Data::HashMap::Shared::I32S::flush_expired_partial");
706	10		REGISTER_KW(i32s, mmap_size, "Data::HashMap::Shared::I32S::mmap_size");
707	10		REGISTER_KW(i32s, touch, "Data::HashMap::Shared::I32S::touch");
708	10		REGISTER_KW(i32s, reserve, "Data::HashMap::Shared::I32S::reserve");
709	10		REGISTER_KW(i32s, stat_evictions, "Data::HashMap::Shared::I32S::stat_evictions");
710	10		REGISTER_KW(i32s, stat_expired, "Data::HashMap::Shared::I32S::stat_expired");
711	10		REGISTER_KW(i32s, stat_recoveries, "Data::HashMap::Shared::I32S::stat_recoveries");
712	10		REGISTER_KW(is, put, "Data::HashMap::Shared::IS::put");
713	10		REGISTER_KW(is, get, "Data::HashMap::Shared::IS::get");
714	10		REGISTER_KW(is, remove, "Data::HashMap::Shared::IS::remove");
715	10		REGISTER_KW(is, exists, "Data::HashMap::Shared::IS::exists");
716	10		REGISTER_KW(is, size, "Data::HashMap::Shared::IS::size");
717	10		REGISTER_KW(is, keys, "Data::HashMap::Shared::IS::keys");
718	10		REGISTER_KW(is, values, "Data::HashMap::Shared::IS::values");
719	10		REGISTER_KW(is, items, "Data::HashMap::Shared::IS::items");
720	10		REGISTER_KW(is, each, "Data::HashMap::Shared::IS::each");
721	10		REGISTER_KW(is, iter_reset, "Data::HashMap::Shared::IS::iter_reset");
722	10		REGISTER_KW(is, clear, "Data::HashMap::Shared::IS::clear");
723	10		REGISTER_KW(is, to_hash, "Data::HashMap::Shared::IS::to_hash");
724	10		REGISTER_KW(is, max_entries, "Data::HashMap::Shared::IS::max_entries");
725	10		REGISTER_KW(is, get_or_set, "Data::HashMap::Shared::IS::get_or_set");
726	10		REGISTER_KW(is, put_ttl, "Data::HashMap::Shared::IS::put_ttl");
727	10		REGISTER_KW(is, max_size, "Data::HashMap::Shared::IS::max_size");
728	10		REGISTER_KW(is, ttl, "Data::HashMap::Shared::IS::ttl");
729	10		REGISTER_KW(is, cursor, "Data::HashMap::Shared::IS::cursor");
730	10		REGISTER_KW(is, cursor_next, "Data::HashMap::Shared::IS::Cursor::next");
731	10		REGISTER_KW(is, cursor_reset, "Data::HashMap::Shared::IS::Cursor::reset");
732	10		REGISTER_KW(is, cursor_seek, "Data::HashMap::Shared::IS::Cursor::seek");
733	10		REGISTER_KW(is, ttl_remaining, "Data::HashMap::Shared::IS::ttl_remaining");
734	10		REGISTER_KW(is, capacity, "Data::HashMap::Shared::IS::capacity");
735	10		REGISTER_KW(is, tombstones, "Data::HashMap::Shared::IS::tombstones");
736	10		REGISTER_KW(is, take, "Data::HashMap::Shared::IS::take");
737	10		REGISTER_KW(is, flush_expired, "Data::HashMap::Shared::IS::flush_expired");
738	10		REGISTER_KW(is, flush_expired_partial, "Data::HashMap::Shared::IS::flush_expired_partial");
739	10		REGISTER_KW(is, mmap_size, "Data::HashMap::Shared::IS::mmap_size");
740	10		REGISTER_KW(is, touch, "Data::HashMap::Shared::IS::touch");
741	10		REGISTER_KW(is, reserve, "Data::HashMap::Shared::IS::reserve");
742	10		REGISTER_KW(is, stat_evictions, "Data::HashMap::Shared::IS::stat_evictions");
743	10		REGISTER_KW(is, stat_expired, "Data::HashMap::Shared::IS::stat_expired");
744	10		REGISTER_KW(is, stat_recoveries, "Data::HashMap::Shared::IS::stat_recoveries");
745	10		REGISTER_KW(si16, put, "Data::HashMap::Shared::SI16::put");
746	10		REGISTER_KW(si16, get, "Data::HashMap::Shared::SI16::get");
747	10		REGISTER_KW(si16, remove, "Data::HashMap::Shared::SI16::remove");
748	10		REGISTER_KW(si16, exists, "Data::HashMap::Shared::SI16::exists");
749	10		REGISTER_KW(si16, incr, "Data::HashMap::Shared::SI16::incr");
750	10		REGISTER_KW(si16, decr, "Data::HashMap::Shared::SI16::decr");
751	10		REGISTER_KW(si16, incr_by, "Data::HashMap::Shared::SI16::incr_by");
752	10		REGISTER_KW(si16, size, "Data::HashMap::Shared::SI16::size");
753	10		REGISTER_KW(si16, keys, "Data::HashMap::Shared::SI16::keys");
754	10		REGISTER_KW(si16, values, "Data::HashMap::Shared::SI16::values");
755	10		REGISTER_KW(si16, items, "Data::HashMap::Shared::SI16::items");
756	10		REGISTER_KW(si16, each, "Data::HashMap::Shared::SI16::each");
757	10		REGISTER_KW(si16, iter_reset, "Data::HashMap::Shared::SI16::iter_reset");
758	10		REGISTER_KW(si16, clear, "Data::HashMap::Shared::SI16::clear");
759	10		REGISTER_KW(si16, to_hash, "Data::HashMap::Shared::SI16::to_hash");
760	10		REGISTER_KW(si16, max_entries, "Data::HashMap::Shared::SI16::max_entries");
761	10		REGISTER_KW(si16, get_or_set, "Data::HashMap::Shared::SI16::get_or_set");
762	10		REGISTER_KW(si16, put_ttl, "Data::HashMap::Shared::SI16::put_ttl");
763	10		REGISTER_KW(si16, max_size, "Data::HashMap::Shared::SI16::max_size");
764	10		REGISTER_KW(si16, ttl, "Data::HashMap::Shared::SI16::ttl");
765	10		REGISTER_KW(si16, cursor, "Data::HashMap::Shared::SI16::cursor");
766	10		REGISTER_KW(si16, cursor_next, "Data::HashMap::Shared::SI16::Cursor::next");
767	10		REGISTER_KW(si16, cursor_reset, "Data::HashMap::Shared::SI16::Cursor::reset");
768	10		REGISTER_KW(si16, cursor_seek, "Data::HashMap::Shared::SI16::Cursor::seek");
769	10		REGISTER_KW(si16, ttl_remaining, "Data::HashMap::Shared::SI16::ttl_remaining");
770	10		REGISTER_KW(si16, capacity, "Data::HashMap::Shared::SI16::capacity");
771	10		REGISTER_KW(si16, tombstones, "Data::HashMap::Shared::SI16::tombstones");
772	10		REGISTER_KW(si16, take, "Data::HashMap::Shared::SI16::take");
773	10		REGISTER_KW(si16, flush_expired, "Data::HashMap::Shared::SI16::flush_expired");
774	10		REGISTER_KW(si16, flush_expired_partial, "Data::HashMap::Shared::SI16::flush_expired_partial");
775	10		REGISTER_KW(si16, mmap_size, "Data::HashMap::Shared::SI16::mmap_size");
776	10		REGISTER_KW(si16, touch, "Data::HashMap::Shared::SI16::touch");
777	10		REGISTER_KW(si16, reserve, "Data::HashMap::Shared::SI16::reserve");
778	10		REGISTER_KW(si16, stat_evictions, "Data::HashMap::Shared::SI16::stat_evictions");
779	10		REGISTER_KW(si16, stat_expired, "Data::HashMap::Shared::SI16::stat_expired");
780	10		REGISTER_KW(si16, stat_recoveries, "Data::HashMap::Shared::SI16::stat_recoveries");
781	10		REGISTER_KW(si32, put, "Data::HashMap::Shared::SI32::put");
782	10		REGISTER_KW(si32, get, "Data::HashMap::Shared::SI32::get");
783	10		REGISTER_KW(si32, remove, "Data::HashMap::Shared::SI32::remove");
784	10		REGISTER_KW(si32, exists, "Data::HashMap::Shared::SI32::exists");
785	10		REGISTER_KW(si32, incr, "Data::HashMap::Shared::SI32::incr");
786	10		REGISTER_KW(si32, decr, "Data::HashMap::Shared::SI32::decr");
787	10		REGISTER_KW(si32, incr_by, "Data::HashMap::Shared::SI32::incr_by");
788	10		REGISTER_KW(si32, size, "Data::HashMap::Shared::SI32::size");
789	10		REGISTER_KW(si32, keys, "Data::HashMap::Shared::SI32::keys");
790	10		REGISTER_KW(si32, values, "Data::HashMap::Shared::SI32::values");
791	10		REGISTER_KW(si32, items, "Data::HashMap::Shared::SI32::items");
792	10		REGISTER_KW(si32, each, "Data::HashMap::Shared::SI32::each");
793	10		REGISTER_KW(si32, iter_reset, "Data::HashMap::Shared::SI32::iter_reset");
794	10		REGISTER_KW(si32, clear, "Data::HashMap::Shared::SI32::clear");
795	10		REGISTER_KW(si32, to_hash, "Data::HashMap::Shared::SI32::to_hash");
796	10		REGISTER_KW(si32, max_entries, "Data::HashMap::Shared::SI32::max_entries");
797	10		REGISTER_KW(si32, get_or_set, "Data::HashMap::Shared::SI32::get_or_set");
798	10		REGISTER_KW(si32, put_ttl, "Data::HashMap::Shared::SI32::put_ttl");
799	10		REGISTER_KW(si32, max_size, "Data::HashMap::Shared::SI32::max_size");
800	10		REGISTER_KW(si32, ttl, "Data::HashMap::Shared::SI32::ttl");
801	10		REGISTER_KW(si32, cursor, "Data::HashMap::Shared::SI32::cursor");
802	10		REGISTER_KW(si32, cursor_next, "Data::HashMap::Shared::SI32::Cursor::next");
803	10		REGISTER_KW(si32, cursor_reset, "Data::HashMap::Shared::SI32::Cursor::reset");
804	10		REGISTER_KW(si32, cursor_seek, "Data::HashMap::Shared::SI32::Cursor::seek");
805	10		REGISTER_KW(si32, ttl_remaining, "Data::HashMap::Shared::SI32::ttl_remaining");
806	10		REGISTER_KW(si32, capacity, "Data::HashMap::Shared::SI32::capacity");
807	10		REGISTER_KW(si32, tombstones, "Data::HashMap::Shared::SI32::tombstones");
808	10		REGISTER_KW(si32, take, "Data::HashMap::Shared::SI32::take");
809	10		REGISTER_KW(si32, flush_expired, "Data::HashMap::Shared::SI32::flush_expired");
810	10		REGISTER_KW(si32, flush_expired_partial, "Data::HashMap::Shared::SI32::flush_expired_partial");
811	10		REGISTER_KW(si32, mmap_size, "Data::HashMap::Shared::SI32::mmap_size");
812	10		REGISTER_KW(si32, touch, "Data::HashMap::Shared::SI32::touch");
813	10		REGISTER_KW(si32, reserve, "Data::HashMap::Shared::SI32::reserve");
814	10		REGISTER_KW(si32, stat_evictions, "Data::HashMap::Shared::SI32::stat_evictions");
815	10		REGISTER_KW(si32, stat_expired, "Data::HashMap::Shared::SI32::stat_expired");
816	10		REGISTER_KW(si32, stat_recoveries, "Data::HashMap::Shared::SI32::stat_recoveries");
817	10		REGISTER_KW(si, put, "Data::HashMap::Shared::SI::put");
818	10		REGISTER_KW(si, get, "Data::HashMap::Shared::SI::get");
819	10		REGISTER_KW(si, remove, "Data::HashMap::Shared::SI::remove");
820	10		REGISTER_KW(si, exists, "Data::HashMap::Shared::SI::exists");
821	10		REGISTER_KW(si, incr, "Data::HashMap::Shared::SI::incr");
822	10		REGISTER_KW(si, decr, "Data::HashMap::Shared::SI::decr");
823	10		REGISTER_KW(si, incr_by, "Data::HashMap::Shared::SI::incr_by");
824	10		REGISTER_KW(si, size, "Data::HashMap::Shared::SI::size");
825	10		REGISTER_KW(si, keys, "Data::HashMap::Shared::SI::keys");
826	10		REGISTER_KW(si, values, "Data::HashMap::Shared::SI::values");
827	10		REGISTER_KW(si, items, "Data::HashMap::Shared::SI::items");
828	10		REGISTER_KW(si, each, "Data::HashMap::Shared::SI::each");
829	10		REGISTER_KW(si, iter_reset, "Data::HashMap::Shared::SI::iter_reset");
830	10		REGISTER_KW(si, clear, "Data::HashMap::Shared::SI::clear");
831	10		REGISTER_KW(si, to_hash, "Data::HashMap::Shared::SI::to_hash");
832	10		REGISTER_KW(si, max_entries, "Data::HashMap::Shared::SI::max_entries");
833	10		REGISTER_KW(si, get_or_set, "Data::HashMap::Shared::SI::get_or_set");
834	10		REGISTER_KW(si, put_ttl, "Data::HashMap::Shared::SI::put_ttl");
835	10		REGISTER_KW(si, max_size, "Data::HashMap::Shared::SI::max_size");
836	10		REGISTER_KW(si, ttl, "Data::HashMap::Shared::SI::ttl");
837	10		REGISTER_KW(si, cursor, "Data::HashMap::Shared::SI::cursor");
838	10		REGISTER_KW(si, cursor_next, "Data::HashMap::Shared::SI::Cursor::next");
839	10		REGISTER_KW(si, cursor_reset, "Data::HashMap::Shared::SI::Cursor::reset");
840	10		REGISTER_KW(si, cursor_seek, "Data::HashMap::Shared::SI::Cursor::seek");
841	10		REGISTER_KW(si, ttl_remaining, "Data::HashMap::Shared::SI::ttl_remaining");
842	10		REGISTER_KW(si, capacity, "Data::HashMap::Shared::SI::capacity");
843	10		REGISTER_KW(si, tombstones, "Data::HashMap::Shared::SI::tombstones");
844	10		REGISTER_KW(si, take, "Data::HashMap::Shared::SI::take");
845	10		REGISTER_KW(si, flush_expired, "Data::HashMap::Shared::SI::flush_expired");
846	10		REGISTER_KW(si, flush_expired_partial, "Data::HashMap::Shared::SI::flush_expired_partial");
847	10		REGISTER_KW(si, mmap_size, "Data::HashMap::Shared::SI::mmap_size");
848	10		REGISTER_KW(si, touch, "Data::HashMap::Shared::SI::touch");
849	10		REGISTER_KW(si, reserve, "Data::HashMap::Shared::SI::reserve");
850	10		REGISTER_KW(si, stat_evictions, "Data::HashMap::Shared::SI::stat_evictions");
851	10		REGISTER_KW(si, stat_expired, "Data::HashMap::Shared::SI::stat_expired");
852	10		REGISTER_KW(si, stat_recoveries, "Data::HashMap::Shared::SI::stat_recoveries");
853	10		REGISTER_KW(ss, put, "Data::HashMap::Shared::SS::put");
854	10		REGISTER_KW(ss, get, "Data::HashMap::Shared::SS::get");
855	10		REGISTER_KW(ss, remove, "Data::HashMap::Shared::SS::remove");
856	10		REGISTER_KW(ss, exists, "Data::HashMap::Shared::SS::exists");
857	10		REGISTER_KW(ss, size, "Data::HashMap::Shared::SS::size");
858	10		REGISTER_KW(ss, keys, "Data::HashMap::Shared::SS::keys");
859	10		REGISTER_KW(ss, values, "Data::HashMap::Shared::SS::values");
860	10		REGISTER_KW(ss, items, "Data::HashMap::Shared::SS::items");
861	10		REGISTER_KW(ss, each, "Data::HashMap::Shared::SS::each");
862	10		REGISTER_KW(ss, iter_reset, "Data::HashMap::Shared::SS::iter_reset");
863	10		REGISTER_KW(ss, clear, "Data::HashMap::Shared::SS::clear");
864	10		REGISTER_KW(ss, to_hash, "Data::HashMap::Shared::SS::to_hash");
865	10		REGISTER_KW(ss, max_entries, "Data::HashMap::Shared::SS::max_entries");
866	10		REGISTER_KW(ss, get_or_set, "Data::HashMap::Shared::SS::get_or_set");
867	10		REGISTER_KW(ss, put_ttl, "Data::HashMap::Shared::SS::put_ttl");
868	10		REGISTER_KW(ss, max_size, "Data::HashMap::Shared::SS::max_size");
869	10		REGISTER_KW(ss, ttl, "Data::HashMap::Shared::SS::ttl");
870	10		REGISTER_KW(ss, cursor, "Data::HashMap::Shared::SS::cursor");
871	10		REGISTER_KW(ss, cursor_next, "Data::HashMap::Shared::SS::Cursor::next");
872	10		REGISTER_KW(ss, cursor_reset, "Data::HashMap::Shared::SS::Cursor::reset");
873	10		REGISTER_KW(ss, cursor_seek, "Data::HashMap::Shared::SS::Cursor::seek");
874	10		REGISTER_KW(ss, ttl_remaining, "Data::HashMap::Shared::SS::ttl_remaining");
875	10		REGISTER_KW(ss, capacity, "Data::HashMap::Shared::SS::capacity");
876	10		REGISTER_KW(ss, tombstones, "Data::HashMap::Shared::SS::tombstones");
877	10		REGISTER_KW(ss, take, "Data::HashMap::Shared::SS::take");
878	10		REGISTER_KW(ss, flush_expired, "Data::HashMap::Shared::SS::flush_expired");
879	10		REGISTER_KW(ss, flush_expired_partial, "Data::HashMap::Shared::SS::flush_expired_partial");
880	10		REGISTER_KW(ss, mmap_size, "Data::HashMap::Shared::SS::mmap_size");
881	10		REGISTER_KW(ss, touch, "Data::HashMap::Shared::SS::touch");
882	10		REGISTER_KW(ss, reserve, "Data::HashMap::Shared::SS::reserve");
883	10		REGISTER_KW(ss, stat_evictions, "Data::HashMap::Shared::SS::stat_evictions");
884	10		REGISTER_KW(ss, stat_expired, "Data::HashMap::Shared::SS::stat_expired");
885	10		REGISTER_KW(ss, stat_recoveries, "Data::HashMap::Shared::SS::stat_recoveries");
886
887			SV*
888			new(char* class, char* path, UV max_entries, UV lru_max = 0, UV ttl_default = 0)
889			CODE:
890	2		char errbuf[SHM_ERR_BUFLEN]; ShmHandle* map = shm_i16_create(path, (uint32_t)max_entries, (uint32_t)lru_max, (uint32_t)ttl_default, errbuf);
891	2	50	if (!map) croak("HashMap::Shared::I16: %s", errbuf[0] ? errbuf : "unknown error");
		0
892	2		RETVAL = sv_setref_pv(newSV(0), class, (void*)map);
893			OUTPUT:
894			RETVAL
895
896			void
897			DESTROY(SV* self_sv)
898			CODE:
899	2	50	if (!SvROK(self_sv)) return;
900	2		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_sv)));
901	2	50	if (!h) return;
902	2		shm_close_map(h);
903	2		sv_setiv(SvRV(self_sv), 0);
904
905			bool
906			put(SV* self_sv, int16_t key, int16_t value)
907			CODE:
908	10	50	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		50
		50
909	10	50	RETVAL = shm_i16_put(h, key, value);
910			OUTPUT:
911			RETVAL
912
913			SV*
914			get(SV* self_sv, int16_t key)
915			CODE:
916	6	50	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		50
		50
917			int16_t value;
918	6	100	if (!shm_i16_get(h, key, &value)) XSRETURN_UNDEF;
919	5		RETVAL = newSViv(value);
920			OUTPUT:
921			RETVAL
922
923			bool
924			remove(SV* self_sv, int16_t key)
925			CODE:
926	1	50	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		50
		50
927	1	50	RETVAL = shm_i16_remove(h, key);
928			OUTPUT:
929			RETVAL
930
931			bool
932			exists(SV* self_sv, int16_t key)
933			CODE:
934	2	50	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		50
		50
935	2	100	RETVAL = shm_i16_exists(h, key);
936			OUTPUT:
937			RETVAL
938
939			SV*
940			incr(SV* self_sv, int16_t key)
941			CODE:
942	2	50	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		50
		50
943			int ok;
944	2		int16_t val = shm_i16_incr_by(h, key, 1, &ok);
945	2	50	if (!ok) croak("HashMap::Shared::I16: increment failed");
946	2		RETVAL = newSViv(val);
947			OUTPUT:
948			RETVAL
949
950			SV*
951			decr(SV* self_sv, int16_t key)
952			CODE:
953	1	50	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		50
		50
954			int ok;
955	1		int16_t val = shm_i16_incr_by(h, key, -1, &ok);
956	1	50	if (!ok) croak("HashMap::Shared::I16: decrement failed");
957	1		RETVAL = newSViv(val);
958			OUTPUT:
959			RETVAL
960
961			SV*
962			incr_by(SV* self_sv, int16_t key, int16_t delta)
963			CODE:
964	1	50	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		50
		50
965			int ok;
966	1		int16_t val = shm_i16_incr_by(h, key, delta, &ok);
967	1	50	if (!ok) croak("HashMap::Shared::I16: incr_by failed");
968	1		RETVAL = newSViv(val);
969			OUTPUT:
970			RETVAL
971
972			UV
973			size(SV* self_sv)
974			CODE:
975	1	50	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		50
		50
976	1	50	RETVAL = (UV)shm_i16_size(h);
977			OUTPUT:
978			RETVAL
979
980			UV
981			max_entries(SV* self_sv)
982			CODE:
983	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
984	0	0	RETVAL = (UV)shm_i16_max_entries(h);
985			OUTPUT:
986			RETVAL
987
988			void
989			keys(SV* self_sv)
990			PPCODE:
991	1	50	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		50
		50
992	1		ShmHeader *hdr = h->hdr;
993	1		ShmNodeI16 nodes = (ShmNodeI16 )h->nodes;
994	1	50	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
995	1		RDLOCK_GUARD(hdr);
996	1	50	EXTEND(SP, hdr->size);
997	17	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
998	16	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now))
		50
		0
		0
999	5	50	mXPUSHi(nodes[i].key);
1000			}
1001
1002			void
1003			values(SV* self_sv)
1004			PPCODE:
1005	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1006	0		ShmHeader *hdr = h->hdr;
1007	0		ShmNodeI16 nodes = (ShmNodeI16 )h->nodes;
1008	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
1009	0		RDLOCK_GUARD(hdr);
1010	0	0	EXTEND(SP, hdr->size);
1011	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
1012	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now))
		0
		0
		0
1013	0	0	mXPUSHi(nodes[i].value);
1014			}
1015
1016
1017			void
1018			items(SV* self_sv)
1019			PPCODE:
1020	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1021	0		ShmHeader *hdr = h->hdr;
1022	0		ShmNodeI16 nodes = (ShmNodeI16 )h->nodes;
1023	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
1024	0		RDLOCK_GUARD(hdr);
1025	0	0	EXTEND(SP, hdr->size * 2);
1026	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
1027	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		0
		0
		0
1028	0	0	mXPUSHi(nodes[i].key);
1029	0	0	mXPUSHi(nodes[i].value);
1030			}
1031			}
1032
1033
1034			void
1035			each(SV* self_sv)
1036			PPCODE:
1037	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1038			int16_t out_key, out_value;
1039	0	0	if (shm_i16_each(h, &out_key, &out_value)) {
1040	0	0	EXTEND(SP, 2);
1041	0	0	mXPUSHi(out_key);
1042	0	0	mXPUSHi(out_value);
1043	0		XSRETURN(2);
1044			}
1045	0		shm_i16_flush_deferred(h);
1046	0		XSRETURN_EMPTY;
1047
1048			void
1049			iter_reset(SV* self_sv)
1050			CODE:
1051	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1052	0		shm_i16_iter_reset(h);
1053	0		shm_i16_flush_deferred(h);
1054
1055			void
1056			clear(SV* self_sv)
1057			CODE:
1058	1	50	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		50
		50
1059	1		shm_i16_clear(h);
1060
1061			SV*
1062			to_hash(SV* self_sv)
1063			CODE:
1064	1	50	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		50
		50
1065	1		HV* hv = newHV();
1066	1		ShmHeader *hdr = h->hdr;
1067	1		ShmNodeI16 nodes = (ShmNodeI16 )h->nodes;
1068	1	50	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
1069	1		RDLOCK_GUARD(hdr);
1070	17	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
1071	16	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		50
		0
		0
1072	5		SV* val = newSViv(nodes[i].value);
1073			char kbuf[24];
1074	5		int klen = my_snprintf(kbuf, sizeof(kbuf), "%" IVdf, (IV)nodes[i].key);
1075	5	50	if (!hv_store(hv, kbuf, klen, val, 0)) SvREFCNT_dec(val);
1076			}
1077			}
1078
1079	1		RETVAL = newRV_noinc((SV*)hv);
1080			OUTPUT:
1081			RETVAL
1082
1083			SV*
1084			get_or_set(SV* self_sv, int16_t key, int16_t default_value)
1085			CODE:
1086	2	50	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		50
		50
1087			int16_t out;
1088	2		int rc = shm_i16_get_or_set(h, key, default_value, &out);
1089	2	50	if (!rc) XSRETURN_UNDEF;
1090	2		RETVAL = newSViv(out);
1091			OUTPUT:
1092			RETVAL
1093
1094			bool
1095			put_ttl(SV* self_sv, int16_t key, int16_t value, UV ttl_sec)
1096			CODE:
1097	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1098	0	0	REQUIRE_TTL(h);
1099	0	0	RETVAL = shm_i16_put_ttl(h, key, value, (uint32_t)ttl_sec);
1100			OUTPUT:
1101			RETVAL
1102
1103			UV
1104			max_size(SV* self_sv)
1105			CODE:
1106	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1107	0	0	RETVAL = (UV)shm_i16_max_size(h);
1108			OUTPUT:
1109			RETVAL
1110
1111			UV
1112			ttl(SV* self_sv)
1113			CODE:
1114	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1115	0	0	RETVAL = (UV)shm_i16_ttl(h);
1116			OUTPUT:
1117			RETVAL
1118
1119			SV*
1120			take(SV* self_sv, int16_t key)
1121			CODE:
1122	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1123			int16_t out_value;
1124	0	0	if (!shm_i16_take(h, key, &out_value)) XSRETURN_UNDEF;
1125	0		RETVAL = newSViv(out_value);
1126			OUTPUT:
1127			RETVAL
1128
1129			UV
1130			flush_expired(SV* self_sv)
1131			CODE:
1132	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1133	0	0	RETVAL = (UV)shm_i16_flush_expired(h);
1134			OUTPUT:
1135			RETVAL
1136
1137
1138			void
1139			flush_expired_partial(SV* self_sv, UV limit)
1140			PPCODE:
1141	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1142	0		int done = 0;
1143	0		uint32_t flushed = shm_i16_flush_expired_partial(h, (uint32_t)limit, &done);
1144	0	0	EXTEND(SP, 2);
1145	0		mPUSHu(flushed);
1146	0		mPUSHi(done);
1147
1148			UV
1149			mmap_size(SV* self_sv)
1150			CODE:
1151	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1152	0		RETVAL = (UV)shm_i16_mmap_size(h);
1153			OUTPUT:
1154			RETVAL
1155
1156
1157			bool
1158			touch(SV* self_sv, int16_t key)
1159			CODE:
1160	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1161	0	0	RETVAL = shm_i16_touch(h, key);
1162			OUTPUT:
1163			RETVAL
1164
1165			bool
1166			reserve(SV* self_sv, UV target)
1167			CODE:
1168	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1169	0	0	RETVAL = shm_i16_reserve(h, (uint32_t)target);
1170			OUTPUT:
1171			RETVAL
1172
1173			UV
1174			stat_evictions(SV* self_sv)
1175			CODE:
1176	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1177	0		RETVAL = (UV)shm_i16_stat_evictions(h);
1178			OUTPUT:
1179			RETVAL
1180
1181			UV
1182			stat_expired(SV* self_sv)
1183			CODE:
1184	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1185	0		RETVAL = (UV)shm_i16_stat_expired(h);
1186			OUTPUT:
1187			RETVAL
1188
1189
1190
1191			UV
1192			stat_recoveries(SV* self_sv)
1193			CODE:
1194	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1195	0	0	RETVAL = (UV)shm_i16_stat_recoveries(h);
1196			OUTPUT:
1197			RETVAL
1198
1199			SV*
1200			path(SV* self_sv)
1201			CODE:
1202	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1203	0		RETVAL = newSVpv(h->path, 0);
1204			OUTPUT:
1205			RETVAL
1206
1207
1208			bool
1209			unlink(SV* self_or_class, ...)
1210			CODE:
1211			const char *p;
1212	0	0	if (SvROK(self_or_class) && SvOBJECT(SvRV(self_or_class))) {
		0
1213	0		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_or_class)));
1214	0	0	if (!h) croak("Attempted to use a destroyed Data::HashMap::Shared::I16 object");
1215	0		p = h->path;
1216			} else {
1217	0	0	if (items < 2) croak("Usage: Data::HashMap::Shared::I16->unlink($path)");
1218	0		p = SvPV_nolen(ST(1));
1219			}
1220	0	0	RETVAL = shm_unlink_path(p);
1221			OUTPUT:
1222			RETVAL
1223
1224			SV*
1225			ttl_remaining(SV* self_sv, int16_t key)
1226			CODE:
1227	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1228	0		int64_t remaining = shm_i16_ttl_remaining(h, key);
1229	0	0	if (remaining < 0) XSRETURN_UNDEF;
1230	0		RETVAL = newSViv(remaining);
1231			OUTPUT:
1232			RETVAL
1233
1234			UV
1235			capacity(SV* self_sv)
1236			CODE:
1237	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1238	0	0	RETVAL = (UV)shm_i16_capacity(h);
1239			OUTPUT:
1240			RETVAL
1241
1242			UV
1243			tombstones(SV* self_sv)
1244			CODE:
1245	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1246	0	0	RETVAL = (UV)shm_i16_tombstones(h);
1247			OUTPUT:
1248			RETVAL
1249
1250			SV*
1251			cursor(SV* self_sv)
1252			CODE:
1253	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16", self_sv);
		0
		0
1254	0		ShmCursor* c = shm_cursor_create(h);
1255	0	0	if (!c) croak("Failed to allocate cursor");
1256	0		RETVAL = sv_setref_pv(newSV(0), "Data::HashMap::Shared::I16::Cursor", (void*)c);
1257			OUTPUT:
1258			RETVAL
1259
1260			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::I16::Cursor
1261			PROTOTYPES: DISABLE
1262
1263			void
1264			DESTROY(SV* self_sv)
1265			CODE:
1266	0	0	if (!SvROK(self_sv)) return;
1267	0		ShmCursor* c = INT2PTR(ShmCursor*, SvIV(SvRV(self_sv)));
1268	0	0	if (!c) return;
1269	0		ShmHandle* h = c->handle;
1270	0		shm_cursor_destroy(c);
1271	0	0	if (h) shm_i16_flush_deferred(h);
1272	0		sv_setiv(SvRV(self_sv), 0);
1273
1274			void
1275			next(SV* self_sv)
1276			PPCODE:
1277	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::I16::Cursor", self_sv);
		0
		0
1278			int16_t out_key, out_value;
1279	0	0	if (shm_i16_cursor_next(c, &out_key, &out_value)) {
1280	0	0	EXTEND(SP, 2);
1281	0	0	mXPUSHi(out_key);
1282	0	0	mXPUSHi(out_value);
1283	0		XSRETURN(2);
1284			}
1285	0		XSRETURN_EMPTY;
1286
1287			void
1288			reset(SV* self_sv)
1289			CODE:
1290	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::I16::Cursor", self_sv);
		0
		0
1291	0		shm_i16_cursor_reset(c);
1292
1293			bool
1294			seek(SV* self_sv, int16_t key)
1295			CODE:
1296	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::I16::Cursor", self_sv);
		0
		0
1297	0	0	RETVAL = shm_i16_cursor_seek(c, key);
1298			OUTPUT:
1299			RETVAL
1300
1301
1302			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::I32
1303			PROTOTYPES: DISABLE
1304
1305			SV*
1306			new(char* class, char* path, UV max_entries, UV lru_max = 0, UV ttl_default = 0)
1307			CODE:
1308	3		char errbuf[SHM_ERR_BUFLEN]; ShmHandle* map = shm_i32_create(path, (uint32_t)max_entries, (uint32_t)lru_max, (uint32_t)ttl_default, errbuf);
1309	3	50	if (!map) croak("HashMap::Shared::I32: %s", errbuf[0] ? errbuf : "unknown error");
		0
1310	3		RETVAL = sv_setref_pv(newSV(0), class, (void*)map);
1311			OUTPUT:
1312			RETVAL
1313
1314			void
1315			DESTROY(SV* self_sv)
1316			CODE:
1317	3	50	if (!SvROK(self_sv)) return;
1318	3		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_sv)));
1319	3	50	if (!h) return;
1320	3		shm_close_map(h);
1321	3		sv_setiv(SvRV(self_sv), 0);
1322
1323			bool
1324			put(SV* self_sv, int32_t key, int32_t value)
1325			CODE:
1326	1014	50	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		50
		50
1327	1014	50	RETVAL = shm_i32_put(h, key, value);
1328			OUTPUT:
1329			RETVAL
1330
1331			SV*
1332			get(SV* self_sv, int32_t key)
1333			CODE:
1334	5	50	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		50
		50
1335			int32_t value;
1336	5	50	if (!shm_i32_get(h, key, &value)) XSRETURN_UNDEF;
1337	5		RETVAL = newSViv(value);
1338			OUTPUT:
1339			RETVAL
1340
1341			bool
1342			remove(SV* self_sv, int32_t key)
1343			CODE:
1344	500	50	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		50
		50
1345	500	50	RETVAL = shm_i32_remove(h, key);
1346			OUTPUT:
1347			RETVAL
1348
1349			bool
1350			exists(SV* self_sv, int32_t key)
1351			CODE:
1352	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1353	0	0	RETVAL = shm_i32_exists(h, key);
1354			OUTPUT:
1355			RETVAL
1356
1357			SV*
1358			incr(SV* self_sv, int32_t key)
1359			CODE:
1360	1	50	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		50
		50
1361			int ok;
1362	1		int32_t val = shm_i32_incr_by(h, key, 1, &ok);
1363	1	50	if (!ok) croak("HashMap::Shared::I32: increment failed");
1364	1		RETVAL = newSViv(val);
1365			OUTPUT:
1366			RETVAL
1367
1368			SV*
1369			decr(SV* self_sv, int32_t key)
1370			CODE:
1371	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1372			int ok;
1373	0		int32_t val = shm_i32_incr_by(h, key, -1, &ok);
1374	0	0	if (!ok) croak("HashMap::Shared::I32: decrement failed");
1375	0		RETVAL = newSViv(val);
1376			OUTPUT:
1377			RETVAL
1378
1379			SV*
1380			incr_by(SV* self_sv, int32_t key, int32_t delta)
1381			CODE:
1382	1	50	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		50
		50
1383			int ok;
1384	1		int32_t val = shm_i32_incr_by(h, key, delta, &ok);
1385	1	50	if (!ok) croak("HashMap::Shared::I32: incr_by failed");
1386	1		RETVAL = newSViv(val);
1387			OUTPUT:
1388			RETVAL
1389
1390			UV
1391			size(SV* self_sv)
1392			CODE:
1393	2	50	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		50
		50
1394	2	50	RETVAL = (UV)shm_i32_size(h);
1395			OUTPUT:
1396			RETVAL
1397
1398			UV
1399			max_entries(SV* self_sv)
1400			CODE:
1401	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1402	0	0	RETVAL = (UV)shm_i32_max_entries(h);
1403			OUTPUT:
1404			RETVAL
1405
1406			void
1407			keys(SV* self_sv)
1408			PPCODE:
1409	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1410	0		ShmHeader *hdr = h->hdr;
1411	0		ShmNodeI32 nodes = (ShmNodeI32 )h->nodes;
1412	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
1413	0		RDLOCK_GUARD(hdr);
1414	0	0	EXTEND(SP, hdr->size);
1415	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
1416	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now))
		0
		0
		0
1417	0	0	mXPUSHi(nodes[i].key);
1418			}
1419
1420
1421			void
1422			values(SV* self_sv)
1423			PPCODE:
1424	1	50	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		50
		50
1425	1		ShmHeader *hdr = h->hdr;
1426	1		ShmNodeI32 nodes = (ShmNodeI32 )h->nodes;
1427	1	50	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
1428	1		RDLOCK_GUARD(hdr);
1429	1	50	EXTEND(SP, hdr->size);
1430	17	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
1431	16	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now))
		50
		0
		0
1432	10	50	mXPUSHi(nodes[i].value);
1433			}
1434
1435
1436			void
1437			items(SV* self_sv)
1438			PPCODE:
1439	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1440	0		ShmHeader *hdr = h->hdr;
1441	0		ShmNodeI32 nodes = (ShmNodeI32 )h->nodes;
1442	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
1443	0		RDLOCK_GUARD(hdr);
1444	0	0	EXTEND(SP, hdr->size * 2);
1445	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
1446	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		0
		0
		0
1447	0	0	mXPUSHi(nodes[i].key);
1448	0	0	mXPUSHi(nodes[i].value);
1449			}
1450			}
1451
1452
1453			void
1454			each(SV* self_sv)
1455			PPCODE:
1456	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1457			int32_t out_key, out_value;
1458	0	0	if (shm_i32_each(h, &out_key, &out_value)) {
1459	0	0	EXTEND(SP, 2);
1460	0	0	mXPUSHi(out_key);
1461	0	0	mXPUSHi(out_value);
1462	0		XSRETURN(2);
1463			}
1464	0		shm_i32_flush_deferred(h);
1465	0		XSRETURN_EMPTY;
1466
1467			void
1468			iter_reset(SV* self_sv)
1469			CODE:
1470	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1471	0		shm_i32_iter_reset(h);
1472	0		shm_i32_flush_deferred(h);
1473
1474			void
1475			clear(SV* self_sv)
1476			CODE:
1477	1	50	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		50
		50
1478	1		shm_i32_clear(h);
1479
1480			SV*
1481			to_hash(SV* self_sv)
1482			CODE:
1483	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1484	0		HV* hv = newHV();
1485	0		ShmHeader *hdr = h->hdr;
1486	0		ShmNodeI32 nodes = (ShmNodeI32 )h->nodes;
1487	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
1488	0		RDLOCK_GUARD(hdr);
1489	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
1490	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		0
		0
		0
1491	0		SV* val = newSViv(nodes[i].value);
1492			char kbuf[24];
1493	0		int klen = my_snprintf(kbuf, sizeof(kbuf), "%" IVdf, (IV)nodes[i].key);
1494	0	0	if (!hv_store(hv, kbuf, klen, val, 0)) SvREFCNT_dec(val);
1495			}
1496			}
1497
1498	0		RETVAL = newRV_noinc((SV*)hv);
1499			OUTPUT:
1500			RETVAL
1501
1502			SV*
1503			get_or_set(SV* self_sv, int32_t key, int32_t default_value)
1504			CODE:
1505	2	50	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		50
		50
1506			int32_t out;
1507	2		int rc = shm_i32_get_or_set(h, key, default_value, &out);
1508	2	50	if (!rc) XSRETURN_UNDEF;
1509	2		RETVAL = newSViv(out);
1510			OUTPUT:
1511			RETVAL
1512
1513			bool
1514			put_ttl(SV* self_sv, int32_t key, int32_t value, UV ttl_sec)
1515			CODE:
1516	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1517	0	0	REQUIRE_TTL(h);
1518	0	0	RETVAL = shm_i32_put_ttl(h, key, value, (uint32_t)ttl_sec);
1519			OUTPUT:
1520			RETVAL
1521
1522			UV
1523			max_size(SV* self_sv)
1524			CODE:
1525	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1526	0	0	RETVAL = (UV)shm_i32_max_size(h);
1527			OUTPUT:
1528			RETVAL
1529
1530			UV
1531			ttl(SV* self_sv)
1532			CODE:
1533	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1534	0	0	RETVAL = (UV)shm_i32_ttl(h);
1535			OUTPUT:
1536			RETVAL
1537
1538
1539
1540			SV*
1541			take(SV* self_sv, int32_t key)
1542			CODE:
1543	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1544			int32_t out_value;
1545	0	0	if (!shm_i32_take(h, key, &out_value)) XSRETURN_UNDEF;
1546	0		RETVAL = newSViv(out_value);
1547			OUTPUT:
1548			RETVAL
1549
1550			UV
1551			flush_expired(SV* self_sv)
1552			CODE:
1553	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1554	0	0	RETVAL = (UV)shm_i32_flush_expired(h);
1555			OUTPUT:
1556			RETVAL
1557
1558
1559			void
1560			flush_expired_partial(SV* self_sv, UV limit)
1561			PPCODE:
1562	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1563	0		int done = 0;
1564	0		uint32_t flushed = shm_i32_flush_expired_partial(h, (uint32_t)limit, &done);
1565	0	0	EXTEND(SP, 2);
1566	0		mPUSHu(flushed);
1567	0		mPUSHi(done);
1568
1569			UV
1570			mmap_size(SV* self_sv)
1571			CODE:
1572	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1573	0		RETVAL = (UV)shm_i32_mmap_size(h);
1574			OUTPUT:
1575			RETVAL
1576
1577
1578			bool
1579			touch(SV* self_sv, int32_t key)
1580			CODE:
1581	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1582	0	0	RETVAL = shm_i32_touch(h, key);
1583			OUTPUT:
1584			RETVAL
1585
1586			bool
1587			reserve(SV* self_sv, UV target)
1588			CODE:
1589	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1590	0	0	RETVAL = shm_i32_reserve(h, (uint32_t)target);
1591			OUTPUT:
1592			RETVAL
1593
1594			UV
1595			stat_evictions(SV* self_sv)
1596			CODE:
1597	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1598	0		RETVAL = (UV)shm_i32_stat_evictions(h);
1599			OUTPUT:
1600			RETVAL
1601
1602			UV
1603			stat_expired(SV* self_sv)
1604			CODE:
1605	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1606	0		RETVAL = (UV)shm_i32_stat_expired(h);
1607			OUTPUT:
1608			RETVAL
1609
1610
1611
1612			UV
1613			stat_recoveries(SV* self_sv)
1614			CODE:
1615	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1616	0	0	RETVAL = (UV)shm_i32_stat_recoveries(h);
1617			OUTPUT:
1618			RETVAL
1619
1620			SV*
1621			path(SV* self_sv)
1622			CODE:
1623	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1624	0		RETVAL = newSVpv(h->path, 0);
1625			OUTPUT:
1626			RETVAL
1627
1628
1629			bool
1630			unlink(SV* self_or_class, ...)
1631			CODE:
1632			const char *p;
1633	0	0	if (SvROK(self_or_class) && SvOBJECT(SvRV(self_or_class))) {
		0
1634	0		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_or_class)));
1635	0	0	if (!h) croak("Attempted to use a destroyed Data::HashMap::Shared::I32 object");
1636	0		p = h->path;
1637			} else {
1638	0	0	if (items < 2) croak("Usage: Data::HashMap::Shared::I32->unlink($path)");
1639	0		p = SvPV_nolen(ST(1));
1640			}
1641	0	0	RETVAL = shm_unlink_path(p);
1642			OUTPUT:
1643			RETVAL
1644
1645			SV*
1646			ttl_remaining(SV* self_sv, int32_t key)
1647			CODE:
1648	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1649	0		int64_t remaining = shm_i32_ttl_remaining(h, key);
1650	0	0	if (remaining < 0) XSRETURN_UNDEF;
1651	0		RETVAL = newSViv(remaining);
1652			OUTPUT:
1653			RETVAL
1654
1655			UV
1656			capacity(SV* self_sv)
1657			CODE:
1658	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1659	0	0	RETVAL = (UV)shm_i32_capacity(h);
1660			OUTPUT:
1661			RETVAL
1662
1663			UV
1664			tombstones(SV* self_sv)
1665			CODE:
1666	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1667	0	0	RETVAL = (UV)shm_i32_tombstones(h);
1668			OUTPUT:
1669			RETVAL
1670
1671			SV*
1672			cursor(SV* self_sv)
1673			CODE:
1674	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32", self_sv);
		0
		0
1675	0		ShmCursor* c = shm_cursor_create(h);
1676	0	0	if (!c) croak("Failed to allocate cursor");
1677	0		RETVAL = sv_setref_pv(newSV(0), "Data::HashMap::Shared::I32::Cursor", (void*)c);
1678			OUTPUT:
1679			RETVAL
1680
1681			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::I32::Cursor
1682			PROTOTYPES: DISABLE
1683
1684			void
1685			DESTROY(SV* self_sv)
1686			CODE:
1687	0	0	if (!SvROK(self_sv)) return;
1688	0		ShmCursor* c = INT2PTR(ShmCursor*, SvIV(SvRV(self_sv)));
1689	0	0	if (!c) return;
1690	0		ShmHandle* h = c->handle;
1691	0		shm_cursor_destroy(c);
1692	0	0	if (h) shm_i32_flush_deferred(h);
1693	0		sv_setiv(SvRV(self_sv), 0);
1694
1695			void
1696			next(SV* self_sv)
1697			PPCODE:
1698	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::I32::Cursor", self_sv);
		0
		0
1699			int32_t out_key; int32_t out_value;
1700	0	0	if (shm_i32_cursor_next(c, &out_key, &out_value)) {
1701	0	0	EXTEND(SP, 2);
1702	0	0	mXPUSHi(out_key);
1703	0	0	mXPUSHi(out_value);
1704	0		XSRETURN(2);
1705			}
1706	0		XSRETURN_EMPTY;
1707
1708			void
1709			reset(SV* self_sv)
1710			CODE:
1711	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::I32::Cursor", self_sv);
		0
		0
1712	0		shm_i32_cursor_reset(c);
1713
1714			bool
1715			seek(SV* self_sv, int32_t key)
1716			CODE:
1717	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::I32::Cursor", self_sv);
		0
		0
1718	0	0	RETVAL = shm_i32_cursor_seek(c, key);
1719			OUTPUT:
1720			RETVAL
1721
1722
1723			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::II
1724			PROTOTYPES: DISABLE
1725
1726			SV*
1727			new(char* class, char* path, UV max_entries, UV lru_max = 0, UV ttl_default = 0)
1728			CODE:
1729	82		char errbuf[SHM_ERR_BUFLEN]; ShmHandle* map = shm_ii_create(path, (uint32_t)max_entries, (uint32_t)lru_max, (uint32_t)ttl_default, errbuf);
1730	82	100	if (!map) croak("HashMap::Shared::II: %s", errbuf[0] ? errbuf : "unknown error");
		50
1731	81		RETVAL = sv_setref_pv(newSV(0), class, (void*)map);
1732			OUTPUT:
1733			RETVAL
1734
1735			void
1736			DESTROY(SV* self_sv)
1737			CODE:
1738	81	50	if (!SvROK(self_sv)) return;
1739	81		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_sv)));
1740	81	50	if (!h) return;
1741	81		shm_close_map(h);
1742	81		sv_setiv(SvRV(self_sv), 0);
1743
1744			bool
1745			put(SV* self_sv, int64_t key, int64_t value)
1746			CODE:
1747	2492	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1748	2492	100	RETVAL = shm_ii_put(h, key, value);
1749			OUTPUT:
1750			RETVAL
1751
1752			SV*
1753			get(SV* self_sv, int64_t key)
1754			CODE:
1755	184	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1756			int64_t value;
1757	184	100	if (!shm_ii_get(h, key, &value)) XSRETURN_UNDEF;
1758	100		RETVAL = newSViv(value);
1759			OUTPUT:
1760			RETVAL
1761
1762			bool
1763			remove(SV* self_sv, int64_t key)
1764			CODE:
1765	279	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1766	279	50	RETVAL = shm_ii_remove(h, key);
1767			OUTPUT:
1768			RETVAL
1769
1770			bool
1771			exists(SV* self_sv, int64_t key)
1772			CODE:
1773	4	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1774	4	100	RETVAL = shm_ii_exists(h, key);
1775			OUTPUT:
1776			RETVAL
1777
1778			SV*
1779			incr(SV* self_sv, int64_t key)
1780			CODE:
1781	6	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1782			int ok;
1783	6		int64_t val = shm_ii_incr_by(h, key, 1, &ok);
1784	6	50	if (!ok) croak("HashMap::Shared::II: increment failed");
1785	6		RETVAL = newSViv(val);
1786			OUTPUT:
1787			RETVAL
1788
1789			SV*
1790			decr(SV* self_sv, int64_t key)
1791			CODE:
1792	2	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1793			int ok;
1794	2		int64_t val = shm_ii_incr_by(h, key, -1, &ok);
1795	2	50	if (!ok) croak("HashMap::Shared::II: decrement failed");
1796	2		RETVAL = newSViv(val);
1797			OUTPUT:
1798			RETVAL
1799
1800			SV*
1801			incr_by(SV* self_sv, int64_t key, int64_t delta)
1802			CODE:
1803	3	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1804			int ok;
1805	3		int64_t val = shm_ii_incr_by(h, key, delta, &ok);
1806	3	50	if (!ok) croak("HashMap::Shared::II: incr_by failed");
1807	3		RETVAL = newSViv(val);
1808			OUTPUT:
1809			RETVAL
1810
1811			UV
1812			size(SV* self_sv)
1813			CODE:
1814	31	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1815	31	50	RETVAL = (UV)shm_ii_size(h);
1816			OUTPUT:
1817			RETVAL
1818
1819			UV
1820			max_entries(SV* self_sv)
1821			CODE:
1822	2	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1823	2	50	RETVAL = (UV)shm_ii_max_entries(h);
1824			OUTPUT:
1825			RETVAL
1826
1827			void
1828			keys(SV* self_sv)
1829			PPCODE:
1830	2	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1831	2		ShmHeader *hdr = h->hdr;
1832	2		ShmNodeII nodes = (ShmNodeII )h->nodes;
1833	2	100	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
1834	2		RDLOCK_GUARD(hdr);
1835	2	50	EXTEND(SP, hdr->size);
1836	34	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
1837	32	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now))
		100
		50
		100
1838	4	50	mXPUSHi(nodes[i].key);
1839			}
1840
1841
1842			void
1843			values(SV* self_sv)
1844			PPCODE:
1845	1	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1846	1		ShmHeader *hdr = h->hdr;
1847	1		ShmNodeII nodes = (ShmNodeII )h->nodes;
1848	1	50	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
1849	1		RDLOCK_GUARD(hdr);
1850	1	50	EXTEND(SP, hdr->size);
1851	17	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
1852	16	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now))
		50
		0
		0
1853	3	50	mXPUSHi(nodes[i].value);
1854			}
1855
1856
1857			void
1858			items(SV* self_sv)
1859			PPCODE:
1860	1	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1861	1		ShmHeader *hdr = h->hdr;
1862	1		ShmNodeII nodes = (ShmNodeII )h->nodes;
1863	1	50	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
1864	1		RDLOCK_GUARD(hdr);
1865	1	50	EXTEND(SP, hdr->size * 2);
1866	17	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
1867	16	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		50
		0
		0
1868	3	50	mXPUSHi(nodes[i].key);
1869	3	50	mXPUSHi(nodes[i].value);
1870			}
1871			}
1872
1873
1874			void
1875			each(SV* self_sv)
1876			PPCODE:
1877	325	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1878			int64_t out_key, out_value;
1879	325	100	if (shm_ii_each(h, &out_key, &out_value)) {
1880	319	50	EXTEND(SP, 2);
1881	319	50	mXPUSHi(out_key);
1882	319	50	mXPUSHi(out_value);
1883	319		XSRETURN(2);
1884			}
1885	6		shm_ii_flush_deferred(h);
1886	6		XSRETURN_EMPTY;
1887
1888			void
1889			iter_reset(SV* self_sv)
1890			CODE:
1891	1	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1892	1		shm_ii_iter_reset(h);
1893	1		shm_ii_flush_deferred(h);
1894
1895			void
1896			clear(SV* self_sv)
1897			CODE:
1898	5	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1899	5		shm_ii_clear(h);
1900
1901			SV*
1902			to_hash(SV* self_sv)
1903			CODE:
1904	1	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1905	1		HV* hv = newHV();
1906	1		ShmHeader *hdr = h->hdr;
1907	1		ShmNodeII nodes = (ShmNodeII )h->nodes;
1908	1	50	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
1909	1		RDLOCK_GUARD(hdr);
1910	17	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
1911	16	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		50
		0
		0
1912	2		SV* val = newSViv(nodes[i].value);
1913			char kbuf[24];
1914	2		int klen = my_snprintf(kbuf, sizeof(kbuf), "%" IVdf, (IV)nodes[i].key);
1915	2	50	if (!hv_store(hv, kbuf, klen, val, 0)) SvREFCNT_dec(val);
1916			}
1917			}
1918
1919	1		RETVAL = newRV_noinc((SV*)hv);
1920			OUTPUT:
1921			RETVAL
1922
1923			SV*
1924			get_or_set(SV* self_sv, int64_t key, int64_t default_value)
1925			CODE:
1926	5	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1927			int64_t out;
1928	5		int rc = shm_ii_get_or_set(h, key, default_value, &out);
1929	5	50	if (!rc) XSRETURN_UNDEF;
1930	5		RETVAL = newSViv(out);
1931			OUTPUT:
1932			RETVAL
1933
1934			bool
1935			put_ttl(SV* self_sv, int64_t key, int64_t value, UV ttl_sec)
1936			CODE:
1937	13	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1938	13	100	REQUIRE_TTL(h);
1939	12	50	RETVAL = shm_ii_put_ttl(h, key, value, (uint32_t)ttl_sec);
1940			OUTPUT:
1941			RETVAL
1942
1943			UV
1944			max_size(SV* self_sv)
1945			CODE:
1946	4	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1947	4	50	RETVAL = (UV)shm_ii_max_size(h);
1948			OUTPUT:
1949			RETVAL
1950
1951			UV
1952			ttl(SV* self_sv)
1953			CODE:
1954	4	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1955	4	50	RETVAL = (UV)shm_ii_ttl(h);
1956			OUTPUT:
1957			RETVAL
1958
1959
1960
1961			SV*
1962			take(SV* self_sv, int64_t key)
1963			CODE:
1964	4	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1965			int64_t out_value;
1966	4	100	if (!shm_ii_take(h, key, &out_value)) XSRETURN_UNDEF;
1967	2		RETVAL = newSViv(out_value);
1968			OUTPUT:
1969			RETVAL
1970
1971			UV
1972			flush_expired(SV* self_sv)
1973			CODE:
1974	6	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1975	6	50	RETVAL = (UV)shm_ii_flush_expired(h);
1976			OUTPUT:
1977			RETVAL
1978
1979
1980			void
1981			flush_expired_partial(SV* self_sv, UV limit)
1982			PPCODE:
1983	19	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1984	19		int done = 0;
1985	19		uint32_t flushed = shm_ii_flush_expired_partial(h, (uint32_t)limit, &done);
1986	19	50	EXTEND(SP, 2);
1987	19		mPUSHu(flushed);
1988	19		mPUSHi(done);
1989
1990			UV
1991			mmap_size(SV* self_sv)
1992			CODE:
1993	3	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
1994	3		RETVAL = (UV)shm_ii_mmap_size(h);
1995			OUTPUT:
1996			RETVAL
1997
1998
1999			bool
2000			touch(SV* self_sv, int64_t key)
2001			CODE:
2002	8	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
2003	8	100	RETVAL = shm_ii_touch(h, key);
2004			OUTPUT:
2005			RETVAL
2006
2007			bool
2008			reserve(SV* self_sv, UV target)
2009			CODE:
2010	4	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
2011	4	100	RETVAL = shm_ii_reserve(h, (uint32_t)target);
2012			OUTPUT:
2013			RETVAL
2014
2015			UV
2016			stat_evictions(SV* self_sv)
2017			CODE:
2018	8	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
2019	8		RETVAL = (UV)shm_ii_stat_evictions(h);
2020			OUTPUT:
2021			RETVAL
2022
2023			UV
2024			stat_expired(SV* self_sv)
2025			CODE:
2026	5	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
2027	5		RETVAL = (UV)shm_ii_stat_expired(h);
2028			OUTPUT:
2029			RETVAL
2030
2031
2032
2033			UV
2034			stat_recoveries(SV* self_sv)
2035			CODE:
2036	1	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
2037	1	50	RETVAL = (UV)shm_ii_stat_recoveries(h);
2038			OUTPUT:
2039			RETVAL
2040
2041			SV*
2042			path(SV* self_sv)
2043			CODE:
2044	1	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
2045	1		RETVAL = newSVpv(h->path, 0);
2046			OUTPUT:
2047			RETVAL
2048
2049
2050			bool
2051			unlink(SV* self_or_class, ...)
2052			CODE:
2053			const char *p;
2054	3	100	if (SvROK(self_or_class) && SvOBJECT(SvRV(self_or_class))) {
		50
2055	1		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_or_class)));
2056	1	50	if (!h) croak("Attempted to use a destroyed Data::HashMap::Shared::II object");
2057	1		p = h->path;
2058			} else {
2059	2	50	if (items < 2) croak("Usage: Data::HashMap::Shared::II->unlink($path)");
2060	2		p = SvPV_nolen(ST(1));
2061			}
2062	3	100	RETVAL = shm_unlink_path(p);
2063			OUTPUT:
2064			RETVAL
2065
2066			SV*
2067			ttl_remaining(SV* self_sv, int64_t key)
2068			CODE:
2069	13	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
2070	13		int64_t remaining = shm_ii_ttl_remaining(h, key);
2071	13	100	if (remaining < 0) XSRETURN_UNDEF;
2072	11		RETVAL = newSViv(remaining);
2073			OUTPUT:
2074			RETVAL
2075
2076			UV
2077			capacity(SV* self_sv)
2078			CODE:
2079	10	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
2080	10	50	RETVAL = (UV)shm_ii_capacity(h);
2081			OUTPUT:
2082			RETVAL
2083
2084			UV
2085			tombstones(SV* self_sv)
2086			CODE:
2087	4	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
2088	4	50	RETVAL = (UV)shm_ii_tombstones(h);
2089			OUTPUT:
2090			RETVAL
2091
2092			SV*
2093			cursor(SV* self_sv)
2094			CODE:
2095	12	50	EXTRACT_MAP("Data::HashMap::Shared::II", self_sv);
		50
		50
2096	12		ShmCursor* c = shm_cursor_create(h);
2097	12	50	if (!c) croak("Failed to allocate cursor");
2098	12		RETVAL = sv_setref_pv(newSV(0), "Data::HashMap::Shared::II::Cursor", (void*)c);
2099			OUTPUT:
2100			RETVAL
2101
2102			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::II::Cursor
2103			PROTOTYPES: DISABLE
2104
2105			void
2106			DESTROY(SV* self_sv)
2107			CODE:
2108	12	50	if (!SvROK(self_sv)) return;
2109	12		ShmCursor* c = INT2PTR(ShmCursor*, SvIV(SvRV(self_sv)));
2110	12	50	if (!c) return;
2111	12		ShmHandle* h = c->handle;
2112	12		shm_cursor_destroy(c);
2113	12	50	if (h) shm_ii_flush_deferred(h);
2114	12		sv_setiv(SvRV(self_sv), 0);
2115
2116			void
2117			next(SV* self_sv)
2118			PPCODE:
2119	88	50	EXTRACT_CURSOR("Data::HashMap::Shared::II::Cursor", self_sv);
		50
		50
2120			int64_t out_key; int64_t out_value;
2121	88	100	if (shm_ii_cursor_next(c, &out_key, &out_value)) {
2122	80	50	EXTEND(SP, 2);
2123	80	50	mXPUSHi(out_key);
2124	80	50	mXPUSHi(out_value);
2125	80		XSRETURN(2);
2126			}
2127	8		XSRETURN_EMPTY;
2128
2129			void
2130			reset(SV* self_sv)
2131			CODE:
2132	1	50	EXTRACT_CURSOR("Data::HashMap::Shared::II::Cursor", self_sv);
		50
		50
2133	1		shm_ii_cursor_reset(c);
2134
2135			bool
2136			seek(SV* self_sv, int64_t key)
2137			CODE:
2138	4	50	EXTRACT_CURSOR("Data::HashMap::Shared::II::Cursor", self_sv);
		50
		50
2139	4	100	RETVAL = shm_ii_cursor_seek(c, key);
2140			OUTPUT:
2141			RETVAL
2142
2143
2144			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::I16S
2145			PROTOTYPES: DISABLE
2146
2147			SV*
2148			new(char* class, char* path, UV max_entries, UV lru_max = 0, UV ttl_default = 0)
2149			CODE:
2150	2		char errbuf[SHM_ERR_BUFLEN]; ShmHandle* map = shm_i16s_create(path, (uint32_t)max_entries, (uint32_t)lru_max, (uint32_t)ttl_default, errbuf);
2151	2	50	if (!map) croak("HashMap::Shared::I16S: %s", errbuf[0] ? errbuf : "unknown error");
		0
2152	2		RETVAL = sv_setref_pv(newSV(0), class, (void*)map);
2153			OUTPUT:
2154			RETVAL
2155
2156			void
2157			DESTROY(SV* self_sv)
2158			CODE:
2159	2	50	if (!SvROK(self_sv)) return;
2160	2		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_sv)));
2161	2	50	if (!h) return;
2162	2		shm_close_map(h);
2163	2		sv_setiv(SvRV(self_sv), 0);
2164
2165			bool
2166			put(SV* self_sv, int16_t key, SV* value)
2167			CODE:
2168	4	50	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		50
		50
2169	4	50	EXTRACT_STR_VAL(value);
2170	4	50	RETVAL = shm_i16s_put(h, key, _vstr, (uint32_t)_vlen, _vutf8);
2171			OUTPUT:
2172			RETVAL
2173
2174			bool
2175			put_ttl(SV* self_sv, int16_t key, SV* value, UV ttl_sec)
2176			CODE:
2177	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2178	0	0	EXTRACT_STR_VAL(value);
2179	0	0	REQUIRE_TTL(h);
2180	0	0	RETVAL = shm_i16s_put_ttl(h, key, _vstr, (uint32_t)_vlen, _vutf8, (uint32_t)ttl_sec);
2181			OUTPUT:
2182			RETVAL
2183
2184			UV
2185			max_size(SV* self_sv)
2186			CODE:
2187	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2188	0	0	RETVAL = (UV)shm_i16s_max_size(h);
2189			OUTPUT:
2190			RETVAL
2191
2192			UV
2193			ttl(SV* self_sv)
2194			CODE:
2195	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2196	0	0	RETVAL = (UV)shm_i16s_ttl(h);
2197			OUTPUT:
2198			RETVAL
2199
2200			SV*
2201			get(SV* self_sv, int16_t key)
2202			CODE:
2203	5	50	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		50
		50
2204			const char* val; uint32_t val_len; bool val_utf8;
2205	5	100	if (!shm_i16s_get(h, key, &val, &val_len, &val_utf8)) XSRETURN_UNDEF;
2206	4		RETVAL = newSVpvn(val, val_len);
2207	4	100	if (val_utf8) SvUTF8_on(RETVAL);
2208			OUTPUT:
2209			RETVAL
2210
2211			bool
2212			remove(SV* self_sv, int16_t key)
2213			CODE:
2214	1	50	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		50
		50
2215	1	50	RETVAL = shm_i16s_remove(h, key);
2216			OUTPUT:
2217			RETVAL
2218
2219			bool
2220			exists(SV* self_sv, int16_t key)
2221			CODE:
2222	1	50	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		50
		50
2223	1	50	RETVAL = shm_i16s_exists(h, key);
2224			OUTPUT:
2225			RETVAL
2226
2227			UV
2228			size(SV* self_sv)
2229			CODE:
2230	1	50	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		50
		50
2231	1	50	RETVAL = (UV)shm_i16s_size(h);
2232			OUTPUT:
2233			RETVAL
2234
2235			UV
2236			max_entries(SV* self_sv)
2237			CODE:
2238	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2239	0	0	RETVAL = (UV)shm_i16s_max_entries(h);
2240			OUTPUT:
2241			RETVAL
2242
2243			void
2244			keys(SV* self_sv)
2245			PPCODE:
2246	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2247	0		ShmHeader *hdr = h->hdr;
2248	0		ShmNodeI16S nodes = (ShmNodeI16S )h->nodes;
2249	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
2250	0		RDLOCK_GUARD(hdr);
2251	0	0	EXTEND(SP, hdr->size);
2252	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
2253	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now))
		0
		0
		0
2254	0	0	mXPUSHi(nodes[i].key);
2255			}
2256
2257
2258			void
2259			values(SV* self_sv)
2260			PPCODE:
2261	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2262	0		ShmHeader *hdr = h->hdr;
2263	0		ShmNodeI16S nodes = (ShmNodeI16S )h->nodes;
2264	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
2265	0		RDLOCK_GUARD(hdr);
2266	0	0	EXTEND(SP, hdr->size);
2267	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
2268	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		0
		0
		0
2269	0		uint32_t vlen = SHM_UNPACK_LEN(nodes[i].val_len);
2270	0		SV* sv = newSVpvn(h->arena + nodes[i].val_off, vlen);
2271	0	0	if (SHM_UNPACK_UTF8(nodes[i].val_len)) SvUTF8_on(sv);
2272	0	0	mXPUSHs(sv);
2273			}
2274			}
2275
2276
2277			void
2278			items(SV* self_sv)
2279			PPCODE:
2280	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2281	0		ShmHeader *hdr = h->hdr;
2282	0		ShmNodeI16S nodes = (ShmNodeI16S )h->nodes;
2283	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
2284	0		RDLOCK_GUARD(hdr);
2285	0	0	EXTEND(SP, hdr->size * 2);
2286	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
2287	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		0
		0
		0
2288	0	0	mXPUSHi(nodes[i].key);
2289	0		uint32_t vlen = SHM_UNPACK_LEN(nodes[i].val_len);
2290	0		SV* sv = newSVpvn(h->arena + nodes[i].val_off, vlen);
2291	0	0	if (SHM_UNPACK_UTF8(nodes[i].val_len)) SvUTF8_on(sv);
2292	0	0	mXPUSHs(sv);
2293			}
2294			}
2295
2296
2297			void
2298			each(SV* self_sv)
2299			PPCODE:
2300	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2301			int16_t out_key;
2302			const char *out_val; uint32_t out_vlen; bool out_vutf8;
2303	0	0	if (shm_i16s_each(h, &out_key, &out_val, &out_vlen, &out_vutf8)) {
2304	0	0	EXTEND(SP, 2);
2305	0	0	mXPUSHi(out_key);
2306	0		SV* sv = newSVpvn(out_val, out_vlen);
2307	0	0	if (out_vutf8) SvUTF8_on(sv);
2308	0	0	mXPUSHs(sv);
2309	0		XSRETURN(2);
2310			}
2311	0		shm_i16s_flush_deferred(h);
2312	0		XSRETURN_EMPTY;
2313
2314			void
2315			iter_reset(SV* self_sv)
2316			CODE:
2317	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2318	0		shm_i16s_iter_reset(h);
2319	0		shm_i16s_flush_deferred(h);
2320
2321			void
2322			clear(SV* self_sv)
2323			CODE:
2324	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2325	0		shm_i16s_clear(h);
2326
2327			SV*
2328			to_hash(SV* self_sv)
2329			CODE:
2330	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2331	0		HV* hv = newHV();
2332	0		ShmHeader *hdr = h->hdr;
2333	0		ShmNodeI16S nodes = (ShmNodeI16S )h->nodes;
2334	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
2335	0		RDLOCK_GUARD(hdr);
2336	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
2337	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		0
		0
		0
2338	0		uint32_t vlen = SHM_UNPACK_LEN(nodes[i].val_len);
2339	0		bool vutf8 = SHM_UNPACK_UTF8(nodes[i].val_len);
2340	0		SV* val = newSVpvn(h->arena + nodes[i].val_off, vlen);
2341	0	0	if (vutf8) SvUTF8_on(val);
2342			char kbuf[24];
2343	0		int klen = my_snprintf(kbuf, sizeof(kbuf), "%" IVdf, (IV)nodes[i].key);
2344	0	0	if (!hv_store(hv, kbuf, klen, val, 0)) SvREFCNT_dec(val);
2345			}
2346			}
2347
2348	0		RETVAL = newRV_noinc((SV*)hv);
2349			OUTPUT:
2350			RETVAL
2351
2352			SV*
2353			get_or_set(SV* self_sv, int16_t key, SV* default_sv)
2354			CODE:
2355	2	50	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		50
		50
2356			const char *out_str; uint32_t out_len; bool out_utf8;
2357	2	50	EXTRACT_STR_VAL(default_sv);
2358	2		int rc = shm_i16s_get_or_set(h, key, _vstr, (uint32_t)_vlen, _vutf8, &out_str, &out_len, &out_utf8);
2359	2	50	if (!rc) XSRETURN_UNDEF;
2360	2		RETVAL = newSVpvn(out_str, out_len);
2361	2	50	if (out_utf8) SvUTF8_on(RETVAL);
2362			OUTPUT:
2363			RETVAL
2364
2365
2366
2367			SV*
2368			ttl_remaining(SV* self_sv, int16_t key)
2369			CODE:
2370	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2371	0		int64_t remaining = shm_i16s_ttl_remaining(h, key);
2372	0	0	if (remaining < 0) XSRETURN_UNDEF;
2373	0		RETVAL = newSViv(remaining);
2374			OUTPUT:
2375			RETVAL
2376
2377			UV
2378			capacity(SV* self_sv)
2379			CODE:
2380	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2381	0	0	RETVAL = (UV)shm_i16s_capacity(h);
2382			OUTPUT:
2383			RETVAL
2384
2385			UV
2386			tombstones(SV* self_sv)
2387			CODE:
2388	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2389	0	0	RETVAL = (UV)shm_i16s_tombstones(h);
2390			OUTPUT:
2391			RETVAL
2392
2393			SV*
2394			cursor(SV* self_sv)
2395			CODE:
2396	1	50	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		50
		50
2397	1		ShmCursor* c = shm_cursor_create(h);
2398	1	50	if (!c) croak("Failed to allocate cursor");
2399	1		RETVAL = sv_setref_pv(newSV(0), "Data::HashMap::Shared::I16S::Cursor", (void*)c);
2400			OUTPUT:
2401			RETVAL
2402
2403			SV*
2404			take(SV* self_sv, int16_t key)
2405			CODE:
2406	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2407			const char *out_str; uint32_t out_len; bool out_utf8;
2408	0	0	if (!shm_i16s_take(h, key, &out_str, &out_len, &out_utf8)) XSRETURN_UNDEF;
2409	0		RETVAL = newSVpvn(out_str, out_len);
2410	0	0	if (out_utf8) SvUTF8_on(RETVAL);
2411			OUTPUT:
2412			RETVAL
2413
2414			UV
2415			flush_expired(SV* self_sv)
2416			CODE:
2417	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2418	0	0	RETVAL = (UV)shm_i16s_flush_expired(h);
2419			OUTPUT:
2420			RETVAL
2421
2422
2423			void
2424			flush_expired_partial(SV* self_sv, UV limit)
2425			PPCODE:
2426	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2427	0		int done = 0;
2428	0		uint32_t flushed = shm_i16s_flush_expired_partial(h, (uint32_t)limit, &done);
2429	0	0	EXTEND(SP, 2);
2430	0		mPUSHu(flushed);
2431	0		mPUSHi(done);
2432
2433			UV
2434			mmap_size(SV* self_sv)
2435			CODE:
2436	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2437	0		RETVAL = (UV)shm_i16s_mmap_size(h);
2438			OUTPUT:
2439			RETVAL
2440
2441
2442			bool
2443			touch(SV* self_sv, int16_t key)
2444			CODE:
2445	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2446	0	0	RETVAL = shm_i16s_touch(h, key);
2447			OUTPUT:
2448			RETVAL
2449
2450			bool
2451			reserve(SV* self_sv, UV target)
2452			CODE:
2453	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2454	0	0	RETVAL = shm_i16s_reserve(h, (uint32_t)target);
2455			OUTPUT:
2456			RETVAL
2457
2458			UV
2459			stat_evictions(SV* self_sv)
2460			CODE:
2461	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2462	0		RETVAL = (UV)shm_i16s_stat_evictions(h);
2463			OUTPUT:
2464			RETVAL
2465
2466			UV
2467			stat_expired(SV* self_sv)
2468			CODE:
2469	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2470	0		RETVAL = (UV)shm_i16s_stat_expired(h);
2471			OUTPUT:
2472			RETVAL
2473
2474
2475
2476			UV
2477			stat_recoveries(SV* self_sv)
2478			CODE:
2479	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2480	0	0	RETVAL = (UV)shm_i16s_stat_recoveries(h);
2481			OUTPUT:
2482			RETVAL
2483
2484			SV*
2485			path(SV* self_sv)
2486			CODE:
2487	0	0	EXTRACT_MAP("Data::HashMap::Shared::I16S", self_sv);
		0
		0
2488	0		RETVAL = newSVpv(h->path, 0);
2489			OUTPUT:
2490			RETVAL
2491
2492
2493			bool
2494			unlink(SV* self_or_class, ...)
2495			CODE:
2496			const char *p;
2497	0	0	if (SvROK(self_or_class) && SvOBJECT(SvRV(self_or_class))) {
		0
2498	0		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_or_class)));
2499	0	0	if (!h) croak("Attempted to use a destroyed Data::HashMap::Shared::I16S object");
2500	0		p = h->path;
2501			} else {
2502	0	0	if (items < 2) croak("Usage: Data::HashMap::Shared::I16S->unlink($path)");
2503	0		p = SvPV_nolen(ST(1));
2504			}
2505	0	0	RETVAL = shm_unlink_path(p);
2506			OUTPUT:
2507			RETVAL
2508
2509			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::I16S::Cursor
2510			PROTOTYPES: DISABLE
2511
2512			void
2513			DESTROY(SV* self_sv)
2514			CODE:
2515	1	50	if (!SvROK(self_sv)) return;
2516	1		ShmCursor* c = INT2PTR(ShmCursor*, SvIV(SvRV(self_sv)));
2517	1	50	if (!c) return;
2518	1		ShmHandle* h = c->handle;
2519	1		shm_cursor_destroy(c);
2520	1	50	if (h) shm_i16s_flush_deferred(h);
2521	1		sv_setiv(SvRV(self_sv), 0);
2522
2523			void
2524			next(SV* self_sv)
2525			PPCODE:
2526	3	50	EXTRACT_CURSOR("Data::HashMap::Shared::I16S::Cursor", self_sv);
		50
		50
2527			int16_t out_key;
2528			const char *out_val; uint32_t out_vlen; bool out_vutf8;
2529	3	100	if (shm_i16s_cursor_next(c, &out_key, &out_val, &out_vlen, &out_vutf8)) {
2530	2	50	EXTEND(SP, 2);
2531	2	50	mXPUSHi(out_key);
2532	2		SV* sv = newSVpvn(out_val, out_vlen);
2533	2	100	if (out_vutf8) SvUTF8_on(sv);
2534	2	50	mXPUSHs(sv);
2535	2		XSRETURN(2);
2536			}
2537	1		XSRETURN_EMPTY;
2538
2539			void
2540			reset(SV* self_sv)
2541			CODE:
2542	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::I16S::Cursor", self_sv);
		0
		0
2543	0		shm_i16s_cursor_reset(c);
2544
2545			bool
2546			seek(SV* self_sv, int16_t key)
2547			CODE:
2548	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::I16S::Cursor", self_sv);
		0
		0
2549	0	0	RETVAL = shm_i16s_cursor_seek(c, key);
2550			OUTPUT:
2551			RETVAL
2552
2553
2554			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::I32S
2555			PROTOTYPES: DISABLE
2556
2557			SV*
2558			new(char* class, char* path, UV max_entries, UV lru_max = 0, UV ttl_default = 0)
2559			CODE:
2560	1		char errbuf[SHM_ERR_BUFLEN]; ShmHandle* map = shm_i32s_create(path, (uint32_t)max_entries, (uint32_t)lru_max, (uint32_t)ttl_default, errbuf);
2561	1	50	if (!map) croak("HashMap::Shared::I32S: %s", errbuf[0] ? errbuf : "unknown error");
		0
2562	1		RETVAL = sv_setref_pv(newSV(0), class, (void*)map);
2563			OUTPUT:
2564			RETVAL
2565
2566			void
2567			DESTROY(SV* self_sv)
2568			CODE:
2569	1	50	if (!SvROK(self_sv)) return;
2570	1		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_sv)));
2571	1	50	if (!h) return;
2572	1		shm_close_map(h);
2573	1		sv_setiv(SvRV(self_sv), 0);
2574
2575			bool
2576			put(SV* self_sv, int32_t key, SV* value)
2577			CODE:
2578	13	50	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		50
		50
2579	13	50	EXTRACT_STR_VAL(value);
2580	13	50	RETVAL = shm_i32s_put(h, key, _vstr, (uint32_t)_vlen, _vutf8);
2581			OUTPUT:
2582			RETVAL
2583
2584			bool
2585			put_ttl(SV* self_sv, int32_t key, SV* value, UV ttl_sec)
2586			CODE:
2587	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2588	0	0	EXTRACT_STR_VAL(value);
2589	0	0	REQUIRE_TTL(h);
2590	0	0	RETVAL = shm_i32s_put_ttl(h, key, _vstr, (uint32_t)_vlen, _vutf8, (uint32_t)ttl_sec);
2591			OUTPUT:
2592			RETVAL
2593
2594			UV
2595			max_size(SV* self_sv)
2596			CODE:
2597	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2598	0	0	RETVAL = (UV)shm_i32s_max_size(h);
2599			OUTPUT:
2600			RETVAL
2601
2602			UV
2603			ttl(SV* self_sv)
2604			CODE:
2605	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2606	0	0	RETVAL = (UV)shm_i32s_ttl(h);
2607			OUTPUT:
2608			RETVAL
2609
2610			SV*
2611			get(SV* self_sv, int32_t key)
2612			CODE:
2613	3	50	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		50
		50
2614			const char* val; uint32_t val_len; bool val_utf8;
2615	3	50	if (!shm_i32s_get(h, key, &val, &val_len, &val_utf8)) XSRETURN_UNDEF;
2616	3		RETVAL = newSVpvn(val, val_len);
2617	3	50	if (val_utf8) SvUTF8_on(RETVAL);
2618			OUTPUT:
2619			RETVAL
2620
2621			bool
2622			remove(SV* self_sv, int32_t key)
2623			CODE:
2624	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2625	0	0	RETVAL = shm_i32s_remove(h, key);
2626			OUTPUT:
2627			RETVAL
2628
2629			bool
2630			exists(SV* self_sv, int32_t key)
2631			CODE:
2632	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2633	0	0	RETVAL = shm_i32s_exists(h, key);
2634			OUTPUT:
2635			RETVAL
2636
2637			UV
2638			size(SV* self_sv)
2639			CODE:
2640	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2641	0	0	RETVAL = (UV)shm_i32s_size(h);
2642			OUTPUT:
2643			RETVAL
2644
2645			UV
2646			max_entries(SV* self_sv)
2647			CODE:
2648	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2649	0	0	RETVAL = (UV)shm_i32s_max_entries(h);
2650			OUTPUT:
2651			RETVAL
2652
2653			void
2654			keys(SV* self_sv)
2655			PPCODE:
2656	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2657	0		ShmHeader *hdr = h->hdr;
2658	0		ShmNodeI32S nodes = (ShmNodeI32S )h->nodes;
2659	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
2660	0		RDLOCK_GUARD(hdr);
2661	0	0	EXTEND(SP, hdr->size);
2662	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
2663	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now))
		0
		0
		0
2664	0	0	mXPUSHi(nodes[i].key);
2665			}
2666
2667
2668			void
2669			values(SV* self_sv)
2670			PPCODE:
2671	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2672	0		ShmHeader *hdr = h->hdr;
2673	0		ShmNodeI32S nodes = (ShmNodeI32S )h->nodes;
2674	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
2675	0		RDLOCK_GUARD(hdr);
2676	0	0	EXTEND(SP, hdr->size);
2677	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
2678	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		0
		0
		0
2679	0		uint32_t vlen = SHM_UNPACK_LEN(nodes[i].val_len);
2680	0		SV* sv = newSVpvn(h->arena + nodes[i].val_off, vlen);
2681	0	0	if (SHM_UNPACK_UTF8(nodes[i].val_len)) SvUTF8_on(sv);
2682	0	0	mXPUSHs(sv);
2683			}
2684			}
2685
2686
2687			void
2688			items(SV* self_sv)
2689			PPCODE:
2690	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2691	0		ShmHeader *hdr = h->hdr;
2692	0		ShmNodeI32S nodes = (ShmNodeI32S )h->nodes;
2693	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
2694	0		RDLOCK_GUARD(hdr);
2695	0	0	EXTEND(SP, hdr->size * 2);
2696	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
2697	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		0
		0
		0
2698	0	0	mXPUSHi(nodes[i].key);
2699	0		uint32_t vlen = SHM_UNPACK_LEN(nodes[i].val_len);
2700	0		SV* sv = newSVpvn(h->arena + nodes[i].val_off, vlen);
2701	0	0	if (SHM_UNPACK_UTF8(nodes[i].val_len)) SvUTF8_on(sv);
2702	0	0	mXPUSHs(sv);
2703			}
2704			}
2705
2706
2707			void
2708			each(SV* self_sv)
2709			PPCODE:
2710	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2711			int32_t out_key;
2712			const char *out_val; uint32_t out_vlen; bool out_vutf8;
2713	0	0	if (shm_i32s_each(h, &out_key, &out_val, &out_vlen, &out_vutf8)) {
2714	0	0	EXTEND(SP, 2);
2715	0	0	mXPUSHi(out_key);
2716	0		SV* sv = newSVpvn(out_val, out_vlen);
2717	0	0	if (out_vutf8) SvUTF8_on(sv);
2718	0	0	mXPUSHs(sv);
2719	0		XSRETURN(2);
2720			}
2721	0		shm_i32s_flush_deferred(h);
2722	0		XSRETURN_EMPTY;
2723
2724			void
2725			iter_reset(SV* self_sv)
2726			CODE:
2727	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2728	0		shm_i32s_iter_reset(h);
2729	0		shm_i32s_flush_deferred(h);
2730
2731			void
2732			clear(SV* self_sv)
2733			CODE:
2734	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2735	0		shm_i32s_clear(h);
2736
2737			SV*
2738			to_hash(SV* self_sv)
2739			CODE:
2740	1	50	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		50
		50
2741	1		HV* hv = newHV();
2742	1		ShmHeader *hdr = h->hdr;
2743	1		ShmNodeI32S nodes = (ShmNodeI32S )h->nodes;
2744	1	50	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
2745	1		RDLOCK_GUARD(hdr);
2746	17	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
2747	16	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		50
		0
		0
2748	12		uint32_t vlen = SHM_UNPACK_LEN(nodes[i].val_len);
2749	12		bool vutf8 = SHM_UNPACK_UTF8(nodes[i].val_len);
2750	12		SV* val = newSVpvn(h->arena + nodes[i].val_off, vlen);
2751	12	50	if (vutf8) SvUTF8_on(val);
2752			char kbuf[24];
2753	12		int klen = my_snprintf(kbuf, sizeof(kbuf), "%" IVdf, (IV)nodes[i].key);
2754	12	50	if (!hv_store(hv, kbuf, klen, val, 0)) SvREFCNT_dec(val);
2755			}
2756			}
2757
2758	1		RETVAL = newRV_noinc((SV*)hv);
2759			OUTPUT:
2760			RETVAL
2761
2762			SV*
2763			get_or_set(SV* self_sv, int32_t key, SV* default_sv)
2764			CODE:
2765	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2766			const char *out_str; uint32_t out_len; bool out_utf8;
2767	0	0	EXTRACT_STR_VAL(default_sv);
2768	0		int rc = shm_i32s_get_or_set(h, key, _vstr, (uint32_t)_vlen, _vutf8, &out_str, &out_len, &out_utf8);
2769	0	0	if (!rc) XSRETURN_UNDEF;
2770	0		RETVAL = newSVpvn(out_str, out_len);
2771	0	0	if (out_utf8) SvUTF8_on(RETVAL);
2772			OUTPUT:
2773			RETVAL
2774
2775
2776
2777			SV*
2778			ttl_remaining(SV* self_sv, int32_t key)
2779			CODE:
2780	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2781	0		int64_t remaining = shm_i32s_ttl_remaining(h, key);
2782	0	0	if (remaining < 0) XSRETURN_UNDEF;
2783	0		RETVAL = newSViv(remaining);
2784			OUTPUT:
2785			RETVAL
2786
2787			UV
2788			capacity(SV* self_sv)
2789			CODE:
2790	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2791	0	0	RETVAL = (UV)shm_i32s_capacity(h);
2792			OUTPUT:
2793			RETVAL
2794
2795			UV
2796			tombstones(SV* self_sv)
2797			CODE:
2798	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2799	0	0	RETVAL = (UV)shm_i32s_tombstones(h);
2800			OUTPUT:
2801			RETVAL
2802
2803			SV*
2804			cursor(SV* self_sv)
2805			CODE:
2806	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2807	0		ShmCursor* c = shm_cursor_create(h);
2808	0	0	if (!c) croak("Failed to allocate cursor");
2809	0		RETVAL = sv_setref_pv(newSV(0), "Data::HashMap::Shared::I32S::Cursor", (void*)c);
2810			OUTPUT:
2811			RETVAL
2812
2813			SV*
2814			take(SV* self_sv, int32_t key)
2815			CODE:
2816	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2817			const char *out_str; uint32_t out_len; bool out_utf8;
2818	0	0	if (!shm_i32s_take(h, key, &out_str, &out_len, &out_utf8)) XSRETURN_UNDEF;
2819	0		RETVAL = newSVpvn(out_str, out_len);
2820	0	0	if (out_utf8) SvUTF8_on(RETVAL);
2821			OUTPUT:
2822			RETVAL
2823
2824			UV
2825			flush_expired(SV* self_sv)
2826			CODE:
2827	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2828	0	0	RETVAL = (UV)shm_i32s_flush_expired(h);
2829			OUTPUT:
2830			RETVAL
2831
2832
2833			void
2834			flush_expired_partial(SV* self_sv, UV limit)
2835			PPCODE:
2836	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2837	0		int done = 0;
2838	0		uint32_t flushed = shm_i32s_flush_expired_partial(h, (uint32_t)limit, &done);
2839	0	0	EXTEND(SP, 2);
2840	0		mPUSHu(flushed);
2841	0		mPUSHi(done);
2842
2843			UV
2844			mmap_size(SV* self_sv)
2845			CODE:
2846	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2847	0		RETVAL = (UV)shm_i32s_mmap_size(h);
2848			OUTPUT:
2849			RETVAL
2850
2851
2852			bool
2853			touch(SV* self_sv, int32_t key)
2854			CODE:
2855	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2856	0	0	RETVAL = shm_i32s_touch(h, key);
2857			OUTPUT:
2858			RETVAL
2859
2860			bool
2861			reserve(SV* self_sv, UV target)
2862			CODE:
2863	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2864	0	0	RETVAL = shm_i32s_reserve(h, (uint32_t)target);
2865			OUTPUT:
2866			RETVAL
2867
2868			UV
2869			stat_evictions(SV* self_sv)
2870			CODE:
2871	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2872	0		RETVAL = (UV)shm_i32s_stat_evictions(h);
2873			OUTPUT:
2874			RETVAL
2875
2876			UV
2877			stat_expired(SV* self_sv)
2878			CODE:
2879	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2880	0		RETVAL = (UV)shm_i32s_stat_expired(h);
2881			OUTPUT:
2882			RETVAL
2883
2884
2885
2886			UV
2887			stat_recoveries(SV* self_sv)
2888			CODE:
2889	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2890	0	0	RETVAL = (UV)shm_i32s_stat_recoveries(h);
2891			OUTPUT:
2892			RETVAL
2893
2894			SV*
2895			path(SV* self_sv)
2896			CODE:
2897	0	0	EXTRACT_MAP("Data::HashMap::Shared::I32S", self_sv);
		0
		0
2898	0		RETVAL = newSVpv(h->path, 0);
2899			OUTPUT:
2900			RETVAL
2901
2902
2903			bool
2904			unlink(SV* self_or_class, ...)
2905			CODE:
2906			const char *p;
2907	0	0	if (SvROK(self_or_class) && SvOBJECT(SvRV(self_or_class))) {
		0
2908	0		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_or_class)));
2909	0	0	if (!h) croak("Attempted to use a destroyed Data::HashMap::Shared::I32S object");
2910	0		p = h->path;
2911			} else {
2912	0	0	if (items < 2) croak("Usage: Data::HashMap::Shared::I32S->unlink($path)");
2913	0		p = SvPV_nolen(ST(1));
2914			}
2915	0	0	RETVAL = shm_unlink_path(p);
2916			OUTPUT:
2917			RETVAL
2918
2919			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::I32S::Cursor
2920			PROTOTYPES: DISABLE
2921
2922			void
2923			DESTROY(SV* self_sv)
2924			CODE:
2925	0	0	if (!SvROK(self_sv)) return;
2926	0		ShmCursor* c = INT2PTR(ShmCursor*, SvIV(SvRV(self_sv)));
2927	0	0	if (!c) return;
2928	0		ShmHandle* h = c->handle;
2929	0		shm_cursor_destroy(c);
2930	0	0	if (h) shm_i32s_flush_deferred(h);
2931	0		sv_setiv(SvRV(self_sv), 0);
2932
2933			void
2934			next(SV* self_sv)
2935			PPCODE:
2936	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::I32S::Cursor", self_sv);
		0
		0
2937			int32_t out_key;
2938			const char *out_val; uint32_t out_vlen; bool out_vutf8;
2939	0	0	if (shm_i32s_cursor_next(c, &out_key, &out_val, &out_vlen, &out_vutf8)) {
2940	0	0	EXTEND(SP, 2);
2941	0	0	mXPUSHi(out_key);
2942	0		SV* sv = newSVpvn(out_val, out_vlen);
2943	0	0	if (out_vutf8) SvUTF8_on(sv);
2944	0	0	mXPUSHs(sv);
2945	0		XSRETURN(2);
2946			}
2947	0		XSRETURN_EMPTY;
2948
2949			void
2950			reset(SV* self_sv)
2951			CODE:
2952	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::I32S::Cursor", self_sv);
		0
		0
2953	0		shm_i32s_cursor_reset(c);
2954
2955			bool
2956			seek(SV* self_sv, int32_t key)
2957			CODE:
2958	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::I32S::Cursor", self_sv);
		0
		0
2959	0	0	RETVAL = shm_i32s_cursor_seek(c, key);
2960			OUTPUT:
2961			RETVAL
2962
2963
2964			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::IS
2965			PROTOTYPES: DISABLE
2966
2967			SV*
2968			new(char* class, char* path, UV max_entries, UV lru_max = 0, UV ttl_default = 0)
2969			CODE:
2970	2		char errbuf[SHM_ERR_BUFLEN]; ShmHandle* map = shm_is_create(path, (uint32_t)max_entries, (uint32_t)lru_max, (uint32_t)ttl_default, errbuf);
2971	2	50	if (!map) croak("HashMap::Shared::IS: %s", errbuf[0] ? errbuf : "unknown error");
		0
2972	2		RETVAL = sv_setref_pv(newSV(0), class, (void*)map);
2973			OUTPUT:
2974			RETVAL
2975
2976			void
2977			DESTROY(SV* self_sv)
2978			CODE:
2979	2	50	if (!SvROK(self_sv)) return;
2980	2		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_sv)));
2981	2	50	if (!h) return;
2982	2		shm_close_map(h);
2983	2		sv_setiv(SvRV(self_sv), 0);
2984
2985			bool
2986			put(SV* self_sv, int64_t key, SV* value)
2987			CODE:
2988	5	50	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		50
		50
2989	5	50	EXTRACT_STR_VAL(value);
2990	5	50	RETVAL = shm_is_put(h, key, _vstr, (uint32_t)_vlen, _vutf8);
2991			OUTPUT:
2992			RETVAL
2993
2994			bool
2995			put_ttl(SV* self_sv, int64_t key, SV* value, UV ttl_sec)
2996			CODE:
2997	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
2998	0	0	EXTRACT_STR_VAL(value);
2999	0	0	REQUIRE_TTL(h);
3000	0	0	RETVAL = shm_is_put_ttl(h, key, _vstr, (uint32_t)_vlen, _vutf8, (uint32_t)ttl_sec);
3001			OUTPUT:
3002			RETVAL
3003
3004			UV
3005			max_size(SV* self_sv)
3006			CODE:
3007	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3008	0	0	RETVAL = (UV)shm_is_max_size(h);
3009			OUTPUT:
3010			RETVAL
3011
3012			UV
3013			ttl(SV* self_sv)
3014			CODE:
3015	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3016	0	0	RETVAL = (UV)shm_is_ttl(h);
3017			OUTPUT:
3018			RETVAL
3019
3020			SV*
3021			get(SV* self_sv, int64_t key)
3022			CODE:
3023	3	50	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		50
		50
3024			const char* val; uint32_t val_len; bool val_utf8;
3025	3	50	if (!shm_is_get(h, key, &val, &val_len, &val_utf8)) XSRETURN_UNDEF;
3026	3		RETVAL = newSVpvn(val, val_len);
3027	3	100	if (val_utf8) SvUTF8_on(RETVAL);
3028			OUTPUT:
3029			RETVAL
3030
3031			bool
3032			remove(SV* self_sv, int64_t key)
3033			CODE:
3034	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3035	0	0	RETVAL = shm_is_remove(h, key);
3036			OUTPUT:
3037			RETVAL
3038
3039			bool
3040			exists(SV* self_sv, int64_t key)
3041			CODE:
3042	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3043	0	0	RETVAL = shm_is_exists(h, key);
3044			OUTPUT:
3045			RETVAL
3046
3047			UV
3048			size(SV* self_sv)
3049			CODE:
3050	2	50	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		50
		50
3051	2	50	RETVAL = (UV)shm_is_size(h);
3052			OUTPUT:
3053			RETVAL
3054
3055			UV
3056			max_entries(SV* self_sv)
3057			CODE:
3058	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3059	0	0	RETVAL = (UV)shm_is_max_entries(h);
3060			OUTPUT:
3061			RETVAL
3062
3063			void
3064			keys(SV* self_sv)
3065			PPCODE:
3066	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3067	0		ShmHeader *hdr = h->hdr;
3068	0		ShmNodeIS nodes = (ShmNodeIS )h->nodes;
3069	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
3070	0		RDLOCK_GUARD(hdr);
3071	0	0	EXTEND(SP, hdr->size);
3072	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
3073	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now))
		0
		0
		0
3074	0	0	mXPUSHi(nodes[i].key);
3075			}
3076
3077
3078			void
3079			values(SV* self_sv)
3080			PPCODE:
3081	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3082	0		ShmHeader *hdr = h->hdr;
3083	0		ShmNodeIS nodes = (ShmNodeIS )h->nodes;
3084	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
3085	0		RDLOCK_GUARD(hdr);
3086	0	0	EXTEND(SP, hdr->size);
3087	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
3088	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		0
		0
		0
3089	0		uint32_t vlen = SHM_UNPACK_LEN(nodes[i].val_len);
3090	0		SV* sv = newSVpvn(h->arena + nodes[i].val_off, vlen);
3091	0	0	if (SHM_UNPACK_UTF8(nodes[i].val_len)) SvUTF8_on(sv);
3092	0	0	mXPUSHs(sv);
3093			}
3094			}
3095
3096
3097			void
3098			items(SV* self_sv)
3099			PPCODE:
3100	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3101	0		ShmHeader *hdr = h->hdr;
3102	0		ShmNodeIS nodes = (ShmNodeIS )h->nodes;
3103	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
3104	0		RDLOCK_GUARD(hdr);
3105	0	0	EXTEND(SP, hdr->size * 2);
3106	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
3107	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		0
		0
		0
3108	0	0	mXPUSHi(nodes[i].key);
3109	0		uint32_t vlen = SHM_UNPACK_LEN(nodes[i].val_len);
3110	0		SV* sv = newSVpvn(h->arena + nodes[i].val_off, vlen);
3111	0	0	if (SHM_UNPACK_UTF8(nodes[i].val_len)) SvUTF8_on(sv);
3112	0	0	mXPUSHs(sv);
3113			}
3114			}
3115
3116
3117			void
3118			each(SV* self_sv)
3119			PPCODE:
3120	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3121			int64_t out_key;
3122			const char *out_val; uint32_t out_vlen; bool out_vutf8;
3123	0	0	if (shm_is_each(h, &out_key, &out_val, &out_vlen, &out_vutf8)) {
3124	0	0	EXTEND(SP, 2);
3125	0	0	mXPUSHi(out_key);
3126	0		SV* sv = newSVpvn(out_val, out_vlen);
3127	0	0	if (out_vutf8) SvUTF8_on(sv);
3128	0	0	mXPUSHs(sv);
3129	0		XSRETURN(2);
3130			}
3131	0		shm_is_flush_deferred(h);
3132	0		XSRETURN_EMPTY;
3133
3134			void
3135			iter_reset(SV* self_sv)
3136			CODE:
3137	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3138	0		shm_is_iter_reset(h);
3139	0		shm_is_flush_deferred(h);
3140
3141			void
3142			clear(SV* self_sv)
3143			CODE:
3144	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3145	0		shm_is_clear(h);
3146
3147			SV*
3148			to_hash(SV* self_sv)
3149			CODE:
3150	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3151	0		HV* hv = newHV();
3152	0		ShmHeader *hdr = h->hdr;
3153	0		ShmNodeIS nodes = (ShmNodeIS )h->nodes;
3154	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
3155	0		RDLOCK_GUARD(hdr);
3156	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
3157	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		0
		0
		0
3158	0		uint32_t vlen = SHM_UNPACK_LEN(nodes[i].val_len);
3159	0		bool vutf8 = SHM_UNPACK_UTF8(nodes[i].val_len);
3160	0		SV* val = newSVpvn(h->arena + nodes[i].val_off, vlen);
3161	0	0	if (vutf8) SvUTF8_on(val);
3162			char kbuf[24];
3163	0		int klen = my_snprintf(kbuf, sizeof(kbuf), "%" IVdf, (IV)nodes[i].key);
3164	0	0	if (!hv_store(hv, kbuf, klen, val, 0)) SvREFCNT_dec(val);
3165			}
3166			}
3167
3168	0		RETVAL = newRV_noinc((SV*)hv);
3169			OUTPUT:
3170			RETVAL
3171
3172			SV*
3173			get_or_set(SV* self_sv, int64_t key, SV* default_sv)
3174			CODE:
3175	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3176			const char *out_str; uint32_t out_len; bool out_utf8;
3177	0	0	EXTRACT_STR_VAL(default_sv);
3178	0		int rc = shm_is_get_or_set(h, key, _vstr, (uint32_t)_vlen, _vutf8, &out_str, &out_len, &out_utf8);
3179	0	0	if (!rc) XSRETURN_UNDEF;
3180	0		RETVAL = newSVpvn(out_str, out_len);
3181	0	0	if (out_utf8) SvUTF8_on(RETVAL);
3182			OUTPUT:
3183			RETVAL
3184
3185
3186
3187			SV*
3188			ttl_remaining(SV* self_sv, int64_t key)
3189			CODE:
3190	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3191	0		int64_t remaining = shm_is_ttl_remaining(h, key);
3192	0	0	if (remaining < 0) XSRETURN_UNDEF;
3193	0		RETVAL = newSViv(remaining);
3194			OUTPUT:
3195			RETVAL
3196
3197			UV
3198			capacity(SV* self_sv)
3199			CODE:
3200	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3201	0	0	RETVAL = (UV)shm_is_capacity(h);
3202			OUTPUT:
3203			RETVAL
3204
3205			UV
3206			tombstones(SV* self_sv)
3207			CODE:
3208	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3209	0	0	RETVAL = (UV)shm_is_tombstones(h);
3210			OUTPUT:
3211			RETVAL
3212
3213			SV*
3214			cursor(SV* self_sv)
3215			CODE:
3216	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3217	0		ShmCursor* c = shm_cursor_create(h);
3218	0	0	if (!c) croak("Failed to allocate cursor");
3219	0		RETVAL = sv_setref_pv(newSV(0), "Data::HashMap::Shared::IS::Cursor", (void*)c);
3220			OUTPUT:
3221			RETVAL
3222
3223			SV*
3224			take(SV* self_sv, int64_t key)
3225			CODE:
3226	1	50	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		50
		50
3227			const char *out_str; uint32_t out_len; bool out_utf8;
3228	1	50	if (!shm_is_take(h, key, &out_str, &out_len, &out_utf8)) XSRETURN_UNDEF;
3229	1		RETVAL = newSVpvn(out_str, out_len);
3230	1	50	if (out_utf8) SvUTF8_on(RETVAL);
3231			OUTPUT:
3232			RETVAL
3233
3234			UV
3235			flush_expired(SV* self_sv)
3236			CODE:
3237	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3238	0	0	RETVAL = (UV)shm_is_flush_expired(h);
3239			OUTPUT:
3240			RETVAL
3241
3242
3243			void
3244			flush_expired_partial(SV* self_sv, UV limit)
3245			PPCODE:
3246	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3247	0		int done = 0;
3248	0		uint32_t flushed = shm_is_flush_expired_partial(h, (uint32_t)limit, &done);
3249	0	0	EXTEND(SP, 2);
3250	0		mPUSHu(flushed);
3251	0		mPUSHi(done);
3252
3253			UV
3254			mmap_size(SV* self_sv)
3255			CODE:
3256	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3257	0		RETVAL = (UV)shm_is_mmap_size(h);
3258			OUTPUT:
3259			RETVAL
3260
3261
3262			bool
3263			touch(SV* self_sv, int64_t key)
3264			CODE:
3265	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3266	0	0	RETVAL = shm_is_touch(h, key);
3267			OUTPUT:
3268			RETVAL
3269
3270			bool
3271			reserve(SV* self_sv, UV target)
3272			CODE:
3273	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3274	0	0	RETVAL = shm_is_reserve(h, (uint32_t)target);
3275			OUTPUT:
3276			RETVAL
3277
3278			UV
3279			stat_evictions(SV* self_sv)
3280			CODE:
3281	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3282	0		RETVAL = (UV)shm_is_stat_evictions(h);
3283			OUTPUT:
3284			RETVAL
3285
3286			UV
3287			stat_expired(SV* self_sv)
3288			CODE:
3289	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3290	0		RETVAL = (UV)shm_is_stat_expired(h);
3291			OUTPUT:
3292			RETVAL
3293
3294
3295
3296			UV
3297			stat_recoveries(SV* self_sv)
3298			CODE:
3299	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3300	0	0	RETVAL = (UV)shm_is_stat_recoveries(h);
3301			OUTPUT:
3302			RETVAL
3303
3304			SV*
3305			path(SV* self_sv)
3306			CODE:
3307	0	0	EXTRACT_MAP("Data::HashMap::Shared::IS", self_sv);
		0
		0
3308	0		RETVAL = newSVpv(h->path, 0);
3309			OUTPUT:
3310			RETVAL
3311
3312
3313			bool
3314			unlink(SV* self_or_class, ...)
3315			CODE:
3316			const char *p;
3317	0	0	if (SvROK(self_or_class) && SvOBJECT(SvRV(self_or_class))) {
		0
3318	0		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_or_class)));
3319	0	0	if (!h) croak("Attempted to use a destroyed Data::HashMap::Shared::IS object");
3320	0		p = h->path;
3321			} else {
3322	0	0	if (items < 2) croak("Usage: Data::HashMap::Shared::IS->unlink($path)");
3323	0		p = SvPV_nolen(ST(1));
3324			}
3325	0	0	RETVAL = shm_unlink_path(p);
3326			OUTPUT:
3327			RETVAL
3328
3329			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::IS::Cursor
3330			PROTOTYPES: DISABLE
3331
3332			void
3333			DESTROY(SV* self_sv)
3334			CODE:
3335	0	0	if (!SvROK(self_sv)) return;
3336	0		ShmCursor* c = INT2PTR(ShmCursor*, SvIV(SvRV(self_sv)));
3337	0	0	if (!c) return;
3338	0		ShmHandle* h = c->handle;
3339	0		shm_cursor_destroy(c);
3340	0	0	if (h) shm_is_flush_deferred(h);
3341	0		sv_setiv(SvRV(self_sv), 0);
3342
3343			void
3344			next(SV* self_sv)
3345			PPCODE:
3346	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::IS::Cursor", self_sv);
		0
		0
3347			int64_t out_key;
3348			const char *out_val; uint32_t out_vlen; bool out_vutf8;
3349	0	0	if (shm_is_cursor_next(c, &out_key, &out_val, &out_vlen, &out_vutf8)) {
3350	0	0	EXTEND(SP, 2);
3351	0	0	mXPUSHi(out_key);
3352	0		SV* sv = newSVpvn(out_val, out_vlen);
3353	0	0	if (out_vutf8) SvUTF8_on(sv);
3354	0	0	mXPUSHs(sv);
3355	0		XSRETURN(2);
3356			}
3357	0		XSRETURN_EMPTY;
3358
3359			void
3360			reset(SV* self_sv)
3361			CODE:
3362	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::IS::Cursor", self_sv);
		0
		0
3363	0		shm_is_cursor_reset(c);
3364
3365			bool
3366			seek(SV* self_sv, int64_t key)
3367			CODE:
3368	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::IS::Cursor", self_sv);
		0
		0
3369	0	0	RETVAL = shm_is_cursor_seek(c, key);
3370			OUTPUT:
3371			RETVAL
3372
3373
3374			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::SI16
3375			PROTOTYPES: DISABLE
3376
3377			SV*
3378			new(char* class, char* path, UV max_entries, UV lru_max = 0, UV ttl_default = 0)
3379			CODE:
3380	2		char errbuf[SHM_ERR_BUFLEN]; ShmHandle* map = shm_si16_create(path, (uint32_t)max_entries, (uint32_t)lru_max, (uint32_t)ttl_default, errbuf);
3381	2	50	if (!map) croak("HashMap::Shared::SI16: %s", errbuf[0] ? errbuf : "unknown error");
		0
3382	2		RETVAL = sv_setref_pv(newSV(0), class, (void*)map);
3383			OUTPUT:
3384			RETVAL
3385
3386			void
3387			DESTROY(SV* self_sv)
3388			CODE:
3389	2	50	if (!SvROK(self_sv)) return;
3390	2		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_sv)));
3391	2	50	if (!h) return;
3392	2		shm_close_map(h);
3393	2		sv_setiv(SvRV(self_sv), 0);
3394
3395			bool
3396			put(SV* self_sv, SV* key_sv, int16_t value)
3397			CODE:
3398	5	50	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		50
		50
3399	5	50	EXTRACT_STR_KEY(key_sv);
3400	5	50	RETVAL = shm_si16_put(h, _kstr, (uint32_t)_klen, _kutf8, value);
3401			OUTPUT:
3402			RETVAL
3403
3404			bool
3405			put_ttl(SV* self_sv, SV* key_sv, int16_t value, UV ttl_sec)
3406			CODE:
3407	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3408	0	0	EXTRACT_STR_KEY(key_sv);
3409	0	0	REQUIRE_TTL(h);
3410	0	0	RETVAL = shm_si16_put_ttl(h, _kstr, (uint32_t)_klen, _kutf8, value, (uint32_t)ttl_sec);
3411			OUTPUT:
3412			RETVAL
3413
3414			UV
3415			max_size(SV* self_sv)
3416			CODE:
3417	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3418	0	0	RETVAL = (UV)shm_si16_max_size(h);
3419			OUTPUT:
3420			RETVAL
3421
3422			UV
3423			ttl(SV* self_sv)
3424			CODE:
3425	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3426	0	0	RETVAL = (UV)shm_si16_ttl(h);
3427			OUTPUT:
3428			RETVAL
3429
3430			SV*
3431			get(SV* self_sv, SV* key_sv)
3432			CODE:
3433	5	50	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		50
		50
3434	5	50	EXTRACT_STR_KEY(key_sv);
3435			int16_t value;
3436	5	50	if (!shm_si16_get(h, _kstr, (uint32_t)_klen, _kutf8, &value)) XSRETURN_UNDEF;
3437	5		RETVAL = newSViv(value);
3438			OUTPUT:
3439			RETVAL
3440
3441			bool
3442			remove(SV* self_sv, SV* key_sv)
3443			CODE:
3444	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		50
		50
3445	1	50	EXTRACT_STR_KEY(key_sv);
3446	1	50	RETVAL = shm_si16_remove(h, _kstr, (uint32_t)_klen, _kutf8);
3447			OUTPUT:
3448			RETVAL
3449
3450			bool
3451			exists(SV* self_sv, SV* key_sv)
3452			CODE:
3453	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		50
		50
3454	1	50	EXTRACT_STR_KEY(key_sv);
3455	1	50	RETVAL = shm_si16_exists(h, _kstr, (uint32_t)_klen, _kutf8);
3456			OUTPUT:
3457			RETVAL
3458
3459			SV*
3460			incr(SV* self_sv, SV* key_sv)
3461			CODE:
3462	2	50	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		50
		50
3463	2	50	EXTRACT_STR_KEY(key_sv);
3464			int ok;
3465	2		int16_t val = shm_si16_incr_by(h, _kstr, (uint32_t)_klen, _kutf8, 1, &ok);
3466	2	50	if (!ok) croak("HashMap::Shared::SI16: increment failed");
3467	2		RETVAL = newSViv(val);
3468			OUTPUT:
3469			RETVAL
3470
3471			SV*
3472			decr(SV* self_sv, SV* key_sv)
3473			CODE:
3474	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		50
		50
3475	1	50	EXTRACT_STR_KEY(key_sv);
3476			int ok;
3477	1		int16_t val = shm_si16_incr_by(h, _kstr, (uint32_t)_klen, _kutf8, -1, &ok);
3478	1	50	if (!ok) croak("HashMap::Shared::SI16: decrement failed");
3479	1		RETVAL = newSViv(val);
3480			OUTPUT:
3481			RETVAL
3482
3483			SV*
3484			incr_by(SV* self_sv, SV* key_sv, int16_t delta)
3485			CODE:
3486	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3487	0	0	EXTRACT_STR_KEY(key_sv);
3488			int ok;
3489	0		int16_t val = shm_si16_incr_by(h, _kstr, (uint32_t)_klen, _kutf8, delta, &ok);
3490	0	0	if (!ok) croak("HashMap::Shared::SI16: incr_by failed");
3491	0		RETVAL = newSViv(val);
3492			OUTPUT:
3493			RETVAL
3494
3495			UV
3496			size(SV* self_sv)
3497			CODE:
3498	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3499	0	0	RETVAL = (UV)shm_si16_size(h);
3500			OUTPUT:
3501			RETVAL
3502
3503			UV
3504			max_entries(SV* self_sv)
3505			CODE:
3506	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3507	0	0	RETVAL = (UV)shm_si16_max_entries(h);
3508			OUTPUT:
3509			RETVAL
3510
3511			void
3512			keys(SV* self_sv)
3513			PPCODE:
3514	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3515	0		ShmHeader *hdr = h->hdr;
3516	0		ShmNodeSI16 nodes = (ShmNodeSI16 )h->nodes;
3517	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
3518	0		RDLOCK_GUARD(hdr);
3519	0	0	EXTEND(SP, hdr->size);
3520	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
3521	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		0
		0
		0
3522	0		uint32_t klen = SHM_UNPACK_LEN(nodes[i].key_len);
3523	0		SV* sv = newSVpvn(h->arena + nodes[i].key_off, klen);
3524	0	0	if (SHM_UNPACK_UTF8(nodes[i].key_len)) SvUTF8_on(sv);
3525	0	0	mXPUSHs(sv);
3526			}
3527			}
3528
3529
3530			void
3531			values(SV* self_sv)
3532			PPCODE:
3533	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3534	0		ShmHeader *hdr = h->hdr;
3535	0		ShmNodeSI16 nodes = (ShmNodeSI16 )h->nodes;
3536	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
3537	0		RDLOCK_GUARD(hdr);
3538	0	0	EXTEND(SP, hdr->size);
3539	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
3540	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now))
		0
		0
		0
3541	0	0	mXPUSHi(nodes[i].value);
3542			}
3543
3544
3545			void
3546			items(SV* self_sv)
3547			PPCODE:
3548	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3549	0		ShmHeader *hdr = h->hdr;
3550	0		ShmNodeSI16 nodes = (ShmNodeSI16 )h->nodes;
3551	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
3552	0		RDLOCK_GUARD(hdr);
3553	0	0	EXTEND(SP, hdr->size * 2);
3554	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
3555	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		0
		0
		0
3556	0		uint32_t klen = SHM_UNPACK_LEN(nodes[i].key_len);
3557	0		SV* sv = newSVpvn(h->arena + nodes[i].key_off, klen);
3558	0	0	if (SHM_UNPACK_UTF8(nodes[i].key_len)) SvUTF8_on(sv);
3559	0	0	mXPUSHs(sv);
3560	0	0	mXPUSHi(nodes[i].value);
3561			}
3562			}
3563
3564
3565			void
3566			each(SV* self_sv)
3567			PPCODE:
3568	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3569			const char *out_key; uint32_t out_klen; bool out_kutf8;
3570			int16_t out_value;
3571	0	0	if (shm_si16_each(h, &out_key, &out_klen, &out_kutf8, &out_value)) {
3572	0	0	EXTEND(SP, 2);
3573	0		SV* ksv = newSVpvn(out_key, out_klen);
3574	0	0	if (out_kutf8) SvUTF8_on(ksv);
3575	0	0	mXPUSHs(ksv);
3576	0	0	mXPUSHi(out_value);
3577	0		XSRETURN(2);
3578			}
3579	0		shm_si16_flush_deferred(h);
3580	0		XSRETURN_EMPTY;
3581
3582			void
3583			iter_reset(SV* self_sv)
3584			CODE:
3585	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3586	0		shm_si16_iter_reset(h);
3587	0		shm_si16_flush_deferred(h);
3588
3589			void
3590			clear(SV* self_sv)
3591			CODE:
3592	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3593	0		shm_si16_clear(h);
3594
3595			SV*
3596			to_hash(SV* self_sv)
3597			CODE:
3598	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3599	0		HV* hv = newHV();
3600	0		ShmHeader *hdr = h->hdr;
3601	0		ShmNodeSI16 nodes = (ShmNodeSI16 )h->nodes;
3602	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
3603	0		RDLOCK_GUARD(hdr);
3604	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
3605	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		0
		0
		0
3606	0		uint32_t klen = SHM_UNPACK_LEN(nodes[i].key_len);
3607	0		bool kutf8 = SHM_UNPACK_UTF8(nodes[i].key_len);
3608	0		SV* val = newSViv(nodes[i].value);
3609	0	0	if (!hv_store(hv, h->arena + nodes[i].key_off,
		0
3610	0		kutf8 ? -(I32)klen : (I32)klen, val, 0)) SvREFCNT_dec(val);
3611			}
3612			}
3613
3614	0		RETVAL = newRV_noinc((SV*)hv);
3615			OUTPUT:
3616			RETVAL
3617
3618			SV*
3619			get_or_set(SV* self_sv, SV* key_sv, int16_t default_value)
3620			CODE:
3621	2	50	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		50
		50
3622	2	50	EXTRACT_STR_KEY(key_sv);
3623			int16_t out;
3624	2		int rc = shm_si16_get_or_set(h, _kstr, (uint32_t)_klen, _kutf8, default_value, &out);
3625	2	50	if (!rc) XSRETURN_UNDEF;
3626	2		RETVAL = newSViv(out);
3627			OUTPUT:
3628			RETVAL
3629
3630
3631
3632			SV*
3633			take(SV* self_sv, SV* key_sv)
3634			CODE:
3635	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3636	0	0	EXTRACT_STR_KEY(key_sv);
3637			int16_t out_value;
3638	0	0	if (!shm_si16_take(h, _kstr, (uint32_t)_klen, _kutf8, &out_value)) XSRETURN_UNDEF;
3639	0		RETVAL = newSViv(out_value);
3640			OUTPUT:
3641			RETVAL
3642
3643			UV
3644			flush_expired(SV* self_sv)
3645			CODE:
3646	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3647	0	0	RETVAL = (UV)shm_si16_flush_expired(h);
3648			OUTPUT:
3649			RETVAL
3650
3651
3652			void
3653			flush_expired_partial(SV* self_sv, UV limit)
3654			PPCODE:
3655	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3656	0		int done = 0;
3657	0		uint32_t flushed = shm_si16_flush_expired_partial(h, (uint32_t)limit, &done);
3658	0	0	EXTEND(SP, 2);
3659	0		mPUSHu(flushed);
3660	0		mPUSHi(done);
3661
3662			UV
3663			mmap_size(SV* self_sv)
3664			CODE:
3665	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3666	0		RETVAL = (UV)shm_si16_mmap_size(h);
3667			OUTPUT:
3668			RETVAL
3669
3670
3671			bool
3672			touch(SV* self_sv, SV* key_sv)
3673			CODE:
3674	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3675	0	0	EXTRACT_STR_KEY(key_sv);
3676	0	0	RETVAL = shm_si16_touch(h, _kstr, (uint32_t)_klen, _kutf8);
3677			OUTPUT:
3678			RETVAL
3679
3680			bool
3681			reserve(SV* self_sv, UV target)
3682			CODE:
3683	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3684	0	0	RETVAL = shm_si16_reserve(h, (uint32_t)target);
3685			OUTPUT:
3686			RETVAL
3687
3688			UV
3689			stat_evictions(SV* self_sv)
3690			CODE:
3691	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3692	0		RETVAL = (UV)shm_si16_stat_evictions(h);
3693			OUTPUT:
3694			RETVAL
3695
3696			UV
3697			stat_expired(SV* self_sv)
3698			CODE:
3699	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3700	0		RETVAL = (UV)shm_si16_stat_expired(h);
3701			OUTPUT:
3702			RETVAL
3703
3704
3705
3706			UV
3707			stat_recoveries(SV* self_sv)
3708			CODE:
3709	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3710	0	0	RETVAL = (UV)shm_si16_stat_recoveries(h);
3711			OUTPUT:
3712			RETVAL
3713
3714			SV*
3715			path(SV* self_sv)
3716			CODE:
3717	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3718	0		RETVAL = newSVpv(h->path, 0);
3719			OUTPUT:
3720			RETVAL
3721
3722
3723			bool
3724			unlink(SV* self_or_class, ...)
3725			CODE:
3726			const char *p;
3727	0	0	if (SvROK(self_or_class) && SvOBJECT(SvRV(self_or_class))) {
		0
3728	0		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_or_class)));
3729	0	0	if (!h) croak("Attempted to use a destroyed Data::HashMap::Shared::SI16 object");
3730	0		p = h->path;
3731			} else {
3732	0	0	if (items < 2) croak("Usage: Data::HashMap::Shared::SI16->unlink($path)");
3733	0		p = SvPV_nolen(ST(1));
3734			}
3735	0	0	RETVAL = shm_unlink_path(p);
3736			OUTPUT:
3737			RETVAL
3738
3739			SV*
3740			ttl_remaining(SV* self_sv, SV* key_sv)
3741			CODE:
3742	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3743	0	0	EXTRACT_STR_KEY(key_sv);
3744	0		int64_t remaining = shm_si16_ttl_remaining(h, _kstr, (uint32_t)_klen, _kutf8);
3745	0	0	if (remaining < 0) XSRETURN_UNDEF;
3746	0		RETVAL = newSViv(remaining);
3747			OUTPUT:
3748			RETVAL
3749
3750			UV
3751			capacity(SV* self_sv)
3752			CODE:
3753	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3754	0	0	RETVAL = (UV)shm_si16_capacity(h);
3755			OUTPUT:
3756			RETVAL
3757
3758			UV
3759			tombstones(SV* self_sv)
3760			CODE:
3761	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3762	0	0	RETVAL = (UV)shm_si16_tombstones(h);
3763			OUTPUT:
3764			RETVAL
3765
3766			SV*
3767			cursor(SV* self_sv)
3768			CODE:
3769	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI16", self_sv);
		0
		0
3770	0		ShmCursor* c = shm_cursor_create(h);
3771	0	0	if (!c) croak("Failed to allocate cursor");
3772	0		RETVAL = sv_setref_pv(newSV(0), "Data::HashMap::Shared::SI16::Cursor", (void*)c);
3773			OUTPUT:
3774			RETVAL
3775
3776			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::SI16::Cursor
3777			PROTOTYPES: DISABLE
3778
3779			void
3780			DESTROY(SV* self_sv)
3781			CODE:
3782	0	0	if (!SvROK(self_sv)) return;
3783	0		ShmCursor* c = INT2PTR(ShmCursor*, SvIV(SvRV(self_sv)));
3784	0	0	if (!c) return;
3785	0		ShmHandle* h = c->handle;
3786	0		shm_cursor_destroy(c);
3787	0	0	if (h) shm_si16_flush_deferred(h);
3788	0		sv_setiv(SvRV(self_sv), 0);
3789
3790			void
3791			next(SV* self_sv)
3792			PPCODE:
3793	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::SI16::Cursor", self_sv);
		0
		0
3794			const char *out_key; uint32_t out_klen; bool out_kutf8;
3795			int16_t out_value;
3796	0	0	if (shm_si16_cursor_next(c, &out_key, &out_klen, &out_kutf8, &out_value)) {
3797	0	0	EXTEND(SP, 2);
3798	0		SV* ksv = newSVpvn(out_key, out_klen);
3799	0	0	if (out_kutf8) SvUTF8_on(ksv);
3800	0	0	mXPUSHs(ksv);
3801	0	0	mXPUSHi(out_value);
3802	0		XSRETURN(2);
3803			}
3804	0		XSRETURN_EMPTY;
3805
3806			void
3807			reset(SV* self_sv)
3808			CODE:
3809	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::SI16::Cursor", self_sv);
		0
		0
3810	0		shm_si16_cursor_reset(c);
3811
3812			bool
3813			seek(SV* self_sv, SV* key_sv)
3814			CODE:
3815	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::SI16::Cursor", self_sv);
		0
		0
3816	0	0	EXTRACT_STR_KEY(key_sv);
3817	0	0	RETVAL = shm_si16_cursor_seek(c, _kstr, (uint32_t)_klen, _kutf8);
3818			OUTPUT:
3819			RETVAL
3820
3821
3822			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::SI32
3823			PROTOTYPES: DISABLE
3824
3825			SV*
3826			new(char* class, char* path, UV max_entries, UV lru_max = 0, UV ttl_default = 0)
3827			CODE:
3828	1		char errbuf[SHM_ERR_BUFLEN]; ShmHandle* map = shm_si32_create(path, (uint32_t)max_entries, (uint32_t)lru_max, (uint32_t)ttl_default, errbuf);
3829	1	50	if (!map) croak("HashMap::Shared::SI32: %s", errbuf[0] ? errbuf : "unknown error");
		0
3830	1		RETVAL = sv_setref_pv(newSV(0), class, (void*)map);
3831			OUTPUT:
3832			RETVAL
3833
3834			void
3835			DESTROY(SV* self_sv)
3836			CODE:
3837	1	50	if (!SvROK(self_sv)) return;
3838	1		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_sv)));
3839	1	50	if (!h) return;
3840	1		shm_close_map(h);
3841	1		sv_setiv(SvRV(self_sv), 0);
3842
3843			bool
3844			put(SV* self_sv, SV* key_sv, int32_t value)
3845			CODE:
3846	13	50	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		50
		50
3847	13	50	EXTRACT_STR_KEY(key_sv);
3848	13	50	RETVAL = shm_si32_put(h, _kstr, (uint32_t)_klen, _kutf8, value);
3849			OUTPUT:
3850			RETVAL
3851
3852			bool
3853			put_ttl(SV* self_sv, SV* key_sv, int32_t value, UV ttl_sec)
3854			CODE:
3855	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
3856	0	0	EXTRACT_STR_KEY(key_sv);
3857	0	0	REQUIRE_TTL(h);
3858	0	0	RETVAL = shm_si32_put_ttl(h, _kstr, (uint32_t)_klen, _kutf8, value, (uint32_t)ttl_sec);
3859			OUTPUT:
3860			RETVAL
3861
3862			UV
3863			max_size(SV* self_sv)
3864			CODE:
3865	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
3866	0	0	RETVAL = (UV)shm_si32_max_size(h);
3867			OUTPUT:
3868			RETVAL
3869
3870			UV
3871			ttl(SV* self_sv)
3872			CODE:
3873	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
3874	0	0	RETVAL = (UV)shm_si32_ttl(h);
3875			OUTPUT:
3876			RETVAL
3877
3878			SV*
3879			get(SV* self_sv, SV* key_sv)
3880			CODE:
3881	3	50	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		50
		50
3882	3	50	EXTRACT_STR_KEY(key_sv);
3883			int32_t value;
3884	3	50	if (!shm_si32_get(h, _kstr, (uint32_t)_klen, _kutf8, &value)) XSRETURN_UNDEF;
3885	3		RETVAL = newSViv(value);
3886			OUTPUT:
3887			RETVAL
3888
3889			bool
3890			remove(SV* self_sv, SV* key_sv)
3891			CODE:
3892	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
3893	0	0	EXTRACT_STR_KEY(key_sv);
3894	0	0	RETVAL = shm_si32_remove(h, _kstr, (uint32_t)_klen, _kutf8);
3895			OUTPUT:
3896			RETVAL
3897
3898			bool
3899			exists(SV* self_sv, SV* key_sv)
3900			CODE:
3901	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
3902	0	0	EXTRACT_STR_KEY(key_sv);
3903	0	0	RETVAL = shm_si32_exists(h, _kstr, (uint32_t)_klen, _kutf8);
3904			OUTPUT:
3905			RETVAL
3906
3907			SV*
3908			incr(SV* self_sv, SV* key_sv)
3909			CODE:
3910	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		50
		50
3911	1	50	EXTRACT_STR_KEY(key_sv);
3912			int ok;
3913	1		int32_t val = shm_si32_incr_by(h, _kstr, (uint32_t)_klen, _kutf8, 1, &ok);
3914	1	50	if (!ok) croak("HashMap::Shared::SI32: increment failed");
3915	1		RETVAL = newSViv(val);
3916			OUTPUT:
3917			RETVAL
3918
3919			SV*
3920			decr(SV* self_sv, SV* key_sv)
3921			CODE:
3922	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
3923	0	0	EXTRACT_STR_KEY(key_sv);
3924			int ok;
3925	0		int32_t val = shm_si32_incr_by(h, _kstr, (uint32_t)_klen, _kutf8, -1, &ok);
3926	0	0	if (!ok) croak("HashMap::Shared::SI32: decrement failed");
3927	0		RETVAL = newSViv(val);
3928			OUTPUT:
3929			RETVAL
3930
3931			SV*
3932			incr_by(SV* self_sv, SV* key_sv, int32_t delta)
3933			CODE:
3934	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		50
		50
3935	1	50	EXTRACT_STR_KEY(key_sv);
3936			int ok;
3937	1		int32_t val = shm_si32_incr_by(h, _kstr, (uint32_t)_klen, _kutf8, delta, &ok);
3938	1	50	if (!ok) croak("HashMap::Shared::SI32: incr_by failed");
3939	1		RETVAL = newSViv(val);
3940			OUTPUT:
3941			RETVAL
3942
3943			UV
3944			size(SV* self_sv)
3945			CODE:
3946	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
3947	0	0	RETVAL = (UV)shm_si32_size(h);
3948			OUTPUT:
3949			RETVAL
3950
3951			UV
3952			max_entries(SV* self_sv)
3953			CODE:
3954	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
3955	0	0	RETVAL = (UV)shm_si32_max_entries(h);
3956			OUTPUT:
3957			RETVAL
3958
3959			void
3960			keys(SV* self_sv)
3961			PPCODE:
3962	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		50
		50
3963	1		ShmHeader *hdr = h->hdr;
3964	1		ShmNodeSI32 nodes = (ShmNodeSI32 )h->nodes;
3965	1	50	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
3966	1		RDLOCK_GUARD(hdr);
3967	1	50	EXTEND(SP, hdr->size);
3968	17	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
3969	16	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		50
		0
		0
3970	13		uint32_t klen = SHM_UNPACK_LEN(nodes[i].key_len);
3971	13		SV* sv = newSVpvn(h->arena + nodes[i].key_off, klen);
3972	13	50	if (SHM_UNPACK_UTF8(nodes[i].key_len)) SvUTF8_on(sv);
3973	13	50	mXPUSHs(sv);
3974			}
3975			}
3976
3977
3978			void
3979			values(SV* self_sv)
3980			PPCODE:
3981	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
3982	0		ShmHeader *hdr = h->hdr;
3983	0		ShmNodeSI32 nodes = (ShmNodeSI32 )h->nodes;
3984	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
3985	0		RDLOCK_GUARD(hdr);
3986	0	0	EXTEND(SP, hdr->size);
3987	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
3988	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now))
		0
		0
		0
3989	0	0	mXPUSHi(nodes[i].value);
3990			}
3991
3992
3993			void
3994			items(SV* self_sv)
3995			PPCODE:
3996	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
3997	0		ShmHeader *hdr = h->hdr;
3998	0		ShmNodeSI32 nodes = (ShmNodeSI32 )h->nodes;
3999	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
4000	0		RDLOCK_GUARD(hdr);
4001	0	0	EXTEND(SP, hdr->size * 2);
4002	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
4003	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		0
		0
		0
4004	0		uint32_t klen = SHM_UNPACK_LEN(nodes[i].key_len);
4005	0		SV* sv = newSVpvn(h->arena + nodes[i].key_off, klen);
4006	0	0	if (SHM_UNPACK_UTF8(nodes[i].key_len)) SvUTF8_on(sv);
4007	0	0	mXPUSHs(sv);
4008	0	0	mXPUSHi(nodes[i].value);
4009			}
4010			}
4011
4012
4013			void
4014			each(SV* self_sv)
4015			PPCODE:
4016	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4017			const char *out_key; uint32_t out_klen; bool out_kutf8;
4018			int32_t out_value;
4019	0	0	if (shm_si32_each(h, &out_key, &out_klen, &out_kutf8, &out_value)) {
4020	0	0	EXTEND(SP, 2);
4021	0		SV* ksv = newSVpvn(out_key, out_klen);
4022	0	0	if (out_kutf8) SvUTF8_on(ksv);
4023	0	0	mXPUSHs(ksv);
4024	0	0	mXPUSHi(out_value);
4025	0		XSRETURN(2);
4026			}
4027	0		shm_si32_flush_deferred(h);
4028	0		XSRETURN_EMPTY;
4029
4030			void
4031			iter_reset(SV* self_sv)
4032			CODE:
4033	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4034	0		shm_si32_iter_reset(h);
4035	0		shm_si32_flush_deferred(h);
4036
4037			void
4038			clear(SV* self_sv)
4039			CODE:
4040	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4041	0		shm_si32_clear(h);
4042
4043			SV*
4044			to_hash(SV* self_sv)
4045			CODE:
4046	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		50
		50
4047	1		HV* hv = newHV();
4048	1		ShmHeader *hdr = h->hdr;
4049	1		ShmNodeSI32 nodes = (ShmNodeSI32 )h->nodes;
4050	1	50	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
4051	1		RDLOCK_GUARD(hdr);
4052	17	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
4053	16	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		50
		0
		0
4054	13		uint32_t klen = SHM_UNPACK_LEN(nodes[i].key_len);
4055	13		bool kutf8 = SHM_UNPACK_UTF8(nodes[i].key_len);
4056	13		SV* val = newSViv(nodes[i].value);
4057	13	50	if (!hv_store(hv, h->arena + nodes[i].key_off,
		50
4058	0		kutf8 ? -(I32)klen : (I32)klen, val, 0)) SvREFCNT_dec(val);
4059			}
4060			}
4061
4062	1		RETVAL = newRV_noinc((SV*)hv);
4063			OUTPUT:
4064			RETVAL
4065
4066			SV*
4067			get_or_set(SV* self_sv, SV* key_sv, int32_t default_value)
4068			CODE:
4069	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4070	0	0	EXTRACT_STR_KEY(key_sv);
4071			int32_t out;
4072	0		int rc = shm_si32_get_or_set(h, _kstr, (uint32_t)_klen, _kutf8, default_value, &out);
4073	0	0	if (!rc) XSRETURN_UNDEF;
4074	0		RETVAL = newSViv(out);
4075			OUTPUT:
4076			RETVAL
4077
4078
4079
4080			SV*
4081			ttl_remaining(SV* self_sv, SV* key_sv)
4082			CODE:
4083	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4084	0	0	EXTRACT_STR_KEY(key_sv);
4085	0		int64_t remaining = shm_si32_ttl_remaining(h, _kstr, (uint32_t)_klen, _kutf8);
4086	0	0	if (remaining < 0) XSRETURN_UNDEF;
4087	0		RETVAL = newSViv(remaining);
4088			OUTPUT:
4089			RETVAL
4090
4091			UV
4092			capacity(SV* self_sv)
4093			CODE:
4094	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4095	0	0	RETVAL = (UV)shm_si32_capacity(h);
4096			OUTPUT:
4097			RETVAL
4098
4099			UV
4100			tombstones(SV* self_sv)
4101			CODE:
4102	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4103	0	0	RETVAL = (UV)shm_si32_tombstones(h);
4104			OUTPUT:
4105			RETVAL
4106
4107			SV*
4108			cursor(SV* self_sv)
4109			CODE:
4110	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4111	0		ShmCursor* c = shm_cursor_create(h);
4112	0	0	if (!c) croak("Failed to allocate cursor");
4113	0		RETVAL = sv_setref_pv(newSV(0), "Data::HashMap::Shared::SI32::Cursor", (void*)c);
4114			OUTPUT:
4115			RETVAL
4116
4117			SV*
4118			take(SV* self_sv, SV* key_sv)
4119			CODE:
4120	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4121	0	0	EXTRACT_STR_KEY(key_sv);
4122			int32_t out_value;
4123	0	0	if (!shm_si32_take(h, _kstr, (uint32_t)_klen, _kutf8, &out_value)) XSRETURN_UNDEF;
4124	0		RETVAL = newSViv(out_value);
4125			OUTPUT:
4126			RETVAL
4127
4128			UV
4129			flush_expired(SV* self_sv)
4130			CODE:
4131	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4132	0	0	RETVAL = (UV)shm_si32_flush_expired(h);
4133			OUTPUT:
4134			RETVAL
4135
4136
4137			void
4138			flush_expired_partial(SV* self_sv, UV limit)
4139			PPCODE:
4140	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4141	0		int done = 0;
4142	0		uint32_t flushed = shm_si32_flush_expired_partial(h, (uint32_t)limit, &done);
4143	0	0	EXTEND(SP, 2);
4144	0		mPUSHu(flushed);
4145	0		mPUSHi(done);
4146
4147			UV
4148			mmap_size(SV* self_sv)
4149			CODE:
4150	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4151	0		RETVAL = (UV)shm_si32_mmap_size(h);
4152			OUTPUT:
4153			RETVAL
4154
4155
4156			bool
4157			touch(SV* self_sv, SV* key_sv)
4158			CODE:
4159	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4160	0	0	EXTRACT_STR_KEY(key_sv);
4161	0	0	RETVAL = shm_si32_touch(h, _kstr, (uint32_t)_klen, _kutf8);
4162			OUTPUT:
4163			RETVAL
4164
4165			bool
4166			reserve(SV* self_sv, UV target)
4167			CODE:
4168	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4169	0	0	RETVAL = shm_si32_reserve(h, (uint32_t)target);
4170			OUTPUT:
4171			RETVAL
4172
4173			UV
4174			stat_evictions(SV* self_sv)
4175			CODE:
4176	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4177	0		RETVAL = (UV)shm_si32_stat_evictions(h);
4178			OUTPUT:
4179			RETVAL
4180
4181			UV
4182			stat_expired(SV* self_sv)
4183			CODE:
4184	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4185	0		RETVAL = (UV)shm_si32_stat_expired(h);
4186			OUTPUT:
4187			RETVAL
4188
4189
4190
4191			UV
4192			stat_recoveries(SV* self_sv)
4193			CODE:
4194	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4195	0	0	RETVAL = (UV)shm_si32_stat_recoveries(h);
4196			OUTPUT:
4197			RETVAL
4198
4199			SV*
4200			path(SV* self_sv)
4201			CODE:
4202	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI32", self_sv);
		0
		0
4203	0		RETVAL = newSVpv(h->path, 0);
4204			OUTPUT:
4205			RETVAL
4206
4207
4208			bool
4209			unlink(SV* self_or_class, ...)
4210			CODE:
4211			const char *p;
4212	0	0	if (SvROK(self_or_class) && SvOBJECT(SvRV(self_or_class))) {
		0
4213	0		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_or_class)));
4214	0	0	if (!h) croak("Attempted to use a destroyed Data::HashMap::Shared::SI32 object");
4215	0		p = h->path;
4216			} else {
4217	0	0	if (items < 2) croak("Usage: Data::HashMap::Shared::SI32->unlink($path)");
4218	0		p = SvPV_nolen(ST(1));
4219			}
4220	0	0	RETVAL = shm_unlink_path(p);
4221			OUTPUT:
4222			RETVAL
4223
4224			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::SI32::Cursor
4225			PROTOTYPES: DISABLE
4226
4227			void
4228			DESTROY(SV* self_sv)
4229			CODE:
4230	0	0	if (!SvROK(self_sv)) return;
4231	0		ShmCursor* c = INT2PTR(ShmCursor*, SvIV(SvRV(self_sv)));
4232	0	0	if (!c) return;
4233	0		ShmHandle* h = c->handle;
4234	0		shm_cursor_destroy(c);
4235	0	0	if (h) shm_si32_flush_deferred(h);
4236	0		sv_setiv(SvRV(self_sv), 0);
4237
4238			void
4239			next(SV* self_sv)
4240			PPCODE:
4241	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::SI32::Cursor", self_sv);
		0
		0
4242			const char *out_key; uint32_t out_klen; bool out_kutf8;
4243			int32_t out_value;
4244	0	0	if (shm_si32_cursor_next(c, &out_key, &out_klen, &out_kutf8, &out_value)) {
4245	0	0	EXTEND(SP, 2);
4246	0		SV* ksv = newSVpvn(out_key, out_klen);
4247	0	0	if (out_kutf8) SvUTF8_on(ksv);
4248	0	0	mXPUSHs(ksv);
4249	0	0	mXPUSHi(out_value);
4250	0		XSRETURN(2);
4251			}
4252	0		XSRETURN_EMPTY;
4253
4254			void
4255			reset(SV* self_sv)
4256			CODE:
4257	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::SI32::Cursor", self_sv);
		0
		0
4258	0		shm_si32_cursor_reset(c);
4259
4260			bool
4261			seek(SV* self_sv, SV* key_sv)
4262			CODE:
4263	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::SI32::Cursor", self_sv);
		0
		0
4264	0	0	EXTRACT_STR_KEY(key_sv);
4265	0	0	RETVAL = shm_si32_cursor_seek(c, _kstr, (uint32_t)_klen, _kutf8);
4266			OUTPUT:
4267			RETVAL
4268
4269
4270			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::SI
4271			PROTOTYPES: DISABLE
4272
4273			SV*
4274			new(char* class, char* path, UV max_entries, UV lru_max = 0, UV ttl_default = 0)
4275			CODE:
4276	10		char errbuf[SHM_ERR_BUFLEN]; ShmHandle* map = shm_si_create(path, (uint32_t)max_entries, (uint32_t)lru_max, (uint32_t)ttl_default, errbuf);
4277	10	50	if (!map) croak("HashMap::Shared::SI: %s", errbuf[0] ? errbuf : "unknown error");
		0
4278	10		RETVAL = sv_setref_pv(newSV(0), class, (void*)map);
4279			OUTPUT:
4280			RETVAL
4281
4282			void
4283			DESTROY(SV* self_sv)
4284			CODE:
4285	10	50	if (!SvROK(self_sv)) return;
4286	10		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_sv)));
4287	10	50	if (!h) return;
4288	10		shm_close_map(h);
4289	10		sv_setiv(SvRV(self_sv), 0);
4290
4291			bool
4292			put(SV* self_sv, SV* key_sv, int64_t value)
4293			CODE:
4294	16	50	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		50
		50
4295	16	50	EXTRACT_STR_KEY(key_sv);
4296	16	50	RETVAL = shm_si_put(h, _kstr, (uint32_t)_klen, _kutf8, value);
4297			OUTPUT:
4298			RETVAL
4299
4300			bool
4301			put_ttl(SV* self_sv, SV* key_sv, int64_t value, UV ttl_sec)
4302			CODE:
4303	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4304	0	0	EXTRACT_STR_KEY(key_sv);
4305	0	0	REQUIRE_TTL(h);
4306	0	0	RETVAL = shm_si_put_ttl(h, _kstr, (uint32_t)_klen, _kutf8, value, (uint32_t)ttl_sec);
4307			OUTPUT:
4308			RETVAL
4309
4310			UV
4311			max_size(SV* self_sv)
4312			CODE:
4313	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4314	0	0	RETVAL = (UV)shm_si_max_size(h);
4315			OUTPUT:
4316			RETVAL
4317
4318			UV
4319			ttl(SV* self_sv)
4320			CODE:
4321	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4322	0	0	RETVAL = (UV)shm_si_ttl(h);
4323			OUTPUT:
4324			RETVAL
4325
4326			SV*
4327			get(SV* self_sv, SV* key_sv)
4328			CODE:
4329	5	50	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		50
		50
4330	5	50	EXTRACT_STR_KEY(key_sv);
4331			int64_t value;
4332	5	100	if (!shm_si_get(h, _kstr, (uint32_t)_klen, _kutf8, &value)) XSRETURN_UNDEF;
4333	3		RETVAL = newSViv(value);
4334			OUTPUT:
4335			RETVAL
4336
4337			bool
4338			remove(SV* self_sv, SV* key_sv)
4339			CODE:
4340	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		50
		50
4341	1	50	EXTRACT_STR_KEY(key_sv);
4342	1	50	RETVAL = shm_si_remove(h, _kstr, (uint32_t)_klen, _kutf8);
4343			OUTPUT:
4344			RETVAL
4345
4346			bool
4347			exists(SV* self_sv, SV* key_sv)
4348			CODE:
4349	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		50
		50
4350	1	50	EXTRACT_STR_KEY(key_sv);
4351	1	50	RETVAL = shm_si_exists(h, _kstr, (uint32_t)_klen, _kutf8);
4352			OUTPUT:
4353			RETVAL
4354
4355			SV*
4356			incr(SV* self_sv, SV* key_sv)
4357			CODE:
4358	2	50	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		50
		50
4359	2	50	EXTRACT_STR_KEY(key_sv);
4360			int ok;
4361	2		int64_t val = shm_si_incr_by(h, _kstr, (uint32_t)_klen, _kutf8, 1, &ok);
4362	2	50	if (!ok) croak("HashMap::Shared::SI: increment failed");
4363	2		RETVAL = newSViv(val);
4364			OUTPUT:
4365			RETVAL
4366
4367			SV*
4368			decr(SV* self_sv, SV* key_sv)
4369			CODE:
4370	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		50
		50
4371	1	50	EXTRACT_STR_KEY(key_sv);
4372			int ok;
4373	1		int64_t val = shm_si_incr_by(h, _kstr, (uint32_t)_klen, _kutf8, -1, &ok);
4374	1	50	if (!ok) croak("HashMap::Shared::SI: decrement failed");
4375	1		RETVAL = newSViv(val);
4376			OUTPUT:
4377			RETVAL
4378
4379			SV*
4380			incr_by(SV* self_sv, SV* key_sv, int64_t delta)
4381			CODE:
4382	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		50
		50
4383	1	50	EXTRACT_STR_KEY(key_sv);
4384			int ok;
4385	1		int64_t val = shm_si_incr_by(h, _kstr, (uint32_t)_klen, _kutf8, delta, &ok);
4386	1	50	if (!ok) croak("HashMap::Shared::SI: incr_by failed");
4387	1		RETVAL = newSViv(val);
4388			OUTPUT:
4389			RETVAL
4390
4391			UV
4392			size(SV* self_sv)
4393			CODE:
4394	2	50	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		50
		50
4395	2	50	RETVAL = (UV)shm_si_size(h);
4396			OUTPUT:
4397			RETVAL
4398
4399			UV
4400			max_entries(SV* self_sv)
4401			CODE:
4402	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4403	0	0	RETVAL = (UV)shm_si_max_entries(h);
4404			OUTPUT:
4405			RETVAL
4406
4407			void
4408			keys(SV* self_sv)
4409			PPCODE:
4410	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		50
		50
4411	1		ShmHeader *hdr = h->hdr;
4412	1		ShmNodeSI nodes = (ShmNodeSI )h->nodes;
4413	1	50	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
4414	1		RDLOCK_GUARD(hdr);
4415	1	50	EXTEND(SP, hdr->size);
4416	17	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
4417	16	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		50
		0
		0
4418	2		uint32_t klen = SHM_UNPACK_LEN(nodes[i].key_len);
4419	2		SV* sv = newSVpvn(h->arena + nodes[i].key_off, klen);
4420	2	50	if (SHM_UNPACK_UTF8(nodes[i].key_len)) SvUTF8_on(sv);
4421	2	50	mXPUSHs(sv);
4422			}
4423			}
4424
4425
4426			void
4427			values(SV* self_sv)
4428			PPCODE:
4429	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		50
		50
4430	1		ShmHeader *hdr = h->hdr;
4431	1		ShmNodeSI nodes = (ShmNodeSI )h->nodes;
4432	1	50	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
4433	1		RDLOCK_GUARD(hdr);
4434	1	50	EXTEND(SP, hdr->size);
4435	17	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
4436	16	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now))
		50
		0
		0
4437	2	50	mXPUSHi(nodes[i].value);
4438			}
4439
4440
4441			void
4442			items(SV* self_sv)
4443			PPCODE:
4444	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4445	0		ShmHeader *hdr = h->hdr;
4446	0		ShmNodeSI nodes = (ShmNodeSI )h->nodes;
4447	0	0	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
4448	0		RDLOCK_GUARD(hdr);
4449	0	0	EXTEND(SP, hdr->size * 2);
4450	0	0	for (uint32_t i = 0; i < hdr->table_cap; i++) {
4451	0	0	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		0
		0
		0
4452	0		uint32_t klen = SHM_UNPACK_LEN(nodes[i].key_len);
4453	0		SV* sv = newSVpvn(h->arena + nodes[i].key_off, klen);
4454	0	0	if (SHM_UNPACK_UTF8(nodes[i].key_len)) SvUTF8_on(sv);
4455	0	0	mXPUSHs(sv);
4456	0	0	mXPUSHi(nodes[i].value);
4457			}
4458			}
4459
4460
4461			void
4462			each(SV* self_sv)
4463			PPCODE:
4464	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4465			const char *out_key; uint32_t out_klen; bool out_kutf8;
4466			int64_t out_value;
4467	0	0	if (shm_si_each(h, &out_key, &out_klen, &out_kutf8, &out_value)) {
4468	0	0	EXTEND(SP, 2);
4469	0		SV* ksv = newSVpvn(out_key, out_klen);
4470	0	0	if (out_kutf8) SvUTF8_on(ksv);
4471	0	0	mXPUSHs(ksv);
4472	0	0	mXPUSHi(out_value);
4473	0		XSRETURN(2);
4474			}
4475	0		shm_si_flush_deferred(h);
4476	0		XSRETURN_EMPTY;
4477
4478			void
4479			iter_reset(SV* self_sv)
4480			CODE:
4481	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4482	0		shm_si_iter_reset(h);
4483	0		shm_si_flush_deferred(h);
4484
4485			void
4486			clear(SV* self_sv)
4487			CODE:
4488	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4489	0		shm_si_clear(h);
4490
4491			SV*
4492			to_hash(SV* self_sv)
4493			CODE:
4494	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		50
		50
4495	1		HV* hv = newHV();
4496	1		ShmHeader *hdr = h->hdr;
4497	1		ShmNodeSI nodes = (ShmNodeSI )h->nodes;
4498	1	50	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
4499	1		RDLOCK_GUARD(hdr);
4500	17	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
4501	16	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		50
		0
		0
4502	2		uint32_t klen = SHM_UNPACK_LEN(nodes[i].key_len);
4503	2		bool kutf8 = SHM_UNPACK_UTF8(nodes[i].key_len);
4504	2		SV* val = newSViv(nodes[i].value);
4505	2	50	if (!hv_store(hv, h->arena + nodes[i].key_off,
		50
4506	0		kutf8 ? -(I32)klen : (I32)klen, val, 0)) SvREFCNT_dec(val);
4507			}
4508			}
4509
4510	1		RETVAL = newRV_noinc((SV*)hv);
4511			OUTPUT:
4512			RETVAL
4513
4514			SV*
4515			get_or_set(SV* self_sv, SV* key_sv, int64_t default_value)
4516			CODE:
4517	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4518	0	0	EXTRACT_STR_KEY(key_sv);
4519			int64_t out;
4520	0		int rc = shm_si_get_or_set(h, _kstr, (uint32_t)_klen, _kutf8, default_value, &out);
4521	0	0	if (!rc) XSRETURN_UNDEF;
4522	0		RETVAL = newSViv(out);
4523			OUTPUT:
4524			RETVAL
4525
4526
4527
4528			SV*
4529			ttl_remaining(SV* self_sv, SV* key_sv)
4530			CODE:
4531	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4532	0	0	EXTRACT_STR_KEY(key_sv);
4533	0		int64_t remaining = shm_si_ttl_remaining(h, _kstr, (uint32_t)_klen, _kutf8);
4534	0	0	if (remaining < 0) XSRETURN_UNDEF;
4535	0		RETVAL = newSViv(remaining);
4536			OUTPUT:
4537			RETVAL
4538
4539			UV
4540			capacity(SV* self_sv)
4541			CODE:
4542	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4543	0	0	RETVAL = (UV)shm_si_capacity(h);
4544			OUTPUT:
4545			RETVAL
4546
4547			UV
4548			tombstones(SV* self_sv)
4549			CODE:
4550	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4551	0	0	RETVAL = (UV)shm_si_tombstones(h);
4552			OUTPUT:
4553			RETVAL
4554
4555			SV*
4556			cursor(SV* self_sv)
4557			CODE:
4558	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		50
		50
4559	1		ShmCursor* c = shm_cursor_create(h);
4560	1	50	if (!c) croak("Failed to allocate cursor");
4561	1		RETVAL = sv_setref_pv(newSV(0), "Data::HashMap::Shared::SI::Cursor", (void*)c);
4562			OUTPUT:
4563			RETVAL
4564
4565			SV*
4566			take(SV* self_sv, SV* key_sv)
4567			CODE:
4568	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		50
		50
4569	1	50	EXTRACT_STR_KEY(key_sv);
4570			int64_t out_value;
4571	1	50	if (!shm_si_take(h, _kstr, (uint32_t)_klen, _kutf8, &out_value)) XSRETURN_UNDEF;
4572	1		RETVAL = newSViv(out_value);
4573			OUTPUT:
4574			RETVAL
4575
4576			UV
4577			flush_expired(SV* self_sv)
4578			CODE:
4579	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4580	0	0	RETVAL = (UV)shm_si_flush_expired(h);
4581			OUTPUT:
4582			RETVAL
4583
4584
4585			void
4586			flush_expired_partial(SV* self_sv, UV limit)
4587			PPCODE:
4588	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4589	0		int done = 0;
4590	0		uint32_t flushed = shm_si_flush_expired_partial(h, (uint32_t)limit, &done);
4591	0	0	EXTEND(SP, 2);
4592	0		mPUSHu(flushed);
4593	0		mPUSHi(done);
4594
4595			UV
4596			mmap_size(SV* self_sv)
4597			CODE:
4598	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4599	0		RETVAL = (UV)shm_si_mmap_size(h);
4600			OUTPUT:
4601			RETVAL
4602
4603
4604			bool
4605			touch(SV* self_sv, SV* key_sv)
4606			CODE:
4607	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		50
		50
4608	1	50	EXTRACT_STR_KEY(key_sv);
4609	1	50	RETVAL = shm_si_touch(h, _kstr, (uint32_t)_klen, _kutf8);
4610			OUTPUT:
4611			RETVAL
4612
4613			bool
4614			reserve(SV* self_sv, UV target)
4615			CODE:
4616	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4617	0	0	RETVAL = shm_si_reserve(h, (uint32_t)target);
4618			OUTPUT:
4619			RETVAL
4620
4621			UV
4622			stat_evictions(SV* self_sv)
4623			CODE:
4624	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4625	0		RETVAL = (UV)shm_si_stat_evictions(h);
4626			OUTPUT:
4627			RETVAL
4628
4629			UV
4630			stat_expired(SV* self_sv)
4631			CODE:
4632	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4633	0		RETVAL = (UV)shm_si_stat_expired(h);
4634			OUTPUT:
4635			RETVAL
4636
4637
4638
4639			UV
4640			stat_recoveries(SV* self_sv)
4641			CODE:
4642	0	0	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		0
		0
4643	0	0	RETVAL = (UV)shm_si_stat_recoveries(h);
4644			OUTPUT:
4645			RETVAL
4646
4647			SV*
4648			path(SV* self_sv)
4649			CODE:
4650	1	50	EXTRACT_MAP("Data::HashMap::Shared::SI", self_sv);
		50
		50
4651	1		RETVAL = newSVpv(h->path, 0);
4652			OUTPUT:
4653			RETVAL
4654
4655
4656			bool
4657			unlink(SV* self_or_class, ...)
4658			CODE:
4659			const char *p;
4660	0	0	if (SvROK(self_or_class) && SvOBJECT(SvRV(self_or_class))) {
		0
4661	0		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_or_class)));
4662	0	0	if (!h) croak("Attempted to use a destroyed Data::HashMap::Shared::SI object");
4663	0		p = h->path;
4664			} else {
4665	0	0	if (items < 2) croak("Usage: Data::HashMap::Shared::SI->unlink($path)");
4666	0		p = SvPV_nolen(ST(1));
4667			}
4668	0	0	RETVAL = shm_unlink_path(p);
4669			OUTPUT:
4670			RETVAL
4671
4672			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::SI::Cursor
4673			PROTOTYPES: DISABLE
4674
4675			void
4676			DESTROY(SV* self_sv)
4677			CODE:
4678	1	50	if (!SvROK(self_sv)) return;
4679	1		ShmCursor* c = INT2PTR(ShmCursor*, SvIV(SvRV(self_sv)));
4680	1	50	if (!c) return;
4681	1		ShmHandle* h = c->handle;
4682	1		shm_cursor_destroy(c);
4683	1	50	if (h) shm_si_flush_deferred(h);
4684	1		sv_setiv(SvRV(self_sv), 0);
4685
4686			void
4687			next(SV* self_sv)
4688			PPCODE:
4689	6	50	EXTRACT_CURSOR("Data::HashMap::Shared::SI::Cursor", self_sv);
		50
		50
4690			const char *out_key; uint32_t out_klen; bool out_kutf8;
4691			int64_t out_value;
4692	6	100	if (shm_si_cursor_next(c, &out_key, &out_klen, &out_kutf8, &out_value)) {
4693	5	50	EXTEND(SP, 2);
4694	5		SV* ksv = newSVpvn(out_key, out_klen);
4695	5	50	if (out_kutf8) SvUTF8_on(ksv);
4696	5	50	mXPUSHs(ksv);
4697	5	50	mXPUSHi(out_value);
4698	5		XSRETURN(2);
4699			}
4700	1		XSRETURN_EMPTY;
4701
4702			void
4703			reset(SV* self_sv)
4704			CODE:
4705	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::SI::Cursor", self_sv);
		0
		0
4706	0		shm_si_cursor_reset(c);
4707
4708			bool
4709			seek(SV* self_sv, SV* key_sv)
4710			CODE:
4711	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::SI::Cursor", self_sv);
		0
		0
4712	0	0	EXTRACT_STR_KEY(key_sv);
4713	0	0	RETVAL = shm_si_cursor_seek(c, _kstr, (uint32_t)_klen, _kutf8);
4714			OUTPUT:
4715			RETVAL
4716
4717
4718			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::SS
4719			PROTOTYPES: DISABLE
4720
4721			SV*
4722			new(char* class, char* path, UV max_entries, UV lru_max = 0, UV ttl_default = 0)
4723			CODE:
4724	24		char errbuf[SHM_ERR_BUFLEN]; ShmHandle* map = shm_ss_create(path, (uint32_t)max_entries, (uint32_t)lru_max, (uint32_t)ttl_default, errbuf);
4725	24	100	if (!map) croak("HashMap::Shared::SS: %s", errbuf[0] ? errbuf : "unknown error");
		50
4726	22		RETVAL = sv_setref_pv(newSV(0), class, (void*)map);
4727			OUTPUT:
4728			RETVAL
4729
4730			void
4731			DESTROY(SV* self_sv)
4732			CODE:
4733	22	50	if (!SvROK(self_sv)) return;
4734	22		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_sv)));
4735	22	50	if (!h) return;
4736	22		shm_close_map(h);
4737	22		sv_setiv(SvRV(self_sv), 0);
4738
4739			bool
4740			put(SV* self_sv, SV* key_sv, SV* value)
4741			CODE:
4742	34	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4743	34	50	EXTRACT_STR_KEY(key_sv);
4744	34	50	EXTRACT_STR_VAL(value);
4745	34	50	RETVAL = shm_ss_put(h, _kstr, (uint32_t)_klen, _kutf8, _vstr, (uint32_t)_vlen, _vutf8);
4746			OUTPUT:
4747			RETVAL
4748
4749			bool
4750			put_ttl(SV* self_sv, SV* key_sv, SV* value, UV ttl_sec)
4751			CODE:
4752	1	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4753	1	50	EXTRACT_STR_KEY(key_sv);
4754	1	50	EXTRACT_STR_VAL(value);
4755	1	50	REQUIRE_TTL(h);
4756	1	50	RETVAL = shm_ss_put_ttl(h, _kstr, (uint32_t)_klen, _kutf8, _vstr, (uint32_t)_vlen, _vutf8, (uint32_t)ttl_sec);
4757			OUTPUT:
4758			RETVAL
4759
4760			UV
4761			max_size(SV* self_sv)
4762			CODE:
4763	0	0	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		0
		0
4764	0	0	RETVAL = (UV)shm_ss_max_size(h);
4765			OUTPUT:
4766			RETVAL
4767
4768			UV
4769			ttl(SV* self_sv)
4770			CODE:
4771	0	0	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		0
		0
4772	0	0	RETVAL = (UV)shm_ss_ttl(h);
4773			OUTPUT:
4774			RETVAL
4775
4776			SV*
4777			get(SV* self_sv, SV* key_sv)
4778			CODE:
4779	13	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4780	13	50	EXTRACT_STR_KEY(key_sv);
4781			const char* val; uint32_t val_len; bool val_utf8;
4782	13	100	if (!shm_ss_get(h, _kstr, (uint32_t)_klen, _kutf8, &val, &val_len, &val_utf8))
4783	4		XSRETURN_UNDEF;
4784	9		RETVAL = newSVpvn(val, val_len);
4785	9	100	if (val_utf8) SvUTF8_on(RETVAL);
4786			OUTPUT:
4787			RETVAL
4788
4789			bool
4790			remove(SV* self_sv, SV* key_sv)
4791			CODE:
4792	2	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4793	2	50	EXTRACT_STR_KEY(key_sv);
4794	2	50	RETVAL = shm_ss_remove(h, _kstr, (uint32_t)_klen, _kutf8);
4795			OUTPUT:
4796			RETVAL
4797
4798			bool
4799			exists(SV* self_sv, SV* key_sv)
4800			CODE:
4801	1	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4802	1	50	EXTRACT_STR_KEY(key_sv);
4803	1	50	RETVAL = shm_ss_exists(h, _kstr, (uint32_t)_klen, _kutf8);
4804			OUTPUT:
4805			RETVAL
4806
4807			UV
4808			size(SV* self_sv)
4809			CODE:
4810	5	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4811	5	50	RETVAL = (UV)shm_ss_size(h);
4812			OUTPUT:
4813			RETVAL
4814
4815			UV
4816			max_entries(SV* self_sv)
4817			CODE:
4818	0	0	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		0
		0
4819	0	0	RETVAL = (UV)shm_ss_max_entries(h);
4820			OUTPUT:
4821			RETVAL
4822
4823			void
4824			keys(SV* self_sv)
4825			PPCODE:
4826	1	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4827	1		ShmHeader *hdr = h->hdr;
4828	1		ShmNodeSS nodes = (ShmNodeSS )h->nodes;
4829	1	50	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
4830	1		RDLOCK_GUARD(hdr);
4831	1	50	EXTEND(SP, hdr->size);
4832	17	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
4833	16	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		50
		0
		0
4834	3		uint32_t klen = SHM_UNPACK_LEN(nodes[i].key_len);
4835	3		SV* sv = newSVpvn(h->arena + nodes[i].key_off, klen);
4836	3	50	if (SHM_UNPACK_UTF8(nodes[i].key_len)) SvUTF8_on(sv);
4837	3	50	mXPUSHs(sv);
4838			}
4839			}
4840
4841
4842			void
4843			values(SV* self_sv)
4844			PPCODE:
4845	1	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4846	1		ShmHeader *hdr = h->hdr;
4847	1		ShmNodeSS nodes = (ShmNodeSS )h->nodes;
4848	1	50	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
4849	1		RDLOCK_GUARD(hdr);
4850	1	50	EXTEND(SP, hdr->size);
4851	17	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
4852	16	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		50
		0
		0
4853	3		uint32_t vlen = SHM_UNPACK_LEN(nodes[i].val_len);
4854	3		SV* sv = newSVpvn(h->arena + nodes[i].val_off, vlen);
4855	3	50	if (SHM_UNPACK_UTF8(nodes[i].val_len)) SvUTF8_on(sv);
4856	3	50	mXPUSHs(sv);
4857			}
4858			}
4859
4860
4861			void
4862			items(SV* self_sv)
4863			PPCODE:
4864	1	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4865	1		ShmHeader *hdr = h->hdr;
4866	1		ShmNodeSS nodes = (ShmNodeSS )h->nodes;
4867	1	50	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
4868	1		RDLOCK_GUARD(hdr);
4869	1	50	EXTEND(SP, hdr->size * 2);
4870	17	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
4871	16	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		50
		0
		0
4872	3		uint32_t klen = SHM_UNPACK_LEN(nodes[i].key_len);
4873	3		SV* ksv = newSVpvn(h->arena + nodes[i].key_off, klen);
4874	3	50	if (SHM_UNPACK_UTF8(nodes[i].key_len)) SvUTF8_on(ksv);
4875	3	50	mXPUSHs(ksv);
4876	3		uint32_t vlen = SHM_UNPACK_LEN(nodes[i].val_len);
4877	3		SV* vsv = newSVpvn(h->arena + nodes[i].val_off, vlen);
4878	3	50	if (SHM_UNPACK_UTF8(nodes[i].val_len)) SvUTF8_on(vsv);
4879	3	50	mXPUSHs(vsv);
4880			}
4881			}
4882
4883
4884			void
4885			each(SV* self_sv)
4886			PPCODE:
4887	3	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4888			const char out_key, out_val;
4889			uint32_t out_klen, out_vlen;
4890			bool out_kutf8, out_vutf8;
4891	3	100	if (shm_ss_each(h, &out_key, &out_klen, &out_kutf8, &out_val, &out_vlen, &out_vutf8)) {
4892	2	50	EXTEND(SP, 2);
4893	2		SV* ksv = newSVpvn(out_key, out_klen);
4894	2	50	if (out_kutf8) SvUTF8_on(ksv);
4895	2	50	mXPUSHs(ksv);
4896	2		SV* vsv = newSVpvn(out_val, out_vlen);
4897	2	50	if (out_vutf8) SvUTF8_on(vsv);
4898	2	50	mXPUSHs(vsv);
4899	2		XSRETURN(2);
4900			}
4901	1		shm_ss_flush_deferred(h);
4902	1		XSRETURN_EMPTY;
4903
4904			void
4905			iter_reset(SV* self_sv)
4906			CODE:
4907	0	0	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		0
		0
4908	0		shm_ss_iter_reset(h);
4909	0		shm_ss_flush_deferred(h);
4910
4911			void
4912			clear(SV* self_sv)
4913			CODE:
4914	1	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4915	1		shm_ss_clear(h);
4916
4917			SV*
4918			to_hash(SV* self_sv)
4919			CODE:
4920	1	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4921	1		HV* hv = newHV();
4922	1		ShmHeader *hdr = h->hdr;
4923	1		ShmNodeSS nodes = (ShmNodeSS )h->nodes;
4924	1	50	uint32_t now = h->expires_at ? (uint32_t)time(NULL) : 0;
4925	1		RDLOCK_GUARD(hdr);
4926	17	100	for (uint32_t i = 0; i < hdr->table_cap; i++) {
4927	16	100	if (h->states[i] == SHM_LIVE && !SHM_IS_EXPIRED(h, i, now)) {
		50
		0
		0
4928	2		uint32_t klen = SHM_UNPACK_LEN(nodes[i].key_len);
4929	2		bool kutf8 = SHM_UNPACK_UTF8(nodes[i].key_len);
4930	2		uint32_t vlen = SHM_UNPACK_LEN(nodes[i].val_len);
4931	2		bool vutf8 = SHM_UNPACK_UTF8(nodes[i].val_len);
4932	2		SV* val = newSVpvn(h->arena + nodes[i].val_off, vlen);
4933	2	50	if (vutf8) SvUTF8_on(val);
4934	2	50	if (!hv_store(hv, h->arena + nodes[i].key_off,
		50
4935	0		kutf8 ? -(I32)klen : (I32)klen, val, 0)) SvREFCNT_dec(val);
4936			}
4937			}
4938
4939	1		RETVAL = newRV_noinc((SV*)hv);
4940			OUTPUT:
4941			RETVAL
4942
4943			SV*
4944			get_or_set(SV* self_sv, SV* key_sv, SV* default_sv)
4945			CODE:
4946	4	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4947	4	50	EXTRACT_STR_KEY(key_sv);
4948			const char *out_str; uint32_t out_len; bool out_utf8;
4949	4	50	EXTRACT_STR_VAL(default_sv);
4950	4		int rc = shm_ss_get_or_set(h, _kstr, (uint32_t)_klen, _kutf8, _vstr, (uint32_t)_vlen, _vutf8, &out_str, &out_len, &out_utf8);
4951	4	50	if (!rc) XSRETURN_UNDEF;
4952	4		RETVAL = newSVpvn(out_str, out_len);
4953	4	50	if (out_utf8) SvUTF8_on(RETVAL);
4954			OUTPUT:
4955			RETVAL
4956
4957
4958			SV*
4959			ttl_remaining(SV* self_sv, SV* key_sv)
4960			CODE:
4961	2	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4962	2	50	EXTRACT_STR_KEY(key_sv);
4963	2		int64_t remaining = shm_ss_ttl_remaining(h, _kstr, (uint32_t)_klen, _kutf8);
4964	2	100	if (remaining < 0) XSRETURN_UNDEF;
4965	1		RETVAL = newSViv(remaining);
4966			OUTPUT:
4967			RETVAL
4968
4969			UV
4970			capacity(SV* self_sv)
4971			CODE:
4972	1	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4973	1	50	RETVAL = (UV)shm_ss_capacity(h);
4974			OUTPUT:
4975			RETVAL
4976
4977			UV
4978			tombstones(SV* self_sv)
4979			CODE:
4980	0	0	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		0
		0
4981	0	0	RETVAL = (UV)shm_ss_tombstones(h);
4982			OUTPUT:
4983			RETVAL
4984
4985			SV*
4986			cursor(SV* self_sv)
4987			CODE:
4988	2	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4989	2		ShmCursor* c = shm_cursor_create(h);
4990	2	50	if (!c) croak("Failed to allocate cursor");
4991	2		RETVAL = sv_setref_pv(newSV(0), "Data::HashMap::Shared::SS::Cursor", (void*)c);
4992			OUTPUT:
4993			RETVAL
4994
4995			SV*
4996			take(SV* self_sv, SV* key_sv)
4997			CODE:
4998	3	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
4999	3	50	EXTRACT_STR_KEY(key_sv);
5000			const char *out_str; uint32_t out_len; bool out_utf8;
5001	3	100	if (!shm_ss_take(h, _kstr, (uint32_t)_klen, _kutf8, &out_str, &out_len, &out_utf8)) XSRETURN_UNDEF;
5002	2		RETVAL = newSVpvn(out_str, out_len);
5003	2	100	if (out_utf8) SvUTF8_on(RETVAL);
5004			OUTPUT:
5005			RETVAL
5006
5007			UV
5008			flush_expired(SV* self_sv)
5009			CODE:
5010	1	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
5011	1	50	RETVAL = (UV)shm_ss_flush_expired(h);
5012			OUTPUT:
5013			RETVAL
5014
5015
5016			void
5017			flush_expired_partial(SV* self_sv, UV limit)
5018			PPCODE:
5019	0	0	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		0
		0
5020	0		int done = 0;
5021	0		uint32_t flushed = shm_ss_flush_expired_partial(h, (uint32_t)limit, &done);
5022	0	0	EXTEND(SP, 2);
5023	0		mPUSHu(flushed);
5024	0		mPUSHi(done);
5025
5026			UV
5027			mmap_size(SV* self_sv)
5028			CODE:
5029	1	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
5030	1		RETVAL = (UV)shm_ss_mmap_size(h);
5031			OUTPUT:
5032			RETVAL
5033
5034
5035			bool
5036			touch(SV* self_sv, SV* key_sv)
5037			CODE:
5038	2	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
5039	2	50	EXTRACT_STR_KEY(key_sv);
5040	2	100	RETVAL = shm_ss_touch(h, _kstr, (uint32_t)_klen, _kutf8);
5041			OUTPUT:
5042			RETVAL
5043
5044			bool
5045			reserve(SV* self_sv, UV target)
5046			CODE:
5047	1	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
5048	1	50	RETVAL = shm_ss_reserve(h, (uint32_t)target);
5049			OUTPUT:
5050			RETVAL
5051
5052			UV
5053			stat_evictions(SV* self_sv)
5054			CODE:
5055	1	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
5056	1		RETVAL = (UV)shm_ss_stat_evictions(h);
5057			OUTPUT:
5058			RETVAL
5059
5060			UV
5061			stat_expired(SV* self_sv)
5062			CODE:
5063	0	0	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		0
		0
5064	0		RETVAL = (UV)shm_ss_stat_expired(h);
5065			OUTPUT:
5066			RETVAL
5067
5068
5069
5070			UV
5071			stat_recoveries(SV* self_sv)
5072			CODE:
5073	0	0	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		0
		0
5074	0	0	RETVAL = (UV)shm_ss_stat_recoveries(h);
5075			OUTPUT:
5076			RETVAL
5077
5078			SV*
5079			path(SV* self_sv)
5080			CODE:
5081	1	50	EXTRACT_MAP("Data::HashMap::Shared::SS", self_sv);
		50
		50
5082	1		RETVAL = newSVpv(h->path, 0);
5083			OUTPUT:
5084			RETVAL
5085
5086
5087			bool
5088			unlink(SV* self_or_class, ...)
5089			CODE:
5090			const char *p;
5091	0	0	if (SvROK(self_or_class) && SvOBJECT(SvRV(self_or_class))) {
		0
5092	0		ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(self_or_class)));
5093	0	0	if (!h) croak("Attempted to use a destroyed Data::HashMap::Shared::SS object");
5094	0		p = h->path;
5095			} else {
5096	0	0	if (items < 2) croak("Usage: Data::HashMap::Shared::SS->unlink($path)");
5097	0		p = SvPV_nolen(ST(1));
5098			}
5099	0	0	RETVAL = shm_unlink_path(p);
5100			OUTPUT:
5101			RETVAL
5102
5103			MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::SS::Cursor
5104			PROTOTYPES: DISABLE
5105
5106			void
5107			DESTROY(SV* self_sv)
5108			CODE:
5109	2	50	if (!SvROK(self_sv)) return;
5110	2		ShmCursor* c = INT2PTR(ShmCursor*, SvIV(SvRV(self_sv)));
5111	2	50	if (!c) return;
5112	2		ShmHandle* h = c->handle;
5113	2		shm_cursor_destroy(c);
5114	2	50	if (h) shm_ss_flush_deferred(h);
5115	2		sv_setiv(SvRV(self_sv), 0);
5116
5117			void
5118			next(SV* self_sv)
5119			PPCODE:
5120	7	50	EXTRACT_CURSOR("Data::HashMap::Shared::SS::Cursor", self_sv);
		50
		50
5121			const char out_key, out_val;
5122			uint32_t out_klen, out_vlen;
5123			bool out_kutf8, out_vutf8;
5124	7	100	if (shm_ss_cursor_next(c, &out_key, &out_klen, &out_kutf8, &out_val, &out_vlen, &out_vutf8)) {
5125	6	50	EXTEND(SP, 2);
5126	6		SV* ksv = newSVpvn(out_key, out_klen);
5127	6	50	if (out_kutf8) SvUTF8_on(ksv);
5128	6	50	mXPUSHs(ksv);
5129	6		SV* vsv = newSVpvn(out_val, out_vlen);
5130	6	50	if (out_vutf8) SvUTF8_on(vsv);
5131	6	50	mXPUSHs(vsv);
5132	6		XSRETURN(2);
5133			}
5134	1		XSRETURN_EMPTY;
5135
5136			void
5137			reset(SV* self_sv)
5138			CODE:
5139	0	0	EXTRACT_CURSOR("Data::HashMap::Shared::SS::Cursor", self_sv);
		0
		0
5140	0		shm_ss_cursor_reset(c);
5141
5142			bool
5143			seek(SV* self_sv, SV* key_sv)
5144			CODE:
5145	1	50	EXTRACT_CURSOR("Data::HashMap::Shared::SS::Cursor", self_sv);
		50
		50
5146	1	50	EXTRACT_STR_KEY(key_sv);
5147	1	50	RETVAL = shm_ss_cursor_seek(c, _kstr, (uint32_t)_klen, _kutf8);
5148			OUTPUT:
5149			RETVAL
5150