File Coverage

/usr/local/lib/perl5/site_perl/5.26.1/x86_64-linux/Panda/XS.x/i/xs/xs-private.h

Criterion	Covered	Total	%
statement	14	26	53.8
branch	3	14	21.4
condition			n/a
subroutine			n/a
pod			n/a
total	17	40	42.5

#pragma once
#include

namespace xs { namespace _tm {

template
inline DOWN downgrade (UP* var) { return static_cast(var); }
template
inline DOWN downgrade (const panda::shared_ptr& sp) { return panda::static_pointer_cast(sp); }
template
inline DOWN downgrade (const panda::shared_ptr& sp) { return panda::static_pointer_cast(sp); }
template
inline DOWN downgrade (const std::shared_ptr& sp) { return std::static_pointer_cast(sp); }

template
inline UP upgrade (DOWN* var) { return panda::dyn_cast(var); }
template
inline UP upgrade (const panda::shared_ptr& sp) { return panda::dynamic_pointer_cast(sp); }
template
inline UP upgrade (const panda::shared_ptr& sp) { return panda::dynamic_pointer_cast(sp); }
template
inline UP upgrade (const std::shared_ptr& sp) { return std::dynamic_pointer_cast(sp); }


inline SV* out_oref (pTHX_ SV* var, HV* CLASS) {
    return var ? sv_bless(newRV_noinc(var), CLASS) : &PL_sv_undef;
}
inline SV* out_oref (pTHX_ SV* var, const char* CLASS) {
    return out_oref(aTHX_ var, gv_stashpvn(CLASS, strlen(CLASS), GV_ADD));
}
inline SV* out_oref (pTHX_ SV* var, SV* CLASS) {
    return out_oref(aTHX_ var, gv_stashsv(CLASS, GV_ADD));
}

inline SV* out_optr (pTHX_ void* var, HV* CLASS) {
    return var ? sv_bless(newRV_noinc(newSViv((IV)var)), CLASS) : &PL_sv_undef;
}
inline SV* out_optr (pTHX_ void* var, const char* CLASS) {
    return out_optr(aTHX_ var, gv_stashpvn(CLASS, strlen(CLASS), GV_ADD));
}
inline SV* out_optr (pTHX_ void* var, SV* CLASS) {
    return out_optr(aTHX_ var, gv_stashsv(CLASS, GV_ADD));
}

template
inline SV* out_optr (pTHX_ const panda::shared_ptr& sp, C CLASS) {
     if (sp) sp->retain();
     return out_optr(aTHX_ sp.get(), CLASS);
}

template
inline SV* out_optr (pTHX_ const panda::shared_ptr& sp, C CLASS) {
    return out_optr(aTHX_ new panda::shared_ptr(sp), CLASS);
}

template
inline SV* out_optr (pTHX_ const std::shared_ptr& sp, C CLASS) {
    return out_optr(aTHX_ new std::shared_ptr(sp), CLASS);
}



template
void* out_oext_mgp (T* varptr) { return varptr; }
template
void* out_oext_mgp (const panda::shared_ptr& sp) { if (sp) sp->retain(); return sp.get(); }
template
void* out_oext_mgp (const panda::shared_ptr& sp) { return new panda::shared_ptr(sp); }
template
void* out_oext_mgp (const std::shared_ptr& sp) { return new std::shared_ptr(sp); }

SV* _out_oext (pTHX_ SV* self, void* var, HV* CLASS, payload_marker_t* marker = NULL);
SV* _out_oext (pTHX_ SV* self, void* var, SV* CLASS, payload_marker_t* marker = NULL);
SV* _out_oext (pTHX_ SV* self, void* var, const char* CLASS, payload_marker_t* marker = NULL);

template
inline SV* out_oext (pTHX_ SV* self, T var, C CLASS, payload_marker_t* marker = NULL) {
     return _out_oext(aTHX_ self, out_oext_mgp(var), CLASS, marker);
}



template
inline void* in_optr (pTHX_ SV* arg, T* varptr) {
    if (sv_isobject(arg)) {
        SV* obj = SvRV(arg);
        if (SvIOK(obj)) {
            void* mgp = (void*)SvIVX(obj);
            *varptr = static_cast(mgp);
            return mgp;
        }
    }
    *varptr = NULL;
    return NULL;
}

template
inline void* in_optr (pTHX_ SV* arg, panda::shared_ptr* sptr) {
    void* mgp;
    in_optr(aTHX_ arg, &mgp);
    *sptr = static_cast(mgp);
    return mgp;
}

template
inline void* in_optr (pTHX_ SV* arg, panda::shared_ptr* sptr) {
    void* mgp;
    in_optr(aTHX_ arg, &mgp);
    *sptr = *(static_cast*>(mgp));
    return mgp;
}

template
inline void* in_optr (pTHX_ SV* arg, std::shared_ptr* sptr) {
    void* mgp;
    in_optr(aTHX_ arg, &mgp);
    *sptr = *(static_cast*>(mgp));
    return mgp;
}



template
inline void in_oext_mgp (T* varptr, void* mgp) { *varptr = static_cast(mgp); }
template
inline void in_oext_mgp (panda::shared_ptr* sptr, void* mgp) { *sptr = static_cast(mgp); }
template
inline void in_oext_mgp (panda::shared_ptr* sptr, void* mgp) { *sptr = *(static_cast*>(mgp)); }
template
inline void in_oext_mgp (std::shared_ptr* sptr, void* mgp) { *sptr = *(static_cast*>(mgp)); }

// set null only for pointers, not for shared pointers as they are already nulls on creation
template
inline void vnull (T** varptr) { *varptr = NULL; }
template
inline void vnull (T* varptr) { PERL_UNUSED_VAR(varptr); }

template
inline void* in_oext (pTHX_ SV* arg, T* varptr, payload_marker_t* marker = NULL) {
    if (SvROK(arg)) {
        void* mgp = rv_payload(aTHX_ arg, marker);
        if (mgp) {
            in_oext_mgp(varptr, mgp);
            return mgp;
        }
    }
    vnull(varptr);
    return NULL;
}


template
struct AutoRelease {
    T obj;
    AutoRelease (T obj) : obj(obj) {}
    ~AutoRelease () { xs::refcnt_dec(obj); }
};

template
struct AutoDelete {
    UP obj;
    AutoDelete (UP obj, void* /*mgp*/) : obj(obj) {}
    ~AutoDelete () { delete obj; }
};

// These destructors don't kill an object instantly, because it is possibly needed for user-defined XS DESTROY function code.
// local $var shared ptr holds it until the end of DESTROY XS function
// These funcs just decrease refcnt, so that local $var shared ptr becomes the last owner of the object.
template
struct AutoDelete, DOWN> {
    AutoDelete (const panda::shared_ptr& sp, void* /*mgp*/) { sp->release(); }
};

template
struct AutoDelete, DOWN> {
    AutoDelete (const panda::shared_ptr& /*sp*/, void* mgp) { delete static_cast*>(mgp); }
};

template
struct AutoDelete, DOWN> {
    AutoDelete (const std::shared_ptr& /*sp*/, void* mgp) { delete static_cast*>(mgp); }
};

template
xs::XSBackref* get_xsbr (T var) { return panda::dyn_cast(var); }
template
xs::XSBackref* get_xsbr (panda::shared_ptr& var) { return panda::dyn_cast(var.get()); }
template
xs::XSBackref* get_xsbr (panda::shared_ptr& var) { return panda::dyn_cast(var.get()); }
template
xs::XSBackref* get_xsbr (std::shared_ptr& var) { return panda::dyn_cast(var.get()); }

template
T svdup_clone (pTHX_ T obj) { return obj->clone(); }
template
T svdup_retain (pTHX_ T obj) { xs::refcnt_inc(obj); return obj; }

}}