view release on metacpan or  search on metacpan

xs/i32s.xsi  view on Meta::CPAN

    CODE:
        EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
        RETVAL = hashmap_i32s_remove(self, key);
    OUTPUT:
        RETVAL

SV*
take(SV* self_sv, int32_t key)
    CODE:
        EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
        const char* val; uint32_t val_len; bool val_utf8;
        if (!hashmap_i32s_take(self, key, &val, &val_len, &val_utf8)) XSRETURN_UNDEF;
        RETVAL = newSVpvn(val, val_len);
        if (val_utf8) SvUTF8_on(RETVAL);
        free((void*)val);
    OUTPUT:
        RETVAL

bool
exists(SV* self_sv, int32_t key)
    CODE:
        EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
        RETVAL = hashmap_i32s_exists(self, key);
    OUTPUT:
        RETVAL

size_t
size(SV* self_sv)
    CODE:
        EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
        RETVAL = self->size;
    OUTPUT:
        RETVAL

size_t
max_size(SV* self_sv)
    CODE:
        EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
        RETVAL = self->max_size;
    OUTPUT:
        RETVAL

UV
ttl(SV* self_sv)
    CODE:
        EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
        RETVAL = (UV)self->default_ttl;
    OUTPUT:
        RETVAL

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,
                                       HM_UNPACK_LEN(self->nodes[i].val_len));
                    if (HM_UNPACK_UTF8(self->nodes[i].val_len)) SvUTF8_on(vsv);
                    mXPUSHs(vsv);
                } else {
                    XPUSHs(&PL_sv_undef);
                }
                XSRETURN(2);
            }
        }
        self->iter_pos = 0;
        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));
                    if (HM_UNPACK_UTF8(self->nodes[i].val_len)) SvUTF8_on(sv);
                    mXPUSHs(sv);
                } else { XPUSHs(&PL_sv_undef); }
                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);
                if (self->nodes[idx].value) {
                    SV* sv = newSVpvn(self->nodes[idx].value, HM_UNPACK_LEN(self->nodes[idx].val_len));
                    if (HM_UNPACK_UTF8(self->nodes[idx].val_len)) SvUTF8_on(sv);
                    mXPUSHs(sv);
                } else { XPUSHs(&PL_sv_undef); }
                hashmap_i32s_lru_unlink(self, idx);
                hashmap_i32s_tombstone_at(self, idx);
                HM_MAYBE_COMPACT_XS(self, hashmap_i32s_compact);
                XSRETURN(2);
            }
            XSRETURN_EMPTY;
        } else {
            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 (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); }
                    hashmap_i32s_tombstone_at(self, i);
                    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);
                if (self->nodes[idx].value) {
                    SV* sv = newSVpvn(self->nodes[idx].value, HM_UNPACK_LEN(self->nodes[idx].val_len));
                    if (HM_UNPACK_UTF8(self->nodes[idx].val_len)) SvUTF8_on(sv);
                    mXPUSHs(sv);
                } else { XPUSHs(&PL_sv_undef); }
                hashmap_i32s_lru_unlink(self, idx);
                hashmap_i32s_tombstone_at(self, idx);
                HM_MAYBE_COMPACT_XS(self, hashmap_i32s_compact);
                XSRETURN(2);
            }
            XSRETURN_EMPTY;
        } else {
            if (self->iter_pos == 0) self->iter_pos = self->capacity;
            while (self->iter_pos > 0) {
                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 (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); }
                    hashmap_i32s_tombstone_at(self, i);
                    HM_MAYBE_COMPACT_XS(self, hashmap_i32s_compact);
                    XSRETURN(2);
                }
            }
            XSRETURN_EMPTY;
        }


void
clear(SV* self_sv)
    CODE:
        EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
        hashmap_i32s_clear(self);

void
reserve(SV* self_sv, UV count)
    CODE:
        EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
        if (!hashmap_i32s_reserve(self, (size_t)count))
            croak("Failed to reserve capacity");

void
purge(SV* self_sv)
    CODE:
        EXTRACT_MAP(HashMapI32S, stash_i32s, "Data::HashMap::I32S", self_sv);
        hashmap_i32s_purge(self);