File Coverage

xs/str.xs

Criterion	Covered	Total	%
statement	99	133	74.4
branch	89	248	35.8
condition			n/a
subroutine			n/a
pod			n/a
total	188	381	49.3

MODULE = Data::Buffer::Shared    PACKAGE = Data::Buffer::Shared::Str
PROTOTYPES: DISABLE

SV*
new(char* class, char* path, UV capacity, UV str_len, UV file_mode = 0600)
    CODE:
        char errbuf[BUF_ERR_BUFLEN];
        BufHandle* buf = buf_str_create(path, (uint64_t)capacity, (uint32_t)str_len, (mode_t)file_mode, errbuf);
        if (!buf) croak("Data::Buffer::Shared::Str: %s", errbuf[0] ? errbuf : "unknown error");
        RETVAL = sv_setref_pv(newSV(0), class, (void*)buf);
    OUTPUT:
        RETVAL

void
DESTROY(SV* self_sv)
    CODE:
        if (!SvROK(self_sv)) return;
        BufHandle* h = INT2PTR(BufHandle*, SvIV(SvRV(self_sv)));
        if (!h) return;
        sv_setiv(SvRV(self_sv), 0);
        buf_close_map(h);

SV*
get(SV* self_sv, UV idx)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        uint32_t esz = h->hdr->elem_size;
        char *tmp;
        Newx(tmp, esz + 1, char);
        SAVEFREEPV(tmp);
        uint32_t out_len;
        if (!buf_str_get(h, (uint64_t)idx, tmp, &out_len)) XSRETURN_UNDEF;
        RETVAL = newSVpvn(tmp, out_len);
    OUTPUT:
        RETVAL

