view release on metacpan or  search on metacpan

xs/Apache/DAV/Lock/Lock.xs  view on Meta::CPAN

void Apache__DAV__Lock_new_init (pTHX_ Apache__DAV__Lock  obj, SV * item, int overwrite) {

    SV * * tmpsv ;

    if (SvTYPE(item) == SVt_PVMG) 
        memcpy (obj, (void *)SvIVX(item), sizeof (*obj)) ;
    else if (SvTYPE(item) == SVt_PVHV) {
        if ((tmpsv = hv_fetch((HV *)item, "is_locknull", sizeof("is_locknull") - 1, 0)) || overwrite) {
            obj -> is_locknull = (int)davxs_sv2_IV((tmpsv && *tmpsv?*tmpsv:&PL_sv_undef)) ;
        }
        if ((tmpsv = hv_fetch((HV *)item, "depth", sizeof("depth") - 1, 0)) || overwrite) {
            obj -> depth = (int)davxs_sv2_IV((tmpsv && *tmpsv?*tmpsv:&PL_sv_undef)) ;
        }
        if ((tmpsv = hv_fetch((HV *)item, "timeout", sizeof("timeout") - 1, 0)) || overwrite) {
            obj -> timeout = (time_t)davxs_sv2_NV((tmpsv && *tmpsv?*tmpsv:&PL_sv_undef)) ;
        }
        if ((tmpsv = hv_fetch((HV *)item, "locktoken", sizeof("locktoken") - 1, 0)) || overwrite) {
            obj -> locktoken = (const dav_locktoken *)davxs_sv2_Apache__DAV__LockToken((tmpsv && *tmpsv?*tmpsv:&PL_sv_undef)) ;
        }
        if ((tmpsv = hv_fetch((HV *)item, "owner", sizeof("owner") - 1, 0)) || overwrite) {
            const char * tmpobj = ((const char *)davxs_sv2_PV((tmpsv && *tmpsv?*tmpsv:&PL_sv_undef)));
            if (tmpobj)
                obj -> owner = (const char *)strdup(tmpobj);
            else
                obj -> owner = NULL ;
        }
        if ((tmpsv = hv_fetch((HV *)item, "auth_user", sizeof("auth_user") - 1, 0)) || overwrite) {
            const char * tmpobj = ((const char *)davxs_sv2_PV((tmpsv && *tmpsv?*tmpsv:&PL_sv_undef)));
            if (tmpobj)
                obj -> auth_user = (const char *)strdup(tmpobj);
            else
                obj -> auth_user = NULL ;
        }
        if ((tmpsv = hv_fetch((HV *)item, "next", sizeof("next") - 1, 0)) || overwrite) {
            obj -> next = (struct dav_lock *)davxs_sv2_Apache__DAV__Lock((tmpsv && *tmpsv?*tmpsv:&PL_sv_undef)) ;
        }
   ; }

    else
        croak ("initializer for Apache::DAV::Lock::new is not a hash or object reference") ;

} ;


MODULE = Apache::DAV::Lock    PACKAGE = Apache::DAV::Lock 

