Data-HashMap
view release on metacpan or search on metacpan
UV
lru_skip(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapI16, stash_i16, "Data::HashMap::I16", self_sv);
RETVAL = (UV)self->lru_skip;
OUTPUT:
RETVAL
void
keys(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16, stash_i16, "Data::HashMap::I16", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I16_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now))
mXPUSHi(self->nodes[i].key);
}
void
values(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16, stash_i16, "Data::HashMap::I16", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I16_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now))
mXPUSHi(self->nodes[i].value);
}
void
items(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16, stash_i16, "Data::HashMap::I16", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size * 2);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I16_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
mXPUSHi(self->nodes[i].value);
}
}
void
each(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16, stash_i16, "Data::HashMap::I16", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
while (self->iter_pos < self->capacity) {
size_t i = self->iter_pos++;
if (I16_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
EXTEND(SP, 2);
mXPUSHi(self->nodes[i].key);
if (GIMME_V == G_SCALAR) XSRETURN(1);
mXPUSHi(self->nodes[i].value);
XSRETURN(2);
XSRETURN_EMPTY;
void
iter_reset(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapI16, stash_i16, "Data::HashMap::I16", self_sv);
self->iter_pos = 0;
void
drain(SV* self_sv, UV count)
PPCODE:
EXTRACT_MAP(HashMapI16, stash_i16, "Data::HashMap::I16", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
UV n = 0;
EXTEND(SP, (count < self->size ? count : self->size) * 2);
while (self->iter_pos < self->capacity && n < count) {
size_t i = self->iter_pos++;
if (I16_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
mXPUSHi(self->nodes[i].value);
if (HM_UNLIKELY(self->lru_prev)) hashmap_i16_lru_unlink(self, (uint32_t)i);
hashmap_i16_tombstone_at(self, i);
n++;
}
}
if (self->iter_pos >= self->capacity) self->iter_pos = 0;
HM_MAYBE_COMPACT_XS(self, hashmap_i16_compact);
void
pop(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16, stash_i16, "Data::HashMap::I16", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_tail != HM_LRU_NONE) {
uint32_t idx = self->lru_tail;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_i16_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
HM_MAYBE_COMPACT_XS(self, hashmap_i16_compact);
XSRETURN(2);
}
}
self->iter_pos = 0;
XSRETURN_EMPTY;
}
void
shift(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16, stash_i16, "Data::HashMap::I16", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_head != HM_LRU_NONE) {
uint32_t idx = self->lru_head;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_i16_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
xs/i16a.xsi view on Meta::CPAN
UV
lru_skip(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapI16A, stash_i16a, "Data::HashMap::I16A", self_sv);
RETVAL = (UV)self->lru_skip;
OUTPUT:
RETVAL
void
keys(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16A, stash_i16a, "Data::HashMap::I16A", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I16A_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now))
mXPUSHi(self->nodes[i].key);
}
void
values(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16A, stash_i16a, "Data::HashMap::I16A", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I16A_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
SV* sv = self->nodes[i].value ? SvREFCNT_inc((SV*)self->nodes[i].value) : &PL_sv_undef;
mXPUSHs(sv);
}
}
void
items(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16A, stash_i16a, "Data::HashMap::I16A", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size * 2);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I16A_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
SV* sv = self->nodes[i].value ? SvREFCNT_inc((SV*)self->nodes[i].value) : &PL_sv_undef;
mXPUSHs(sv);
}
}
void
each(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16A, stash_i16a, "Data::HashMap::I16A", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
while (self->iter_pos < self->capacity) {
size_t i = self->iter_pos++;
if (I16A_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
EXTEND(SP, 2);
mXPUSHi(self->nodes[i].key);
if (GIMME_V == G_SCALAR) XSRETURN(1);
SV* sv = self->nodes[i].value ? SvREFCNT_inc((SV*)self->nodes[i].value) : &PL_sv_undef;
mXPUSHs(sv);
xs/i16a.xsi view on Meta::CPAN
XSRETURN_EMPTY;
void
iter_reset(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapI16A, stash_i16a, "Data::HashMap::I16A", self_sv);
self->iter_pos = 0;
void
drain(SV* self_sv, UV count)
PPCODE:
EXTRACT_MAP(HashMapI16A, stash_i16a, "Data::HashMap::I16A", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
UV n = 0;
EXTEND(SP, (count < self->size ? count : self->size) * 2);
while (self->iter_pos < self->capacity && n < count) {
size_t i = self->iter_pos++;
if (I16A_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
if (self->nodes[i].value) {
mXPUSHs((SV*)self->nodes[i].value);
xs/i16a.xsi view on Meta::CPAN
if (HM_UNLIKELY(self->lru_prev)) hashmap_i16a_lru_unlink(self, (uint32_t)i);
hashmap_i16a_tombstone_at(self, i);
n++;
}
}
if (self->iter_pos >= self->capacity) self->iter_pos = 0;
HM_MAYBE_COMPACT_XS(self, hashmap_i16a_compact);
void
pop(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16A, stash_i16a, "Data::HashMap::I16A", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_tail != HM_LRU_NONE) {
uint32_t idx = self->lru_tail;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_i16a_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
xs/i16a.xsi view on Meta::CPAN
HM_MAYBE_COMPACT_XS(self, hashmap_i16a_compact);
XSRETURN(2);
}
}
self->iter_pos = 0;
XSRETURN_EMPTY;
}
void
shift(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16A, stash_i16a, "Data::HashMap::I16A", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_head != HM_LRU_NONE) {
uint32_t idx = self->lru_head;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_i16a_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
xs/i16s.xsi view on Meta::CPAN
UV
lru_skip(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapI16S, stash_i16s, "Data::HashMap::I16S", self_sv);
RETVAL = (UV)self->lru_skip;
OUTPUT:
RETVAL
void
keys(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16S, stash_i16s, "Data::HashMap::I16S", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I16S_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now))
mXPUSHi(self->nodes[i].key);
}
void
values(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16S, stash_i16s, "Data::HashMap::I16S", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I16S_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
if (self->nodes[i].value) {
SV* sv = newSVpvn(self->nodes[i].value,
HM_UNPACK_LEN(self->nodes[i].val_len));
if (HM_UNPACK_UTF8(self->nodes[i].val_len)) SvUTF8_on(sv);
mXPUSHs(sv);
} else {
XPUSHs(&PL_sv_undef);
}
}
}
void
items(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16S, stash_i16s, "Data::HashMap::I16S", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size * 2);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I16S_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
if (self->nodes[i].value) {
SV* sv = newSVpvn(self->nodes[i].value,
HM_UNPACK_LEN(self->nodes[i].val_len));
if (HM_UNPACK_UTF8(self->nodes[i].val_len)) SvUTF8_on(sv);
mXPUSHs(sv);
} else {
XPUSHs(&PL_sv_undef);
}
}
}
void
each(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16S, stash_i16s, "Data::HashMap::I16S", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
while (self->iter_pos < self->capacity) {
size_t i = self->iter_pos++;
if (I16S_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
EXTEND(SP, 2);
mXPUSHi(self->nodes[i].key);
if (GIMME_V == G_SCALAR) XSRETURN(1);
if (self->nodes[i].value) {
SV* vsv = newSVpvn(self->nodes[i].value,
xs/i16s.xsi view on Meta::CPAN
XSRETURN_EMPTY;
void
iter_reset(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapI16S, stash_i16s, "Data::HashMap::I16S", self_sv);
self->iter_pos = 0;
void
drain(SV* self_sv, UV count)
PPCODE:
EXTRACT_MAP(HashMapI16S, stash_i16s, "Data::HashMap::I16S", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
UV n = 0;
EXTEND(SP, (count < self->size ? count : self->size) * 2);
while (self->iter_pos < self->capacity && n < count) {
size_t i = self->iter_pos++;
if (I16S_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
if (self->nodes[i].value) {
SV* sv = newSVpvn(self->nodes[i].value, HM_UNPACK_LEN(self->nodes[i].val_len));
xs/i16s.xsi view on Meta::CPAN
if (HM_UNLIKELY(self->lru_prev)) hashmap_i16s_lru_unlink(self, (uint32_t)i);
hashmap_i16s_tombstone_at(self, i);
n++;
}
}
if (self->iter_pos >= self->capacity) self->iter_pos = 0;
HM_MAYBE_COMPACT_XS(self, hashmap_i16s_compact);
void
pop(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16S, stash_i16s, "Data::HashMap::I16S", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_tail != HM_LRU_NONE) {
uint32_t idx = self->lru_tail;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_i16s_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
xs/i16s.xsi view on Meta::CPAN
HM_MAYBE_COMPACT_XS(self, hashmap_i16s_compact);
XSRETURN(2);
}
}
self->iter_pos = 0;
XSRETURN_EMPTY;
}
void
shift(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI16S, stash_i16s, "Data::HashMap::I16S", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_head != HM_LRU_NONE) {
uint32_t idx = self->lru_head;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_i16s_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
UV
lru_skip(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapI32, stash_i32, "Data::HashMap::I32", self_sv);
RETVAL = (UV)self->lru_skip;
OUTPUT:
RETVAL
void
keys(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32, stash_i32, "Data::HashMap::I32", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I32_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now))
mXPUSHi(self->nodes[i].key);
}
void
values(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32, stash_i32, "Data::HashMap::I32", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I32_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now))
mXPUSHi(self->nodes[i].value);
}
void
items(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32, stash_i32, "Data::HashMap::I32", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size * 2);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I32_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
mXPUSHi(self->nodes[i].value);
}
}
void
each(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32, stash_i32, "Data::HashMap::I32", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
while (self->iter_pos < self->capacity) {
size_t i = self->iter_pos++;
if (I32_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
EXTEND(SP, 2);
mXPUSHi(self->nodes[i].key);
if (GIMME_V == G_SCALAR) XSRETURN(1);
mXPUSHi(self->nodes[i].value);
XSRETURN(2);
XSRETURN_EMPTY;
void
iter_reset(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapI32, stash_i32, "Data::HashMap::I32", self_sv);
self->iter_pos = 0;
void
drain(SV* self_sv, UV count)
PPCODE:
EXTRACT_MAP(HashMapI32, stash_i32, "Data::HashMap::I32", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
UV n = 0;
EXTEND(SP, (count < self->size ? count : self->size) * 2);
while (self->iter_pos < self->capacity && n < count) {
size_t i = self->iter_pos++;
if (I32_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
mXPUSHi(self->nodes[i].value);
if (HM_UNLIKELY(self->lru_prev)) hashmap_i32_lru_unlink(self, (uint32_t)i);
hashmap_i32_tombstone_at(self, i);
n++;
}
}
if (self->iter_pos >= self->capacity) self->iter_pos = 0;
HM_MAYBE_COMPACT_XS(self, hashmap_i32_compact);
void
pop(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32, stash_i32, "Data::HashMap::I32", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_tail != HM_LRU_NONE) {
uint32_t idx = self->lru_tail;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_i32_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
HM_MAYBE_COMPACT_XS(self, hashmap_i32_compact);
XSRETURN(2);
}
}
self->iter_pos = 0;
XSRETURN_EMPTY;
}
void
shift(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32, stash_i32, "Data::HashMap::I32", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_head != HM_LRU_NONE) {
uint32_t idx = self->lru_head;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_i32_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
xs/i32a.xsi view on Meta::CPAN
UV
lru_skip(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapI32A, stash_i32a, "Data::HashMap::I32A", self_sv);
RETVAL = (UV)self->lru_skip;
OUTPUT:
RETVAL
void
keys(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32A, stash_i32a, "Data::HashMap::I32A", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I32A_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now))
mXPUSHi(self->nodes[i].key);
}
void
values(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32A, stash_i32a, "Data::HashMap::I32A", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I32A_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
SV* sv = self->nodes[i].value ? SvREFCNT_inc((SV*)self->nodes[i].value) : &PL_sv_undef;
mXPUSHs(sv);
}
}
void
items(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32A, stash_i32a, "Data::HashMap::I32A", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size * 2);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I32A_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
SV* sv = self->nodes[i].value ? SvREFCNT_inc((SV*)self->nodes[i].value) : &PL_sv_undef;
mXPUSHs(sv);
}
}
void
each(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32A, stash_i32a, "Data::HashMap::I32A", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
while (self->iter_pos < self->capacity) {
size_t i = self->iter_pos++;
if (I32A_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
EXTEND(SP, 2);
mXPUSHi(self->nodes[i].key);
if (GIMME_V == G_SCALAR) XSRETURN(1);
SV* sv = self->nodes[i].value ? SvREFCNT_inc((SV*)self->nodes[i].value) : &PL_sv_undef;
mXPUSHs(sv);
xs/i32a.xsi view on Meta::CPAN
XSRETURN_EMPTY;
void
iter_reset(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapI32A, stash_i32a, "Data::HashMap::I32A", self_sv);
self->iter_pos = 0;
void
drain(SV* self_sv, UV count)
PPCODE:
EXTRACT_MAP(HashMapI32A, stash_i32a, "Data::HashMap::I32A", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
UV n = 0;
EXTEND(SP, (count < self->size ? count : self->size) * 2);
while (self->iter_pos < self->capacity && n < count) {
size_t i = self->iter_pos++;
if (I32A_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
if (self->nodes[i].value) {
mXPUSHs((SV*)self->nodes[i].value);
xs/i32a.xsi view on Meta::CPAN
if (HM_UNLIKELY(self->lru_prev)) hashmap_i32a_lru_unlink(self, (uint32_t)i);
hashmap_i32a_tombstone_at(self, i);
n++;
}
}
if (self->iter_pos >= self->capacity) self->iter_pos = 0;
HM_MAYBE_COMPACT_XS(self, hashmap_i32a_compact);
void
pop(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32A, stash_i32a, "Data::HashMap::I32A", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_tail != HM_LRU_NONE) {
uint32_t idx = self->lru_tail;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_i32a_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
xs/i32a.xsi view on Meta::CPAN
HM_MAYBE_COMPACT_XS(self, hashmap_i32a_compact);
XSRETURN(2);
}
}
self->iter_pos = 0;
XSRETURN_EMPTY;
}
void
shift(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32A, stash_i32a, "Data::HashMap::I32A", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_head != HM_LRU_NONE) {
uint32_t idx = self->lru_head;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_i32a_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
xs/i32s.xsi view on Meta::CPAN
UV
lru_skip(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
RETVAL = (UV)self->lru_skip;
OUTPUT:
RETVAL
void
keys(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I32S_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now))
mXPUSHi(self->nodes[i].key);
}
void
values(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I32S_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
if (self->nodes[i].value) {
SV* sv = newSVpvn(self->nodes[i].value,
HM_UNPACK_LEN(self->nodes[i].val_len));
if (HM_UNPACK_UTF8(self->nodes[i].val_len)) SvUTF8_on(sv);
mXPUSHs(sv);
} else {
XPUSHs(&PL_sv_undef);
}
}
}
void
items(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size * 2);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (I32S_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
if (self->nodes[i].value) {
SV* sv = newSVpvn(self->nodes[i].value,
HM_UNPACK_LEN(self->nodes[i].val_len));
if (HM_UNPACK_UTF8(self->nodes[i].val_len)) SvUTF8_on(sv);
mXPUSHs(sv);
} else {
XPUSHs(&PL_sv_undef);
}
}
}
void
each(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
while (self->iter_pos < self->capacity) {
size_t i = self->iter_pos++;
if (I32S_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
EXTEND(SP, 2);
mXPUSHi(self->nodes[i].key);
if (GIMME_V == G_SCALAR) XSRETURN(1);
if (self->nodes[i].value) {
SV* vsv = newSVpvn(self->nodes[i].value,
xs/i32s.xsi view on Meta::CPAN
XSRETURN_EMPTY;
void
iter_reset(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
self->iter_pos = 0;
void
drain(SV* self_sv, UV count)
PPCODE:
EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
UV n = 0;
EXTEND(SP, (count < self->size ? count : self->size) * 2);
while (self->iter_pos < self->capacity && n < count) {
size_t i = self->iter_pos++;
if (I32S_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
if (self->nodes[i].value) {
SV* sv = newSVpvn(self->nodes[i].value, HM_UNPACK_LEN(self->nodes[i].val_len));
xs/i32s.xsi view on Meta::CPAN
if (HM_UNLIKELY(self->lru_prev)) hashmap_i32s_lru_unlink(self, (uint32_t)i);
hashmap_i32s_tombstone_at(self, i);
n++;
}
}
if (self->iter_pos >= self->capacity) self->iter_pos = 0;
HM_MAYBE_COMPACT_XS(self, hashmap_i32s_compact);
void
pop(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_tail != HM_LRU_NONE) {
uint32_t idx = self->lru_tail;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_i32s_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
xs/i32s.xsi view on Meta::CPAN
HM_MAYBE_COMPACT_XS(self, hashmap_i32s_compact);
XSRETURN(2);
}
}
self->iter_pos = 0;
XSRETURN_EMPTY;
}
void
shift(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_head != HM_LRU_NONE) {
uint32_t idx = self->lru_head;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_i32s_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
UV
lru_skip(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapIA, stash_ia, "Data::HashMap::IA", self_sv);
RETVAL = (UV)self->lru_skip;
OUTPUT:
RETVAL
void
keys(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapIA, stash_ia, "Data::HashMap::IA", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (IA_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now))
mXPUSHi(self->nodes[i].key);
}
void
values(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapIA, stash_ia, "Data::HashMap::IA", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (IA_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
SV* sv = self->nodes[i].value ? SvREFCNT_inc((SV*)self->nodes[i].value) : &PL_sv_undef;
mXPUSHs(sv);
}
}
void
items(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapIA, stash_ia, "Data::HashMap::IA", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size * 2);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (IA_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
SV* sv = self->nodes[i].value ? SvREFCNT_inc((SV*)self->nodes[i].value) : &PL_sv_undef;
mXPUSHs(sv);
}
}
void
each(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapIA, stash_ia, "Data::HashMap::IA", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
while (self->iter_pos < self->capacity) {
size_t i = self->iter_pos++;
if (IA_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
EXTEND(SP, 2);
mXPUSHi(self->nodes[i].key);
if (GIMME_V == G_SCALAR) XSRETURN(1);
SV* sv = self->nodes[i].value ? SvREFCNT_inc((SV*)self->nodes[i].value) : &PL_sv_undef;
mXPUSHs(sv);
XSRETURN_EMPTY;
void
iter_reset(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapIA, stash_ia, "Data::HashMap::IA", self_sv);
self->iter_pos = 0;
void
drain(SV* self_sv, UV count)
PPCODE:
EXTRACT_MAP(HashMapIA, stash_ia, "Data::HashMap::IA", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
UV n = 0;
EXTEND(SP, (count < self->size ? count : self->size) * 2);
while (self->iter_pos < self->capacity && n < count) {
size_t i = self->iter_pos++;
if (IA_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
if (self->nodes[i].value) {
mXPUSHs((SV*)self->nodes[i].value);
if (HM_UNLIKELY(self->lru_prev)) hashmap_ia_lru_unlink(self, (uint32_t)i);
hashmap_ia_tombstone_at(self, i);
n++;
}
}
if (self->iter_pos >= self->capacity) self->iter_pos = 0;
HM_MAYBE_COMPACT_XS(self, hashmap_ia_compact);
void
pop(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapIA, stash_ia, "Data::HashMap::IA", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_tail != HM_LRU_NONE) {
uint32_t idx = self->lru_tail;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_ia_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
HM_MAYBE_COMPACT_XS(self, hashmap_ia_compact);
XSRETURN(2);
}
}
self->iter_pos = 0;
XSRETURN_EMPTY;
}
void
shift(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapIA, stash_ia, "Data::HashMap::IA", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_head != HM_LRU_NONE) {
uint32_t idx = self->lru_head;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_ia_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
UV
lru_skip(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapII, stash_ii, "Data::HashMap::II", self_sv);
RETVAL = (UV)self->lru_skip;
OUTPUT:
RETVAL
void
keys(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapII, stash_ii, "Data::HashMap::II", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (II_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now))
mXPUSHi(self->nodes[i].key);
}
void
values(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapII, stash_ii, "Data::HashMap::II", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (II_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now))
mXPUSHi(self->nodes[i].value);
}
void
items(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapII, stash_ii, "Data::HashMap::II", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size * 2);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (II_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
mXPUSHi(self->nodes[i].value);
}
}
void
each(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapII, stash_ii, "Data::HashMap::II", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
while (self->iter_pos < self->capacity) {
size_t i = self->iter_pos++;
if (II_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
EXTEND(SP, 2);
mXPUSHi(self->nodes[i].key);
if (GIMME_V == G_SCALAR) XSRETURN(1);
mXPUSHi(self->nodes[i].value);
XSRETURN(2);
XSRETURN_EMPTY;
void
iter_reset(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapII, stash_ii, "Data::HashMap::II", self_sv);
self->iter_pos = 0;
void
drain(SV* self_sv, UV count)
PPCODE:
EXTRACT_MAP(HashMapII, stash_ii, "Data::HashMap::II", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
UV n = 0;
EXTEND(SP, (count < self->size ? count : self->size) * 2);
while (self->iter_pos < self->capacity && n < count) {
size_t i = self->iter_pos++;
if (II_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
mXPUSHi(self->nodes[i].value);
if (HM_UNLIKELY(self->lru_prev)) hashmap_ii_lru_unlink(self, (uint32_t)i);
hashmap_ii_tombstone_at(self, i);
n++;
}
}
if (self->iter_pos >= self->capacity) self->iter_pos = 0;
HM_MAYBE_COMPACT_XS(self, hashmap_ii_compact);
void
pop(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapII, stash_ii, "Data::HashMap::II", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_tail != HM_LRU_NONE) {
uint32_t idx = self->lru_tail;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_ii_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
HM_MAYBE_COMPACT_XS(self, hashmap_ii_compact);
XSRETURN(2);
}
}
self->iter_pos = 0;
XSRETURN_EMPTY;
}
void
shift(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapII, stash_ii, "Data::HashMap::II", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_head != HM_LRU_NONE) {
uint32_t idx = self->lru_head;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_ii_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
UV
lru_skip(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapIS, stash_is, "Data::HashMap::IS", self_sv);
RETVAL = (UV)self->lru_skip;
OUTPUT:
RETVAL
void
keys(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapIS, stash_is, "Data::HashMap::IS", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (IS_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now))
mXPUSHi(self->nodes[i].key);
}
void
values(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapIS, stash_is, "Data::HashMap::IS", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (IS_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
if (self->nodes[i].value) {
SV* sv = newSVpvn(self->nodes[i].value,
HM_UNPACK_LEN(self->nodes[i].val_len));
if (HM_UNPACK_UTF8(self->nodes[i].val_len)) SvUTF8_on(sv);
mXPUSHs(sv);
} else {
XPUSHs(&PL_sv_undef);
}
}
}
void
items(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapIS, stash_is, "Data::HashMap::IS", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size * 2);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (IS_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
if (self->nodes[i].value) {
SV* sv = newSVpvn(self->nodes[i].value,
HM_UNPACK_LEN(self->nodes[i].val_len));
if (HM_UNPACK_UTF8(self->nodes[i].val_len)) SvUTF8_on(sv);
mXPUSHs(sv);
} else {
XPUSHs(&PL_sv_undef);
}
}
}
void
each(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapIS, stash_is, "Data::HashMap::IS", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
while (self->iter_pos < self->capacity) {
size_t i = self->iter_pos++;
if (IS_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
EXTEND(SP, 2);
mXPUSHi(self->nodes[i].key);
if (GIMME_V == G_SCALAR) XSRETURN(1);
if (self->nodes[i].value) {
SV* vsv = newSVpvn(self->nodes[i].value,
XSRETURN_EMPTY;
void
iter_reset(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapIS, stash_is, "Data::HashMap::IS", self_sv);
self->iter_pos = 0;
void
drain(SV* self_sv, UV count)
PPCODE:
EXTRACT_MAP(HashMapIS, stash_is, "Data::HashMap::IS", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
UV n = 0;
EXTEND(SP, (count < self->size ? count : self->size) * 2);
while (self->iter_pos < self->capacity && n < count) {
size_t i = self->iter_pos++;
if (IS_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
mXPUSHi(self->nodes[i].key);
if (self->nodes[i].value) {
SV* sv = newSVpvn(self->nodes[i].value, HM_UNPACK_LEN(self->nodes[i].val_len));
if (HM_UNLIKELY(self->lru_prev)) hashmap_is_lru_unlink(self, (uint32_t)i);
hashmap_is_tombstone_at(self, i);
n++;
}
}
if (self->iter_pos >= self->capacity) self->iter_pos = 0;
HM_MAYBE_COMPACT_XS(self, hashmap_is_compact);
void
pop(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapIS, stash_is, "Data::HashMap::IS", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_tail != HM_LRU_NONE) {
uint32_t idx = self->lru_tail;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_is_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
HM_MAYBE_COMPACT_XS(self, hashmap_is_compact);
XSRETURN(2);
}
}
self->iter_pos = 0;
XSRETURN_EMPTY;
}
void
shift(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapIS, stash_is, "Data::HashMap::IS", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_head != HM_LRU_NONE) {
uint32_t idx = self->lru_head;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_is_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
mXPUSHi(self->nodes[idx].key);
UV
lru_skip(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapSA, stash_sa, "Data::HashMap::SA", self_sv);
RETVAL = (UV)self->lru_skip;
OUTPUT:
RETVAL
void
keys(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSA, stash_sa, "Data::HashMap::SA", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (SA_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
uint32_t klen = HM_UNPACK_LEN(self->nodes[i].key_len);
SV* sv = newSVpvn(self->nodes[i].key, klen);
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(sv);
mXPUSHs(sv);
}
}
void
values(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSA, stash_sa, "Data::HashMap::SA", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (SA_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
SV* sv = self->nodes[i].value ? SvREFCNT_inc((SV*)self->nodes[i].value) : &PL_sv_undef;
mXPUSHs(sv);
}
}
void
items(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSA, stash_sa, "Data::HashMap::SA", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size * 2);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (SA_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
uint32_t klen = HM_UNPACK_LEN(self->nodes[i].key_len);
SV* ksv = newSVpvn(self->nodes[i].key, klen);
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(ksv);
mXPUSHs(ksv);
SV* vsv = self->nodes[i].value ? SvREFCNT_inc((SV*)self->nodes[i].value) : &PL_sv_undef;
mXPUSHs(vsv);
}
}
void
each(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSA, stash_sa, "Data::HashMap::SA", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
while (self->iter_pos < self->capacity) {
size_t i = self->iter_pos++;
if (SA_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
EXTEND(SP, 2);
{
uint32_t klen = HM_UNPACK_LEN(self->nodes[i].key_len);
SV* ksv = newSVpvn(self->nodes[i].key, klen);
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(ksv);
XSRETURN_EMPTY;
void
iter_reset(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapSA, stash_sa, "Data::HashMap::SA", self_sv);
self->iter_pos = 0;
void
drain(SV* self_sv, UV count)
PPCODE:
EXTRACT_MAP(HashMapSA, stash_sa, "Data::HashMap::SA", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
UV n = 0;
EXTEND(SP, (count < self->size ? count : self->size) * 2);
while (self->iter_pos < self->capacity && n < count) {
size_t i = self->iter_pos++;
if (SA_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
{
SV* ksv = newSVpvn(self->nodes[i].key, HM_UNPACK_LEN(self->nodes[i].key_len));
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(ksv);
if (HM_UNLIKELY(self->lru_prev)) hashmap_sa_lru_unlink(self, (uint32_t)i);
hashmap_sa_tombstone_at(self, i);
n++;
}
}
if (self->iter_pos >= self->capacity) self->iter_pos = 0;
HM_MAYBE_COMPACT_XS(self, hashmap_sa_compact);
void
pop(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSA, stash_sa, "Data::HashMap::SA", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_tail != HM_LRU_NONE) {
uint32_t idx = self->lru_tail;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_sa_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
{
HM_MAYBE_COMPACT_XS(self, hashmap_sa_compact);
XSRETURN(2);
}
}
self->iter_pos = 0;
XSRETURN_EMPTY;
}
void
shift(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSA, stash_sa, "Data::HashMap::SA", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_head != HM_LRU_NONE) {
uint32_t idx = self->lru_head;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_sa_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
{
UV
lru_skip(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapSI, stash_si, "Data::HashMap::SI", self_sv);
RETVAL = (UV)self->lru_skip;
OUTPUT:
RETVAL
void
keys(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI, stash_si, "Data::HashMap::SI", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (SI_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
uint32_t klen = HM_UNPACK_LEN(self->nodes[i].key_len);
SV* sv = newSVpvn(self->nodes[i].key, klen);
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(sv);
mXPUSHs(sv);
}
}
void
values(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI, stash_si, "Data::HashMap::SI", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (SI_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now))
mXPUSHi(self->nodes[i].value);
}
void
items(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI, stash_si, "Data::HashMap::SI", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size * 2);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (SI_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
uint32_t klen = HM_UNPACK_LEN(self->nodes[i].key_len);
SV* sv = newSVpvn(self->nodes[i].key, klen);
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(sv);
mXPUSHs(sv);
mXPUSHi(self->nodes[i].value);
}
}
void
each(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI, stash_si, "Data::HashMap::SI", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
while (self->iter_pos < self->capacity) {
size_t i = self->iter_pos++;
if (SI_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
EXTEND(SP, 2);
{
uint32_t klen = HM_UNPACK_LEN(self->nodes[i].key_len);
SV* ksv = newSVpvn(self->nodes[i].key, klen);
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(ksv);
XSRETURN_EMPTY;
void
iter_reset(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapSI, stash_si, "Data::HashMap::SI", self_sv);
self->iter_pos = 0;
void
drain(SV* self_sv, UV count)
PPCODE:
EXTRACT_MAP(HashMapSI, stash_si, "Data::HashMap::SI", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
UV n = 0;
EXTEND(SP, (count < self->size ? count : self->size) * 2);
while (self->iter_pos < self->capacity && n < count) {
size_t i = self->iter_pos++;
if (SI_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
{
SV* ksv = newSVpvn(self->nodes[i].key, HM_UNPACK_LEN(self->nodes[i].key_len));
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(ksv);
if (HM_UNLIKELY(self->lru_prev)) hashmap_si_lru_unlink(self, (uint32_t)i);
hashmap_si_tombstone_at(self, i);
n++;
}
}
if (self->iter_pos >= self->capacity) self->iter_pos = 0;
HM_MAYBE_COMPACT_XS(self, hashmap_si_compact);
void
pop(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI, stash_si, "Data::HashMap::SI", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_tail != HM_LRU_NONE) {
uint32_t idx = self->lru_tail;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_si_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
{
HM_MAYBE_COMPACT_XS(self, hashmap_si_compact);
XSRETURN(2);
}
}
self->iter_pos = 0;
XSRETURN_EMPTY;
}
void
shift(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI, stash_si, "Data::HashMap::SI", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_head != HM_LRU_NONE) {
uint32_t idx = self->lru_head;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_si_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
{
xs/si16.xsi view on Meta::CPAN
UV
lru_skip(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapSI16, stash_si16, "Data::HashMap::SI16", self_sv);
RETVAL = (UV)self->lru_skip;
OUTPUT:
RETVAL
void
keys(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI16, stash_si16, "Data::HashMap::SI16", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (SI16_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
uint32_t klen = HM_UNPACK_LEN(self->nodes[i].key_len);
SV* sv = newSVpvn(self->nodes[i].key, klen);
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(sv);
mXPUSHs(sv);
}
}
void
values(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI16, stash_si16, "Data::HashMap::SI16", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (SI16_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now))
mXPUSHi(self->nodes[i].value);
}
void
items(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI16, stash_si16, "Data::HashMap::SI16", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size * 2);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (SI16_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
uint32_t klen = HM_UNPACK_LEN(self->nodes[i].key_len);
SV* sv = newSVpvn(self->nodes[i].key, klen);
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(sv);
mXPUSHs(sv);
mXPUSHi(self->nodes[i].value);
}
}
void
each(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI16, stash_si16, "Data::HashMap::SI16", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
while (self->iter_pos < self->capacity) {
size_t i = self->iter_pos++;
if (SI16_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
EXTEND(SP, 2);
{
uint32_t klen = HM_UNPACK_LEN(self->nodes[i].key_len);
SV* ksv = newSVpvn(self->nodes[i].key, klen);
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(ksv);
xs/si16.xsi view on Meta::CPAN
XSRETURN_EMPTY;
void
iter_reset(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapSI16, stash_si16, "Data::HashMap::SI16", self_sv);
self->iter_pos = 0;
void
drain(SV* self_sv, UV count)
PPCODE:
EXTRACT_MAP(HashMapSI16, stash_si16, "Data::HashMap::SI16", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
UV n = 0;
EXTEND(SP, (count < self->size ? count : self->size) * 2);
while (self->iter_pos < self->capacity && n < count) {
size_t i = self->iter_pos++;
if (SI16_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
{
SV* ksv = newSVpvn(self->nodes[i].key, HM_UNPACK_LEN(self->nodes[i].key_len));
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(ksv);
xs/si16.xsi view on Meta::CPAN
if (HM_UNLIKELY(self->lru_prev)) hashmap_si16_lru_unlink(self, (uint32_t)i);
hashmap_si16_tombstone_at(self, i);
n++;
}
}
if (self->iter_pos >= self->capacity) self->iter_pos = 0;
HM_MAYBE_COMPACT_XS(self, hashmap_si16_compact);
void
pop(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI16, stash_si16, "Data::HashMap::SI16", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_tail != HM_LRU_NONE) {
uint32_t idx = self->lru_tail;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_si16_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
{
xs/si16.xsi view on Meta::CPAN
HM_MAYBE_COMPACT_XS(self, hashmap_si16_compact);
XSRETURN(2);
}
}
self->iter_pos = 0;
XSRETURN_EMPTY;
}
void
shift(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI16, stash_si16, "Data::HashMap::SI16", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_head != HM_LRU_NONE) {
uint32_t idx = self->lru_head;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_si16_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
{
xs/si32.xsi view on Meta::CPAN
UV
lru_skip(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapSI32, stash_si32, "Data::HashMap::SI32", self_sv);
RETVAL = (UV)self->lru_skip;
OUTPUT:
RETVAL
void
keys(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI32, stash_si32, "Data::HashMap::SI32", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (SI32_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
uint32_t klen = HM_UNPACK_LEN(self->nodes[i].key_len);
SV* sv = newSVpvn(self->nodes[i].key, klen);
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(sv);
mXPUSHs(sv);
}
}
void
values(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI32, stash_si32, "Data::HashMap::SI32", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (SI32_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now))
mXPUSHi(self->nodes[i].value);
}
void
items(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI32, stash_si32, "Data::HashMap::SI32", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size * 2);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (SI32_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
uint32_t klen = HM_UNPACK_LEN(self->nodes[i].key_len);
SV* sv = newSVpvn(self->nodes[i].key, klen);
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(sv);
mXPUSHs(sv);
mXPUSHi(self->nodes[i].value);
}
}
void
each(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI32, stash_si32, "Data::HashMap::SI32", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
while (self->iter_pos < self->capacity) {
size_t i = self->iter_pos++;
if (SI32_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
EXTEND(SP, 2);
{
uint32_t klen = HM_UNPACK_LEN(self->nodes[i].key_len);
SV* ksv = newSVpvn(self->nodes[i].key, klen);
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(ksv);
xs/si32.xsi view on Meta::CPAN
XSRETURN_EMPTY;
void
iter_reset(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapSI32, stash_si32, "Data::HashMap::SI32", self_sv);
self->iter_pos = 0;
void
drain(SV* self_sv, UV count)
PPCODE:
EXTRACT_MAP(HashMapSI32, stash_si32, "Data::HashMap::SI32", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
UV n = 0;
EXTEND(SP, (count < self->size ? count : self->size) * 2);
while (self->iter_pos < self->capacity && n < count) {
size_t i = self->iter_pos++;
if (SI32_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
{
SV* ksv = newSVpvn(self->nodes[i].key, HM_UNPACK_LEN(self->nodes[i].key_len));
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(ksv);
xs/si32.xsi view on Meta::CPAN
if (HM_UNLIKELY(self->lru_prev)) hashmap_si32_lru_unlink(self, (uint32_t)i);
hashmap_si32_tombstone_at(self, i);
n++;
}
}
if (self->iter_pos >= self->capacity) self->iter_pos = 0;
HM_MAYBE_COMPACT_XS(self, hashmap_si32_compact);
void
pop(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI32, stash_si32, "Data::HashMap::SI32", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_tail != HM_LRU_NONE) {
uint32_t idx = self->lru_tail;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_si32_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
{
xs/si32.xsi view on Meta::CPAN
HM_MAYBE_COMPACT_XS(self, hashmap_si32_compact);
XSRETURN(2);
}
}
self->iter_pos = 0;
XSRETURN_EMPTY;
}
void
shift(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSI32, stash_si32, "Data::HashMap::SI32", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_head != HM_LRU_NONE) {
uint32_t idx = self->lru_head;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_si32_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
{
UV
lru_skip(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapSS, stash_ss, "Data::HashMap::SS", self_sv);
RETVAL = (UV)self->lru_skip;
OUTPUT:
RETVAL
void
keys(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSS, stash_ss, "Data::HashMap::SS", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (SS_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
uint32_t klen = HM_UNPACK_LEN(self->nodes[i].key_len);
SV* sv = newSVpvn(self->nodes[i].key, klen);
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(sv);
mXPUSHs(sv);
}
}
void
values(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSS, stash_ss, "Data::HashMap::SS", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (SS_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
if (self->nodes[i].value) {
SV* sv = newSVpvn(self->nodes[i].value,
HM_UNPACK_LEN(self->nodes[i].val_len));
if (HM_UNPACK_UTF8(self->nodes[i].val_len)) SvUTF8_on(sv);
mXPUSHs(sv);
} else {
XPUSHs(&PL_sv_undef);
}
}
}
void
items(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSS, stash_ss, "Data::HashMap::SS", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
EXTEND(SP, self->size * 2);
size_t i;
for (i = 0; i < self->capacity; i++) {
if (SS_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
uint32_t klen = HM_UNPACK_LEN(self->nodes[i].key_len);
SV* sv = newSVpvn(self->nodes[i].key, klen);
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(sv);
mXPUSHs(sv);
if (HM_UNPACK_UTF8(self->nodes[i].val_len)) SvUTF8_on(vsv);
mXPUSHs(vsv);
} else {
XPUSHs(&PL_sv_undef);
}
}
}
void
each(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSS, stash_ss, "Data::HashMap::SS", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
while (self->iter_pos < self->capacity) {
size_t i = self->iter_pos++;
if (SS_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
EXTEND(SP, 2);
{
uint32_t klen = HM_UNPACK_LEN(self->nodes[i].key_len);
SV* ksv = newSVpvn(self->nodes[i].key, klen);
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(ksv);
XSRETURN_EMPTY;
void
iter_reset(SV* self_sv)
CODE:
EXTRACT_MAP(HashMapSS, stash_ss, "Data::HashMap::SS", self_sv);
self->iter_pos = 0;
void
drain(SV* self_sv, UV count)
PPCODE:
EXTRACT_MAP(HashMapSS, stash_ss, "Data::HashMap::SS", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
UV n = 0;
EXTEND(SP, (count < self->size ? count : self->size) * 2);
while (self->iter_pos < self->capacity && n < count) {
size_t i = self->iter_pos++;
if (SS_NODE_LIVE(self->nodes[i]) && !HM_TTL_SKIP_EXPIRED(self, i, now)) {
{
SV* ksv = newSVpvn(self->nodes[i].key, HM_UNPACK_LEN(self->nodes[i].key_len));
if (HM_UNPACK_UTF8(self->nodes[i].key_len)) SvUTF8_on(ksv);
if (HM_UNLIKELY(self->lru_prev)) hashmap_ss_lru_unlink(self, (uint32_t)i);
hashmap_ss_tombstone_at(self, i);
n++;
}
}
if (self->iter_pos >= self->capacity) self->iter_pos = 0;
HM_MAYBE_COMPACT_XS(self, hashmap_ss_compact);
void
pop(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSS, stash_ss, "Data::HashMap::SS", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_tail != HM_LRU_NONE) {
uint32_t idx = self->lru_tail;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_ss_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
{
HM_MAYBE_COMPACT_XS(self, hashmap_ss_compact);
XSRETURN(2);
}
}
self->iter_pos = 0;
XSRETURN_EMPTY;
}
void
shift(SV* self_sv)
PPCODE:
EXTRACT_MAP(HashMapSS, stash_ss, "Data::HashMap::SS", self_sv);
uint32_t now = self->expires_at ? (uint32_t)time(NULL) : 0;
if (self->lru_prev) {
while (self->lru_head != HM_LRU_NONE) {
uint32_t idx = self->lru_head;
if (HM_UNLIKELY(HM_TTL_SKIP_EXPIRED(self, idx, now))) {
hashmap_ss_expire_at(self, idx, true); continue;
}
EXTEND(SP, 2);
{
( run in 1.004 second using v1.01-cache-2.11-cpan-71847e10f99 )