bool
set(SV* self_sv, UV idx, SV* val_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        STRLEN vlen;
        const char *vstr = SvPV(val_sv, vlen);
        RETVAL = buf_str_set(h, (uint64_t)idx, vstr, (uint32_t)vlen);
    OUTPUT:
        RETVAL

void
slice(SV* self_sv, UV from, UV count)
    PPCODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        if (count == 0) XSRETURN_EMPTY;
        uint32_t esz = h->hdr->elem_size;
        char *tmp;
        Newx(tmp, count * esz, char);
        SAVEFREEPV(tmp);
        if (!buf_str_get_slice(h, (uint64_t)from, (uint64_t)count, tmp))
            croak("Data::Buffer::Shared::Str: slice out of bounds");
        EXTEND(SP, count);
        for (UV i = 0; i < count; i++) {
            char *elem = tmp + i * esz;
            uint32_t len = esz;
            while (len > 0 && elem[len - 1] == '\0') len--;
            mXPUSHp(elem, len);
        }

bool
set_slice(SV* self_sv, UV from, ...)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        UV count = items - 2;
        if (count == 0) XSRETURN(1);
        uint32_t esz = h->hdr->elem_size;
        char *tmp;
        Newxz(tmp, count * esz, char);
        SAVEFREEPV(tmp);
        for (UV i = 0; i < count; i++) {
            STRLEN vlen;
            const char *vstr = SvPV(ST(i + 2), vlen);
            uint32_t copy_len = (uint32_t)(vlen < esz ? vlen : esz);
            memcpy(tmp + i * esz, vstr, copy_len);
        }
        RETVAL = buf_str_set_slice(h, (uint64_t)from, (uint64_t)count, tmp);
    OUTPUT:
        RETVAL

void
fill(SV* self_sv, SV* val_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        STRLEN vlen;
        const char *vstr = SvPV(val_sv, vlen);
        buf_str_fill(h, vstr, (uint32_t)vlen);

UV
capacity(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        RETVAL = (UV)buf_str_capacity(h);
    OUTPUT:
        RETVAL

UV
mmap_size(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        RETVAL = (UV)buf_str_mmap_size(h);
    OUTPUT:
        RETVAL

UV
elem_size(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        RETVAL = (UV)buf_str_elem_size(h);
    OUTPUT:
        RETVAL

SV*
path(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        if (h->path) RETVAL = newSVpv(h->path, 0); else XSRETURN_UNDEF;
    OUTPUT:
        RETVAL

void
lock_wr(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        buf_str_lock_wr(h);

void
unlock_wr(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        buf_str_unlock_wr(h);

void
lock_rd(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        buf_str_lock_rd(h);

void
unlock_rd(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        buf_str_unlock_rd(h);

void
unlink(SV* self_or_class, ...)
    CODE:
        const char *p;
        if (SvROK(self_or_class)) {
            BufHandle* h = INT2PTR(BufHandle*, SvIV(SvRV(self_or_class)));
            if (h) { if (!h->path) croak("cannot unlink anonymous buffer"); p = h->path; }
            else croak("Data::Buffer::Shared::Str: destroyed object");
        } else {
            if (items < 2) croak("Usage: Data::Buffer::Shared::Str->unlink($path)");
            p = SvPV_nolen(ST(1));
        }
        if (unlink(p) != 0) croak("unlink(%s): %s", p, strerror(errno));

UV
ptr(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        RETVAL = PTR2UV(buf_str_ptr(h));
    OUTPUT:
        RETVAL

UV
ptr_at(SV* self_sv, UV idx)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        void *p = buf_str_ptr_at(h, (uint64_t)idx);
        if (!p) croak("Data::Buffer::Shared::Str: index out of bounds");
        RETVAL = PTR2UV(p);
    OUTPUT:
        RETVAL

SV*
new_anon(char* class, UV capacity, UV str_len)
    CODE:
        char errbuf[BUF_ERR_BUFLEN];
        BufHandle* buf = buf_str_create_anon((uint64_t)capacity, (uint32_t)str_len, errbuf);
        if (!buf) croak("Data::Buffer::Shared::Str: %s", errbuf[0] ? errbuf : "unknown error");
        RETVAL = sv_setref_pv(newSV(0), class, (void*)buf);
    OUTPUT:
        RETVAL

void
clear(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        buf_str_clear(h);

SV*
get_raw(SV* self_sv, UV byte_off, UV nbytes)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        RETVAL = newSV(nbytes ? nbytes : 1);
        SvPOK_on(RETVAL);
        SvCUR_set(RETVAL, nbytes);
        if (nbytes) SvPVX(RETVAL)[nbytes] = '\0';  /* NUL-terminate; newSV reserved nbytes+1 */
        if (!buf_str_get_raw(h, (uint64_t)byte_off, (uint64_t)nbytes, SvPVX(RETVAL))) {
            SvREFCNT_dec(RETVAL);
            croak("Data::Buffer::Shared::Str: get_raw out of bounds");
        }
    OUTPUT:
        RETVAL

bool
set_raw(SV* self_sv, UV byte_off, SV* data_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        STRLEN dlen;
        const char *dptr = SvPV(data_sv, dlen);
        RETVAL = buf_str_set_raw(h, (uint64_t)byte_off, (uint64_t)dlen, dptr);
    OUTPUT:
        RETVAL

SV*
new_memfd(char* class, char* name, UV capacity, UV str_len)
    CODE:
        char errbuf[BUF_ERR_BUFLEN];
        BufHandle* buf = buf_str_create_memfd(name, (uint64_t)capacity, (uint32_t)str_len, errbuf);
        if (!buf) croak("Data::Buffer::Shared::Str: %s", errbuf[0] ? errbuf : "unknown error");
        RETVAL = sv_setref_pv(newSV(0), class, (void*)buf);
    OUTPUT:
        RETVAL

SV*
new_from_fd(char* class, int fd, UV str_len)
    CODE:
        char errbuf[BUF_ERR_BUFLEN];
        BufHandle* buf = buf_str_open_fd(fd, (uint32_t)str_len, errbuf);
        if (!buf) croak("Data::Buffer::Shared::Str: %s", errbuf[0] ? errbuf : "unknown error");
        RETVAL = sv_setref_pv(newSV(0), class, (void*)buf);
    OUTPUT:
        RETVAL

SV*
fd(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        if (h->fd < 0) XSRETURN_UNDEF;
        RETVAL = newSViv(h->fd);
    OUTPUT:
        RETVAL

SV*
as_scalar(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        size_t len = (size_t)(h->hdr->capacity * h->hdr->elem_size);
        SV *inner = newSV_type(SVt_PV);
        SvPV_set(inner, (char *)h->data);
        SvCUR_set(inner, len);
        SvLEN_set(inner, 0);
        SvPOK_on(inner);
        SvREADONLY_on(inner);
        MAGIC *mg = sv_magicext(inner, NULL, PERL_MAGIC_ext, &buf_scalar_magic_vtbl, NULL, 0);
        mg->mg_obj = SvREFCNT_inc_simple_NN(self_sv);
        RETVAL = newRV_noinc(inner);
    OUTPUT:
        RETVAL

IV
create_eventfd(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        RETVAL = (IV)buf_create_eventfd(h);
        if (RETVAL < 0) croak("Data::Buffer::Shared::Str: eventfd: %s", strerror(errno));
    OUTPUT:
        RETVAL

void
attach_eventfd(SV* self_sv, int efd)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        buf_attach_eventfd(h, efd);

SV*
eventfd(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        if (h->efd < 0) XSRETURN_UNDEF;
        RETVAL = newSViv(h->efd);
    OUTPUT:
        RETVAL

bool
notify(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        RETVAL = buf_notify(h);
    OUTPUT:
        RETVAL

SV*
wait_notify(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        int64_t val = buf_wait_notify(h);
        if (val < 0) XSRETURN_UNDEF;
        RETVAL = newSViv(val);
    OUTPUT:
        RETVAL

void
sync(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        if (buf_msync(h) != 0) croak("Data::Buffer::Shared::Str sync: %s", strerror(errno));

SV*
stats(SV* self_sv)
    CODE:
        EXTRACT_BUF("Data::Buffer::Shared::Str", self_sv);
        HV *hv = newHV();
        hv_store(hv, "capacity",   8, newSVuv((UV)h->hdr->capacity), 0);
        hv_store(hv, "elem_size",  9, newSVuv((UV)h->hdr->elem_size), 0);
        hv_store(hv, "mmap_size",  9, newSVuv((UV)h->mmap_size), 0);
        hv_store(hv, "variant_id",10, newSVuv((UV)h->hdr->variant_id), 0);
        hv_store(hv, "recoveries",10, newSVuv((UV)__atomic_load_n(&h->hdr->stat_recoveries, __ATOMIC_RELAXED)), 0);
        RETVAL = newRV_noinc((SV*)hv);
    OUTPUT:
        RETVAL