Apache::DAV::LockRectype
rectype(obj, val=NULL)
    Apache::DAV::Lock obj
    Apache::DAV::LockRectype val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (Apache__DAV__LockRectype) & obj->rectype;
    if (items > 1) {
         croak ("rectype is read only") ;
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Lock    PACKAGE = Apache::DAV::Lock 

int
is_locknull(obj, val=0)
    Apache::DAV::Lock obj
    int val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (int)  obj->is_locknull;

    if (items > 1) {
        obj->is_locknull = (int) val;
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Lock    PACKAGE = Apache::DAV::Lock 

Apache::DAV::LockScope
scope(obj, val=NULL)
    Apache::DAV::Lock obj
    Apache::DAV::LockScope val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (Apache__DAV__LockScope) & obj->scope;
    if (items > 1) {
         croak ("scope is read only") ;
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Lock    PACKAGE = Apache::DAV::Lock 

Apache::DAV::LockType
type(obj, val=NULL)
    Apache::DAV::Lock obj
    Apache::DAV::LockType val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (Apache__DAV__LockType) & obj->type;
    if (items > 1) {
         croak ("type is read only") ;
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Lock    PACKAGE = Apache::DAV::Lock 

int
depth(obj, val=0)
    Apache::DAV::Lock obj
    int val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (int)  obj->depth;

    if (items > 1) {
        obj->depth = (int) val;
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Lock    PACKAGE = Apache::DAV::Lock 

time_t
timeout(obj, val=0)
    Apache::DAV::Lock obj
    time_t val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (time_t)  obj->timeout;

    if (items > 1) {
        obj->timeout = (time_t) val;
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Lock    PACKAGE = Apache::DAV::Lock 

Apache::DAV::LockToken
locktoken(obj, val=NULL)
    Apache::DAV::Lock obj
    Apache::DAV::LockToken val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (Apache__DAV__LockToken)  obj->locktoken;

    if (items > 1) {
        obj->locktoken = (Apache__DAV__LockToken) val;
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Lock    PACKAGE = Apache::DAV::Lock 

const char *
owner(obj, val=NULL)
    Apache::DAV::Lock obj
    const char * val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (const char *)  obj->owner;

    if (items > 1) {
        obj->owner = (const char *)strdup(val);
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Lock    PACKAGE = Apache::DAV::Lock 

const char *
auth_user(obj, val=NULL)
    Apache::DAV::Lock obj
    const char * val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (const char *)  obj->auth_user;

    if (items > 1) {
        obj->auth_user = (const char *)strdup(val);
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Lock    PACKAGE = Apache::DAV::Lock 

Apache::DAV::Lock
next(obj, val=NULL)
    Apache::DAV::Lock obj
    Apache::DAV::Lock val
  PREINIT:
    /*nada*/

  CODE:
    RETVAL = (Apache__DAV__Lock)  obj->next;

    if (items > 1) {
        obj->next = (Apache__DAV__Lock) val;
    }
  OUTPUT:
    RETVAL

MODULE = Apache::DAV::Lock    PACKAGE = Apache::DAV::Lock 



SV *
new (class,initializer=NULL)
    char * class
    SV * initializer 
PREINIT:
    SV * svobj ;
    Apache__DAV__Lock  cobj ;
    SV * tmpsv ;
CODE:
    davxs_Apache__DAV__Lock_create_obj(cobj,svobj,RETVAL,malloc(sizeof(*cobj))) ;

    if (initializer) {
        if (!SvROK(initializer) || !(tmpsv = SvRV(initializer))) 
            croak ("initializer for Apache::DAV::Lock::new is not a reference") ;

        if (SvTYPE(tmpsv) == SVt_PVHV || SvTYPE(tmpsv) == SVt_PVMG)  
            Apache__DAV__Lock_new_init (aTHX_ cobj, tmpsv, 0) ;
        else if (SvTYPE(tmpsv) == SVt_PVAV) {
            int i ;
            SvGROW(svobj, sizeof (*cobj) * av_len((AV *)tmpsv)) ;     
            for (i = 0; i <= av_len((AV *)tmpsv); i++) {
                SV * * itemrv = av_fetch((AV *)tmpsv, i, 0) ;
                SV * item ;
                if (!itemrv || !*itemrv || !SvROK(*itemrv) || !(item = SvRV(*itemrv))) 
                    croak ("array element of initializer for Apache::DAV::Lock::new is not a reference") ;
                Apache__DAV__Lock_new_init (aTHX_ &cobj[i], item, 1) ;
            }
        }
        else {
             croak ("initializer for Apache::DAV::Lock::new is not a hash/array/object reference") ;
        }
    }
OUTPUT:
    RETVAL 

PROTOTYPES: disabled

BOOT:
    items = items; /* -Wall */