PPCODE results from the CPAN

PPCODE

ObjStore

view release on metacpan or search on metacpan

void OSPV_Cursor::next()
{ NOTFOUND("next"); }

// These APIs should be non-type specific! XXX

MODULE = ObjStore::CORE	PACKAGE = ObjStore

void
_inuse_bridges(...)
	PROTOTYPE: ;$
	PPCODE:
	IV show = items>0? sv_true(ST(0)) : 0;
	IV cnt=0;
#if OSP_BRIDGE_TRACE
	osp_bridge *br = (osp_bridge*) osp_bridge::All.next_self();
	while (br) {
	  if (show) {
	    SV *sv = sv_2mortal(newSVpv("",0));
	    sv_catpvf(sv,"[%d]osp_bridge 0x%x\n", cnt, br);
	    sv_catpvf(sv,"  refs         : %d\n", br->refs);
	    sv_catpvf(sv,"  detached     : %d\n", br->detached);

API/Core.xs view on Meta::CPAN

	if (show) warn("_inuse_bridges detail is not available");
	XPUSHs(sv_2mortal(newSViv(osp_bridge::Inuse)));
#endif

MODULE = ObjStore::CORE	PACKAGE = ObjStore::UNIVERSAL

void
OSSVPV::_new_ref(type, sv1)
	int type;
	SV *sv1;
	PPCODE:
	PUTBACK;
	os_segment *seg = osp_thr::sv_2segment(sv1);
	SV *ret;
	OSSVPV *tpv;
	if (type == 0) {
	  NEW_OS_OBJECT(tpv, seg, OSPV_Ref2_protect::get_os_typespec(),
			OSPV_Ref2_protect(THIS));
	  ret = osp_thr::ospv_2sv(tpv, 1);
	} else if (type == 1) {
	  NEW_OS_OBJECT(tpv, seg, OSPV_Ref2_hard::get_os_typespec(),

API/Core.xs view on Meta::CPAN


MODULE = ObjStore::CORE	PACKAGE = ObjStore::Ref

void
_load(CLASS, sv1, type, dump, db)
	SV *CLASS;
	SV *sv1;
	int type;
	char *dump;
	os_database *db;
	PPCODE:
	PUTBACK;
	os_segment *seg = osp_thr::sv_2segment(sv1);
	OSPV_Ref2 *ref;
	if (type == 0) {
	  ref = new (seg, OSPV_Ref2_protect::get_os_typespec())
			OSPV_Ref2_protect(dump, db);
	} else if (type == 1) {
	  ref = new (seg, OSPV_Ref2_hard::get_os_typespec())
			OSPV_Ref2_hard(dump, db);
	} else { croak("OSSVPV->_load(): unknown type"); }

API/Core.xs view on Meta::CPAN

	  char *str = SvPV(side, PL_na);
	  if (strEQ(str, "end")) THIS->seek_pole(1);
	  else warn("%p->moveto(%s): undefined", THIS, str);
	} else if (SvIOK(side)) {
	  if (SvIV(side)==0 || SvIV(side)==-1) THIS->seek_pole(0);
	  else warn("%p->moveto(%d): unsupported", THIS, SvIV(side));
	} else croak("moveto");

void
OSPV_Cursor::at()
	PPCODE:
	PUTBACK; THIS->at(); return;

void
OSPV_Cursor::next()
	PPCODE:
	PUTBACK; THIS->next(); return;

#-----------------------------# Ref

MODULE = ObjStore::CORE	PACKAGE = ObjStore::DEPRECIATED::Ref

os_database *
OSPV_Ref::get_database()
	PREINIT:
	char *CLASS = "ObjStore::Database";

int
OSPV_Ref::deleted()

void
OSPV_Ref::focus()
	PPCODE:
	PUTBACK;
	SV *sv = osp_thr::ospv_2sv(THIS->focus());
	SPAGAIN;
	XPUSHs(sv);

Main/ObjStore.xs view on Meta::CPAN

#include "osp-preamble.h"
#include "osperl.h"

/*

void
readonly(sv)
	SV *sv
	PPCODE:
	if (!sv || !SvANY(sv)) XSRETURN_NO;
	if (SvREADONLY(sv)) XSRETURN_YES;
	XSRETURN_NO;


*/

// A few bits of the ObjectStore API are callable outside a
// transaction.  We need to wrap each of these in OSP_START0
// & OSP_END0

Main/ObjStore.xs view on Meta::CPAN

  osp_thr::register_schema("ObjStore", &ObjStore_dll_schema_info);
//
  newXSproto("ObjStore::translate", XS_ObjStore_translate, file, "$$");
//
  HV *szof = perl_get_hv("ObjStore::sizeof", TRUE);


void
_mark_method(sub)
	SV *sub
	PPCODE:
#ifdef CVf_METHOD
	if (SvROK(sub)) {
	    sub = SvRV(sub);
	    if (SvTYPE(sub) != SVt_PVCV)
		sub = Nullsv;
	} else {
	    char *name = SvPV(sub, PL_na);
	    sub = (SV*)perl_get_cv(name, FALSE);
	}
	if (!sub)

Main/ObjStore.xs view on Meta::CPAN


void
_sv_dump_on_error(yes)
	int yes;
	CODE:
	osp_thr::sv_dump_on_error = yes;

void
reftype(ref)
	SV *ref
	PPCODE:
	if (!SvROK(ref)) XSRETURN_NO;
	ref = SvRV(ref);
	XSRETURN_PV(sv_reftype(ref, 0));

void
blessed(sv)
	SV *sv
	PPCODE:
	if(!sv_isobject(sv))  /*snarfed from builtin:GBARR*/
	  XSRETURN_UNDEF;
	XSRETURN_PV(sv_reftype(SvRV(sv),TRUE));

void
_sv_dump(sv)
	SV *sv
	CODE:
	Perl_sv_dump(sv);

void
_debug(mask)
	int mask
	PPCODE:
	dOSP ;
	int old = osp->debug;
	osp->debug = mask;
	XSRETURN_IV(old);


char *
_SEGV_reason()
	PPCODE:
	dOSP;
	if (!osp->report) XSRETURN_UNDEF;
#ifndef _OS_CPP_EXCEPTIONS
	osp->hand->hand._unwind_part_1(osp->cause, osp->value, osp->report);
#endif
	SAVEDESTRUCTOR(osp_unwind_part2, osp);
	XPUSHs(sv_2mortal(newSVpv(osp->report, 0)));
	osp->cause = 0;
	osp->value = 0;
	osp->report = 0;

Main/ObjStore.xs view on Meta::CPAN

SV *
set_stargate(code)
	SV *code
	CODE:
	ST(0) = osp_thr::stargate? sv_mortalcopy(osp_thr::stargate):&PL_sv_undef;
	if (!osp_thr::stargate) { osp_thr::stargate = newSVsv(code); }
	else { sv_setsv(osp_thr::stargate, code); }

void
release_name()
	PPCODE:
	XSRETURN_PV((char*) objectstore::release_name());

void
os_version()
	PPCODE:
	// (rad perl style version number... :-)
	XSRETURN_NV(objectstore::release_major() + objectstore::release_minor()/100 + objectstore::release_maintenance()/10000);

double
get_unassigned_address_space()
	CODE:
	RETVAL = objectstore::get_unassigned_address_space(); //64bit? XXX
	OUTPUT:
	RETVAL

Main/ObjStore.xs view on Meta::CPAN

	RETVAL

void
_typemap_any_destroy(obj)
	SV *obj
	CODE:
	typemap_any::decode(obj,1);

int
_typemap_any_count()
	PPCODE:
	XPUSHs(sv_2mortal(newSViv(typemap_any::Instances)));

void
get_page_size()
	PPCODE:
	XSRETURN_IV(objectstore::get_page_size());

os_database *
_lookup(path, mode)
	char *path;
	int mode;
	CODE:
	char *CLASS = ObjStore_Database;
	RETVAL = os_database::lookup(path, mode);
	RETVAL->set_check_illegal_pointers(1);

Main/ObjStore.xs view on Meta::CPAN


int
return_all_pages()
	CODE:
	RETVAL = objectstore::return_all_pages();
	OUTPUT:
	RETVAL

void
get_all_servers()
	PPCODE:
	char *CLASS = "ObjStore::Server";
	os_int32 num = objectstore::get_n_servers();
	if (num == 0) XSRETURN_EMPTY;
	os_server_p *svrs = new os_server_p[num];
	SAVEDESTRUCTOR(save_cxxvdelete, svrs);
	objectstore::get_all_servers(num, svrs, num);
	EXTEND(sp, num);
	int xx;
	for (xx=0; xx < num; xx++) {
	  PUSHs(sv_2mortal(osp_thr::any_2sv(svrs[xx], CLASS)));

Main/ObjStore.xs view on Meta::CPAN

os_DLL_schema_info::unload()
	CODE:
	THIS->DLL_unloaded();

#-----------------------------# Notification

MODULE = ObjStore	PACKAGE = ObjStore

void
subscribe(...)
	PPCODE:
	PUTBACK;
	if (items == 0) return;
	os_subscription *subs = new os_subscription[items];
	SAVEDESTRUCTOR(save_cxxvdelete, subs);
	for (int xa=0; xa < items; xa++) {
	  ospv_bridge *br = osp_thr::sv_2bridge(ST(xa), 1);
	  subs[xa].assign(br->ospv());
	}
	os_notification::subscribe(subs, items);
	return;

void
unsubscribe(...)
	PPCODE:
	PUTBACK;
	if (items == 0) return;
	os_subscription *subs = new os_subscription[items];
	SAVEDESTRUCTOR(save_cxxvdelete, subs);
	for (int xa=0; xa < items; xa++) {
	  ospv_bridge *br = osp_thr::sv_2bridge(ST(xa), 1);
	  subs[xa].assign(br->ospv());
	}
	os_notification::unsubscribe(subs, items);
	return;

Main/ObjStore.xs view on Meta::CPAN

MODULE = ObjStore	PACKAGE = ObjStore::Notification

PROTOTYPES: DISABLE

static void
os_notification::set_queue_size(size)
	int size;

static void
os_notification::queue_status()
	PPCODE:
	os_unsigned_int32 sz, pend, over;
	os_notification::queue_status(sz, pend, over);
	EXTEND(SP, 3);
	PUSHs(sv_2mortal(newSViv(sz)));
	PUSHs(sv_2mortal(newSViv(pend)));
	PUSHs(sv_2mortal(newSViv(over)));

static int
os_notification::_get_fd()

static void
os_notification::receive(...)
	PROTOTYPE: $;$
	PPCODE:
	os_int32 timeout = -1;
	if (items > 1) timeout = SvNV(ST(1)) * 1000;
	os_notification *note;
	if (os_notification::receive(note, timeout)) {
	  XPUSHs(sv_2mortal(osp_thr::any_2sv(note, "ObjStore::Notification")));
	} else {
	  XPUSHs(&PL_sv_undef);
	}

void
os_notification::_get_database()
	PPCODE:
	XPUSHs(sv_2mortal(osp_thr::any_2sv(THIS->get_database(),
		 "ObjStore::Database")));

void
os_notification::focus()
	PPCODE:
	PUTBACK;
	SV *ret;
	ret = osp_thr::ospv_2sv((OSSVPV *) THIS->get_reference().resolve());
	SPAGAIN;
	XPUSHs(ret);

void
os_notification::why()
	PPCODE:
	char *str = (char*) THIS->get_string();
	assert(str);
	// number slot is reserved
	XPUSHs(sv_2mortal(newSVpv(str, 0)));

void
DESTROY(obj)
	SV *obj
	CODE:
	delete (os_notification *) typemap_any::decode(obj,1);

Main/ObjStore.xs view on Meta::CPAN

	if (now) os_notification::notify_immediate(&note, 1);
	else     os_notification::notify_on_commit(&note, 1);

#-----------------------------# Transaction

MODULE = ObjStore	PACKAGE = ObjStore::Transaction

osp_txn *
new(...)
	PROTOTYPE: $;$$
	PPCODE:
	char *CLASS = "ObjStore::Transaction";
	os_transaction::transaction_type_enum tt;
	os_transaction::transaction_scope_enum scope;
	os_transaction *cur = os_transaction::get_current();
	if (!cur) {
	  tt = os_transaction::read_only;
	  scope = os_transaction::local;
	} else {
	  tt = cur->get_type();
	  scope = cur->get_scope();

Main/ObjStore.xs view on Meta::CPAN

	XPUSHs(sv_2mortal(SvREFCNT_inc(*tsv)));

void
DESTROY(obj)
	SV *obj
	CODE:
	delete (osp_txn *) typemap_any::decode(obj,1);

void
osp_txn::top_level()
	PPCODE:
	XSRETURN_IV(AvFILL(osp_thr::TXStack) == -1);

bool
osp_txn::is_aborted()

void
osp_txn::abort()

void
osp_txn::commit()

void
osp_txn::checkpoint()

void
osp_txn::name(...)
	PROTOTYPE: $;$
	PPCODE:
	if (!THIS->os) XSRETURN_UNDEF;
	if (items == 2) {
	  THIS->os->set_name(SvPV(ST(1), PL_na));
	} else {
	  char *str = THIS->os->get_name();
	  XPUSHs(newSVpv(str, 0));
	  delete str;
	}

void
osp_txn::post_transaction()

void
get_current()
	PPCODE:
	if (av_len(osp_thr::TXStack) == -1) XSRETURN_UNDEF;
	SV **tsv = av_fetch(osp_thr::TXStack, av_len(osp_thr::TXStack), 0);
	assert(tsv);
	XPUSHs(sv_mortalcopy(*tsv));

void
osp_txn::get_type()
	PPCODE:
	switch (THIS->tt) {
	case os_transaction::abort_only: XSRETURN_PV("abort_only");
	case os_transaction::read_only: XSRETURN_PV("read");
	case os_transaction::update: XSRETURN_PV("update");
	}
	croak("os_transaction::get_type(): unknown transaction type");

MODULE = ObjStore	PACKAGE = ObjStore

void

Main/ObjStore.xs view on Meta::CPAN

	case os_write_lock: RETVAL = "write"; break;
	default: XSRETURN_NO;
	}
	OUTPUT:
	RETVAL

void
lock_timeout(rw,...)
	char *rw;
	PROTOTYPE: $;$
	PPCODE:
	// ODI went COMPLETELY OVERBOARD optimizing this API...  :-)
	int is_read=-1;
	if (strEQ(rw,"read")) is_read=1;
	else if (strEQ(rw,"write")) is_read=0;
	if (is_read==-1) croak("lock_timeout: read or write?");
	if (items == 1) {
	  int tm = (is_read ?
		objectstore::get_readlock_timeout() :
		objectstore::get_writelock_timeout());
	  if (tm == -1) { XSRETURN_UNDEF; }

Main/ObjStore.xs view on Meta::CPAN

os_server::connection_is_broken()

void
os_server::disconnect()

void
os_server::reconnect()

void
os_server::get_databases()
	PPCODE:
	char *CLASS = ObjStore_Database;
	os_int32 num = THIS->get_n_databases();
	assert(num > 0);  //?
	os_database_p *dbs = new os_database_p[num];
	SAVEDESTRUCTOR(save_cxxvdelete, dbs);
	THIS->get_databases(num, dbs, num);
	EXTEND(sp, num);
	int xx;
	for (xx=0; xx < num; xx++) {
	  PUSHs(sv_2mortal(osp_thr::any_2sv(dbs[xx], CLASS)));

Main/ObjStore.xs view on Meta::CPAN

	CODE:
	RETVAL = os_database::get_n_databases();
	OUTPUT:
	RETVAL

MODULE = ObjStore	PACKAGE = ObjStore::Database

void
os_database::_open(read_only)
	int read_only
	PPCODE:
	THIS->open(read_only);
	XSRETURN_YES;

void
os_database::_open_mvcc()
	PPCODE:
	THIS->open_mvcc();
	XSRETURN_YES;

void
os_database::close()
	CODE:
	/*warn("%p=ObjStore::Database->close()", THIS); /*XXX*/
	THIS->close();

void
os_database::_destroy()
	CODE:
	THIS->destroy();

void
os_database::get_host_name()
	PPCODE:
	char *path = THIS->get_host_name();
	XPUSHs(sv_2mortal(newSVpv(path, 0)));
	delete path;

void
os_database::get_pathname()
	PPCODE:
	char *path = THIS->get_pathname();
	XPUSHs(sv_2mortal(newSVpv(path, 0)));
	delete path;

void
os_database::get_relative_directory()
	PPCODE:
	char *path = THIS->get_relative_directory();
	if (!path) XSRETURN_UNDEF;
	XPUSHs(sv_2mortal(newSVpv(path, 0)));
	delete path;

void
os_database::get_id(...)
	PPCODE:
	os_database_id *id = THIS->get_id();
	XPUSHs(sv_2mortal(newSVpvf("%08p%08p%08p",id->word0,id->word1,id->word2)));

int
os_database::get_default_segment_size()

int
os_database::get_sector_size()

int

Main/ObjStore.xs view on Meta::CPAN

	CODE:
	if (THIS->is_open_mvcc()) RETVAL = "mvcc";
	else if (THIS->is_open_read_only()) RETVAL = "read";
	else if (THIS->is_open()) RETVAL = "update";
	else XSRETURN_NO;
	OUTPUT:
	RETVAL

void
os_database::is_writable()
	PPCODE:
	// not ODI spec; but more useful
	if (THIS->is_open_read_only()) XSRETURN_NO;
	osp_txn *txn = osp_txn::current();
	if (txn && txn->tt == os_transaction::read_only) XSRETURN_NO;
	XSRETURN_YES;

void
os_database::set_fetch_policy(policy, ...)
	char *policy;
	PROTOTYPE: $;$

Main/ObjStore.xs view on Meta::CPAN

os_database::get_segment(num)
	int num
	CODE:
	char *CLASS = ObjStore_Segment;
	RETVAL = THIS->get_segment(num);
	OUTPUT:
	RETVAL

void
os_database::get_all_segments()
	PPCODE:
	char *CLASS = ObjStore_Segment;
	os_int32 num = THIS->get_n_segments();
	assert(num > 0); //?ok
	os_segment_p *segs = new os_segment_p[num];
	SAVEDESTRUCTOR(save_cxxvdelete, segs);
	THIS->get_all_segments(num, segs, num);
	EXTEND(sp, num);
	int xx;
	for (xx=0; xx < num; xx++) {
	  PUSHs(sv_2mortal(osp_thr::any_2sv(segs[xx], CLASS)));
	}

void
os_database::_PRIVATE_ROOT()
	PPCODE:
	osp_txn *txn = osp_txn::current();
	os_database_root *rt = THIS->find_root(private_root_name);
	if (!rt && txn && txn->can_update(THIS)) {
	  rt = THIS->create_root(private_root_name);
	  rt->set_value(0, OSSV::get_os_typespec());
	}
	XPUSHs(sv_2mortal(osp_thr::any_2sv(rt, "ObjStore::Root")));

void
os_database::get_all_roots()
	PPCODE:
	char *CLASS = "ObjStore::Root";
	os_int32 num = THIS->get_n_roots();
	if (num == 0) XSRETURN_EMPTY;
	os_database_root_p *roots = new os_database_root_p[num];
	THIS->get_all_roots(num, roots, num);
	for (int xx=0; xx < num; xx++) {
	  assert(roots[xx]);
	  char *nm = roots[xx]->get_name();
	  int priv = strEQ(nm, private_root_name);
	  if (!priv) XPUSHs(sv_2mortal(osp_thr::any_2sv(roots[xx], CLASS)));

Main/ObjStore.xs view on Meta::CPAN

	DEBUG_root(warn("%p->destroy_root()", THIS));
	OSSV *old = (OSSV*) THIS->get_value();
	if (old) delete old;
	delete THIS;

char *
os_database_root::get_name()

void
os_database_root::get_value()
	PPCODE:
	PUTBACK ;
	OSSV *ossv = (OSSV*) THIS->get_value(OSSV::get_os_typespec());
	DEBUG_root(warn("%p->get_value() = OSSV=%p", THIS, ossv));
	SV *ret;
	ret = osp_thr::ossv_2sv(ossv);
	SPAGAIN ;
	XPUSHs(ret);

void
os_database_root::set_value(sv)
	SV *sv
	PPCODE:
	PUTBACK ;
	os_segment *WHERE = os_database::of(THIS)->get_default_segment();
	OSSVPV *pv=0;
	ospv_bridge *br = osp_thr::sv_2bridge(sv, 1, WHERE);
	pv = br->ospv();
	// Disallow scalars in roots because it is fairly useless and messy.
	OSSV *ossv = (OSSV*) THIS->get_value(OSSV::get_os_typespec());
	if (ossv) {
	  DEBUG_root(warn("%p->set_value(): OSSV(%p)=%p", THIS, ossv, pv));
	  ossv->s(pv);

Main/ObjStore.xs view on Meta::CPAN

os_segment::set_comment(info)
	char *info
	CODE:
	char short_info[32];
	strncpy(short_info, info, 31);
	short_info[31] = 0;
	THIS->set_comment(short_info);

void
os_segment::get_comment()
	PPCODE:
	char *cm = THIS->get_comment();
	XPUSHs(sv_2mortal(newSVpv(cm, 0)));
	delete cm;

void
os_segment::lock_into_cache()

void
os_segment::unlock_from_cache()

Main/ObjStore.xs view on Meta::CPAN

	// This is a bit sloppy but it will be fixed when the typemap
	// is re-implemented.
	if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVMG) {
	  ospv_bridge *br = osp_thr::sv_2bridge(sv, 1);
	  br->leave_perl();
	}

void
OSSVPV::DELETED(...)
	PROTOTYPE: $;$
	PPCODE:
	STRLEN len;
	if (items == 1)
	  XPUSHs(boolSV(OSPvDELETED(THIS)));
	else if (items == 2) {
	  if (sv_true(ST(1)))
	    OSPvDELETED_on(THIS);
	  else if (OSPvDELETED(THIS))
	    croak("Cannot undelete OSSVPV=0x%p os_class='%s' rep_class='%s'",
		THIS, THIS->os_class(&len), THIS->rep_class(&len));
	}

Main/ObjStore.xs view on Meta::CPAN

	CODE:
	ospv_bridge *br = osp_thr::sv_2bridge(sv, 0);
	RETVAL = br && os_segment::of(br->ospv()) != os_segment::of(0);
	OUTPUT:
	RETVAL

void
_pstringify(THIS, ...)
	SV *THIS;
	PROTOTYPE: $;$$
	PPCODE:
	ospv_bridge *br = osp_thr::sv_2bridge(THIS, 0);
	SV *ret;
	if (!br) {
	  STRLEN len;
	  int amagic = SvAMAGIC(THIS);  // concurrency problem? XXX
	  SvAMAGIC_off(THIS);
	  char *str = sv_2pv(THIS, &len);
	  if (amagic) SvAMAGIC_on(THIS);
	  assert(str);
	  ret = newSVpv(str, len);

Main/ObjStore.xs view on Meta::CPAN

	  //char *CLASS = br->ospv()->blessed_to(&CLEN);
	  //
	  //optimize!! XXX
	  ret = newSVpvf("%s=%s(0x%p)",	HvNAME(SvSTASH(SvRV(THIS))),
			 sv_reftype(SvRV(THIS), 0), br->ospv());
	}
	XPUSHs(sv_2mortal(ret));

void
_pnumify(...)
	PPCODE:
	int max = items <= 2? items : 2;
	IV ret=0;
	for (int sx=0; sx < max; sx++) {
	  SV *sv = ST(sx);
	  if (SvGMAGICAL(sv))
	    mg_get(sv);
	  if (!SvOK(sv))
	    continue;
	  if (!SvROK(sv)) {
	    if (SvIOKp(sv) || SvIOK(sv)) {

Main/ObjStore.xs view on Meta::CPAN

	ospv_bridge *b2 = osp_thr::sv_2bridge(a2, 0);
	if (!b1 || !b2) XSRETURN_YES;
	//warn("b1=%p b2=%p", b1->ospv(), b2->ospv());
	RETVAL = b1->ospv() != b2->ospv();
	OUTPUT:
	RETVAL

void
OSSVPV::_debug(yes)
	int yes;
	PPCODE:
	BrDEBUG_set(THIS_bridge, yes);

void
OSSVPV::_refcnt()
	PPCODE:
	XPUSHs(sv_2mortal(newSViv(THIS->_refs)));

void
OSSVPV::_blessto_slot(...)
	PROTOTYPE: ;$
	PPCODE:
	PUTBACK;
	// only persistent objects get a persistent blessing
	// so this code does not leak memory
	if (items == 2) {
	  ospv_bridge *br = osp_thr::sv_2bridge(ST(1), 1);
	  OSSVPV *nval = (OSSVPV*) br->ospv();
	  nval->REF_inc();
	  if (OSPvBLESS2(THIS) && THIS->classname)
	    ((OSSVPV*)THIS->classname)->REF_dec();
	  OSPvBLESS2_on(THIS);

Main/ObjStore.xs view on Meta::CPAN

os_segment *
OSSVPV::segment_of()
	CODE:
	char *CLASS = ObjStore_Segment;
	RETVAL = os_segment::of(THIS);
	OUTPUT:
	RETVAL

void
OSSVPV::os_class()
	PPCODE:
	STRLEN len;
	char *str = THIS->os_class(&len);
	XPUSHs(sv_2mortal(newSVpv(str, len)));

void
OSSVPV::rep_class()
	PPCODE:
	STRLEN len;
	char *str = THIS->rep_class(&len);
	XPUSHs(sv_2mortal(newSVpv(str, len)));

void
OSSVPV::get_pointer_numbers()
	PPCODE:
	os_unsigned_int32 n1,n2,n3;
	objectstore::get_pointer_numbers(THIS, n1, n2, n3);
	XPUSHs(sv_2mortal(newSVpvf("%08p%08p", n1, n3)));

void
OSSVPV::HOLD()
	PPCODE:
	THIS_bridge->hold();
	if (GIMME_V != G_VOID) XPUSHs(sv_mortalcopy(ST(0))); //?

void
OSSVPV::const()
	PPCODE:
	THIS->make_constant();

#-----------------------------# Container

MODULE = ObjStore	PACKAGE = ObjStore::Container

double
OSPV_Container::_percent_filled()
	CODE:
	warn("_percent_filled is experimental");
	RETVAL = THIS->_percent_filled();
	if (RETVAL < 0 || RETVAL > 1) XSRETURN_UNDEF;
	OUTPUT:
	RETVAL

void
OSPV_Container::_new_cursor(sv1)
	SV *sv1;
	PPCODE:
	PUTBACK;
	os_segment *seg = osp_thr::sv_2segment(sv1);
	SV *ret = osp_thr::ospv_2sv(THIS->new_cursor(seg), 1);
	SPAGAIN;
	XPUSHs(ret);

void
OSPV_Container::POSH_CD(keyish)
	SV *keyish
	PPCODE:
	PUTBACK;
	THIS->POSH_CD(keyish);
	return;

int
OSPV_Container::FETCHSIZE()

#-----------------------------# PathExam

MODULE = ObjStore	PACKAGE = ObjStore::PathExam

Main/ObjStore.xs view on Meta::CPAN


char *
osp_pathexam::stringify()
	CODE:
	RETVAL = THIS->kv_string();
	OUTPUT:
	RETVAL

void
osp_pathexam::keys()
	PPCODE:
	PUTBACK;
	THIS->push_keys();
	return;

void
osp_pathexam::load_target(pv)
	OSSVPV *pv;
	CODE:
	THIS->load_target('x', pv);

Main/ObjStore.xs view on Meta::CPAN

	OUTPUT:
	RETVAL

#-----------------------------# AV

MODULE = ObjStore	PACKAGE = ObjStore::AV

void
OSPV_Generic::FETCH(xx)
	SV *xx;
	PPCODE:
	PUTBACK;
	THIS->FETCH(xx);
	return;

void
OSPV_Generic::STORE(xx, nval)
	SV *xx;
	SV *nval;
	PPCODE:
	PUTBACK;
	if (SvGMAGICAL(nval))
	    mg_get(nval);
	THIS->STORE(xx, nval);
	return;

void
OSPV_Generic::CLEAR()

void
OSPV_Generic::POP()
	PPCODE:
	PUTBACK;
	THIS->POP();
	return;

void
OSPV_Generic::SHIFT()
	PPCODE:
	PUTBACK;
	THIS->SHIFT();
	return;

void
OSPV_Generic::PUSH(...)
	CODE:
	PUTBACK;
	THIS->PUSH(ax, items);
	SPAGAIN;

Main/ObjStore.xs view on Meta::CPAN

	}
	return;

#-----------------------------# HV

MODULE = ObjStore	PACKAGE = ObjStore::HV

void
OSPV_Generic::FETCH(key)
	SV *key;
	PPCODE:
	PUTBACK;
	THIS->FETCH(key);
	return;

void
OSPV_Generic::STORE(key, nval)
	SV *key;
	SV *nval;
	PPCODE:
	PUTBACK;
	THIS->STORE(key, nval);
	return;

void
OSPV_Generic::DELETE(key)
	SV *key
	PPCODE:
	PUTBACK;
	THIS->DELETE(key);
	return;

bool
OSPV_Generic::EXISTS(key)
	SV *key

void
OSPV_Generic::FIRSTKEY()
	PPCODE:
	PUTBACK;
	THIS->FIRST(&THIS_bridge->info);
	return;

void
OSPV_Generic::NEXTKEY(...)
	PPCODE:
	if (items > 2) croak("NEXTKEY: too many arguments");
	PUTBACK;
	THIS->NEXT(&THIS_bridge->info);
	return;

void
OSPV_Generic::CLEAR()

#-----------------------------# Index

Main/ObjStore.xs view on Meta::CPAN

void
OSPV_Generic::configure(...)
	CODE:
	// NOTE: This does not pop args off of the stack.
	THIS->configure(ax, items);
	return;

void
OSPV_Generic::add(sv)
	SV *sv;
	PPCODE:
	PUTBACK;
	ospv_bridge *br = osp_thr::sv_2bridge(sv, 1, os_segment::of(THIS));
	OSSVPV *pv = br->ospv();
	int added = THIS->add(pv);
	SPAGAIN;
	if (added && GIMME_V != G_VOID) {
	  PUSHs(osp_thr::ospv_2sv(pv));
	}

void
OSPV_Generic::remove(sv)
	SV *sv
	PPCODE:
	PUTBACK;
	ospv_bridge *br = osp_thr::sv_2bridge(sv, 1);
	int rmd = THIS->remove(br->ospv());
	SPAGAIN;
	XPUSHs(boolSV(rmd));

#-----------------------------# Ref

MODULE = ObjStore	PACKAGE = ObjStore::Ref

Main/ObjStore.xs view on Meta::CPAN

	PREINIT:
	char *CLASS = ObjStore_Database;
	CODE:				//should be just like lookup
	RETVAL = THIS->get_database();
	RETVAL->set_check_illegal_pointers(1);
	OUTPUT:
	RETVAL

void
OSPV_Ref2::dump()
	PPCODE:
	char *str = THIS->dump();
	XPUSHs(sv_2mortal(newSVpv(str,0)));
	delete str;

int
OSPV_Ref2::deleted()

void
OSPV_Ref2::focus()
	PPCODE:
	PUTBACK;
	SV *sv = osp_thr::ospv_2sv(THIS->focus());
	SPAGAIN;
	XPUSHs(sv);

#-----------------------------# Cursor

MODULE = ObjStore	PACKAGE = ObjStore::Cursor

void
OSPV_Cursor2::focus()
	PPCODE:
	PUTBACK;
	SV *sv = osp_thr::ospv_2sv(THIS->focus());
	SPAGAIN;
	XPUSHs(sv);

void
OSPV_Cursor2::moveto(where)
	int where

void
OSPV_Cursor2::step(delta)
	int delta
	PPCODE:
	PUTBACK;
	THIS->step(delta);
	return;

void
OSPV_Cursor2::each(...)
	PROTOTYPE: ;$
	PPCODE:
	int delta = 1;
	if (items == 2) {
	  if (!SvIOK(ST(1))) croak("each only accepts integer step sizes");
	  delta = SvIV(ST(1));
	}
	PUTBACK;
	THIS->step(delta);
	THIS->at();
	return;

void
OSPV_Cursor2::at()
	PPCODE:
	PUTBACK;
	THIS->at();
	return;

void
OSPV_Cursor2::store(nval)
	SV *nval
	PPCODE:
	PUTBACK;
	THIS->store(nval);
	return;

void
OSPV_Cursor2::seek(...)
	CODE:
	PUTBACK;
	osp_pathexam *exam;
	if (SvROK(ST(1))) {

Main/ObjStore.xs view on Meta::CPAN

	  exam = &osp->exam;
	}
	ST(0) = boolSV(THIS->seek(*exam));
	XSRETURN(1);

int
OSPV_Cursor2::pos()

void
OSPV_Cursor2::keys()
	PPCODE:
	PUTBACK;
	THIS->keys();
	return;


MODULE = ObjStore	PACKAGE = ObjStore::Database

void
os_database::_allow_external_pointers(yes)
	int yes

REP/ODI/ODI.xs view on Meta::CPAN

#else
  os_collection::set_thread_locking(0);
#endif

MODULE = ObjStore::REP::ODI		PACKAGE = ObjStore::REP::ODI::HV

static void
OSPV_hvdict::new(seg, sz)
	SV *seg;
	int sz;
	PPCODE:
	os_segment *area = osp_thr::sv_2segment(ST(1));
	PUTBACK;
	if (sz <= 0) croak("Non-positive cardinality");
	OSSVPV *pv;
	NEW_OS_OBJECT(pv, area, OSPV_hvdict::get_os_typespec(), OSPV_hvdict(sz));
	pv->bless(ST(0));
	return;

REP/Splash/Splash.xs view on Meta::CPAN

  osp_thr::use("ObjStore::REP::Splash", OSPERL_API_VERSION);
  osp_thr::register_schema("ObjStore::REP::Splash",
	&ObjStore_REP_Splash_dll_schema_info);

MODULE = ObjStore::REP::Splash	PACKAGE = ObjStore::REP::Splash::AV

static void
OSPV_avarray::new(seg, sz)
	SV *seg;
	int sz;
	PPCODE:
	SV *CSV = ST(0);
	os_segment *area = osp_thr::sv_2segment(ST(1));
	PUTBACK;
	if (sz <= 0) {
	  croak("Non-positive cardinality");
	} else if (sz > 100000) {
	  sz = 100000;
	  SERIOUS("Cardinality > 100000; try a more suitable representation");
	}
	OSSVPV *pv;
	NEW_OS_OBJECT(pv, area, OSPV_avarray::get_os_typespec(), OSPV_avarray(sz));
	pv->bless(CSV);
	return;

MODULE = ObjStore::REP::Splash	PACKAGE = ObjStore::REP::Splash::ObjAV

static void
OSSVPV::new(seg, sz)
	SV *seg;
	int sz;
	PPCODE:
	SV *CSV = ST(0);
	os_segment *area = osp_thr::sv_2segment(ST(1));
	PUTBACK;
	if (sz <= 0) {
	  croak("Non-positive cardinality");
	}
	OSSVPV *pv;
	NEW_OS_OBJECT(pv, area, OSPV_av2array::get_os_typespec(), OSPV_av2array(sz));
	pv->bless(CSV);
	return;

MODULE = ObjStore::REP::Splash	PACKAGE = ObjStore::REP::Splash::HV

static void
OSPV_hvarray2::new(seg, sz)
	SV *seg;
	int sz;
	PPCODE:
	SV *CSV = ST(0);
	os_segment *area = osp_thr::sv_2segment(ST(1));
	PUTBACK;
	if (sz <= 0) {
	  croak("Non-positive cardinality");
	} else if (sz > 1000) {
	  sz = 1000;
	  SERIOUS("Cardinality > 1000; try a more suitable representation");
	}
	OSSVPV *pv;
	NEW_OS_OBJECT(pv, area,OSPV_hvarray2::get_os_typespec(), OSPV_hvarray2(sz));
	pv->bless(CSV);
	return;

MODULE = ObjStore::REP::Splash	PACKAGE = ObjStore::REP::Splash::Heap

static void
OSPV_splashheap::new(seg, ...)
	SV *seg;
	PROTOTYPE: $$;$
	PPCODE:
	SV *CSV = ST(0);
	os_segment *area = osp_thr::sv_2segment(ST(1));
	int sz = 20;
	if (items > 2) sz = SvIV(ST(2));
	PUTBACK;
	if (sz <= 0) {
	  croak("Non-positive cardinality");
	} else if (sz > 10000) {
	  sz = 10000;
	  SERIOUS("Cardinality > 10000; try a more suitable representation");
	}
	OSSVPV *pv;
	NEW_OS_OBJECT(pv, area,OSPV_splashheap::get_os_typespec(), OSPV_splashheap(sz));
	pv->bless(CSV);
	return;

void
OSPV_splashheap::_conf_slot(...)
	PPCODE:
	PUTBACK;
	SV *ret = 0;
	if (items == 2) {
	  if (THIS->av.count())
	    croak("Cannot change configuration of an active heap");
	  ospv_bridge *br = osp_thr::sv_2bridge(ST(1), 1, os_segment::of(THIS));
	  THIS->conf_slot = br->ospv();
	} else if (items == 1) {
	  ret = osp_thr::ospv_2sv(THIS->conf_slot);
	} else {

( run in 0.660 second using v1.01-cache-2.11-cpan-5511b514fd6 )