| 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 |
|
| /* Runs a close deferred by a DESTROY that arrived while a lock was held. */ |
| 24 |
113440 |
| static void shm_guard_leave(ShmHandle *h) { |
| 25 |
113440 |
▶ | if (--h->lock_depth == 0 && h->pending_close) shm_close_map_now(h); |
Branch: 2 branches
| Branch | True | False | Total |
| if (--h->lock_depth == 0 && h->pending_close) shm_close_map_now(h); |
113440 |
0 |
113440 |
| if (--h->lock_depth == 0 && h->pending_close) shm_close_map_now(h); |
0 |
113440 |
113440 |
|
| 26 |
113440 |
| } |
| 27 |
|
| |
| 28 |
113440 |
| static void shm_rdunlock_cleanup(pTHX_ void *ptr) { |
| 29 |
113440 |
| ShmHandle *h = (ShmHandle *)ptr; |
| 30 |
113440 |
| shm_rwlock_rdunlock(h); |
| 31 |
113440 |
| shm_guard_leave(h); |
| 32 |
113440 |
| } |
| 33 |
|
| |
| 34 |
|
| #define RDLOCK_GUARD(handle) \ |
| 35 |
|
| shm_rwlock_rdlock(handle); \ |
| 36 |
|
| (handle)->lock_depth++; \ |
| 37 |
|
| SAVEDESTRUCTOR_X(shm_rdunlock_cleanup, (void*)(handle)) |
| 38 |
|
| |
| 39 |
|
| /* ---- The wrlock + seqlock write section of a batch write ---- |
| 40 |
|
| * No destructor releases it: the only croak possible inside, Perl's own |
| 41 |
|
| * pending-signals croak, must leave the lock held and seq odd for stale-lock |
| 42 |
|
| * recovery, never publish a half-written table. shm_sig_check_every keeps that |
| 43 |
|
| * croak out. */ |
| 44 |
|
| #define WRSEQ_BEGIN(handle) \ |
| 45 |
|
| shm_rwlock_wrlock(handle); \ |
| 46 |
|
| shm_seqlock_write_begin(&(handle)->hdr->seq) |
| 47 |
|
| |
| 48 |
|
| #define WRSEQ_END(handle) \ |
| 49 |
|
| shm_seqlock_write_end(&(handle)->hdr->seq); \ |
| 50 |
|
| shm_rwlock_wrunlock(handle) |
| 51 |
|
| |
| 52 |
|
| /* free(), not Safefree: the buffer comes from shm_grow_buf's realloc(). */ |
| 53 |
21 |
| static void shm_free_cleanup(pTHX_ void *ptr) { |
| 54 |
21 |
| free(ptr); |
| 55 |
21 |
| } |
| 56 |
|
| |
| 57 |
|
| /* An embedded NUL would truncate the path: unlink could remove another file. |
| 58 |
|
| * The caller has run get-magic. */ |
| 59 |
44055 |
| static const char *shm_path_arg(pTHX_ SV *sv, const char *what, const char *classname) { |
| 60 |
|
| STRLEN len; |
| 61 |
44055 |
| const char *p = SvPV_nomg(sv, len); |
| 62 |
44055 |
▶ | if (memchr(p, '\0', len)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (memchr(p, '\0', len)) |
5 |
44050 |
44055 |
|
| 63 |
5 |
| croak("%s: %s contains an embedded NUL byte", classname, what); |
| 64 |
44050 |
| return p; |
| 65 |
|
| } |
| 66 |
|
| |
| 67 |
|
| /* As core open: tainted data anywhere in the statement is fatal for a call that |
| 68 |
|
| * writes, creates or removes a file. Use it once every argument has been read; |
| 69 |
|
| * opening read-only by a tainted name is allowed. */ |
| 70 |
|
| #define SHM_TAINT_CHECK(op) STMT_START { TAINT_PROPER(op); } STMT_END |
| 71 |
|
| |
| 72 |
43841 |
| static const char *shm_write_path_arg(pTHX_ SV *sv, const char *what, |
| 73 |
|
| const char *classname, const char *op) { |
| 74 |
43841 |
| const char *p = shm_path_arg(aTHX_ sv, what, classname); |
| 75 |
43838 |
▶ | if (TAINT_get) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (TAINT_get) { |
14 |
43824 |
43838 |
|
| 76 |
|
| /* a -t warning runs Perl code, which may free sv's buffer */ |
| 77 |
14 |
| p = SvPVX(sv_2mortal(newSVpv(p, 0))); |
| 78 |
14 |
▶ | SHM_TAINT_CHECK(op); |
Branch: 1 branch
| Branch | True | False | Total |
| SHM_TAINT_CHECK(op); |
14 |
0 |
14 |
|
| 79 |
|
| } |
| 80 |
43831 |
| return p; |
| 81 |
|
| } |
| 82 |
|
| |
| 83 |
|
| /* A UV parameter would wrap -1 to "everything". */ |
| 84 |
394 |
| static UV shm_count_arg(pTHX_ SV *sv, const char *what, const char *classname) { |
| 85 |
|
| NV nv; |
| 86 |
394 |
▶ | SvGETMAGIC(sv); |
Branch: 2 branches
| Branch | True | False | Total |
| SvGETMAGIC(sv); |
6 |
388 |
394 |
| SvGETMAGIC(sv); |
0 |
6 |
6 |
|
| 87 |
394 |
▶ | if (SvIOK(sv)) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (SvIOK(sv)) { |
177 |
217 |
394 |
|
| 88 |
177 |
▶ | if (!SvIsUV(sv) && SvIVX(sv) < 0) croak("%s: %s must not be negative", classname, what); |
Branch: 2 branches
| Branch | True | False | Total |
| if (!SvIsUV(sv) && SvIVX(sv) < 0) croak("%s: %s must not be negative", classname, what); |
173 |
4 |
177 |
| if (!SvIsUV(sv) && SvIVX(sv) < 0) croak("%s: %s must not be negative", classname, what); |
20 |
153 |
173 |
|
| 89 |
157 |
| return SvUVX(sv); |
| 90 |
|
| } |
| 91 |
217 |
| nv = SvNV_nomg(sv); |
| 92 |
217 |
▶ | if (nv < 0) croak("%s: %s must not be negative", classname, what); |
Branch: 1 branch
| Branch | True | False | Total |
| if (nv < 0) croak("%s: %s must not be negative", classname, what); |
1 |
216 |
217 |
|
| 93 |
216 |
▶ | if (!(nv >= 1)) return 0; /* also NaN */ |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(nv >= 1)) return 0; /* also NaN */ |
0 |
216 |
216 |
|
| 94 |
216 |
▶ | return nv >= (NV)UV_MAX ? UV_MAX : (UV)nv; |
Branch: 1 branch
| Branch | True | False | Total |
| return nv >= (NV)UV_MAX ? UV_MAX : (UV)nv; |
1 |
215 |
216 |
|
| 95 |
|
| } |
| 96 |
|
| |
| 97 |
200051 |
| static inline uint32_t shm_u32_arg(pTHX_ SV *sv, const char *what, const char *classname, uint32_t dflt) { |
| 98 |
|
| UV v; |
| 99 |
200051 |
▶ | if (!sv) return dflt; |
Branch: 1 branch
| Branch | True | False | Total |
| if (!sv) return dflt; |
130637 |
69414 |
200051 |
|
| 100 |
69414 |
▶ | if ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV|SVs_GMG)) == SVf_IOK && (UV)SvIVX(sv) <= 0xFFFFFFFFu) |
Branch: 2 branches
| Branch | True | False | Total |
| if ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV|SVs_GMG)) == SVf_IOK && (UV)SvIVX(sv) <= 0xFFFFFFFFu) |
69198 |
216 |
69414 |
| if ((SvFLAGS(sv) & (SVf_IOK|SVf_IVisUV|SVs_GMG)) == SVf_IOK && (UV)SvIVX(sv) <= 0xFFFFFFFFu) |
69183 |
15 |
69198 |
|
| 101 |
69183 |
| return (uint32_t)SvIVX(sv); |
| 102 |
231 |
| v = shm_count_arg(aTHX_ sv, what, classname); |
| 103 |
217 |
▶ | if (v > 0xFFFFFFFFu) |
Branch: 1 branch
| Branch | True | False | Total |
| if (v > 0xFFFFFFFFu) |
206 |
11 |
217 |
|
| 104 |
206 |
| croak("%s: %s %" UVuf " exceeds the maximum of %u", |
| 105 |
|
| classname, what, v, 0xFFFFFFFFU); |
| 106 |
11 |
| return (uint32_t)v; |
| 107 |
|
| } |
| 108 |
|
| |
| 109 |
|
| /* An object invocant would stringify to "Class=SCALAR(0x...)". */ |
| 110 |
44443 |
| static const char *shm_invocant_class(pTHX_ SV *sv, const char *classname) { |
| 111 |
44443 |
▶ | if (sv_isobject(sv)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (sv_isobject(sv)) |
28 |
44415 |
44443 |
|
| 112 |
28 |
▶ | return HvNAME_get(SvSTASH(SvRV(sv))); |
Branch: 6 branches
| Branch | True | False | Total |
| return HvNAME_get(SvSTASH(SvRV(sv))); |
28 |
0 |
28 |
| return HvNAME_get(SvSTASH(SvRV(sv))); |
28 |
0 |
28 |
| return HvNAME_get(SvSTASH(SvRV(sv))); |
0 |
28 |
28 |
| return HvNAME_get(SvSTASH(SvRV(sv))); |
0 |
0 |
0 |
| return HvNAME_get(SvSTASH(SvRV(sv))); |
28 |
0 |
28 |
| return HvNAME_get(SvSTASH(SvRV(sv))); |
0 |
28 |
28 |
|
| 113 |
44415 |
▶ | if (SvROK(sv)) |
Branch: 1 branch
| Branch | True | False | Total |
| if (SvROK(sv)) |
0 |
44415 |
44415 |
|
| 114 |
0 |
| croak("%s: constructor invocant must be a class name or object", classname); |
| 115 |
44415 |
| return SvPV_nolen(sv); |
| 116 |
|
| } |
| 117 |
|
| |
| 118 |
|
| /* to_hash copies entries under the read lock (integers raw into `raw`, string |
| 119 |
|
| * keys packed into `keys`, string values as SVs into `vals`, NULL for an integer |
| 120 |
|
| * side) and builds the hash here, after the lock is released. */ |
| 121 |
|
| #define SHM_KEY_UTF8_BIT 0x80000000u |
| 122 |
232954 |
| static STRLEN shm_pack_key(pTHX_ SV *keys, STRLEN used, const char *p, uint32_t len, int utf8) { |
| 123 |
232954 |
| STRLEN need = used + sizeof(uint32_t) + len; |
| 124 |
232954 |
▶ | uint32_t word = len | (utf8 ? SHM_KEY_UTF8_BIT : 0); |
Branch: 1 branch
| Branch | True | False | Total |
| uint32_t word = len | (utf8 ? SHM_KEY_UTF8_BIT : 0); |
29720 |
203234 |
232954 |
|
| 125 |
|
| char *d; |
| 126 |
232954 |
▶ | if (need > SvLEN(keys)) SvGROW(keys, need + need / 4); |
Branch: 3 branches
| Branch | True | False | Total |
| if (need > SvLEN(keys)) SvGROW(keys, need + need / 4); |
8 |
232946 |
232954 |
| if (need > SvLEN(keys)) SvGROW(keys, need + need / 4); |
8 |
0 |
8 |
| if (need > SvLEN(keys)) SvGROW(keys, need + need / 4); |
8 |
0 |
8 |
|
| 127 |
232954 |
| d = SvPVX(keys) + used; |
| 128 |
232954 |
| memcpy(d, &word, sizeof word); |
| 129 |
232954 |
| memcpy(d + sizeof word, p, len); |
| 130 |
232954 |
| return need; |
| 131 |
|
| } |
| 132 |
|
| |
| 133 |
52 |
| static SV *shm_copies_to_hashref(pTHX_ SV *raw, SV *keys, AV *vals, SSize_t n) { |
| 134 |
52 |
| HV *hv = newHV(); |
| 135 |
52 |
▶ | const IV *r = raw ? (const IV *)SvPVX(raw) : NULL; |
Branch: 1 branch
| Branch | True | False | Total |
| const IV *r = raw ? (const IV *)SvPVX(raw) : NULL; |
32 |
20 |
52 |
|
| 136 |
52 |
▶ | const char *kb = keys ? SvPVX(keys) : NULL; |
Branch: 1 branch
| Branch | True | False | Total |
| const char *kb = keys ? SvPVX(keys) : NULL; |
30 |
22 |
52 |
|
| 137 |
52 |
▶ | SV **s = vals ? AvARRAY(vals) : NULL; |
Branch: 1 branch
| Branch | True | False | Total |
| SV **s = vals ? AvARRAY(vals) : NULL; |
29 |
23 |
52 |
|
| 138 |
52 |
| SSize_t ri = 0, vi = 0, j; |
| 139 |
52 |
| STRLEN ko = 0; |
| 140 |
52 |
| hv_ksplit(hv, n); |
| 141 |
62655 |
▶ | for (j = 0; j < n; j++) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (j = 0; j < n; j++) { |
62603 |
52 |
62655 |
|
| 142 |
|
| char kbuf[24]; |
| 143 |
62603 |
| const char *kp = kbuf; |
| 144 |
|
| I32 klen; |
| 145 |
|
| SV *val; |
| 146 |
62603 |
▶ | if (!keys) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (!keys) { |
21649 |
40954 |
62603 |
|
| 147 |
21649 |
| klen = my_snprintf(kbuf, sizeof(kbuf), "%" IVdf, r[ri++]); |
| 148 |
|
| } else { |
| 149 |
|
| uint32_t word; |
| 150 |
40954 |
| memcpy(&word, kb + ko, sizeof word); |
| 151 |
40954 |
| kp = kb + ko + sizeof word; |
| 152 |
40954 |
| klen = (I32)(word & ~SHM_KEY_UTF8_BIT); |
| 153 |
40954 |
| ko += sizeof word + (STRLEN)klen; |
| 154 |
40954 |
▶ | if (word & SHM_KEY_UTF8_BIT) klen = -klen; |
Branch: 1 branch
| Branch | True | False | Total |
| if (word & SHM_KEY_UTF8_BIT) klen = -klen; |
8008 |
32946 |
40954 |
|
| 155 |
|
| } |
| 156 |
62603 |
▶ | if (!vals) val = newSViv(r[ri++]); |
Branch: 1 branch
| Branch | True | False | Total |
| if (!vals) val = newSViv(r[ri++]); |
21652 |
40951 |
62603 |
|
| 157 |
40951 |
| else { val = s[vi++]; SvREFCNT_inc_simple_void_NN(val); } |
| 158 |
62603 |
▶ | if (!hv_store(hv, kp, klen, val, 0)) SvREFCNT_dec(val); |
Branch: 1 branch
| Branch | True | False | Total |
| if (!hv_store(hv, kp, klen, val, 0)) SvREFCNT_dec(val); |
0 |
62603 |
62603 |
|
| 159 |
|
| } |
| 160 |
52 |
| return newRV_noinc((SV *)hv); |
| 161 |
|
| } |
| 162 |
|
| |
| 163 |
|
| /* keys/values/items: an integer waits in its stack slot and becomes an SV here, |
| 164 |
|
| * after the lock is released. A string becomes an SV under the lock, or, in a |
| 165 |
|
| * shard of SHM_LIST_PACK_MIN entries, waits packed in `strs` with a NULL slot. |
| 166 |
|
| * Field f of each entry is a string where bit f of `str_fields` is set. */ |
| 167 |
|
| #define SHM_LIST_PACK_MIN 4096u |
| 168 |
224 |
| static void shm_stack_copies_to_svs(pTHX_ SV **slot, SSize_t n, int fields, int str_fields, SV *strs) { |
| 169 |
224 |
▶ | const char *p = strs ? SvPVX(strs) : NULL; |
Branch: 1 branch
| Branch | True | False | Total |
| const char *p = strs ? SvPVX(strs) : NULL; |
16 |
208 |
224 |
|
| 170 |
|
| SSize_t j; |
| 171 |
|
| int f; |
| 172 |
241860 |
▶ | for (j = 0; j < n; j++) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (j = 0; j < n; j++) { |
241636 |
224 |
241860 |
|
| 173 |
545160 |
▶ | for (f = 0; f < fields; f++, slot++) { |
Branch: 1 branch
| Branch | True | False | Total |
| for (f = 0; f < fields; f++, slot++) { |
303524 |
241636 |
545160 |
|
| 174 |
303524 |
▶ | if (!(str_fields >> f & 1)) { |
Branch: 1 branch
| Branch | True | False | Total |
| if (!(str_fields >> f & 1)) { |
108685 |
194839 |
303524 |
|
| 175 |
108685 |
| *slot = sv_2mortal(newSViv(PTR2IV(*slot))); |
| 176 |
194839 |
▶ | } else if (!*slot) { |
Branch: 1 branch
| Branch | True | False | Total |
| } else if (!*slot) { |
192000 |
2839 |
194839 |
|
| 177 |
|
| uint32_t word, len; |
| 178 |
192000 |
| memcpy(&word, p, sizeof word); |
| 179 |
192000 |
| len = word & ~SHM_KEY_UTF8_BIT; |
| 180 |
192000 |
| *slot = sv_2mortal(newSVpvn(p + sizeof word, len)); |
| 181 |
192000 |
▶ | if (word & SHM_KEY_UTF8_BIT) SvUTF8_on(*slot); |
Branch: 1 branch
| Branch | True | False | Total |
| if (word & SHM_KEY_UTF8_BIT) SvUTF8_on(*slot); |
21712 |
170288 |
192000 |
|
| 182 |
192000 |
| p += sizeof word + len; |
| 183 |
|
| } |
| 184 |
|
| } |
| 185 |
|
| } |
| 186 |
224 |
| } |
| 187 |
|
| |
| 188 |
|
| /* Every shard's read lock is held until the last copy is made. `copy` stores |
| 189 |
|
| * an entry's fields in order with SHM_COPY_INT and SHM_COPY_STR. */ |
| 190 |
|
| #define SHM_LIST_COPIES(node_type, fields, str_fields, copy) \ |
| 191 |
|
| STMT_START { \ |
| 192 |
|
| SV *strs = NULL; \ |
| 193 |
|
| SSize_t n = 0; \ |
| 194 |
|
| STRLEN used = 0; \ |
| 195 |
|
| uint32_t ns = h->shard_handles ? h->num_shards : 1; \ |
| 196 |
|
| ENTER; \ |
| 197 |
|
| for (uint32_t si = 0; si < ns; si++) { \ |
| 198 |
|
| ShmHandle *sh = h->shard_handles ? h->shard_handles[si] : h; \ |
| 199 |
|
| ShmHeader *hdr = sh->hdr; \ |
| 200 |
|
| node_type *nodes = (node_type *)sh->nodes; \ |
| 201 |
|
| RDLOCK_GUARD(sh); \ |
| 202 |
|
| uint32_t now = sh->expires_at ? shm_now() : 0, left = hdr->size; \ |
| 203 |
|
| const int pack = (str_fields) && left >= SHM_LIST_PACK_MIN; \ |
| 204 |
|
| EXTEND(SP, (SSize_t)left * (fields)); \ |
| 205 |
|
| if (pack) { \ |
| 206 |
|
| if (!strs) strs = sv_2mortal(newSV(1)); \ |
| 207 |
|
| SvGROW(strs, used + (STRLEN)left * 16 + 16); \ |
| 208 |
|
| } \ |
| 209 |
|
| for (uint32_t i = 0; i < hdr->table_cap && left; i++) { \ |
| 210 |
|
| if (SHM_IS_LIVE(sh->states[i]) && !SHM_IS_EXPIRED(sh, i, now)) { \ |
| 211 |
|
| copy; \ |
| 212 |
|
| n++; left--; \ |
| 213 |
|
| } \ |
| 214 |
|
| } \ |
| 215 |
|
| PERL_UNUSED_VAR(pack); \ |
| 216 |
|
| } \ |
| 217 |
|
| LEAVE; \ |
| 218 |
|
| PERL_UNUSED_VAR(used); \ |
| 219 |
|
| shm_stack_copies_to_svs(aTHX_ SP - n * (fields) + 1, n, fields, str_fields, strs); \ |
| 220 |
|
| } STMT_END |
| 221 |
|
| #define SHM_COPY_INT(value) (*++SP = INT2PTR(SV *, (IV)(value))) |
| 222 |
|
| #define SHM_COPY_STR(off, len) \ |
| 223 |
|
| STMT_START { \ |
| 224 |
|
| char _ib[SHM_INLINE_MAX]; uint32_t _l; \ |
| 225 |
|
| const int _utf8 = SHM_UNPACK_UTF8(nodes[i].len); \ |
| 226 |
|
| const char *_p = shm_str_ptr(nodes[i].off, nodes[i].len, sh->arena, sh->hdr->arena_cap, _ib, &_l); \ |
| 227 |
|
| if (pack) { \ |
| 228 |
|
| used = shm_pack_key(aTHX_ strs, used, _p, _l, _utf8); \ |
| 229 |
|
| *++SP = NULL; \ |
| 230 |
|
| } else { \ |
| 231 |
|
| *++SP = sv_2mortal(newSVpvn(_p, _l)); \ |
| 232 |
|
| if (_utf8) SvUTF8_on(*SP); \ |
| 233 |
|
| } \ |
| 234 |
|
| } STMT_END |
| 235 |
|
| |
| 236 |
|
| /* A regular file's type bits pass, so (stat $file)[2] works as a mode. */ |
| 237 |
43969 |
| static mode_t shm_file_mode(pTHX_ UV mode, const char *classname) { |
| 238 |
43969 |
| UV type = mode & ~(UV)07777; |
| 239 |
43969 |
▶ | if (type && type != S_IFREG) |
Branch: 2 branches
| Branch | True | False | Total |
| if (type && type != S_IFREG) |
4 |
43965 |
43969 |
| if (type && type != S_IFREG) |
3 |
1 |
4 |
|
| 240 |
3 |
| croak("%s: file_mode %#" UVof " exceeds the maximum of 07777", classname, mode); |
| 241 |
43966 |
| return (mode_t)(mode & 07777); |
| 242 |
|
| } |
| 243 |
|
| |
| 244 |
|
| #define SHM_PATH_ARG(sv, what, classname) \ |
| 245 |
|
| (SvGETMAGIC(sv), SvOK(sv) ? shm_path_arg(aTHX_ (sv), (what), (classname)) : NULL) |
| 246 |
|
| #define SHM_WRITE_PATH_ARG(sv, what, classname, method) \ |
| 247 |
|
| (SvGETMAGIC(sv), SvOK(sv) ? shm_write_path_arg(aTHX_ (sv), (what), (classname), classname "->" method) : NULL) |
| 248 |
|
| |
| 249 |
|
| /* max_size comes off the map: attaching ignores the arguments. A FATAL warning |
| 250 |
|
| * croaks, so `sv` must own the handle: SAVEFREESV frees it then, and the |
| 251 |
|
| * reference taken after the warning cancels the free otherwise. */ |
| 252 |
|
| #define CK_MAX_SIZE(map, classname, sv) \ |
| 253 |
|
| do { ShmHeader *_mh = (map)->shard_handles ? (map)->shard_handles[0]->hdr : (map)->hdr; \ |
| 254 |
|
| if (_mh->max_size >= _mh->max_table_cap) { \ |
| 255 |
|
| SAVEFREESV(sv); \ |
| 256 |
|
| Perl_ck_warner(aTHX_ packWARN(WARN_MISC), \ |
| 257 |
|
| "%s: max_size %" UVuf " needs all %" UVuf " slots the map holds; " \ |
| 258 |
|
| "LRU eviction will never trigger", \ |
| 259 |
|
| classname, (UV)_mh->max_size, (UV)_mh->max_table_cap); \ |
| 260 |
|
| SvREFCNT_inc_simple_void_NN(sv); \ |
| 261 |
|
| } } while (0) |
| 262 |
|
| |
| 263 |
|
| #define SHM_RETURN_MAP(map, classname, class) \ |
| 264 |
|
| shm_set_sig_count((map), &PL_sig_pending); \ |
| 265 |
|
| RETVAL = sv_setref_pv(newSV(0), (class), (void*)(map)); \ |
| 266 |
|
| CK_MAX_SIZE((map), (classname), RETVAL) |
| 267 |
|
| |
| 268 |
977381 |
| static int shm_isa(pTHX_ SV *sv, const char *classname) { |
| 269 |
977381 |
▶ | if (!sv_isobject(sv)) return 0; |
Branch: 1 branch
| Branch | True | False | Total |
| if (!sv_isobject(sv)) return 0; |
20 |
977361 |
977381 |
|
| 270 |
977361 |
| HV *stash = SvSTASH(SvRV(sv)); |
| 271 |
977361 |
▶ | const char *name = HvNAME_get(stash); |
Branch: 6 branches
| Branch | True | False | Total |
| const char *name = HvNAME_get(stash); |
977361 |
0 |
977361 |
| const char *name = HvNAME_get(stash); |
977361 |
0 |
977361 |
| const char *name = HvNAME_get(stash); |
0 |
977361 |
977361 |
| const char *name = HvNAME_get(stash); |
0 |
0 |
0 |
| const char *name = HvNAME_get(stash); |
977361 |
0 |
977361 |
| const char *name = HvNAME_get(stash); |
0 |
977361 |
977361 |
|
| 272 |
977361 |
| STRLEN len = strlen(classname); |
| 273 |
977361 |
▶ | return (name && (STRLEN)HvNAMELEN_get(stash) == len && memEQ(name, classname, len)) |
Branch: 8 branches
| Branch | True | False | Total |
| return (name && (STRLEN)HvNAMELEN_get(stash) == len && memEQ(name, classname, len)) |
977361 |
0 |
977361 |
| return (name && (STRLEN)HvNAMELEN_get(stash) == len && memEQ(name, classname, len)) |
977361 |
0 |
977361 |
| return (name && (STRLEN)HvNAMELEN_get(stash) == len && memEQ(name, classname, len)) |
0 |
977361 |
977361 |
| return (name && (STRLEN)HvNAMELEN_get(stash) == len && memEQ(name, classname, len)) |
0 |
0 |
0 |
| return (name && (STRLEN)HvNAMELEN_get(stash) == len && memEQ(name, classname, len)) |
977361 |
0 |
977361 |
| return (name && (STRLEN)HvNAMELEN_get(stash) == len && memEQ(name, classname, len)) |
0 |
977361 |
977361 |
| return (name && (STRLEN)HvNAMELEN_get(stash) == len && memEQ(name, classname, len)) |
977155 |
206 |
977361 |
| return (name && (STRLEN)HvNAMELEN_get(stash) == len && memEQ(name, classname, len)) |
82 |
977073 |
977155 |
|
| 274 |
1954722 |
▶ | || sv_derived_from(sv, classname); |
Branch: 2 branches
| Branch | True | False | Total |
| || sv_derived_from(sv, classname); |
977361 |
0 |
977361 |
| || sv_derived_from(sv, classname); |
5 |
283 |
288 |
|
| 275 |
|
| } |
| 276 |
|
| |
| 277 |
|
| #define EXTRACT_MAP(classname, sv) \ |
| 278 |
|
| if (!shm_isa(aTHX_ sv, classname)) \ |
| 279 |
|
| croak("Expected a %s object", classname); \ |
| 280 |
|
| ShmHandle* h = INT2PTR(ShmHandle*, SvIV(SvRV(sv))); \ |
| 281 |
|
| if (!h) croak("Attempted to use a destroyed %s object", classname); \ |
| 282 |
|
| ShmHandle *h0 = h; PERL_UNUSED_VAR(h0); \ |
| 283 |
|
| const char *shm_class = classname; PERL_UNUSED_VAR(shm_class); \ |
| 284 |
|
| sv_2mortal(SvREFCNT_inc(SvRV(sv))) |
| 285 |
|
| |
| 286 |
|
| /* Argument magic may call $obj->DESTROY, freeing the handle: EXTRACT_MAP's mortal |
| 287 |
|
| * pins only against refcount destruction. Use wherever magic can run between |
| 288 |
|
| * EXTRACT_MAP and the first use of h, and nowhere else. */ |
| 289 |
|
| #define REEXTRACT_MAP(classname, sv) \ |
| 290 |
|
| if (!SvROK(sv)) \ |
| 291 |
|
| croak("%s object was replaced during the call", classname); \ |
| 292 |
|
| h = INT2PTR(ShmHandle*, SvIV(SvRV(sv))); \ |
| 293 |
|
| if (h != h0) croak("%s object replaced or destroyed during the call", classname) |
| 294 |
|
| |
| 295 |
|
| /* Copy a get-magical argument's string when another argument is read after it: |
| 296 |
|
| * that read may be the same tie's FETCH, which frees or rewrites this buffer. */ |
| 297 |
|
| #define SHM_COPY_IF_MAGICAL(sv, str, len) \ |
| 298 |
|
| do { if (SvGMAGICAL(sv)) str = SvPVX(sv_2mortal(newSVpvn(str, len))); } while (0) |
| 299 |
|
| |
| 300 |
|
| #define EXTRACT_STR_KEY(sv) \ |
| 301 |
|
| STRLEN _klen; \ |
| 302 |
|
| const char* _kstr = SvPV(sv, _klen); \ |
| 303 |
|
| if (_klen > SHM_MAX_STR_LEN) croak("%s: key too long (max 1GB)", shm_class); \ |
| 304 |
|
| bool _kutf8 = SvUTF8(sv) ? true : false |
| 305 |
|
| |
| 306 |
|
| #define EXTRACT_STR_VAL(sv) \ |
| 307 |
|
| STRLEN _vlen; \ |
| 308 |
|
| const char* _vstr = SvPV(sv, _vlen); \ |
| 309 |
|
| if (_vlen > SHM_MAX_STR_LEN) croak("%s: value too long (max 1GB)", shm_class); \ |
| 310 |
|
| bool _vutf8 = SvUTF8(sv) ? true : false |
| 311 |
|
| |
| 312 |
|
| #define EXTRACT_STR_EXPECTED(esv) \ |
| 313 |
|
| STRLEN _elen; \ |
| 314 |
|
| const char* _estr = SvPV(esv, _elen); \ |
| 315 |
|
| if (_elen > SHM_MAX_STR_LEN) croak("%s: expected value too long (max 1GB)", shm_class) |
| 316 |
|
| |
| 317 |
|
| #define EXTRACT_STR_EXPECTED_DESIRED(esv, dsv) \ |
| 318 |
|
| EXTRACT_STR_EXPECTED(esv); \ |
| 319 |
|
| SHM_COPY_IF_MAGICAL(esv, _estr, _elen); \ |
| 320 |
|
| STRLEN _dlen; \ |
| 321 |
|
| const char* _dstr = SvPV(dsv, _dlen); \ |
| 322 |
|
| if (_dlen > SHM_MAX_STR_LEN) croak("%s: desired value too long (max 1GB)", shm_class); \ |
| 323 |
|
| bool _dutf8 = SvUTF8(dsv) ? true : false |
| 324 |
|
| |
| 325 |
|
| #define REQUIRE_TTL(h) \ |
| 326 |
|
| { ShmHandle *_th = (h)->shard_handles ? (h)->shard_handles[0] : (h); \ |
| 327 |
|
| if (!_th->expires_at) croak("%s: operation requires a TTL-enabled map (pass ttl > 0 to constructor)", shm_class); } |
| 328 |
|
| |
| 329 |
|
| #define EXTRACT_CURSOR(classname, sv) \ |
| 330 |
|
| if (!shm_isa(aTHX_ sv, classname)) \ |
| 331 |
|
| croak("Expected a %s object", classname); \ |
| 332 |
|
| ShmCursor* c = INT2PTR(ShmCursor*, SvIV(SvRV(sv))); \ |
| 333 |
|
| if (!c) croak("Attempted to use a destroyed %s cursor", classname); \ |
| 334 |
|
| if (c->owner && !SvIV(c->owner)) \ |
| 335 |
|
| croak("Attempted to use a %s cursor whose map was destroyed", classname); \ |
| 336 |
|
| ShmCursor *c0 = c; PERL_UNUSED_VAR(c0); \ |
| 337 |
|
| const char *shm_class = classname; PERL_UNUSED_VAR(shm_class); \ |
| 338 |
|
| sv_2mortal(SvREFCNT_inc(SvRV(sv))) |
| 339 |
|
| |
| 340 |
|
| /* REEXTRACT_MAP for cursors. */ |
| 341 |
|
| #define REEXTRACT_CURSOR(classname, sv) \ |
| 342 |
|
| if (!SvROK(sv)) \ |
| 343 |
|
| croak("%s cursor was replaced during the call", classname); \ |
| 344 |
|
| c = INT2PTR(ShmCursor*, SvIV(SvRV(sv))); \ |
| 345 |
|
| if (c != c0) croak("%s cursor replaced or destroyed during the call", classname); \ |
| 346 |
|
| /* Magic may have destroyed the map since EXTRACT_CURSOR checked it. */ \ |
| 347 |
|
| if (c->owner && !SvIV(c->owner)) \ |
| 348 |
|
| croak("%s cursor whose map was destroyed during the call", classname) |
| 349 |
|
| |
| 350 |
|
| /* An explicit $map->DESTROY leaves a live cursor on a freed handle: detach, so |
| 351 |
|
| * shm_cursor_destroy and flush_deferred do not touch it. */ |
| 352 |
|
| #define CURSOR_DETACH_IF_MAP_GONE(c, owner, h) \ |
| 353 |
|
| SV *owner = (c)->owner; \ |
| 354 |
|
| ShmHandle *h = ((owner) && SvIV(owner)) ? (c)->current : NULL; \ |
| 355 |
|
| if (!(h)) { (c)->current = NULL; (c)->handle = NULL; } |
| 356 |
|
| |
| 357 |
129 |
| static int build_kw_1arg(pTHX_ OP **out, XSParseKeywordPiece *args[], size_t nargs, void *hookdata) { |
| 358 |
|
| (void)nargs; |
| 359 |
129 |
| const char *func = (const char *)hookdata; |
| 360 |
129 |
| OP *map_op = args[0]->op; |
| 361 |
129 |
| OP *cvref = newCVREF(0, newGVOP(OP_GV, 0, gv_fetchpv(func, GV_ADD, SVt_PVCV))); |
| 362 |
129 |
| OP *arglist = op_append_elem(OP_LIST, map_op, cvref); |
| 363 |
|
| /* No OPf_WANT: Perl_scalar() would then skip the op, leaving it in list context. */ |
| 364 |
129 |
| *out = op_convert_list(OP_ENTERSUB, OPf_STACKED, arglist); |
| 365 |
129 |
| return KEYWORD_PLUGIN_EXPR; |
| 366 |
|
| } |
| 367 |
|
| |
| 368 |
170 |
| static int build_kw_2arg(pTHX_ OP **out, XSParseKeywordPiece *args[], size_t nargs, void *hookdata) { |
| 369 |
|
| (void)nargs; |
| 370 |
170 |
| const char *func = (const char *)hookdata; |
| 371 |
170 |
| OP *map_op = args[0]->op; |
| 372 |
170 |
| OP *key_op = args[1]->op; |
| 373 |
170 |
| OP *cvref = newCVREF(0, newGVOP(OP_GV, 0, gv_fetchpv(func, GV_ADD, SVt_PVCV))); |
| 374 |
170 |
| OP *arglist = op_append_elem(OP_LIST, map_op, key_op); |
| 375 |
170 |
| arglist = op_append_elem(OP_LIST, arglist, cvref); |
| 376 |
170 |
| *out = op_convert_list(OP_ENTERSUB, OPf_STACKED, arglist); |
| 377 |
170 |
| return KEYWORD_PLUGIN_EXPR; |
| 378 |
|
| } |
| 379 |
|
| |
| 380 |
184 |
| static int build_kw_3arg(pTHX_ OP **out, XSParseKeywordPiece *args[], size_t nargs, void *hookdata) { |
| 381 |
|
| (void)nargs; |
| 382 |
184 |
| const char *func = (const char *)hookdata; |
| 383 |
184 |
| OP *map_op = args[0]->op; |
| 384 |
184 |
| OP *key_op = args[1]->op; |
| 385 |
184 |
| OP *val_op = args[2]->op; |
| 386 |
184 |
| OP *cvref = newCVREF(0, newGVOP(OP_GV, 0, gv_fetchpv(func, GV_ADD, SVt_PVCV))); |
| 387 |
184 |
| OP *arglist = op_append_elem(OP_LIST, map_op, key_op); |
| 388 |
184 |
| arglist = op_append_elem(OP_LIST, arglist, val_op); |
| 389 |
184 |
| arglist = op_append_elem(OP_LIST, arglist, cvref); |
| 390 |
184 |
| *out = op_convert_list(OP_ENTERSUB, OPf_STACKED, arglist); |
| 391 |
184 |
| return KEYWORD_PLUGIN_EXPR; |
| 392 |
|
| } |
| 393 |
|
| |
| 394 |
43 |
| static int build_kw_4arg(pTHX_ OP **out, XSParseKeywordPiece *args[], size_t nargs, void *hookdata) { |
| 395 |
|
| (void)nargs; |
| 396 |
43 |
| const char *func = (const char *)hookdata; |
| 397 |
43 |
| OP *map_op = args[0]->op; |
| 398 |
43 |
| OP *key_op = args[1]->op; |
| 399 |
43 |
| OP *val_op = args[2]->op; |
| 400 |
43 |
| OP *ttl_op = args[3]->op; |
| 401 |
43 |
| OP *cvref = newCVREF(0, newGVOP(OP_GV, 0, gv_fetchpv(func, GV_ADD, SVt_PVCV))); |
| 402 |
43 |
| OP *arglist = op_append_elem(OP_LIST, map_op, key_op); |
| 403 |
43 |
| arglist = op_append_elem(OP_LIST, arglist, val_op); |
| 404 |
43 |
| arglist = op_append_elem(OP_LIST, arglist, ttl_op); |
| 405 |
43 |
| arglist = op_append_elem(OP_LIST, arglist, cvref); |
| 406 |
43 |
| *out = op_convert_list(OP_ENTERSUB, OPf_STACKED, arglist); |
| 407 |
43 |
| return KEYWORD_PLUGIN_EXPR; |
| 408 |
|
| } |
| 409 |
|
| |
| 410 |
|
| static const struct XSParseKeywordPieceType pieces_1expr[] = { |
| 411 |
|
| XPK_TERMEXPR, {0} |
| 412 |
|
| }; |
| 413 |
|
| |
| 414 |
|
| static const struct XSParseKeywordPieceType pieces_2expr[] = { |
| 415 |
|
| XPK_TERMEXPR, XPK_COMMA, XPK_TERMEXPR, {0} |
| 416 |
|
| }; |
| 417 |
|
| |
| 418 |
|
| static const struct XSParseKeywordPieceType pieces_3expr[] = { |
| 419 |
|
| XPK_TERMEXPR, XPK_COMMA, XPK_TERMEXPR, XPK_COMMA, XPK_TERMEXPR, {0} |
| 420 |
|
| }; |
| 421 |
|
| |
| 422 |
|
| static const struct XSParseKeywordPieceType pieces_4expr[] = { |
| 423 |
|
| XPK_TERMEXPR, XPK_COMMA, XPK_TERMEXPR, XPK_COMMA, XPK_TERMEXPR, XPK_COMMA, XPK_TERMEXPR, {0} |
| 424 |
|
| }; |
| 425 |
|
| |
| 426 |
|
| #define DEFINE_KW_HOOK(variant, PKG, kw, nargs, builder) \ |
| 427 |
|
| static const struct XSParseKeywordHooks hooks_shm_##variant##_##kw = { \ |
| 428 |
|
| .flags = XPK_FLAG_EXPR, \ |
| 429 |
|
| .permit_hintkey = "Data::HashMap::Shared::" PKG "/shm_" #variant "_" #kw, \ |
| 430 |
|
| .pieces = pieces_##nargs##expr, \ |
| 431 |
|
| .build = builder, \ |
| 432 |
|
| }; |
| 433 |
|
| |
| 434 |
|
| DEFINE_KW_HOOK(i16, "I16", put, 3, build_kw_3arg) |
| 435 |
|
| DEFINE_KW_HOOK(i16, "I16", get, 2, build_kw_2arg) |
| 436 |
|
| DEFINE_KW_HOOK(i16, "I16", remove, 2, build_kw_2arg) |
| 437 |
|
| DEFINE_KW_HOOK(i16, "I16", exists, 2, build_kw_2arg) |
| 438 |
|
| DEFINE_KW_HOOK(i16, "I16", incr, 2, build_kw_2arg) |
| 439 |
|
| DEFINE_KW_HOOK(i16, "I16", decr, 2, build_kw_2arg) |
| 440 |
|
| DEFINE_KW_HOOK(i16, "I16", incr_by, 3, build_kw_3arg) |
| 441 |
|
| DEFINE_KW_HOOK(i16, "I16", max, 3, build_kw_3arg) |
| 442 |
|
| DEFINE_KW_HOOK(i16, "I16", min, 3, build_kw_3arg) |
| 443 |
|
| DEFINE_KW_HOOK(i16, "I16", size, 1, build_kw_1arg) |
| 444 |
|
| DEFINE_KW_HOOK(i16, "I16", keys, 1, build_kw_1arg) |
| 445 |
|
| DEFINE_KW_HOOK(i16, "I16", values, 1, build_kw_1arg) |
| 446 |
|
| DEFINE_KW_HOOK(i16, "I16", items, 1, build_kw_1arg) |
| 447 |
|
| DEFINE_KW_HOOK(i16, "I16", each, 1, build_kw_1arg) |
| 448 |
|
| DEFINE_KW_HOOK(i16, "I16", iter_reset, 1, build_kw_1arg) |
| 449 |
|
| DEFINE_KW_HOOK(i16, "I16", clear, 1, build_kw_1arg) |
| 450 |
|
| DEFINE_KW_HOOK(i16, "I16", to_hash, 1, build_kw_1arg) |
| 451 |
|
| DEFINE_KW_HOOK(i16, "I16", max_entries, 1, build_kw_1arg) |
| 452 |
|
| DEFINE_KW_HOOK(i16, "I16", get_or_set, 3, build_kw_3arg) |
| 453 |
|
| DEFINE_KW_HOOK(i16, "I16", put_ttl, 4, build_kw_4arg) |
| 454 |
|
| DEFINE_KW_HOOK(i16, "I16", max_size, 1, build_kw_1arg) |
| 455 |
|
| DEFINE_KW_HOOK(i16, "I16", ttl, 1, build_kw_1arg) |
| 456 |
|
| DEFINE_KW_HOOK(i16, "I16", cursor, 1, build_kw_1arg) |
| 457 |
|
| DEFINE_KW_HOOK(i16, "I16", cursor_next, 1, build_kw_1arg) |
| 458 |
|
| DEFINE_KW_HOOK(i16, "I16", cursor_reset, 1, build_kw_1arg) |
| 459 |
|
| DEFINE_KW_HOOK(i16, "I16", cursor_seek, 2, build_kw_2arg) |
| 460 |
|
| DEFINE_KW_HOOK(i16, "I16", ttl_remaining, 2, build_kw_2arg) |
| 461 |
|
| DEFINE_KW_HOOK(i16, "I16", capacity, 1, build_kw_1arg) |
| 462 |
|
| DEFINE_KW_HOOK(i16, "I16", tombstones, 1, build_kw_1arg) |
| 463 |
|
| DEFINE_KW_HOOK(i16, "I16", take, 2, build_kw_2arg) |
| 464 |
|
| DEFINE_KW_HOOK(i16, "I16", pop, 1, build_kw_1arg) |
| 465 |
|
| DEFINE_KW_HOOK(i16, "I16", shift, 1, build_kw_1arg) |
| 466 |
|
| DEFINE_KW_HOOK(i16, "I16", drain, 2, build_kw_2arg) |
| 467 |
|
| DEFINE_KW_HOOK(i16, "I16", flush_expired, 1, build_kw_1arg) |
| 468 |
|
| DEFINE_KW_HOOK(i16, "I16", flush_expired_partial, 2, build_kw_2arg) |
| 469 |
|
| DEFINE_KW_HOOK(i16, "I16", mmap_size, 1, build_kw_1arg) |
| 470 |
|
| DEFINE_KW_HOOK(i16, "I16", touch, 2, build_kw_2arg) |
| 471 |
|
| DEFINE_KW_HOOK(i16, "I16", reserve, 2, build_kw_2arg) |
| 472 |
|
| DEFINE_KW_HOOK(i16, "I16", stat_evictions, 1, build_kw_1arg) |
| 473 |
|
| DEFINE_KW_HOOK(i16, "I16", stat_expired, 1, build_kw_1arg) |
| 474 |
|
| DEFINE_KW_HOOK(i16, "I16", stat_recoveries, 1, build_kw_1arg) |
| 475 |
|
| DEFINE_KW_HOOK(i16, "I16", arena_used, 1, build_kw_1arg) |
| 476 |
|
| DEFINE_KW_HOOK(i16, "I16", arena_cap, 1, build_kw_1arg) |
| 477 |
|
| DEFINE_KW_HOOK(i16, "I16", add, 3, build_kw_3arg) |
| 478 |
|
| DEFINE_KW_HOOK(i16, "I16", add_ttl, 4, build_kw_4arg) |
| 479 |
|
| DEFINE_KW_HOOK(i16, "I16", update_ttl, 4, build_kw_4arg) |
| 480 |
|
| DEFINE_KW_HOOK(i16, "I16", update, 3, build_kw_3arg) |
| 481 |
|
| DEFINE_KW_HOOK(i16, "I16", swap, 3, build_kw_3arg) |
| 482 |
|
| DEFINE_KW_HOOK(i16, "I16", cas, 4, build_kw_4arg) |
| 483 |
|
| DEFINE_KW_HOOK(i16, "I16", cas_take, 3, build_kw_3arg) |
| 484 |
|
| DEFINE_KW_HOOK(i16, "I16", persist, 2, build_kw_2arg) |
| 485 |
|
| DEFINE_KW_HOOK(i16, "I16", set_ttl, 3, build_kw_3arg) |
| 486 |
|
| |
| 487 |
|
| DEFINE_KW_HOOK(i32, "I32", put, 3, build_kw_3arg) |
| 488 |
|
| DEFINE_KW_HOOK(i32, "I32", get, 2, build_kw_2arg) |
| 489 |
|
| DEFINE_KW_HOOK(i32, "I32", remove, 2, build_kw_2arg) |
| 490 |
|
| DEFINE_KW_HOOK(i32, "I32", exists, 2, build_kw_2arg) |
| 491 |
|
| DEFINE_KW_HOOK(i32, "I32", incr, 2, build_kw_2arg) |
| 492 |
|
| DEFINE_KW_HOOK(i32, "I32", decr, 2, build_kw_2arg) |
| 493 |
|
| DEFINE_KW_HOOK(i32, "I32", incr_by, 3, build_kw_3arg) |
| 494 |
|
| DEFINE_KW_HOOK(i32, "I32", max, 3, build_kw_3arg) |
| 495 |
|
| DEFINE_KW_HOOK(i32, "I32", min, 3, build_kw_3arg) |
| 496 |
|
| DEFINE_KW_HOOK(i32, "I32", size, 1, build_kw_1arg) |
| 497 |
|
| DEFINE_KW_HOOK(i32, "I32", keys, 1, build_kw_1arg) |
| 498 |
|
| DEFINE_KW_HOOK(i32, "I32", values, 1, build_kw_1arg) |
| 499 |
|
| DEFINE_KW_HOOK(i32, "I32", items, 1, build_kw_1arg) |
| 500 |
|
| DEFINE_KW_HOOK(i32, "I32", each, 1, build_kw_1arg) |
| 501 |
|
| DEFINE_KW_HOOK(i32, "I32", iter_reset, 1, build_kw_1arg) |
| 502 |
|
| DEFINE_KW_HOOK(i32, "I32", clear, 1, build_kw_1arg) |
| 503 |
|
| DEFINE_KW_HOOK(i32, "I32", to_hash, 1, build_kw_1arg) |
| 504 |
|
| DEFINE_KW_HOOK(i32, "I32", max_entries, 1, build_kw_1arg) |
| 505 |
|
| DEFINE_KW_HOOK(i32, "I32", get_or_set, 3, build_kw_3arg) |
| 506 |
|
| DEFINE_KW_HOOK(i32, "I32", put_ttl, 4, build_kw_4arg) |
| 507 |
|
| DEFINE_KW_HOOK(i32, "I32", max_size, 1, build_kw_1arg) |
| 508 |
|
| DEFINE_KW_HOOK(i32, "I32", ttl, 1, build_kw_1arg) |
| 509 |
|
| DEFINE_KW_HOOK(i32, "I32", cursor, 1, build_kw_1arg) |
| 510 |
|
| DEFINE_KW_HOOK(i32, "I32", cursor_next, 1, build_kw_1arg) |
| 511 |
|
| DEFINE_KW_HOOK(i32, "I32", cursor_reset, 1, build_kw_1arg) |
| 512 |
|
| DEFINE_KW_HOOK(i32, "I32", cursor_seek, 2, build_kw_2arg) |
| 513 |
|
| DEFINE_KW_HOOK(i32, "I32", ttl_remaining, 2, build_kw_2arg) |
| 514 |
|
| DEFINE_KW_HOOK(i32, "I32", capacity, 1, build_kw_1arg) |
| 515 |
|
| DEFINE_KW_HOOK(i32, "I32", tombstones, 1, build_kw_1arg) |
| 516 |
|
| DEFINE_KW_HOOK(i32, "I32", take, 2, build_kw_2arg) |
| 517 |
|
| DEFINE_KW_HOOK(i32, "I32", pop, 1, build_kw_1arg) |
| 518 |
|
| DEFINE_KW_HOOK(i32, "I32", shift, 1, build_kw_1arg) |
| 519 |
|
| DEFINE_KW_HOOK(i32, "I32", drain, 2, build_kw_2arg) |
| 520 |
|
| DEFINE_KW_HOOK(i32, "I32", flush_expired, 1, build_kw_1arg) |
| 521 |
|
| DEFINE_KW_HOOK(i32, "I32", flush_expired_partial, 2, build_kw_2arg) |
| 522 |
|
| DEFINE_KW_HOOK(i32, "I32", mmap_size, 1, build_kw_1arg) |
| 523 |
|
| DEFINE_KW_HOOK(i32, "I32", touch, 2, build_kw_2arg) |
| 524 |
|
| DEFINE_KW_HOOK(i32, "I32", reserve, 2, build_kw_2arg) |
| 525 |
|
| DEFINE_KW_HOOK(i32, "I32", stat_evictions, 1, build_kw_1arg) |
| 526 |
|
| DEFINE_KW_HOOK(i32, "I32", stat_expired, 1, build_kw_1arg) |
| 527 |
|
| DEFINE_KW_HOOK(i32, "I32", stat_recoveries, 1, build_kw_1arg) |
| 528 |
|
| DEFINE_KW_HOOK(i32, "I32", arena_used, 1, build_kw_1arg) |
| 529 |
|
| DEFINE_KW_HOOK(i32, "I32", arena_cap, 1, build_kw_1arg) |
| 530 |
|
| DEFINE_KW_HOOK(i32, "I32", add, 3, build_kw_3arg) |
| 531 |
|
| DEFINE_KW_HOOK(i32, "I32", add_ttl, 4, build_kw_4arg) |
| 532 |
|
| DEFINE_KW_HOOK(i32, "I32", update_ttl, 4, build_kw_4arg) |
| 533 |
|
| DEFINE_KW_HOOK(i32, "I32", update, 3, build_kw_3arg) |
| 534 |
|
| DEFINE_KW_HOOK(i32, "I32", swap, 3, build_kw_3arg) |
| 535 |
|
| DEFINE_KW_HOOK(i32, "I32", cas, 4, build_kw_4arg) |
| 536 |
|
| DEFINE_KW_HOOK(i32, "I32", cas_take, 3, build_kw_3arg) |
| 537 |
|
| DEFINE_KW_HOOK(i32, "I32", persist, 2, build_kw_2arg) |
| 538 |
|
| DEFINE_KW_HOOK(i32, "I32", set_ttl, 3, build_kw_3arg) |
| 539 |
|
| |
| 540 |
|
| DEFINE_KW_HOOK(ii, "II", put, 3, build_kw_3arg) |
| 541 |
|
| DEFINE_KW_HOOK(ii, "II", get, 2, build_kw_2arg) |
| 542 |
|
| DEFINE_KW_HOOK(ii, "II", remove, 2, build_kw_2arg) |
| 543 |
|
| DEFINE_KW_HOOK(ii, "II", exists, 2, build_kw_2arg) |
| 544 |
|
| DEFINE_KW_HOOK(ii, "II", incr, 2, build_kw_2arg) |
| 545 |
|
| DEFINE_KW_HOOK(ii, "II", decr, 2, build_kw_2arg) |
| 546 |
|
| DEFINE_KW_HOOK(ii, "II", incr_by, 3, build_kw_3arg) |
| 547 |
|
| DEFINE_KW_HOOK(ii, "II", max, 3, build_kw_3arg) |
| 548 |
|
| DEFINE_KW_HOOK(ii, "II", min, 3, build_kw_3arg) |
| 549 |
|
| DEFINE_KW_HOOK(ii, "II", size, 1, build_kw_1arg) |
| 550 |
|
| DEFINE_KW_HOOK(ii, "II", keys, 1, build_kw_1arg) |
| 551 |
|
| DEFINE_KW_HOOK(ii, "II", values, 1, build_kw_1arg) |
| 552 |
|
| DEFINE_KW_HOOK(ii, "II", items, 1, build_kw_1arg) |
| 553 |
|
| DEFINE_KW_HOOK(ii, "II", each, 1, build_kw_1arg) |
| 554 |
|
| DEFINE_KW_HOOK(ii, "II", iter_reset, 1, build_kw_1arg) |
| 555 |
|
| DEFINE_KW_HOOK(ii, "II", clear, 1, build_kw_1arg) |
| 556 |
|
| DEFINE_KW_HOOK(ii, "II", to_hash, 1, build_kw_1arg) |
| 557 |
|
| DEFINE_KW_HOOK(ii, "II", max_entries, 1, build_kw_1arg) |
| 558 |
|
| DEFINE_KW_HOOK(ii, "II", get_or_set, 3, build_kw_3arg) |
| 559 |
|
| DEFINE_KW_HOOK(ii, "II", put_ttl, 4, build_kw_4arg) |
| 560 |
|
| DEFINE_KW_HOOK(ii, "II", max_size, 1, build_kw_1arg) |
| 561 |
|
| DEFINE_KW_HOOK(ii, "II", ttl, 1, build_kw_1arg) |
| 562 |
|
| DEFINE_KW_HOOK(ii, "II", cursor, 1, build_kw_1arg) |
| 563 |
|
| DEFINE_KW_HOOK(ii, "II", cursor_next, 1, build_kw_1arg) |
| 564 |
|
| DEFINE_KW_HOOK(ii, "II", cursor_reset, 1, build_kw_1arg) |
| 565 |
|
| DEFINE_KW_HOOK(ii, "II", cursor_seek, 2, build_kw_2arg) |
| 566 |
|
| DEFINE_KW_HOOK(ii, "II", ttl_remaining, 2, build_kw_2arg) |
| 567 |
|
| DEFINE_KW_HOOK(ii, "II", capacity, 1, build_kw_1arg) |
| 568 |
|
| DEFINE_KW_HOOK(ii, "II", tombstones, 1, build_kw_1arg) |
| 569 |
|
| DEFINE_KW_HOOK(ii, "II", take, 2, build_kw_2arg) |
| 570 |
|
| DEFINE_KW_HOOK(ii, "II", pop, 1, build_kw_1arg) |
| 571 |
|
| DEFINE_KW_HOOK(ii, "II", shift, 1, build_kw_1arg) |
| 572 |
|
| DEFINE_KW_HOOK(ii, "II", drain, 2, build_kw_2arg) |
| 573 |
|
| DEFINE_KW_HOOK(ii, "II", flush_expired, 1, build_kw_1arg) |
| 574 |
|
| DEFINE_KW_HOOK(ii, "II", flush_expired_partial, 2, build_kw_2arg) |
| 575 |
|
| DEFINE_KW_HOOK(ii, "II", mmap_size, 1, build_kw_1arg) |
| 576 |
|
| DEFINE_KW_HOOK(ii, "II", touch, 2, build_kw_2arg) |
| 577 |
|
| DEFINE_KW_HOOK(ii, "II", reserve, 2, build_kw_2arg) |
| 578 |
|
| DEFINE_KW_HOOK(ii, "II", stat_evictions, 1, build_kw_1arg) |
| 579 |
|
| DEFINE_KW_HOOK(ii, "II", stat_expired, 1, build_kw_1arg) |
| 580 |
|
| DEFINE_KW_HOOK(ii, "II", stat_recoveries, 1, build_kw_1arg) |
| 581 |
|
| DEFINE_KW_HOOK(ii, "II", arena_used, 1, build_kw_1arg) |
| 582 |
|
| DEFINE_KW_HOOK(ii, "II", arena_cap, 1, build_kw_1arg) |
| 583 |
|
| DEFINE_KW_HOOK(ii, "II", add, 3, build_kw_3arg) |
| 584 |
|
| DEFINE_KW_HOOK(ii, "II", add_ttl, 4, build_kw_4arg) |
| 585 |
|
| DEFINE_KW_HOOK(ii, "II", update_ttl, 4, build_kw_4arg) |
| 586 |
|
| DEFINE_KW_HOOK(ii, "II", update, 3, build_kw_3arg) |
| 587 |
|
| DEFINE_KW_HOOK(ii, "II", swap, 3, build_kw_3arg) |
| 588 |
|
| DEFINE_KW_HOOK(ii, "II", cas, 4, build_kw_4arg) |
| 589 |
|
| DEFINE_KW_HOOK(ii, "II", cas_take, 3, build_kw_3arg) |
| 590 |
|
| DEFINE_KW_HOOK(ii, "II", persist, 2, build_kw_2arg) |
| 591 |
|
| DEFINE_KW_HOOK(ii, "II", set_ttl, 3, build_kw_3arg) |
| 592 |
|
| |
| 593 |
|
| DEFINE_KW_HOOK(i16s, "I16S", put, 3, build_kw_3arg) |
| 594 |
|
| DEFINE_KW_HOOK(i16s, "I16S", get, 2, build_kw_2arg) |
| 595 |
|
| DEFINE_KW_HOOK(i16s, "I16S", remove, 2, build_kw_2arg) |
| 596 |
|
| DEFINE_KW_HOOK(i16s, "I16S", exists, 2, build_kw_2arg) |
| 597 |
|
| DEFINE_KW_HOOK(i16s, "I16S", size, 1, build_kw_1arg) |
| 598 |
|
| DEFINE_KW_HOOK(i16s, "I16S", keys, 1, build_kw_1arg) |
| 599 |
|
| DEFINE_KW_HOOK(i16s, "I16S", values, 1, build_kw_1arg) |
| 600 |
|
| DEFINE_KW_HOOK(i16s, "I16S", items, 1, build_kw_1arg) |
| 601 |
|
| DEFINE_KW_HOOK(i16s, "I16S", each, 1, build_kw_1arg) |
| 602 |
|
| DEFINE_KW_HOOK(i16s, "I16S", iter_reset, 1, build_kw_1arg) |
| 603 |
|
| DEFINE_KW_HOOK(i16s, "I16S", clear, 1, build_kw_1arg) |
| 604 |
|
| DEFINE_KW_HOOK(i16s, "I16S", to_hash, 1, build_kw_1arg) |
| 605 |
|
| DEFINE_KW_HOOK(i16s, "I16S", max_entries, 1, build_kw_1arg) |
| 606 |
|
| DEFINE_KW_HOOK(i16s, "I16S", get_or_set, 3, build_kw_3arg) |
| 607 |
|
| DEFINE_KW_HOOK(i16s, "I16S", put_ttl, 4, build_kw_4arg) |
| 608 |
|
| DEFINE_KW_HOOK(i16s, "I16S", max_size, 1, build_kw_1arg) |
| 609 |
|
| DEFINE_KW_HOOK(i16s, "I16S", ttl, 1, build_kw_1arg) |
| 610 |
|
| DEFINE_KW_HOOK(i16s, "I16S", cursor, 1, build_kw_1arg) |
| 611 |
|
| DEFINE_KW_HOOK(i16s, "I16S", cursor_next, 1, build_kw_1arg) |
| 612 |
|
| DEFINE_KW_HOOK(i16s, "I16S", cursor_reset, 1, build_kw_1arg) |
| 613 |
|
| DEFINE_KW_HOOK(i16s, "I16S", cursor_seek, 2, build_kw_2arg) |
| 614 |
|
| DEFINE_KW_HOOK(i16s, "I16S", ttl_remaining, 2, build_kw_2arg) |
| 615 |
|
| DEFINE_KW_HOOK(i16s, "I16S", capacity, 1, build_kw_1arg) |
| 616 |
|
| DEFINE_KW_HOOK(i16s, "I16S", tombstones, 1, build_kw_1arg) |
| 617 |
|
| DEFINE_KW_HOOK(i16s, "I16S", take, 2, build_kw_2arg) |
| 618 |
|
| DEFINE_KW_HOOK(i16s, "I16S", pop, 1, build_kw_1arg) |
| 619 |
|
| DEFINE_KW_HOOK(i16s, "I16S", shift, 1, build_kw_1arg) |
| 620 |
|
| DEFINE_KW_HOOK(i16s, "I16S", drain, 2, build_kw_2arg) |
| 621 |
|
| DEFINE_KW_HOOK(i16s, "I16S", flush_expired, 1, build_kw_1arg) |
| 622 |
|
| DEFINE_KW_HOOK(i16s, "I16S", flush_expired_partial, 2, build_kw_2arg) |
| 623 |
|
| DEFINE_KW_HOOK(i16s, "I16S", mmap_size, 1, build_kw_1arg) |
| 624 |
|
| DEFINE_KW_HOOK(i16s, "I16S", touch, 2, build_kw_2arg) |
| 625 |
|
| DEFINE_KW_HOOK(i16s, "I16S", reserve, 2, build_kw_2arg) |
| 626 |
|
| DEFINE_KW_HOOK(i16s, "I16S", stat_evictions, 1, build_kw_1arg) |
| 627 |
|
| DEFINE_KW_HOOK(i16s, "I16S", stat_expired, 1, build_kw_1arg) |
| 628 |
|
| DEFINE_KW_HOOK(i16s, "I16S", stat_recoveries, 1, build_kw_1arg) |
| 629 |
|
| DEFINE_KW_HOOK(i16s, "I16S", arena_used, 1, build_kw_1arg) |
| 630 |
|
| DEFINE_KW_HOOK(i16s, "I16S", arena_cap, 1, build_kw_1arg) |
| 631 |
|
| DEFINE_KW_HOOK(i16s, "I16S", add, 3, build_kw_3arg) |
| 632 |
|
| DEFINE_KW_HOOK(i16s, "I16S", add_ttl, 4, build_kw_4arg) |
| 633 |
|
| DEFINE_KW_HOOK(i16s, "I16S", update_ttl, 4, build_kw_4arg) |
| 634 |
|
| DEFINE_KW_HOOK(i16s, "I16S", update, 3, build_kw_3arg) |
| 635 |
|
| DEFINE_KW_HOOK(i16s, "I16S", swap, 3, build_kw_3arg) |
| 636 |
|
| DEFINE_KW_HOOK(i16s, "I16S", cas, 4, build_kw_4arg) |
| 637 |
|
| DEFINE_KW_HOOK(i16s, "I16S", cas_take, 3, build_kw_3arg) |
| 638 |
|
| DEFINE_KW_HOOK(i16s, "I16S", persist, 2, build_kw_2arg) |
| 639 |
|
| DEFINE_KW_HOOK(i16s, "I16S", set_ttl, 3, build_kw_3arg) |
| 640 |
|
| |
| 641 |
|
| DEFINE_KW_HOOK(i32s, "I32S", put, 3, build_kw_3arg) |
| 642 |
|
| DEFINE_KW_HOOK(i32s, "I32S", get, 2, build_kw_2arg) |
| 643 |
|
| DEFINE_KW_HOOK(i32s, "I32S", remove, 2, build_kw_2arg) |
| 644 |
|
| DEFINE_KW_HOOK(i32s, "I32S", exists, 2, build_kw_2arg) |
| 645 |
|
| DEFINE_KW_HOOK(i32s, "I32S", size, 1, build_kw_1arg) |
| 646 |
|
| DEFINE_KW_HOOK(i32s, "I32S", keys, 1, build_kw_1arg) |
| 647 |
|
| DEFINE_KW_HOOK(i32s, "I32S", values, 1, build_kw_1arg) |
| 648 |
|
| DEFINE_KW_HOOK(i32s, "I32S", items, 1, build_kw_1arg) |
| 649 |
|
| DEFINE_KW_HOOK(i32s, "I32S", each, 1, build_kw_1arg) |
| 650 |
|
| DEFINE_KW_HOOK(i32s, "I32S", iter_reset, 1, build_kw_1arg) |
| 651 |
|
| DEFINE_KW_HOOK(i32s, "I32S", clear, 1, build_kw_1arg) |
| 652 |
|
| DEFINE_KW_HOOK(i32s, "I32S", to_hash, 1, build_kw_1arg) |
| 653 |
|
| DEFINE_KW_HOOK(i32s, "I32S", max_entries, 1, build_kw_1arg) |
| 654 |
|
| DEFINE_KW_HOOK(i32s, "I32S", get_or_set, 3, build_kw_3arg) |
| 655 |
|
| DEFINE_KW_HOOK(i32s, "I32S", put_ttl, 4, build_kw_4arg) |
| 656 |
|
| DEFINE_KW_HOOK(i32s, "I32S", max_size, 1, build_kw_1arg) |
| 657 |
|
| DEFINE_KW_HOOK(i32s, "I32S", ttl, 1, build_kw_1arg) |
| 658 |
|
| DEFINE_KW_HOOK(i32s, "I32S", cursor, 1, build_kw_1arg) |
| 659 |
|
| DEFINE_KW_HOOK(i32s, "I32S", cursor_next, 1, build_kw_1arg) |
| 660 |
|
| DEFINE_KW_HOOK(i32s, "I32S", cursor_reset, 1, build_kw_1arg) |
| 661 |
|
| DEFINE_KW_HOOK(i32s, "I32S", cursor_seek, 2, build_kw_2arg) |
| 662 |
|
| DEFINE_KW_HOOK(i32s, "I32S", ttl_remaining, 2, build_kw_2arg) |
| 663 |
|
| DEFINE_KW_HOOK(i32s, "I32S", capacity, 1, build_kw_1arg) |
| 664 |
|
| DEFINE_KW_HOOK(i32s, "I32S", tombstones, 1, build_kw_1arg) |
| 665 |
|
| DEFINE_KW_HOOK(i32s, "I32S", take, 2, build_kw_2arg) |
| 666 |
|
| DEFINE_KW_HOOK(i32s, "I32S", pop, 1, build_kw_1arg) |
| 667 |
|
| DEFINE_KW_HOOK(i32s, "I32S", shift, 1, build_kw_1arg) |
| 668 |
|
| DEFINE_KW_HOOK(i32s, "I32S", drain, 2, build_kw_2arg) |
| 669 |
|
| DEFINE_KW_HOOK(i32s, "I32S", flush_expired, 1, build_kw_1arg) |
| 670 |
|
| DEFINE_KW_HOOK(i32s, "I32S", flush_expired_partial, 2, build_kw_2arg) |
| 671 |
|
| DEFINE_KW_HOOK(i32s, "I32S", mmap_size, 1, build_kw_1arg) |
| 672 |
|
| DEFINE_KW_HOOK(i32s, "I32S", touch, 2, build_kw_2arg) |
| 673 |
|
| DEFINE_KW_HOOK(i32s, "I32S", reserve, 2, build_kw_2arg) |
| 674 |
|
| DEFINE_KW_HOOK(i32s, "I32S", stat_evictions, 1, build_kw_1arg) |
| 675 |
|
| DEFINE_KW_HOOK(i32s, "I32S", stat_expired, 1, build_kw_1arg) |
| 676 |
|
| DEFINE_KW_HOOK(i32s, "I32S", stat_recoveries, 1, build_kw_1arg) |
| 677 |
|
| DEFINE_KW_HOOK(i32s, "I32S", arena_used, 1, build_kw_1arg) |
| 678 |
|
| DEFINE_KW_HOOK(i32s, "I32S", arena_cap, 1, build_kw_1arg) |
| 679 |
|
| DEFINE_KW_HOOK(i32s, "I32S", add, 3, build_kw_3arg) |
| 680 |
|
| DEFINE_KW_HOOK(i32s, "I32S", add_ttl, 4, build_kw_4arg) |
| 681 |
|
| DEFINE_KW_HOOK(i32s, "I32S", update_ttl, 4, build_kw_4arg) |
| 682 |
|
| DEFINE_KW_HOOK(i32s, "I32S", update, 3, build_kw_3arg) |
| 683 |
|
| DEFINE_KW_HOOK(i32s, "I32S", swap, 3, build_kw_3arg) |
| 684 |
|
| DEFINE_KW_HOOK(i32s, "I32S", cas, 4, build_kw_4arg) |
| 685 |
|
| DEFINE_KW_HOOK(i32s, "I32S", cas_take, 3, build_kw_3arg) |
| 686 |
|
| DEFINE_KW_HOOK(i32s, "I32S", persist, 2, build_kw_2arg) |
| 687 |
|
| DEFINE_KW_HOOK(i32s, "I32S", set_ttl, 3, build_kw_3arg) |
| 688 |
|
| |
| 689 |
|
| DEFINE_KW_HOOK(is, "IS", put, 3, build_kw_3arg) |
| 690 |
|
| DEFINE_KW_HOOK(is, "IS", get, 2, build_kw_2arg) |
| 691 |
|
| DEFINE_KW_HOOK(is, "IS", remove, 2, build_kw_2arg) |
| 692 |
|
| DEFINE_KW_HOOK(is, "IS", exists, 2, build_kw_2arg) |
| 693 |
|
| DEFINE_KW_HOOK(is, "IS", size, 1, build_kw_1arg) |
| 694 |
|
| DEFINE_KW_HOOK(is, "IS", keys, 1, build_kw_1arg) |
| 695 |
|
| DEFINE_KW_HOOK(is, "IS", values, 1, build_kw_1arg) |
| 696 |
|
| DEFINE_KW_HOOK(is, "IS", items, 1, build_kw_1arg) |
| 697 |
|
| DEFINE_KW_HOOK(is, "IS", each, 1, build_kw_1arg) |
| 698 |
|
| DEFINE_KW_HOOK(is, "IS", iter_reset, 1, build_kw_1arg) |
| 699 |
|
| DEFINE_KW_HOOK(is, "IS", clear, 1, build_kw_1arg) |
| 700 |
|
| DEFINE_KW_HOOK(is, "IS", to_hash, 1, build_kw_1arg) |
| 701 |
|
| DEFINE_KW_HOOK(is, "IS", max_entries, 1, build_kw_1arg) |
| 702 |
|
| DEFINE_KW_HOOK(is, "IS", get_or_set, 3, build_kw_3arg) |
| 703 |
|
| DEFINE_KW_HOOK(is, "IS", put_ttl, 4, build_kw_4arg) |
| 704 |
|
| DEFINE_KW_HOOK(is, "IS", max_size, 1, build_kw_1arg) |
| 705 |
|
| DEFINE_KW_HOOK(is, "IS", ttl, 1, build_kw_1arg) |
| 706 |
|
| DEFINE_KW_HOOK(is, "IS", cursor, 1, build_kw_1arg) |
| 707 |
|
| DEFINE_KW_HOOK(is, "IS", cursor_next, 1, build_kw_1arg) |
| 708 |
|
| DEFINE_KW_HOOK(is, "IS", cursor_reset, 1, build_kw_1arg) |
| 709 |
|
| DEFINE_KW_HOOK(is, "IS", cursor_seek, 2, build_kw_2arg) |
| 710 |
|
| DEFINE_KW_HOOK(is, "IS", ttl_remaining, 2, build_kw_2arg) |
| 711 |
|
| DEFINE_KW_HOOK(is, "IS", capacity, 1, build_kw_1arg) |
| 712 |
|
| DEFINE_KW_HOOK(is, "IS", tombstones, 1, build_kw_1arg) |
| 713 |
|
| DEFINE_KW_HOOK(is, "IS", take, 2, build_kw_2arg) |
| 714 |
|
| DEFINE_KW_HOOK(is, "IS", pop, 1, build_kw_1arg) |
| 715 |
|
| DEFINE_KW_HOOK(is, "IS", shift, 1, build_kw_1arg) |
| 716 |
|
| DEFINE_KW_HOOK(is, "IS", drain, 2, build_kw_2arg) |
| 717 |
|
| DEFINE_KW_HOOK(is, "IS", flush_expired, 1, build_kw_1arg) |
| 718 |
|
| DEFINE_KW_HOOK(is, "IS", flush_expired_partial, 2, build_kw_2arg) |
| 719 |
|
| DEFINE_KW_HOOK(is, "IS", mmap_size, 1, build_kw_1arg) |
| 720 |
|
| DEFINE_KW_HOOK(is, "IS", touch, 2, build_kw_2arg) |
| 721 |
|
| DEFINE_KW_HOOK(is, "IS", reserve, 2, build_kw_2arg) |
| 722 |
|
| DEFINE_KW_HOOK(is, "IS", stat_evictions, 1, build_kw_1arg) |
| 723 |
|
| DEFINE_KW_HOOK(is, "IS", stat_expired, 1, build_kw_1arg) |
| 724 |
|
| DEFINE_KW_HOOK(is, "IS", stat_recoveries, 1, build_kw_1arg) |
| 725 |
|
| DEFINE_KW_HOOK(is, "IS", arena_used, 1, build_kw_1arg) |
| 726 |
|
| DEFINE_KW_HOOK(is, "IS", arena_cap, 1, build_kw_1arg) |
| 727 |
|
| DEFINE_KW_HOOK(is, "IS", add, 3, build_kw_3arg) |
| 728 |
|
| DEFINE_KW_HOOK(is, "IS", add_ttl, 4, build_kw_4arg) |
| 729 |
|
| DEFINE_KW_HOOK(is, "IS", update_ttl, 4, build_kw_4arg) |
| 730 |
|
| DEFINE_KW_HOOK(is, "IS", update, 3, build_kw_3arg) |
| 731 |
|
| DEFINE_KW_HOOK(is, "IS", swap, 3, build_kw_3arg) |
| 732 |
|
| DEFINE_KW_HOOK(is, "IS", cas, 4, build_kw_4arg) |
| 733 |
|
| DEFINE_KW_HOOK(is, "IS", cas_take, 3, build_kw_3arg) |
| 734 |
|
| DEFINE_KW_HOOK(is, "IS", persist, 2, build_kw_2arg) |
| 735 |
|
| DEFINE_KW_HOOK(is, "IS", set_ttl, 3, build_kw_3arg) |
| 736 |
|
| |
| 737 |
|
| DEFINE_KW_HOOK(si16, "SI16", put, 3, build_kw_3arg) |
| 738 |
|
| DEFINE_KW_HOOK(si16, "SI16", get, 2, build_kw_2arg) |
| 739 |
|
| DEFINE_KW_HOOK(si16, "SI16", remove, 2, build_kw_2arg) |
| 740 |
|
| DEFINE_KW_HOOK(si16, "SI16", exists, 2, build_kw_2arg) |
| 741 |
|
| DEFINE_KW_HOOK(si16, "SI16", incr, 2, build_kw_2arg) |
| 742 |
|
| DEFINE_KW_HOOK(si16, "SI16", decr, 2, build_kw_2arg) |
| 743 |
|
| DEFINE_KW_HOOK(si16, "SI16", incr_by, 3, build_kw_3arg) |
| 744 |
|
| DEFINE_KW_HOOK(si16, "SI16", max, 3, build_kw_3arg) |
| 745 |
|
| DEFINE_KW_HOOK(si16, "SI16", min, 3, build_kw_3arg) |
| 746 |
|
| DEFINE_KW_HOOK(si16, "SI16", size, 1, build_kw_1arg) |
| 747 |
|
| DEFINE_KW_HOOK(si16, "SI16", keys, 1, build_kw_1arg) |
| 748 |
|
| DEFINE_KW_HOOK(si16, "SI16", values, 1, build_kw_1arg) |
| 749 |
|
| DEFINE_KW_HOOK(si16, "SI16", items, 1, build_kw_1arg) |
| 750 |
|
| DEFINE_KW_HOOK(si16, "SI16", each, 1, build_kw_1arg) |
| 751 |
|
| DEFINE_KW_HOOK(si16, "SI16", iter_reset, 1, build_kw_1arg) |
| 752 |
|
| DEFINE_KW_HOOK(si16, "SI16", clear, 1, build_kw_1arg) |
| 753 |
|
| DEFINE_KW_HOOK(si16, "SI16", to_hash, 1, build_kw_1arg) |
| 754 |
|
| DEFINE_KW_HOOK(si16, "SI16", max_entries, 1, build_kw_1arg) |
| 755 |
|
| DEFINE_KW_HOOK(si16, "SI16", get_or_set, 3, build_kw_3arg) |
| 756 |
|
| DEFINE_KW_HOOK(si16, "SI16", put_ttl, 4, build_kw_4arg) |
| 757 |
|
| DEFINE_KW_HOOK(si16, "SI16", max_size, 1, build_kw_1arg) |
| 758 |
|
| DEFINE_KW_HOOK(si16, "SI16", ttl, 1, build_kw_1arg) |
| 759 |
|
| DEFINE_KW_HOOK(si16, "SI16", cursor, 1, build_kw_1arg) |
| 760 |
|
| DEFINE_KW_HOOK(si16, "SI16", cursor_next, 1, build_kw_1arg) |
| 761 |
|
| DEFINE_KW_HOOK(si16, "SI16", cursor_reset, 1, build_kw_1arg) |
| 762 |
|
| DEFINE_KW_HOOK(si16, "SI16", cursor_seek, 2, build_kw_2arg) |
| 763 |
|
| DEFINE_KW_HOOK(si16, "SI16", ttl_remaining, 2, build_kw_2arg) |
| 764 |
|
| DEFINE_KW_HOOK(si16, "SI16", capacity, 1, build_kw_1arg) |
| 765 |
|
| DEFINE_KW_HOOK(si16, "SI16", tombstones, 1, build_kw_1arg) |
| 766 |
|
| DEFINE_KW_HOOK(si16, "SI16", take, 2, build_kw_2arg) |
| 767 |
|
| DEFINE_KW_HOOK(si16, "SI16", pop, 1, build_kw_1arg) |
| 768 |
|
| DEFINE_KW_HOOK(si16, "SI16", shift, 1, build_kw_1arg) |
| 769 |
|
| DEFINE_KW_HOOK(si16, "SI16", drain, 2, build_kw_2arg) |
| 770 |
|
| DEFINE_KW_HOOK(si16, "SI16", flush_expired, 1, build_kw_1arg) |
| 771 |
|
| DEFINE_KW_HOOK(si16, "SI16", flush_expired_partial, 2, build_kw_2arg) |
| 772 |
|
| DEFINE_KW_HOOK(si16, "SI16", mmap_size, 1, build_kw_1arg) |
| 773 |
|
| DEFINE_KW_HOOK(si16, "SI16", touch, 2, build_kw_2arg) |
| 774 |
|
| DEFINE_KW_HOOK(si16, "SI16", reserve, 2, build_kw_2arg) |
| 775 |
|
| DEFINE_KW_HOOK(si16, "SI16", stat_evictions, 1, build_kw_1arg) |
| 776 |
|
| DEFINE_KW_HOOK(si16, "SI16", stat_expired, 1, build_kw_1arg) |
| 777 |
|
| DEFINE_KW_HOOK(si16, "SI16", stat_recoveries, 1, build_kw_1arg) |
| 778 |
|
| DEFINE_KW_HOOK(si16, "SI16", arena_used, 1, build_kw_1arg) |
| 779 |
|
| DEFINE_KW_HOOK(si16, "SI16", arena_cap, 1, build_kw_1arg) |
| 780 |
|
| DEFINE_KW_HOOK(si16, "SI16", add, 3, build_kw_3arg) |
| 781 |
|
| DEFINE_KW_HOOK(si16, "SI16", add_ttl, 4, build_kw_4arg) |
| 782 |
|
| DEFINE_KW_HOOK(si16, "SI16", update_ttl, 4, build_kw_4arg) |
| 783 |
|
| DEFINE_KW_HOOK(si16, "SI16", update, 3, build_kw_3arg) |
| 784 |
|
| DEFINE_KW_HOOK(si16, "SI16", swap, 3, build_kw_3arg) |
| 785 |
|
| DEFINE_KW_HOOK(si16, "SI16", cas, 4, build_kw_4arg) |
| 786 |
|
| DEFINE_KW_HOOK(si16, "SI16", cas_take, 3, build_kw_3arg) |
| 787 |
|
| DEFINE_KW_HOOK(si16, "SI16", persist, 2, build_kw_2arg) |
| 788 |
|
| DEFINE_KW_HOOK(si16, "SI16", set_ttl, 3, build_kw_3arg) |
| 789 |
|
| |
| 790 |
|
| DEFINE_KW_HOOK(si32, "SI32", put, 3, build_kw_3arg) |
| 791 |
|
| DEFINE_KW_HOOK(si32, "SI32", get, 2, build_kw_2arg) |
| 792 |
|
| DEFINE_KW_HOOK(si32, "SI32", remove, 2, build_kw_2arg) |
| 793 |
|
| DEFINE_KW_HOOK(si32, "SI32", exists, 2, build_kw_2arg) |
| 794 |
|
| DEFINE_KW_HOOK(si32, "SI32", incr, 2, build_kw_2arg) |
| 795 |
|
| DEFINE_KW_HOOK(si32, "SI32", decr, 2, build_kw_2arg) |
| 796 |
|
| DEFINE_KW_HOOK(si32, "SI32", incr_by, 3, build_kw_3arg) |
| 797 |
|
| DEFINE_KW_HOOK(si32, "SI32", max, 3, build_kw_3arg) |
| 798 |
|
| DEFINE_KW_HOOK(si32, "SI32", min, 3, build_kw_3arg) |
| 799 |
|
| DEFINE_KW_HOOK(si32, "SI32", size, 1, build_kw_1arg) |
| 800 |
|
| DEFINE_KW_HOOK(si32, "SI32", keys, 1, build_kw_1arg) |
| 801 |
|
| DEFINE_KW_HOOK(si32, "SI32", values, 1, build_kw_1arg) |
| 802 |
|
| DEFINE_KW_HOOK(si32, "SI32", items, 1, build_kw_1arg) |
| 803 |
|
| DEFINE_KW_HOOK(si32, "SI32", each, 1, build_kw_1arg) |
| 804 |
|
| DEFINE_KW_HOOK(si32, "SI32", iter_reset, 1, build_kw_1arg) |
| 805 |
|
| DEFINE_KW_HOOK(si32, "SI32", clear, 1, build_kw_1arg) |
| 806 |
|
| DEFINE_KW_HOOK(si32, "SI32", to_hash, 1, build_kw_1arg) |
| 807 |
|
| DEFINE_KW_HOOK(si32, "SI32", max_entries, 1, build_kw_1arg) |
| 808 |
|
| DEFINE_KW_HOOK(si32, "SI32", get_or_set, 3, build_kw_3arg) |
| 809 |
|
| DEFINE_KW_HOOK(si32, "SI32", put_ttl, 4, build_kw_4arg) |
| 810 |
|
| DEFINE_KW_HOOK(si32, "SI32", max_size, 1, build_kw_1arg) |
| 811 |
|
| DEFINE_KW_HOOK(si32, "SI32", ttl, 1, build_kw_1arg) |
| 812 |
|
| DEFINE_KW_HOOK(si32, "SI32", cursor, 1, build_kw_1arg) |
| 813 |
|
| DEFINE_KW_HOOK(si32, "SI32", cursor_next, 1, build_kw_1arg) |
| 814 |
|
| DEFINE_KW_HOOK(si32, "SI32", cursor_reset, 1, build_kw_1arg) |
| 815 |
|
| DEFINE_KW_HOOK(si32, "SI32", cursor_seek, 2, build_kw_2arg) |
| 816 |
|
| DEFINE_KW_HOOK(si32, "SI32", ttl_remaining, 2, build_kw_2arg) |
| 817 |
|
| DEFINE_KW_HOOK(si32, "SI32", capacity, 1, build_kw_1arg) |
| 818 |
|
| DEFINE_KW_HOOK(si32, "SI32", tombstones, 1, build_kw_1arg) |
| 819 |
|
| DEFINE_KW_HOOK(si32, "SI32", take, 2, build_kw_2arg) |
| 820 |
|
| DEFINE_KW_HOOK(si32, "SI32", pop, 1, build_kw_1arg) |
| 821 |
|
| DEFINE_KW_HOOK(si32, "SI32", shift, 1, build_kw_1arg) |
| 822 |
|
| DEFINE_KW_HOOK(si32, "SI32", drain, 2, build_kw_2arg) |
| 823 |
|
| DEFINE_KW_HOOK(si32, "SI32", flush_expired, 1, build_kw_1arg) |
| 824 |
|
| DEFINE_KW_HOOK(si32, "SI32", flush_expired_partial, 2, build_kw_2arg) |
| 825 |
|
| DEFINE_KW_HOOK(si32, "SI32", mmap_size, 1, build_kw_1arg) |
| 826 |
|
| DEFINE_KW_HOOK(si32, "SI32", touch, 2, build_kw_2arg) |
| 827 |
|
| DEFINE_KW_HOOK(si32, "SI32", reserve, 2, build_kw_2arg) |
| 828 |
|
| DEFINE_KW_HOOK(si32, "SI32", stat_evictions, 1, build_kw_1arg) |
| 829 |
|
| DEFINE_KW_HOOK(si32, "SI32", stat_expired, 1, build_kw_1arg) |
| 830 |
|
| DEFINE_KW_HOOK(si32, "SI32", stat_recoveries, 1, build_kw_1arg) |
| 831 |
|
| DEFINE_KW_HOOK(si32, "SI32", arena_used, 1, build_kw_1arg) |
| 832 |
|
| DEFINE_KW_HOOK(si32, "SI32", arena_cap, 1, build_kw_1arg) |
| 833 |
|
| DEFINE_KW_HOOK(si32, "SI32", add, 3, build_kw_3arg) |
| 834 |
|
| DEFINE_KW_HOOK(si32, "SI32", add_ttl, 4, build_kw_4arg) |
| 835 |
|
| DEFINE_KW_HOOK(si32, "SI32", update_ttl, 4, build_kw_4arg) |
| 836 |
|
| DEFINE_KW_HOOK(si32, "SI32", update, 3, build_kw_3arg) |
| 837 |
|
| DEFINE_KW_HOOK(si32, "SI32", swap, 3, build_kw_3arg) |
| 838 |
|
| DEFINE_KW_HOOK(si32, "SI32", cas, 4, build_kw_4arg) |
| 839 |
|
| DEFINE_KW_HOOK(si32, "SI32", cas_take, 3, build_kw_3arg) |
| 840 |
|
| DEFINE_KW_HOOK(si32, "SI32", persist, 2, build_kw_2arg) |
| 841 |
|
| DEFINE_KW_HOOK(si32, "SI32", set_ttl, 3, build_kw_3arg) |
| 842 |
|
| |
| 843 |
|
| DEFINE_KW_HOOK(si, "SI", put, 3, build_kw_3arg) |
| 844 |
|
| DEFINE_KW_HOOK(si, "SI", get, 2, build_kw_2arg) |
| 845 |
|
| DEFINE_KW_HOOK(si, "SI", remove, 2, build_kw_2arg) |
| 846 |
|
| DEFINE_KW_HOOK(si, "SI", exists, 2, build_kw_2arg) |
| 847 |
|
| DEFINE_KW_HOOK(si, "SI", incr, 2, build_kw_2arg) |
| 848 |
|
| DEFINE_KW_HOOK(si, "SI", decr, 2, build_kw_2arg) |
| 849 |
|
| DEFINE_KW_HOOK(si, "SI", incr_by, 3, build_kw_3arg) |
| 850 |
|
| DEFINE_KW_HOOK(si, "SI", max, 3, build_kw_3arg) |
| 851 |
|
| DEFINE_KW_HOOK(si, "SI", min, 3, build_kw_3arg) |
| 852 |
|
| DEFINE_KW_HOOK(si, "SI", size, 1, build_kw_1arg) |
| 853 |
|
| DEFINE_KW_HOOK(si, "SI", keys, 1, build_kw_1arg) |
| 854 |
|
| DEFINE_KW_HOOK(si, "SI", values, 1, build_kw_1arg) |
| 855 |
|
| DEFINE_KW_HOOK(si, "SI", items, 1, build_kw_1arg) |
| 856 |
|
| DEFINE_KW_HOOK(si, "SI", each, 1, build_kw_1arg) |
| 857 |
|
| DEFINE_KW_HOOK(si, "SI", iter_reset, 1, build_kw_1arg) |
| 858 |
|
| DEFINE_KW_HOOK(si, "SI", clear, 1, build_kw_1arg) |
| 859 |
|
| DEFINE_KW_HOOK(si, "SI", to_hash, 1, build_kw_1arg) |
| 860 |
|
| DEFINE_KW_HOOK(si, "SI", max_entries, 1, build_kw_1arg) |
| 861 |
|
| DEFINE_KW_HOOK(si, "SI", get_or_set, 3, build_kw_3arg) |
| 862 |
|
| DEFINE_KW_HOOK(si, "SI", put_ttl, 4, build_kw_4arg) |
| 863 |
|
| DEFINE_KW_HOOK(si, "SI", max_size, 1, build_kw_1arg) |
| 864 |
|
| DEFINE_KW_HOOK(si, "SI", ttl, 1, build_kw_1arg) |
| 865 |
|
| DEFINE_KW_HOOK(si, "SI", cursor, 1, build_kw_1arg) |
| 866 |
|
| DEFINE_KW_HOOK(si, "SI", cursor_next, 1, build_kw_1arg) |
| 867 |
|
| DEFINE_KW_HOOK(si, "SI", cursor_reset, 1, build_kw_1arg) |
| 868 |
|
| DEFINE_KW_HOOK(si, "SI", cursor_seek, 2, build_kw_2arg) |
| 869 |
|
| DEFINE_KW_HOOK(si, "SI", ttl_remaining, 2, build_kw_2arg) |
| 870 |
|
| DEFINE_KW_HOOK(si, "SI", capacity, 1, build_kw_1arg) |
| 871 |
|
| DEFINE_KW_HOOK(si, "SI", tombstones, 1, build_kw_1arg) |
| 872 |
|
| DEFINE_KW_HOOK(si, "SI", take, 2, build_kw_2arg) |
| 873 |
|
| DEFINE_KW_HOOK(si, "SI", pop, 1, build_kw_1arg) |
| 874 |
|
| DEFINE_KW_HOOK(si, "SI", shift, 1, build_kw_1arg) |
| 875 |
|
| DEFINE_KW_HOOK(si, "SI", drain, 2, build_kw_2arg) |
| 876 |
|
| DEFINE_KW_HOOK(si, "SI", flush_expired, 1, build_kw_1arg) |
| 877 |
|
| DEFINE_KW_HOOK(si, "SI", flush_expired_partial, 2, build_kw_2arg) |
| 878 |
|
| DEFINE_KW_HOOK(si, "SI", mmap_size, 1, build_kw_1arg) |
| 879 |
|
| DEFINE_KW_HOOK(si, "SI", touch, 2, build_kw_2arg) |
| 880 |
|
| DEFINE_KW_HOOK(si, "SI", reserve, 2, build_kw_2arg) |
| 881 |
|
| DEFINE_KW_HOOK(si, "SI", stat_evictions, 1, build_kw_1arg) |
| 882 |
|
| DEFINE_KW_HOOK(si, "SI", stat_expired, 1, build_kw_1arg) |
| 883 |
|
| DEFINE_KW_HOOK(si, "SI", stat_recoveries, 1, build_kw_1arg) |
| 884 |
|
| DEFINE_KW_HOOK(si, "SI", arena_used, 1, build_kw_1arg) |
| 885 |
|
| DEFINE_KW_HOOK(si, "SI", arena_cap, 1, build_kw_1arg) |
| 886 |
|
| DEFINE_KW_HOOK(si, "SI", add, 3, build_kw_3arg) |
| 887 |
|
| DEFINE_KW_HOOK(si, "SI", add_ttl, 4, build_kw_4arg) |
| 888 |
|
| DEFINE_KW_HOOK(si, "SI", update_ttl, 4, build_kw_4arg) |
| 889 |
|
| DEFINE_KW_HOOK(si, "SI", update, 3, build_kw_3arg) |
| 890 |
|
| DEFINE_KW_HOOK(si, "SI", swap, 3, build_kw_3arg) |
| 891 |
|
| DEFINE_KW_HOOK(si, "SI", cas, 4, build_kw_4arg) |
| 892 |
|
| DEFINE_KW_HOOK(si, "SI", cas_take, 3, build_kw_3arg) |
| 893 |
|
| DEFINE_KW_HOOK(si, "SI", persist, 2, build_kw_2arg) |
| 894 |
|
| DEFINE_KW_HOOK(si, "SI", set_ttl, 3, build_kw_3arg) |
| 895 |
|
| |
| 896 |
|
| DEFINE_KW_HOOK(ss, "SS", put, 3, build_kw_3arg) |
| 897 |
|
| DEFINE_KW_HOOK(ss, "SS", get, 2, build_kw_2arg) |
| 898 |
|
| DEFINE_KW_HOOK(ss, "SS", remove, 2, build_kw_2arg) |
| 899 |
|
| DEFINE_KW_HOOK(ss, "SS", exists, 2, build_kw_2arg) |
| 900 |
|
| DEFINE_KW_HOOK(ss, "SS", size, 1, build_kw_1arg) |
| 901 |
|
| DEFINE_KW_HOOK(ss, "SS", keys, 1, build_kw_1arg) |
| 902 |
|
| DEFINE_KW_HOOK(ss, "SS", values, 1, build_kw_1arg) |
| 903 |
|
| DEFINE_KW_HOOK(ss, "SS", items, 1, build_kw_1arg) |
| 904 |
|
| DEFINE_KW_HOOK(ss, "SS", each, 1, build_kw_1arg) |
| 905 |
|
| DEFINE_KW_HOOK(ss, "SS", iter_reset, 1, build_kw_1arg) |
| 906 |
|
| DEFINE_KW_HOOK(ss, "SS", clear, 1, build_kw_1arg) |
| 907 |
|
| DEFINE_KW_HOOK(ss, "SS", to_hash, 1, build_kw_1arg) |
| 908 |
|
| DEFINE_KW_HOOK(ss, "SS", max_entries, 1, build_kw_1arg) |
| 909 |
|
| DEFINE_KW_HOOK(ss, "SS", get_or_set, 3, build_kw_3arg) |
| 910 |
|
| DEFINE_KW_HOOK(ss, "SS", put_ttl, 4, build_kw_4arg) |
| 911 |
|
| DEFINE_KW_HOOK(ss, "SS", max_size, 1, build_kw_1arg) |
| 912 |
|
| DEFINE_KW_HOOK(ss, "SS", ttl, 1, build_kw_1arg) |
| 913 |
|
| DEFINE_KW_HOOK(ss, "SS", cursor, 1, build_kw_1arg) |
| 914 |
|
| DEFINE_KW_HOOK(ss, "SS", cursor_next, 1, build_kw_1arg) |
| 915 |
|
| DEFINE_KW_HOOK(ss, "SS", cursor_reset, 1, build_kw_1arg) |
| 916 |
|
| DEFINE_KW_HOOK(ss, "SS", cursor_seek, 2, build_kw_2arg) |
| 917 |
|
| DEFINE_KW_HOOK(ss, "SS", ttl_remaining, 2, build_kw_2arg) |
| 918 |
|
| DEFINE_KW_HOOK(ss, "SS", capacity, 1, build_kw_1arg) |
| 919 |
|
| DEFINE_KW_HOOK(ss, "SS", tombstones, 1, build_kw_1arg) |
| 920 |
|
| DEFINE_KW_HOOK(ss, "SS", take, 2, build_kw_2arg) |
| 921 |
|
| DEFINE_KW_HOOK(ss, "SS", pop, 1, build_kw_1arg) |
| 922 |
|
| DEFINE_KW_HOOK(ss, "SS", shift, 1, build_kw_1arg) |
| 923 |
|
| DEFINE_KW_HOOK(ss, "SS", drain, 2, build_kw_2arg) |
| 924 |
|
| DEFINE_KW_HOOK(ss, "SS", flush_expired, 1, build_kw_1arg) |
| 925 |
|
| DEFINE_KW_HOOK(ss, "SS", flush_expired_partial, 2, build_kw_2arg) |
| 926 |
|
| DEFINE_KW_HOOK(ss, "SS", mmap_size, 1, build_kw_1arg) |
| 927 |
|
| DEFINE_KW_HOOK(ss, "SS", touch, 2, build_kw_2arg) |
| 928 |
|
| DEFINE_KW_HOOK(ss, "SS", reserve, 2, build_kw_2arg) |
| 929 |
|
| DEFINE_KW_HOOK(ss, "SS", stat_evictions, 1, build_kw_1arg) |
| 930 |
|
| DEFINE_KW_HOOK(ss, "SS", stat_expired, 1, build_kw_1arg) |
| 931 |
|
| DEFINE_KW_HOOK(ss, "SS", stat_recoveries, 1, build_kw_1arg) |
| 932 |
|
| DEFINE_KW_HOOK(ss, "SS", arena_used, 1, build_kw_1arg) |
| 933 |
|
| DEFINE_KW_HOOK(ss, "SS", arena_cap, 1, build_kw_1arg) |
| 934 |
|
| DEFINE_KW_HOOK(ss, "SS", add, 3, build_kw_3arg) |
| 935 |
|
| DEFINE_KW_HOOK(ss, "SS", add_ttl, 4, build_kw_4arg) |
| 936 |
|
| DEFINE_KW_HOOK(ss, "SS", update_ttl, 4, build_kw_4arg) |
| 937 |
|
| DEFINE_KW_HOOK(ss, "SS", update, 3, build_kw_3arg) |
| 938 |
|
| DEFINE_KW_HOOK(ss, "SS", swap, 3, build_kw_3arg) |
| 939 |
|
| DEFINE_KW_HOOK(ss, "SS", cas, 4, build_kw_4arg) |
| 940 |
|
| DEFINE_KW_HOOK(ss, "SS", cas_take, 3, build_kw_3arg) |
| 941 |
|
| DEFINE_KW_HOOK(ss, "SS", persist, 2, build_kw_2arg) |
| 942 |
|
| DEFINE_KW_HOOK(ss, "SS", set_ttl, 3, build_kw_3arg) |
| 943 |
|
| |
| 944 |
|
| #define REGISTER_KW(variant, kw, func_name) \ |
| 945 |
|
| register_xs_parse_keyword("shm_" #variant "_" #kw, \ |
| 946 |
|
| &hooks_shm_##variant##_##kw, (void*)func_name) |
| 947 |
|
| |
| 948 |
|
| |
| 949 |
|
| MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared::I16 |
| 950 |
|
| PROTOTYPES: DISABLE |
| 951 |
|
| |
| 952 |
|
| BOOT: |
| 953 |
89 |
| boot_xs_parse_keyword(0.40); |
| 954 |
89 |
| REGISTER_KW(i16, put, "Data::HashMap::Shared::I16::put"); |
| 955 |
89 |
| REGISTER_KW(i16, get, "Data::HashMap::Shared::I16::get"); |
| 956 |
89 |
| REGISTER_KW(i16, remove, "Data::HashMap::Shared::I16::remove"); |
| 957 |
89 |
| REGISTER_KW(i16, exists, "Data::HashMap::Shared::I16::exists"); |
| 958 |
89 |
| REGISTER_KW(i16, incr, "Data::HashMap::Shared::I16::incr"); |
| 959 |
89 |
| REGISTER_KW(i16, decr, "Data::HashMap::Shared::I16::decr"); |
| 960 |
89 |
| REGISTER_KW(i16, incr_by, "Data::HashMap::Shared::I16::incr_by"); |
| 961 |
89 |
| REGISTER_KW(i16, max, "Data::HashMap::Shared::I16::max"); |
| 962 |
89 |
| REGISTER_KW(i16, min, "Data::HashMap::Shared::I16::min"); |
| 963 |
89 |
| REGISTER_KW(i16, size, "Data::HashMap::Shared::I16::size"); |
| 964 |
89 |
| REGISTER_KW(i16, keys, "Data::HashMap::Shared::I16::keys"); |
| 965 |
89 |
| REGISTER_KW(i16, values, "Data::HashMap::Shared::I16::values"); |
| 966 |
89 |
| REGISTER_KW(i16, items, "Data::HashMap::Shared::I16::items"); |
| 967 |
89 |
| REGISTER_KW(i16, each, "Data::HashMap::Shared::I16::each"); |
| 968 |
89 |
| REGISTER_KW(i16, iter_reset, "Data::HashMap::Shared::I16::iter_reset"); |
| 969 |
89 |
| REGISTER_KW(i16, clear, "Data::HashMap::Shared::I16::clear"); |
| 970 |
89 |
| REGISTER_KW(i16, to_hash, "Data::HashMap::Shared::I16::to_hash"); |
| 971 |
89 |
| REGISTER_KW(i16, max_entries, "Data::HashMap::Shared::I16::max_entries"); |
| 972 |
89 |
| REGISTER_KW(i16, get_or_set, "Data::HashMap::Shared::I16::get_or_set"); |
| 973 |
89 |
| REGISTER_KW(i16, put_ttl, "Data::HashMap::Shared::I16::put_ttl"); |
| 974 |
89 |
| REGISTER_KW(i16, max_size, "Data::HashMap::Shared::I16::max_size"); |
| 975 |
89 |
| REGISTER_KW(i16, ttl, "Data::HashMap::Shared::I16::ttl"); |
| 976 |
89 |
| REGISTER_KW(i16, cursor, "Data::HashMap::Shared::I16::cursor"); |
| 977 |
89 |
| REGISTER_KW(i16, cursor_next, "Data::HashMap::Shared::I16::Cursor::next"); |
| 978 |
89 |
| REGISTER_KW(i16, cursor_reset, "Data::HashMap::Shared::I16::Cursor::reset"); |
| 979 |
89 |
| REGISTER_KW(i16, cursor_seek, "Data::HashMap::Shared::I16::Cursor::seek"); |
| 980 |
89 |
| REGISTER_KW(i16, ttl_remaining, "Data::HashMap::Shared::I16::ttl_remaining"); |
| 981 |
89 |
| REGISTER_KW(i16, capacity, "Data::HashMap::Shared::I16::capacity"); |
| 982 |
89 |
| REGISTER_KW(i16, tombstones, "Data::HashMap::Shared::I16::tombstones"); |
| 983 |
89 |
| REGISTER_KW(i16, take, "Data::HashMap::Shared::I16::take"); |
| 984 |
89 |
| REGISTER_KW(i16, pop, "Data::HashMap::Shared::I16::pop"); |
| 985 |
89 |
| REGISTER_KW(i16, shift, "Data::HashMap::Shared::I16::shift"); |
| 986 |
89 |
| REGISTER_KW(i16, drain, "Data::HashMap::Shared::I16::drain"); |
| 987 |
89 |
| REGISTER_KW(i16, flush_expired, "Data::HashMap::Shared::I16::flush_expired"); |
| 988 |
89 |
| REGISTER_KW(i16, flush_expired_partial, "Data::HashMap::Shared::I16::flush_expired_partial"); |
| 989 |
89 |
| REGISTER_KW(i16, mmap_size, "Data::HashMap::Shared::I16::mmap_size"); |
| 990 |
89 |
| REGISTER_KW(i16, touch, "Data::HashMap::Shared::I16::touch"); |
| 991 |
89 |
| REGISTER_KW(i16, reserve, "Data::HashMap::Shared::I16::reserve"); |
| 992 |
89 |
| REGISTER_KW(i16, stat_evictions, "Data::HashMap::Shared::I16::stat_evictions"); |
| 993 |
89 |
| REGISTER_KW(i16, stat_expired, "Data::HashMap::Shared::I16::stat_expired"); |
| 994 |
89 |
| REGISTER_KW(i16, stat_recoveries, "Data::HashMap::Shared::I16::stat_recoveries"); |
| 995 |
89 |
| REGISTER_KW(i16, arena_used, "Data::HashMap::Shared::I16::arena_used"); |
| 996 |
89 |
| REGISTER_KW(i16, arena_cap, "Data::HashMap::Shared::I16::arena_cap"); |
| 997 |
89 |
| REGISTER_KW(i16, add, "Data::HashMap::Shared::I16::add"); |
| 998 |
89 |
| REGISTER_KW(i16, add_ttl, "Data::HashMap::Shared::I16::add_ttl"); |
| 999 |
89 |
| REGISTER_KW(i16, update_ttl, "Data::HashMap::Shared::I16::update_ttl"); |
| 1000 |
89 |
| REGISTER_KW(i16, update, "Data::HashMap::Shared::I16::update"); |
| 1001 |
89 |
| REGISTER_KW(i16, swap, "Data::HashMap::Shared::I16::swap"); |
| 1002 |
89 |
| REGISTER_KW(i16, cas, "Data::HashMap::Shared::I16::cas"); |
| 1003 |
89 |
| REGISTER_KW(i16, cas_take, "Data::HashMap::Shared::I16::cas_take"); |
| 1004 |
89 |
| REGISTER_KW(i16, persist, "Data::HashMap::Shared::I16::persist"); |
| 1005 |
89 |
| REGISTER_KW(i16, set_ttl, "Data::HashMap::Shared::I16::set_ttl"); |
| 1006 |
89 |
| REGISTER_KW(i32, put, "Data::HashMap::Shared::I32::put"); |
| 1007 |
89 |
| REGISTER_KW(i32, get, "Data::HashMap::Shared::I32::get"); |
| 1008 |
89 |
| REGISTER_KW(i32, remove, "Data::HashMap::Shared::I32::remove"); |
| 1009 |
89 |
| REGISTER_KW(i32, exists, "Data::HashMap::Shared::I32::exists"); |
| 1010 |
89 |
| REGISTER_KW(i32, incr, "Data::HashMap::Shared::I32::incr"); |
| 1011 |
89 |
| REGISTER_KW(i32, decr, "Data::HashMap::Shared::I32::decr"); |
| 1012 |
89 |
| REGISTER_KW(i32, incr_by, "Data::HashMap::Shared::I32::incr_by"); |
| 1013 |
89 |
| REGISTER_KW(i32, max, "Data::HashMap::Shared::I32::max"); |
| 1014 |
89 |
| REGISTER_KW(i32, min, "Data::HashMap::Shared::I32::min"); |
| 1015 |
89 |
| REGISTER_KW(i32, size, "Data::HashMap::Shared::I32::size"); |
| 1016 |
89 |
| REGISTER_KW(i32, keys, "Data::HashMap::Shared::I32::keys"); |
| 1017 |
89 |
| REGISTER_KW(i32, values, "Data::HashMap::Shared::I32::values"); |
| 1018 |
89 |
| REGISTER_KW(i32, items, "Data::HashMap::Shared::I32::items"); |
| 1019 |
89 |
| REGISTER_KW(i32, each, "Data::HashMap::Shared::I32::each"); |
| 1020 |
89 |
| REGISTER_KW(i32, iter_reset, "Data::HashMap::Shared::I32::iter_reset"); |
| 1021 |
89 |
| REGISTER_KW(i32, clear, "Data::HashMap::Shared::I32::clear"); |
| 1022 |
89 |
| REGISTER_KW(i32, to_hash, "Data::HashMap::Shared::I32::to_hash"); |
| 1023 |
89 |
| REGISTER_KW(i32, max_entries, "Data::HashMap::Shared::I32::max_entries"); |
| 1024 |
89 |
| REGISTER_KW(i32, get_or_set, "Data::HashMap::Shared::I32::get_or_set"); |
| 1025 |
89 |
| REGISTER_KW(i32, put_ttl, "Data::HashMap::Shared::I32::put_ttl"); |
| 1026 |
89 |
| REGISTER_KW(i32, max_size, "Data::HashMap::Shared::I32::max_size"); |
| 1027 |
89 |
| REGISTER_KW(i32, ttl, "Data::HashMap::Shared::I32::ttl"); |
| 1028 |
89 |
| REGISTER_KW(i32, cursor, "Data::HashMap::Shared::I32::cursor"); |
| 1029 |
89 |
| REGISTER_KW(i32, cursor_next, "Data::HashMap::Shared::I32::Cursor::next"); |
| 1030 |
89 |
| REGISTER_KW(i32, cursor_reset, "Data::HashMap::Shared::I32::Cursor::reset"); |
| 1031 |
89 |
| REGISTER_KW(i32, cursor_seek, "Data::HashMap::Shared::I32::Cursor::seek"); |
| 1032 |
89 |
| REGISTER_KW(i32, ttl_remaining, "Data::HashMap::Shared::I32::ttl_remaining"); |
| 1033 |
89 |
| REGISTER_KW(i32, capacity, "Data::HashMap::Shared::I32::capacity"); |
| 1034 |
89 |
| REGISTER_KW(i32, tombstones, "Data::HashMap::Shared::I32::tombstones"); |
| 1035 |
89 |
| REGISTER_KW(i32, take, "Data::HashMap::Shared::I32::take"); |
| 1036 |
89 |
| REGISTER_KW(i32, pop, "Data::HashMap::Shared::I32::pop"); |
| 1037 |
89 |
| REGISTER_KW(i32, shift, "Data::HashMap::Shared::I32::shift"); |
| 1038 |
89 |
| REGISTER_KW(i32, drain, "Data::HashMap::Shared::I32::drain"); |
| 1039 |
89 |
| REGISTER_KW(i32, flush_expired, "Data::HashMap::Shared::I32::flush_expired"); |
| 1040 |
89 |
| REGISTER_KW(i32, flush_expired_partial, "Data::HashMap::Shared::I32::flush_expired_partial"); |
| 1041 |
89 |
| REGISTER_KW(i32, mmap_size, "Data::HashMap::Shared::I32::mmap_size"); |
| 1042 |
89 |
| REGISTER_KW(i32, touch, "Data::HashMap::Shared::I32::touch"); |
| 1043 |
89 |
| REGISTER_KW(i32, reserve, "Data::HashMap::Shared::I32::reserve"); |
| 1044 |
89 |
| REGISTER_KW(i32, stat_evictions, "Data::HashMap::Shared::I32::stat_evictions"); |
| 1045 |
89 |
| REGISTER_KW(i32, stat_expired, "Data::HashMap::Shared::I32::stat_expired"); |
| 1046 |
89 |
| REGISTER_KW(i32, stat_recoveries, "Data::HashMap::Shared::I32::stat_recoveries"); |
| 1047 |
89 |
| REGISTER_KW(i32, arena_used, "Data::HashMap::Shared::I32::arena_used"); |
| 1048 |
89 |
| REGISTER_KW(i32, arena_cap, "Data::HashMap::Shared::I32::arena_cap"); |
| 1049 |
89 |
| REGISTER_KW(i32, add, "Data::HashMap::Shared::I32::add"); |
| 1050 |
89 |
| REGISTER_KW(i32, add_ttl, "Data::HashMap::Shared::I32::add_ttl"); |
| 1051 |
89 |
| REGISTER_KW(i32, update_ttl, "Data::HashMap::Shared::I32::update_ttl"); |
| 1052 |
89 |
| REGISTER_KW(i32, update, "Data::HashMap::Shared::I32::update"); |
| 1053 |
89 |
| REGISTER_KW(i32, swap, "Data::HashMap::Shared::I32::swap"); |
| 1054 |
89 |
| REGISTER_KW(i32, cas, "Data::HashMap::Shared::I32::cas"); |
| 1055 |
89 |
| REGISTER_KW(i32, cas_take, "Data::HashMap::Shared::I32::cas_take"); |
| 1056 |
89 |
| REGISTER_KW(i32, persist, "Data::HashMap::Shared::I32::persist"); |
| 1057 |
89 |
| REGISTER_KW(i32, set_ttl, "Data::HashMap::Shared::I32::set_ttl"); |
| 1058 |
89 |
| REGISTER_KW(ii, put, "Data::HashMap::Shared::II::put"); |
| 1059 |
89 |
| REGISTER_KW(ii, get, "Data::HashMap::Shared::II::get"); |
| 1060 |
89 |
| REGISTER_KW(ii, remove, "Data::HashMap::Shared::II::remove"); |
| 1061 |
89 |
| REGISTER_KW(ii, exists, "Data::HashMap::Shared::II::exists"); |
| 1062 |
89 |
| REGISTER_KW(ii, incr, "Data::HashMap::Shared::II::incr"); |
| 1063 |
89 |
| REGISTER_KW(ii, decr, "Data::HashMap::Shared::II::decr"); |
| 1064 |
89 |
| REGISTER_KW(ii, incr_by, "Data::HashMap::Shared::II::incr_by"); |
| 1065 |
89 |
| REGISTER_KW(ii, max, "Data::HashMap::Shared::II::max"); |
| 1066 |
89 |
| REGISTER_KW(ii, min, "Data::HashMap::Shared::II::min"); |
| 1067 |
89 |
| REGISTER_KW(ii, size, "Data::HashMap::Shared::II::size"); |
| 1068 |
89 |
| REGISTER_KW(ii, keys, "Data::HashMap::Shared::II::keys"); |
| 1069 |
89 |
| REGISTER_KW(ii, values, "Data::HashMap::Shared::II::values"); |
| 1070 |
89 |
| REGISTER_KW(ii, items, "Data::HashMap::Shared::II::items"); |
| 1071 |
89 |
| REGISTER_KW(ii, each, "Data::HashMap::Shared::II::each"); |
| 1072 |
89 |
| REGISTER_KW(ii, iter_reset, "Data::HashMap::Shared::II::iter_reset"); |
| 1073 |
89 |
| REGISTER_KW(ii, clear, "Data::HashMap::Shared::II::clear"); |
| 1074 |
89 |
| REGISTER_KW(ii, to_hash, "Data::HashMap::Shared::II::to_hash"); |
| 1075 |
89 |
| REGISTER_KW(ii, max_entries, "Data::HashMap::Shared::II::max_entries"); |
| 1076 |
89 |
| REGISTER_KW(ii, get_or_set, "Data::HashMap::Shared::II::get_or_set"); |
| 1077 |
89 |
| REGISTER_KW(ii, put_ttl, "Data::HashMap::Shared::II::put_ttl"); |
| 1078 |
89 |
| REGISTER_KW(ii, max_size, "Data::HashMap::Shared::II::max_size"); |
| 1079 |
89 |
| REGISTER_KW(ii, ttl, "Data::HashMap::Shared::II::ttl"); |
| 1080 |
89 |
| REGISTER_KW(ii, cursor, "Data::HashMap::Shared::II::cursor"); |
| 1081 |
89 |
| REGISTER_KW(ii, cursor_next, "Data::HashMap::Shared::II::Cursor::next"); |
| 1082 |
89 |
| REGISTER_KW(ii, cursor_reset, "Data::HashMap::Shared::II::Cursor::reset"); |
| 1083 |
89 |
| REGISTER_KW(ii, cursor_seek, "Data::HashMap::Shared::II::Cursor::seek"); |
| 1084 |
89 |
| REGISTER_KW(ii, ttl_remaining, "Data::HashMap::Shared::II::ttl_remaining"); |
| 1085 |
89 |
| REGISTER_KW(ii, capacity, "Data::HashMap::Shared::II::capacity"); |
| 1086 |
89 |
| REGISTER_KW(ii, tombstones, "Data::HashMap::Shared::II::tombstones"); |
| 1087 |
89 |
| REGISTER_KW(ii, take, "Data::HashMap::Shared::II::take"); |
| 1088 |
89 |
| REGISTER_KW(ii, pop, "Data::HashMap::Shared::II::pop"); |
| 1089 |
89 |
| REGISTER_KW(ii, shift, "Data::HashMap::Shared::II::shift"); |
| 1090 |
89 |
| REGISTER_KW(ii, drain, "Data::HashMap::Shared::II::drain"); |
| 1091 |
89 |
| REGISTER_KW(ii, flush_expired, "Data::HashMap::Shared::II::flush_expired"); |
| 1092 |
89 |
| REGISTER_KW(ii, flush_expired_partial, "Data::HashMap::Shared::II::flush_expired_partial"); |
| 1093 |
89 |
| REGISTER_KW(ii, mmap_size, "Data::HashMap::Shared::II::mmap_size"); |
| 1094 |
89 |
| REGISTER_KW(ii, touch, "Data::HashMap::Shared::II::touch"); |
| 1095 |
89 |
| REGISTER_KW(ii, reserve, "Data::HashMap::Shared::II::reserve"); |
| 1096 |
89 |
| REGISTER_KW(ii, stat_evictions, "Data::HashMap::Shared::II::stat_evictions"); |
| 1097 |
89 |
| REGISTER_KW(ii, stat_expired, "Data::HashMap::Shared::II::stat_expired"); |
| 1098 |
89 |
| REGISTER_KW(ii, stat_recoveries, "Data::HashMap::Shared::II::stat_recoveries"); |
| 1099 |
89 |
| REGISTER_KW(ii, arena_used, "Data::HashMap::Shared::II::arena_used"); |
| 1100 |
89 |
| REGISTER_KW(ii, arena_cap, "Data::HashMap::Shared::II::arena_cap"); |
| 1101 |
89 |
| REGISTER_KW(ii, add, "Data::HashMap::Shared::II::add"); |
| 1102 |
89 |
| REGISTER_KW(ii, add_ttl, "Data::HashMap::Shared::II::add_ttl"); |
| 1103 |
89 |
| REGISTER_KW(ii, update_ttl, "Data::HashMap::Shared::II::update_ttl"); |
| 1104 |
89 |
| REGISTER_KW(ii, update, "Data::HashMap::Shared::II::update"); |
| 1105 |
89 |
| REGISTER_KW(ii, swap, "Data::HashMap::Shared::II::swap"); |
| 1106 |
89 |
| REGISTER_KW(ii, cas, "Data::HashMap::Shared::II::cas"); |
| 1107 |
89 |
| REGISTER_KW(ii, cas_take, "Data::HashMap::Shared::II::cas_take"); |
| 1108 |
89 |
| REGISTER_KW(ii, persist, "Data::HashMap::Shared::II::persist"); |
| 1109 |
89 |
| REGISTER_KW(ii, set_ttl, "Data::HashMap::Shared::II::set_ttl"); |
| 1110 |
89 |
| REGISTER_KW(i16s, put, "Data::HashMap::Shared::I16S::put"); |
| 1111 |
89 |
| REGISTER_KW(i16s, get, "Data::HashMap::Shared::I16S::get"); |
| 1112 |
89 |
| REGISTER_KW(i16s, remove, "Data::HashMap::Shared::I16S::remove"); |
| 1113 |
89 |
| REGISTER_KW(i16s, exists, "Data::HashMap::Shared::I16S::exists"); |
| 1114 |
89 |
| REGISTER_KW(i16s, size, "Data::HashMap::Shared::I16S::size"); |
| 1115 |
89 |
| REGISTER_KW(i16s, keys, "Data::HashMap::Shared::I16S::keys"); |
| 1116 |
89 |
| REGISTER_KW(i16s, values, "Data::HashMap::Shared::I16S::values"); |
| 1117 |
89 |
| REGISTER_KW(i16s, items, "Data::HashMap::Shared::I16S::items"); |
| 1118 |
89 |
| REGISTER_KW(i16s, each, "Data::HashMap::Shared::I16S::each"); |
| 1119 |
89 |
| REGISTER_KW(i16s, iter_reset, "Data::HashMap::Shared::I16S::iter_reset"); |
| 1120 |
89 |
| REGISTER_KW(i16s, clear, "Data::HashMap::Shared::I16S::clear"); |
| 1121 |
89 |
| REGISTER_KW(i16s, to_hash, "Data::HashMap::Shared::I16S::to_hash"); |
| 1122 |
89 |
| REGISTER_KW(i16s, max_entries, "Data::HashMap::Shared::I16S::max_entries"); |
| 1123 |
89 |
| REGISTER_KW(i16s, get_or_set, "Data::HashMap::Shared::I16S::get_or_set"); |
| 1124 |
89 |
| REGISTER_KW(i16s, put_ttl, "Data::HashMap::Shared::I16S::put_ttl"); |
| 1125 |
89 |
| REGISTER_KW(i16s, max_size, "Data::HashMap::Shared::I16S::max_size"); |
| 1126 |
89 |
| REGISTER_KW(i16s, ttl, "Data::HashMap::Shared::I16S::ttl"); |
| 1127 |
89 |
| REGISTER_KW(i16s, cursor, "Data::HashMap::Shared::I16S::cursor"); |
| 1128 |
89 |
| REGISTER_KW(i16s, cursor_next, "Data::HashMap::Shared::I16S::Cursor::next"); |
| 1129 |
89 |
| REGISTER_KW(i16s, cursor_reset, "Data::HashMap::Shared::I16S::Cursor::reset"); |
| 1130 |
89 |
| REGISTER_KW(i16s, cursor_seek, "Data::HashMap::Shared::I16S::Cursor::seek"); |
| 1131 |
89 |
| REGISTER_KW(i16s, ttl_remaining, "Data::HashMap::Shared::I16S::ttl_remaining"); |
| 1132 |
89 |
| REGISTER_KW(i16s, capacity, "Data::HashMap::Shared::I16S::capacity"); |
| 1133 |
89 |
| REGISTER_KW(i16s, tombstones, "Data::HashMap::Shared::I16S::tombstones"); |
| 1134 |
89 |
| REGISTER_KW(i16s, take, "Data::HashMap::Shared::I16S::take"); |
| 1135 |
89 |
| REGISTER_KW(i16s, pop, "Data::HashMap::Shared::I16S::pop"); |
| 1136 |
89 |
| REGISTER_KW(i16s, shift, "Data::HashMap::Shared::I16S::shift"); |
| 1137 |
89 |
| REGISTER_KW(i16s, drain, "Data::HashMap::Shared::I16S::drain"); |
| 1138 |
89 |
| REGISTER_KW(i16s, flush_expired, "Data::HashMap::Shared::I16S::flush_expired"); |
| 1139 |
89 |
| REGISTER_KW(i16s, flush_expired_partial, "Data::HashMap::Shared::I16S::flush_expired_partial"); |
| 1140 |
89 |
| REGISTER_KW(i16s, mmap_size, "Data::HashMap::Shared::I16S::mmap_size"); |
| 1141 |
89 |
| REGISTER_KW(i16s, touch, "Data::HashMap::Shared::I16S::touch"); |
| 1142 |
89 |
| REGISTER_KW(i16s, reserve, "Data::HashMap::Shared::I16S::reserve"); |
| 1143 |
89 |
| REGISTER_KW(i16s, stat_evictions, "Data::HashMap::Shared::I16S::stat_evictions"); |
| 1144 |
89 |
| REGISTER_KW(i16s, stat_expired, "Data::HashMap::Shared::I16S::stat_expired"); |
| 1145 |
89 |
| REGISTER_KW(i16s, stat_recoveries, "Data::HashMap::Shared::I16S::stat_recoveries"); |
| 1146 |
89 |
| REGISTER_KW(i16s, arena_used, "Data::HashMap::Shared::I16S::arena_used"); |
| 1147 |
89 |
| REGISTER_KW(i16s, arena_cap, "Data::HashMap::Shared::I16S::arena_cap"); |
| 1148 |
89 |
| REGISTER_KW(i16s, add, "Data::HashMap::Shared::I16S::add"); |
| 1149 |
89 |
| REGISTER_KW(i16s, add_ttl, "Data::HashMap::Shared::I16S::add_ttl"); |
| 1150 |
89 |
| REGISTER_KW(i16s, update_ttl, "Data::HashMap::Shared::I16S::update_ttl"); |
| 1151 |
89 |
| REGISTER_KW(i16s, update, "Data::HashMap::Shared::I16S::update"); |
| 1152 |
89 |
| REGISTER_KW(i16s, swap, "Data::HashMap::Shared::I16S::swap"); |
| 1153 |
89 |
| REGISTER_KW(i16s, cas, "Data::HashMap::Shared::I16S::cas"); |
| 1154 |
89 |
| REGISTER_KW(i16s, cas_take, "Data::HashMap::Shared::I16S::cas_take"); |
| 1155 |
89 |
| REGISTER_KW(i16s, persist, "Data::HashMap::Shared::I16S::persist"); |
| 1156 |
89 |
| REGISTER_KW(i16s, set_ttl, "Data::HashMap::Shared::I16S::set_ttl"); |
| 1157 |
89 |
| REGISTER_KW(i32s, put, "Data::HashMap::Shared::I32S::put"); |
| 1158 |
89 |
| REGISTER_KW(i32s, get, "Data::HashMap::Shared::I32S::get"); |
| 1159 |
89 |
| REGISTER_KW(i32s, remove, "Data::HashMap::Shared::I32S::remove"); |
| 1160 |
89 |
| REGISTER_KW(i32s, exists, "Data::HashMap::Shared::I32S::exists"); |
| 1161 |
89 |
| REGISTER_KW(i32s, size, "Data::HashMap::Shared::I32S::size"); |
| 1162 |
89 |
| REGISTER_KW(i32s, keys, "Data::HashMap::Shared::I32S::keys"); |
| 1163 |
89 |
| REGISTER_KW(i32s, values, "Data::HashMap::Shared::I32S::values"); |
| 1164 |
89 |
| REGISTER_KW(i32s, items, "Data::HashMap::Shared::I32S::items"); |
| 1165 |
89 |
| REGISTER_KW(i32s, each, "Data::HashMap::Shared::I32S::each"); |
| 1166 |
89 |
| REGISTER_KW(i32s, iter_reset, "Data::HashMap::Shared::I32S::iter_reset"); |
| 1167 |
89 |
| REGISTER_KW(i32s, clear, "Data::HashMap::Shared::I32S::clear"); |
| 1168 |
89 |
| REGISTER_KW(i32s, to_hash, "Data::HashMap::Shared::I32S::to_hash"); |
| 1169 |
89 |
| REGISTER_KW(i32s, max_entries, "Data::HashMap::Shared::I32S::max_entries"); |
| 1170 |
89 |
| REGISTER_KW(i32s, get_or_set, "Data::HashMap::Shared::I32S::get_or_set"); |
| 1171 |
89 |
| REGISTER_KW(i32s, put_ttl, "Data::HashMap::Shared::I32S::put_ttl"); |
| 1172 |
89 |
| REGISTER_KW(i32s, max_size, "Data::HashMap::Shared::I32S::max_size"); |
| 1173 |
89 |
| REGISTER_KW(i32s, ttl, "Data::HashMap::Shared::I32S::ttl"); |
| 1174 |
89 |
| REGISTER_KW(i32s, cursor, "Data::HashMap::Shared::I32S::cursor"); |
| 1175 |
89 |
| REGISTER_KW(i32s, cursor_next, "Data::HashMap::Shared::I32S::Cursor::next"); |
| 1176 |
89 |
| REGISTER_KW(i32s, cursor_reset, "Data::HashMap::Shared::I32S::Cursor::reset"); |
| 1177 |
89 |
| REGISTER_KW(i32s, cursor_seek, "Data::HashMap::Shared::I32S::Cursor::seek"); |
| 1178 |
89 |
| REGISTER_KW(i32s, ttl_remaining, "Data::HashMap::Shared::I32S::ttl_remaining"); |
| 1179 |
89 |
| REGISTER_KW(i32s, capacity, "Data::HashMap::Shared::I32S::capacity"); |
| 1180 |
89 |
| REGISTER_KW(i32s, tombstones, "Data::HashMap::Shared::I32S::tombstones"); |
| 1181 |
89 |
| REGISTER_KW(i32s, take, "Data::HashMap::Shared::I32S::take"); |
| 1182 |
89 |
| REGISTER_KW(i32s, pop, "Data::HashMap::Shared::I32S::pop"); |
| 1183 |
89 |
| REGISTER_KW(i32s, shift, "Data::HashMap::Shared::I32S::shift"); |
| 1184 |
89 |
| REGISTER_KW(i32s, drain, "Data::HashMap::Shared::I32S::drain"); |
| 1185 |
89 |
| REGISTER_KW(i32s, flush_expired, "Data::HashMap::Shared::I32S::flush_expired"); |
| 1186 |
89 |
| REGISTER_KW(i32s, flush_expired_partial, "Data::HashMap::Shared::I32S::flush_expired_partial"); |
| 1187 |
89 |
| REGISTER_KW(i32s, mmap_size, "Data::HashMap::Shared::I32S::mmap_size"); |
| 1188 |
89 |
| REGISTER_KW(i32s, touch, "Data::HashMap::Shared::I32S::touch"); |
| 1189 |
89 |
| REGISTER_KW(i32s, reserve, "Data::HashMap::Shared::I32S::reserve"); |
| 1190 |
89 |
| REGISTER_KW(i32s, stat_evictions, "Data::HashMap::Shared::I32S::stat_evictions"); |
| 1191 |
89 |
| REGISTER_KW(i32s, stat_expired, "Data::HashMap::Shared::I32S::stat_expired"); |
| 1192 |
89 |
| REGISTER_KW(i32s, stat_recoveries, "Data::HashMap::Shared::I32S::stat_recoveries"); |
| 1193 |
89 |
| REGISTER_KW(i32s, arena_used, "Data::HashMap::Shared::I32S::arena_used"); |
| 1194 |
89 |
| REGISTER_KW(i32s, arena_cap, "Data::HashMap::Shared::I32S::arena_cap"); |
| 1195 |
89 |
| REGISTER_KW(i32s, add, "Data::HashMap::Shared::I32S::add"); |
| 1196 |
89 |
| REGISTER_KW(i32s, add_ttl, "Data::HashMap::Shared::I32S::add_ttl"); |
| 1197 |
89 |
| REGISTER_KW(i32s, update_ttl, "Data::HashMap::Shared::I32S::update_ttl"); |
| 1198 |
89 |
| REGISTER_KW(i32s, update, "Data::HashMap::Shared::I32S::update"); |
| 1199 |
89 |
| REGISTER_KW(i32s, swap, "Data::HashMap::Shared::I32S::swap"); |
| 1200 |
89 |
| REGISTER_KW(i32s, cas, "Data::HashMap::Shared::I32S::cas"); |
| 1201 |
89 |
| REGISTER_KW(i32s, cas_take, "Data::HashMap::Shared::I32S::cas_take"); |
| 1202 |
89 |
| REGISTER_KW(i32s, persist, "Data::HashMap::Shared::I32S::persist"); |
| 1203 |
89 |
| REGISTER_KW(i32s, set_ttl, "Data::HashMap::Shared::I32S::set_ttl"); |
| 1204 |
89 |
| REGISTER_KW(is, put, "Data::HashMap::Shared::IS::put"); |
| 1205 |
89 |
| REGISTER_KW(is, get, "Data::HashMap::Shared::IS::get"); |
| 1206 |
89 |
| REGISTER_KW(is, remove, "Data::HashMap::Shared::IS::remove"); |
| 1207 |
89 |
| REGISTER_KW(is, exists, "Data::HashMap::Shared::IS::exists"); |
| 1208 |
89 |
| REGISTER_KW(is, size, "Data::HashMap::Shared::IS::size"); |
| 1209 |
89 |
| REGISTER_KW(is, keys, "Data::HashMap::Shared::IS::keys"); |
| 1210 |
89 |
| REGISTER_KW(is, values, "Data::HashMap::Shared::IS::values"); |
| 1211 |
89 |
| REGISTER_KW(is, items, "Data::HashMap::Shared::IS::items"); |
| 1212 |
89 |
| REGISTER_KW(is, each, "Data::HashMap::Shared::IS::each"); |
| 1213 |
89 |
| REGISTER_KW(is, iter_reset, "Data::HashMap::Shared::IS::iter_reset"); |
| 1214 |
89 |
| REGISTER_KW(is, clear, "Data::HashMap::Shared::IS::clear"); |
| 1215 |
89 |
| REGISTER_KW(is, to_hash, "Data::HashMap::Shared::IS::to_hash"); |
| 1216 |
89 |
| REGISTER_KW(is, max_entries, "Data::HashMap::Shared::IS::max_entries"); |
| 1217 |
89 |
| REGISTER_KW(is, get_or_set, "Data::HashMap::Shared::IS::get_or_set"); |
| 1218 |
89 |
| REGISTER_KW(is, put_ttl, "Data::HashMap::Shared::IS::put_ttl"); |
| 1219 |
89 |
| REGISTER_KW(is, max_size, "Data::HashMap::Shared::IS::max_size"); |
| 1220 |
89 |
| REGISTER_KW(is, ttl, "Data::HashMap::Shared::IS::ttl"); |
| 1221 |
89 |
| REGISTER_KW(is, cursor, "Data::HashMap::Shared::IS::cursor"); |
| 1222 |
89 |
| REGISTER_KW(is, cursor_next, "Data::HashMap::Shared::IS::Cursor::next"); |
| 1223 |
89 |
| REGISTER_KW(is, cursor_reset, "Data::HashMap::Shared::IS::Cursor::reset"); |
| 1224 |
89 |
| REGISTER_KW(is, cursor_seek, "Data::HashMap::Shared::IS::Cursor::seek"); |
| 1225 |
89 |
| REGISTER_KW(is, ttl_remaining, "Data::HashMap::Shared::IS::ttl_remaining"); |
| 1226 |
89 |
| REGISTER_KW(is, capacity, "Data::HashMap::Shared::IS::capacity"); |
| 1227 |
89 |
| REGISTER_KW(is, tombstones, "Data::HashMap::Shared::IS::tombstones"); |
| 1228 |
89 |
| REGISTER_KW(is, take, "Data::HashMap::Shared::IS::take"); |
| 1229 |
89 |
| REGISTER_KW(is, pop, "Data::HashMap::Shared::IS::pop"); |
| 1230 |
89 |
| REGISTER_KW(is, shift, "Data::HashMap::Shared::IS::shift"); |
| 1231 |
89 |
| REGISTER_KW(is, drain, "Data::HashMap::Shared::IS::drain"); |
| 1232 |
89 |
| REGISTER_KW(is, flush_expired, "Data::HashMap::Shared::IS::flush_expired"); |
| 1233 |
89 |
| REGISTER_KW(is, flush_expired_partial, "Data::HashMap::Shared::IS::flush_expired_partial"); |
| 1234 |
89 |
| REGISTER_KW(is, mmap_size, "Data::HashMap::Shared::IS::mmap_size"); |
| 1235 |
89 |
| REGISTER_KW(is, touch, "Data::HashMap::Shared::IS::touch"); |
| 1236 |
89 |
| REGISTER_KW(is, reserve, "Data::HashMap::Shared::IS::reserve"); |
| 1237 |
89 |
| REGISTER_KW(is, stat_evictions, "Data::HashMap::Shared::IS::stat_evictions"); |
| 1238 |
89 |
| REGISTER_KW(is, stat_expired, "Data::HashMap::Shared::IS::stat_expired"); |
| 1239 |
89 |
| REGISTER_KW(is, stat_recoveries, "Data::HashMap::Shared::IS::stat_recoveries"); |
| 1240 |
89 |
| REGISTER_KW(is, arena_used, "Data::HashMap::Shared::IS::arena_used"); |
| 1241 |
89 |
| REGISTER_KW(is, arena_cap, "Data::HashMap::Shared::IS::arena_cap"); |
| 1242 |
89 |
| REGISTER_KW(is, add, "Data::HashMap::Shared::IS::add"); |
| 1243 |
89 |
| REGISTER_KW(is, add_ttl, "Data::HashMap::Shared::IS::add_ttl"); |
| 1244 |
89 |
| REGISTER_KW(is, update_ttl, "Data::HashMap::Shared::IS::update_ttl"); |
| 1245 |
89 |
| REGISTER_KW(is, update, "Data::HashMap::Shared::IS::update"); |
| 1246 |
89 |
| REGISTER_KW(is, swap, "Data::HashMap::Shared::IS::swap"); |
| 1247 |
89 |
| REGISTER_KW(is, cas, "Data::HashMap::Shared::IS::cas"); |
| 1248 |
89 |
| REGISTER_KW(is, cas_take, "Data::HashMap::Shared::IS::cas_take"); |
| 1249 |
89 |
| REGISTER_KW(is, persist, "Data::HashMap::Shared::IS::persist"); |
| 1250 |
89 |
| REGISTER_KW(is, set_ttl, "Data::HashMap::Shared::IS::set_ttl"); |
| 1251 |
89 |
| REGISTER_KW(si16, put, "Data::HashMap::Shared::SI16::put"); |
| 1252 |
89 |
| REGISTER_KW(si16, get, "Data::HashMap::Shared::SI16::get"); |
| 1253 |
89 |
| REGISTER_KW(si16, remove, "Data::HashMap::Shared::SI16::remove"); |
| 1254 |
89 |
| REGISTER_KW(si16, exists, "Data::HashMap::Shared::SI16::exists"); |
| 1255 |
89 |
| REGISTER_KW(si16, incr, "Data::HashMap::Shared::SI16::incr"); |
| 1256 |
89 |
| REGISTER_KW(si16, decr, "Data::HashMap::Shared::SI16::decr"); |
| 1257 |
89 |
| REGISTER_KW(si16, incr_by, "Data::HashMap::Shared::SI16::incr_by"); |
| 1258 |
89 |
| REGISTER_KW(si16, max, "Data::HashMap::Shared::SI16::max"); |
| 1259 |
89 |
| REGISTER_KW(si16, min, "Data::HashMap::Shared::SI16::min"); |
| 1260 |
89 |
| REGISTER_KW(si16, size, "Data::HashMap::Shared::SI16::size"); |
| 1261 |
89 |
| REGISTER_KW(si16, keys, "Data::HashMap::Shared::SI16::keys"); |
| 1262 |
89 |
| REGISTER_KW(si16, values, "Data::HashMap::Shared::SI16::values"); |
| 1263 |
89 |
| REGISTER_KW(si16, items, "Data::HashMap::Shared::SI16::items"); |
| 1264 |
89 |
| REGISTER_KW(si16, each, "Data::HashMap::Shared::SI16::each"); |
| 1265 |
89 |
| REGISTER_KW(si16, iter_reset, "Data::HashMap::Shared::SI16::iter_reset"); |
| 1266 |
89 |
| REGISTER_KW(si16, clear, "Data::HashMap::Shared::SI16::clear"); |
| 1267 |
89 |
| REGISTER_KW(si16, to_hash, "Data::HashMap::Shared::SI16::to_hash"); |
| 1268 |
89 |
| REGISTER_KW(si16, max_entries, "Data::HashMap::Shared::SI16::max_entries"); |
| 1269 |
89 |
| REGISTER_KW(si16, get_or_set, "Data::HashMap::Shared::SI16::get_or_set"); |
| 1270 |
89 |
| REGISTER_KW(si16, put_ttl, "Data::HashMap::Shared::SI16::put_ttl"); |
| 1271 |
89 |
| REGISTER_KW(si16, max_size, "Data::HashMap::Shared::SI16::max_size"); |
| 1272 |
89 |
| REGISTER_KW(si16, ttl, "Data::HashMap::Shared::SI16::ttl"); |
| 1273 |
89 |
| REGISTER_KW(si16, cursor, "Data::HashMap::Shared::SI16::cursor"); |
| 1274 |
89 |
| REGISTER_KW(si16, cursor_next, "Data::HashMap::Shared::SI16::Cursor::next"); |
| 1275 |
89 |
| REGISTER_KW(si16, cursor_reset, "Data::HashMap::Shared::SI16::Cursor::reset"); |
| 1276 |
89 |
| REGISTER_KW(si16, cursor_seek, "Data::HashMap::Shared::SI16::Cursor::seek"); |
| 1277 |
89 |
| REGISTER_KW(si16, ttl_remaining, "Data::HashMap::Shared::SI16::ttl_remaining"); |
| 1278 |
89 |
| REGISTER_KW(si16, capacity, "Data::HashMap::Shared::SI16::capacity"); |
| 1279 |
89 |
| REGISTER_KW(si16, tombstones, "Data::HashMap::Shared::SI16::tombstones"); |
| 1280 |
89 |
| REGISTER_KW(si16, take, "Data::HashMap::Shared::SI16::take"); |
| 1281 |
89 |
| REGISTER_KW(si16, pop, "Data::HashMap::Shared::SI16::pop"); |
| 1282 |
89 |
| REGISTER_KW(si16, shift, "Data::HashMap::Shared::SI16::shift"); |
| 1283 |
89 |
| REGISTER_KW(si16, drain, "Data::HashMap::Shared::SI16::drain"); |
| 1284 |
89 |
| REGISTER_KW(si16, flush_expired, "Data::HashMap::Shared::SI16::flush_expired"); |
| 1285 |
89 |
| REGISTER_KW(si16, flush_expired_partial, "Data::HashMap::Shared::SI16::flush_expired_partial"); |
| 1286 |
89 |
| REGISTER_KW(si16, mmap_size, "Data::HashMap::Shared::SI16::mmap_size"); |
| 1287 |
89 |
| REGISTER_KW(si16, touch, "Data::HashMap::Shared::SI16::touch"); |
| 1288 |
89 |
| REGISTER_KW(si16, reserve, "Data::HashMap::Shared::SI16::reserve"); |
| 1289 |
89 |
| REGISTER_KW(si16, stat_evictions, "Data::HashMap::Shared::SI16::stat_evictions"); |
| 1290 |
89 |
| REGISTER_KW(si16, stat_expired, "Data::HashMap::Shared::SI16::stat_expired"); |
| 1291 |
89 |
| REGISTER_KW(si16, stat_recoveries, "Data::HashMap::Shared::SI16::stat_recoveries"); |
| 1292 |
89 |
| REGISTER_KW(si16, arena_used, "Data::HashMap::Shared::SI16::arena_used"); |
| 1293 |
89 |
| REGISTER_KW(si16, arena_cap, "Data::HashMap::Shared::SI16::arena_cap"); |
| 1294 |
89 |
| REGISTER_KW(si16, add, "Data::HashMap::Shared::SI16::add"); |
| 1295 |
89 |
| REGISTER_KW(si16, add_ttl, "Data::HashMap::Shared::SI16::add_ttl"); |
| 1296 |
89 |
| REGISTER_KW(si16, update_ttl, "Data::HashMap::Shared::SI16::update_ttl"); |
| 1297 |
89 |
| REGISTER_KW(si16, update, "Data::HashMap::Shared::SI16::update"); |
| 1298 |
89 |
| REGISTER_KW(si16, swap, "Data::HashMap::Shared::SI16::swap"); |
| 1299 |
89 |
| REGISTER_KW(si16, cas, "Data::HashMap::Shared::SI16::cas"); |
| 1300 |
89 |
| REGISTER_KW(si16, cas_take, "Data::HashMap::Shared::SI16::cas_take"); |
| 1301 |
89 |
| REGISTER_KW(si16, persist, "Data::HashMap::Shared::SI16::persist"); |
| 1302 |
89 |
| REGISTER_KW(si16, set_ttl, "Data::HashMap::Shared::SI16::set_ttl"); |
| 1303 |
89 |
| REGISTER_KW(si32, put, "Data::HashMap::Shared::SI32::put"); |
| 1304 |
89 |
| REGISTER_KW(si32, get, "Data::HashMap::Shared::SI32::get"); |
| 1305 |
89 |
| REGISTER_KW(si32, remove, "Data::HashMap::Shared::SI32::remove"); |
| 1306 |
89 |
| REGISTER_KW(si32, exists, "Data::HashMap::Shared::SI32::exists"); |
| 1307 |
89 |
| REGISTER_KW(si32, incr, "Data::HashMap::Shared::SI32::incr"); |
| 1308 |
89 |
| REGISTER_KW(si32, decr, "Data::HashMap::Shared::SI32::decr"); |
| 1309 |
89 |
| REGISTER_KW(si32, incr_by, "Data::HashMap::Shared::SI32::incr_by"); |
| 1310 |
89 |
| REGISTER_KW(si32, max, "Data::HashMap::Shared::SI32::max"); |
| 1311 |
89 |
| REGISTER_KW(si32, min, "Data::HashMap::Shared::SI32::min"); |
| 1312 |
89 |
| REGISTER_KW(si32, size, "Data::HashMap::Shared::SI32::size"); |
| 1313 |
89 |
| REGISTER_KW(si32, keys, "Data::HashMap::Shared::SI32::keys"); |
| 1314 |
89 |
| REGISTER_KW(si32, values, "Data::HashMap::Shared::SI32::values"); |
| 1315 |
89 |
| REGISTER_KW(si32, items, "Data::HashMap::Shared::SI32::items"); |
| 1316 |
89 |
| REGISTER_KW(si32, each, "Data::HashMap::Shared::SI32::each"); |
| 1317 |
89 |
| REGISTER_KW(si32, iter_reset, "Data::HashMap::Shared::SI32::iter_reset"); |
| 1318 |
89 |
| REGISTER_KW(si32, clear, "Data::HashMap::Shared::SI32::clear"); |
| 1319 |
89 |
| REGISTER_KW(si32, to_hash, "Data::HashMap::Shared::SI32::to_hash"); |
| 1320 |
89 |
| REGISTER_KW(si32, max_entries, "Data::HashMap::Shared::SI32::max_entries"); |
| 1321 |
89 |
| REGISTER_KW(si32, get_or_set, "Data::HashMap::Shared::SI32::get_or_set"); |
| 1322 |
89 |
| REGISTER_KW(si32, put_ttl, "Data::HashMap::Shared::SI32::put_ttl"); |
| 1323 |
89 |
| REGISTER_KW(si32, max_size, "Data::HashMap::Shared::SI32::max_size"); |
| 1324 |
89 |
| REGISTER_KW(si32, ttl, "Data::HashMap::Shared::SI32::ttl"); |
| 1325 |
89 |
| REGISTER_KW(si32, cursor, "Data::HashMap::Shared::SI32::cursor"); |
| 1326 |
89 |
| REGISTER_KW(si32, cursor_next, "Data::HashMap::Shared::SI32::Cursor::next"); |
| 1327 |
89 |
| REGISTER_KW(si32, cursor_reset, "Data::HashMap::Shared::SI32::Cursor::reset"); |
| 1328 |
89 |
| REGISTER_KW(si32, cursor_seek, "Data::HashMap::Shared::SI32::Cursor::seek"); |
| 1329 |
89 |
| REGISTER_KW(si32, ttl_remaining, "Data::HashMap::Shared::SI32::ttl_remaining"); |
| 1330 |
89 |
| REGISTER_KW(si32, capacity, "Data::HashMap::Shared::SI32::capacity"); |
| 1331 |
89 |
| REGISTER_KW(si32, tombstones, "Data::HashMap::Shared::SI32::tombstones"); |
| 1332 |
89 |
| REGISTER_KW(si32, take, "Data::HashMap::Shared::SI32::take"); |
| 1333 |
89 |
| REGISTER_KW(si32, pop, "Data::HashMap::Shared::SI32::pop"); |
| 1334 |
89 |
| REGISTER_KW(si32, shift, "Data::HashMap::Shared::SI32::shift"); |
| 1335 |
89 |
| REGISTER_KW(si32, drain, "Data::HashMap::Shared::SI32::drain"); |
| 1336 |
89 |
| REGISTER_KW(si32, flush_expired, "Data::HashMap::Shared::SI32::flush_expired"); |
| 1337 |
89 |
| REGISTER_KW(si32, flush_expired_partial, "Data::HashMap::Shared::SI32::flush_expired_partial"); |
| 1338 |
89 |
| REGISTER_KW(si32, mmap_size, "Data::HashMap::Shared::SI32::mmap_size"); |
| 1339 |
89 |
| REGISTER_KW(si32, touch, "Data::HashMap::Shared::SI32::touch"); |
| 1340 |
89 |
| REGISTER_KW(si32, reserve, "Data::HashMap::Shared::SI32::reserve"); |
| 1341 |
89 |
| REGISTER_KW(si32, stat_evictions, "Data::HashMap::Shared::SI32::stat_evictions"); |
| 1342 |
89 |
| REGISTER_KW(si32, stat_expired, "Data::HashMap::Shared::SI32::stat_expired"); |
| 1343 |
89 |
| REGISTER_KW(si32, stat_recoveries, "Data::HashMap::Shared::SI32::stat_recoveries"); |
| 1344 |
89 |
| REGISTER_KW(si32, arena_used, "Data::HashMap::Shared::SI32::arena_used"); |
| 1345 |
89 |
| REGISTER_KW(si32, arena_cap, "Data::HashMap::Shared::SI32::arena_cap"); |
| 1346 |
89 |
| REGISTER_KW(si32, add, "Data::HashMap::Shared::SI32::add"); |
| 1347 |
89 |
| REGISTER_KW(si32, add_ttl, "Data::HashMap::Shared::SI32::add_ttl"); |
| 1348 |
89 |
| REGISTER_KW(si32, update_ttl, "Data::HashMap::Shared::SI32::update_ttl"); |
| 1349 |
89 |
| REGISTER_KW(si32, update, "Data::HashMap::Shared::SI32::update"); |
| 1350 |
89 |
| REGISTER_KW(si32, swap, "Data::HashMap::Shared::SI32::swap"); |
| 1351 |
89 |
| REGISTER_KW(si32, cas, "Data::HashMap::Shared::SI32::cas"); |
| 1352 |
89 |
| REGISTER_KW(si32, cas_take, "Data::HashMap::Shared::SI32::cas_take"); |
| 1353 |
89 |
| REGISTER_KW(si32, persist, "Data::HashMap::Shared::SI32::persist"); |
| 1354 |
89 |
| REGISTER_KW(si32, set_ttl, "Data::HashMap::Shared::SI32::set_ttl"); |
| 1355 |
89 |
| REGISTER_KW(si, put, "Data::HashMap::Shared::SI::put"); |
| 1356 |
89 |
| REGISTER_KW(si, get, "Data::HashMap::Shared::SI::get"); |
| 1357 |
89 |
| REGISTER_KW(si, remove, "Data::HashMap::Shared::SI::remove"); |
| 1358 |
89 |
| REGISTER_KW(si, exists, "Data::HashMap::Shared::SI::exists"); |
| 1359 |
89 |
| REGISTER_KW(si, incr, "Data::HashMap::Shared::SI::incr"); |
| 1360 |
89 |
| REGISTER_KW(si, decr, "Data::HashMap::Shared::SI::decr"); |
| 1361 |
89 |
| REGISTER_KW(si, incr_by, "Data::HashMap::Shared::SI::incr_by"); |
| 1362 |
89 |
| REGISTER_KW(si, max, "Data::HashMap::Shared::SI::max"); |
| 1363 |
89 |
| REGISTER_KW(si, min, "Data::HashMap::Shared::SI::min"); |
| 1364 |
89 |
| REGISTER_KW(si, size, "Data::HashMap::Shared::SI::size"); |
| 1365 |
89 |
| REGISTER_KW(si, keys, "Data::HashMap::Shared::SI::keys"); |
| 1366 |
89 |
| REGISTER_KW(si, values, "Data::HashMap::Shared::SI::values"); |
| 1367 |
89 |
| REGISTER_KW(si, items, "Data::HashMap::Shared::SI::items"); |
| 1368 |
89 |
| REGISTER_KW(si, each, "Data::HashMap::Shared::SI::each"); |
| 1369 |
89 |
| REGISTER_KW(si, iter_reset, "Data::HashMap::Shared::SI::iter_reset"); |
| 1370 |
89 |
| REGISTER_KW(si, clear, "Data::HashMap::Shared::SI::clear"); |
| 1371 |
89 |
| REGISTER_KW(si, to_hash, "Data::HashMap::Shared::SI::to_hash"); |
| 1372 |
89 |
| REGISTER_KW(si, max_entries, "Data::HashMap::Shared::SI::max_entries"); |
| 1373 |
89 |
| REGISTER_KW(si, get_or_set, "Data::HashMap::Shared::SI::get_or_set"); |
| 1374 |
89 |
| REGISTER_KW(si, put_ttl, "Data::HashMap::Shared::SI::put_ttl"); |
| 1375 |
89 |
| REGISTER_KW(si, max_size, "Data::HashMap::Shared::SI::max_size"); |
| 1376 |
89 |
| REGISTER_KW(si, ttl, "Data::HashMap::Shared::SI::ttl"); |
| 1377 |
89 |
| REGISTER_KW(si, cursor, "Data::HashMap::Shared::SI::cursor"); |
| 1378 |
89 |
| REGISTER_KW(si, cursor_next, "Data::HashMap::Shared::SI::Cursor::next"); |
| 1379 |
89 |
| REGISTER_KW(si, cursor_reset, "Data::HashMap::Shared::SI::Cursor::reset"); |
| 1380 |
89 |
| REGISTER_KW(si, cursor_seek, "Data::HashMap::Shared::SI::Cursor::seek"); |
| 1381 |
89 |
| REGISTER_KW(si, ttl_remaining, "Data::HashMap::Shared::SI::ttl_remaining"); |
| 1382 |
89 |
| REGISTER_KW(si, capacity, "Data::HashMap::Shared::SI::capacity"); |
| 1383 |
89 |
| REGISTER_KW(si, tombstones, "Data::HashMap::Shared::SI::tombstones"); |
| 1384 |
89 |
| REGISTER_KW(si, take, "Data::HashMap::Shared::SI::take"); |
| 1385 |
89 |
| REGISTER_KW(si, pop, "Data::HashMap::Shared::SI::pop"); |
| 1386 |
89 |
| REGISTER_KW(si, shift, "Data::HashMap::Shared::SI::shift"); |
| 1387 |
89 |
| REGISTER_KW(si, drain, "Data::HashMap::Shared::SI::drain"); |
| 1388 |
89 |
| REGISTER_KW(si, flush_expired, "Data::HashMap::Shared::SI::flush_expired"); |
| 1389 |
89 |
| REGISTER_KW(si, flush_expired_partial, "Data::HashMap::Shared::SI::flush_expired_partial"); |
| 1390 |
89 |
| REGISTER_KW(si, mmap_size, "Data::HashMap::Shared::SI::mmap_size"); |
| 1391 |
89 |
| REGISTER_KW(si, touch, "Data::HashMap::Shared::SI::touch"); |
| 1392 |
89 |
| REGISTER_KW(si, reserve, "Data::HashMap::Shared::SI::reserve"); |
| 1393 |
89 |
| REGISTER_KW(si, stat_evictions, "Data::HashMap::Shared::SI::stat_evictions"); |
| 1394 |
89 |
| REGISTER_KW(si, stat_expired, "Data::HashMap::Shared::SI::stat_expired"); |
| 1395 |
89 |
| REGISTER_KW(si, stat_recoveries, "Data::HashMap::Shared::SI::stat_recoveries"); |
| 1396 |
89 |
| REGISTER_KW(si, arena_used, "Data::HashMap::Shared::SI::arena_used"); |
| 1397 |
89 |
| REGISTER_KW(si, arena_cap, "Data::HashMap::Shared::SI::arena_cap"); |
| 1398 |
89 |
| REGISTER_KW(si, add, "Data::HashMap::Shared::SI::add"); |
| 1399 |
89 |
| REGISTER_KW(si, add_ttl, "Data::HashMap::Shared::SI::add_ttl"); |
| 1400 |
89 |
| REGISTER_KW(si, update_ttl, "Data::HashMap::Shared::SI::update_ttl"); |
| 1401 |
89 |
| REGISTER_KW(si, update, "Data::HashMap::Shared::SI::update"); |
| 1402 |
89 |
| REGISTER_KW(si, swap, "Data::HashMap::Shared::SI::swap"); |
| 1403 |
89 |
| REGISTER_KW(si, cas, "Data::HashMap::Shared::SI::cas"); |
| 1404 |
89 |
| REGISTER_KW(si, cas_take, "Data::HashMap::Shared::SI::cas_take"); |
| 1405 |
89 |
| REGISTER_KW(si, persist, "Data::HashMap::Shared::SI::persist"); |
| 1406 |
89 |
| REGISTER_KW(si, set_ttl, "Data::HashMap::Shared::SI::set_ttl"); |
| 1407 |
89 |
| REGISTER_KW(ss, put, "Data::HashMap::Shared::SS::put"); |
| 1408 |
89 |
| REGISTER_KW(ss, get, "Data::HashMap::Shared::SS::get"); |
| 1409 |
89 |
| REGISTER_KW(ss, remove, "Data::HashMap::Shared::SS::remove"); |
| 1410 |
89 |
| REGISTER_KW(ss, exists, "Data::HashMap::Shared::SS::exists"); |
| 1411 |
89 |
| REGISTER_KW(ss, size, "Data::HashMap::Shared::SS::size"); |
| 1412 |
89 |
| REGISTER_KW(ss, keys, "Data::HashMap::Shared::SS::keys"); |
| 1413 |
89 |
| REGISTER_KW(ss, values, "Data::HashMap::Shared::SS::values"); |
| 1414 |
89 |
| REGISTER_KW(ss, items, "Data::HashMap::Shared::SS::items"); |
| 1415 |
89 |
| REGISTER_KW(ss, each, "Data::HashMap::Shared::SS::each"); |
| 1416 |
89 |
| REGISTER_KW(ss, iter_reset, "Data::HashMap::Shared::SS::iter_reset"); |
| 1417 |
89 |
| REGISTER_KW(ss, clear, "Data::HashMap::Shared::SS::clear"); |
| 1418 |
89 |
| REGISTER_KW(ss, to_hash, "Data::HashMap::Shared::SS::to_hash"); |
| 1419 |
89 |
| REGISTER_KW(ss, max_entries, "Data::HashMap::Shared::SS::max_entries"); |
| 1420 |
89 |
| REGISTER_KW(ss, get_or_set, "Data::HashMap::Shared::SS::get_or_set"); |
| 1421 |
89 |
| REGISTER_KW(ss, put_ttl, "Data::HashMap::Shared::SS::put_ttl"); |
| 1422 |
89 |
| REGISTER_KW(ss, max_size, "Data::HashMap::Shared::SS::max_size"); |
| 1423 |
89 |
| REGISTER_KW(ss, ttl, "Data::HashMap::Shared::SS::ttl"); |
| 1424 |
89 |
| REGISTER_KW(ss, cursor, "Data::HashMap::Shared::SS::cursor"); |
| 1425 |
89 |
| REGISTER_KW(ss, cursor_next, "Data::HashMap::Shared::SS::Cursor::next"); |
| 1426 |
89 |
| REGISTER_KW(ss, cursor_reset, "Data::HashMap::Shared::SS::Cursor::reset"); |
| 1427 |
89 |
| REGISTER_KW(ss, cursor_seek, "Data::HashMap::Shared::SS::Cursor::seek"); |
| 1428 |
89 |
| REGISTER_KW(ss, ttl_remaining, "Data::HashMap::Shared::SS::ttl_remaining"); |
| 1429 |
89 |
| REGISTER_KW(ss, capacity, "Data::HashMap::Shared::SS::capacity"); |
| 1430 |
89 |
| REGISTER_KW(ss, tombstones, "Data::HashMap::Shared::SS::tombstones"); |
| 1431 |
89 |
| REGISTER_KW(ss, take, "Data::HashMap::Shared::SS::take"); |
| 1432 |
89 |
| REGISTER_KW(ss, pop, "Data::HashMap::Shared::SS::pop"); |
| 1433 |
89 |
| REGISTER_KW(ss, shift, "Data::HashMap::Shared::SS::shift"); |
| 1434 |
89 |
| REGISTER_KW(ss, drain, "Data::HashMap::Shared::SS::drain"); |
| 1435 |
89 |
| REGISTER_KW(ss, flush_expired, "Data::HashMap::Shared::SS::flush_expired"); |
| 1436 |
89 |
| REGISTER_KW(ss, flush_expired_partial, "Data::HashMap::Shared::SS::flush_expired_partial"); |
| 1437 |
89 |
| REGISTER_KW(ss, mmap_size, "Data::HashMap::Shared::SS::mmap_size"); |
| 1438 |
89 |
| REGISTER_KW(ss, touch, "Data::HashMap::Shared::SS::touch"); |
| 1439 |
89 |
| REGISTER_KW(ss, reserve, "Data::HashMap::Shared::SS::reserve"); |
| 1440 |
89 |
| REGISTER_KW(ss, stat_evictions, "Data::HashMap::Shared::SS::stat_evictions"); |
| 1441 |
89 |
| REGISTER_KW(ss, stat_expired, "Data::HashMap::Shared::SS::stat_expired"); |
| 1442 |
89 |
| REGISTER_KW(ss, stat_recoveries, "Data::HashMap::Shared::SS::stat_recoveries"); |
| 1443 |
89 |
| REGISTER_KW(ss, arena_used, "Data::HashMap::Shared::SS::arena_used"); |
| 1444 |
89 |
| REGISTER_KW(ss, arena_cap, "Data::HashMap::Shared::SS::arena_cap"); |
| 1445 |
89 |
| REGISTER_KW(ss, add, "Data::HashMap::Shared::SS::add"); |
| 1446 |
89 |
| REGISTER_KW(ss, add_ttl, "Data::HashMap::Shared::SS::add_ttl"); |
| 1447 |
89 |
| REGISTER_KW(ss, update_ttl, "Data::HashMap::Shared::SS::update_ttl"); |
| 1448 |
89 |
| REGISTER_KW(ss, update, "Data::HashMap::Shared::SS::update"); |
| 1449 |
89 |
| REGISTER_KW(ss, swap, "Data::HashMap::Shared::SS::swap"); |
| 1450 |
89 |
| REGISTER_KW(ss, cas, "Data::HashMap::Shared::SS::cas"); |
| 1451 |
89 |
| REGISTER_KW(ss, cas_take, "Data::HashMap::Shared::SS::cas_take"); |
| 1452 |
89 |
| REGISTER_KW(ss, persist, "Data::HashMap::Shared::SS::persist"); |
| 1453 |
89 |
| REGISTER_KW(ss, set_ttl, "Data::HashMap::Shared::SS::set_ttl"); |
| 1454 |
|
| |
| 1455 |
|
| |
| 1456 |
|
| INCLUDE: xs/i16.xs |
| 1457 |
|
| INCLUDE: xs/i32.xs |
| 1458 |
|
| INCLUDE: xs/ii.xs |
| 1459 |
|
| INCLUDE: xs/i16s.xs |
| 1460 |
|
| INCLUDE: xs/i32s.xs |
| 1461 |
|
| INCLUDE: xs/is.xs |
| 1462 |
|
| INCLUDE: xs/si16.xs |
| 1463 |
|
| INCLUDE: xs/si32.xs |
| 1464 |
|
| INCLUDE: xs/si.xs |
| 1465 |
|
| INCLUDE: xs/ss.xs |
| 1466 |
|
| |
| 1467 |
|
| MODULE = Data::HashMap::Shared PACKAGE = Data::HashMap::Shared |
| 1468 |
|
| |