PPCODE results from the CPAN

QDBM_File

view release on metacpan or search on metacpan

    }
    else {
        XSRETURN_UNDEF;
    }
OUTPUT:
    RETVAL

int
get_record_size(QDBM_File db, datum_key key)
PREINIT:
    STRLEN ksize;
    const char* kbyte;
    dMY_CXT;
CODE:
    SAVESPTR(MY_CXT.comparer);
    MY_CXT.comparer = db->comparer;
    kbyte = SvPV_const(key, ksize);
    RETVAL = vlvsiz( vlptr(db), kbyte, (int)ksize );
OUTPUT:
    RETVAL

int
count_match_records(QDBM_File db, datum_key key)
PREINIT:
    STRLEN ksize;
    const char* kbyte;
    dMY_CXT;
CODE:
    SAVESPTR(MY_CXT.comparer);
    MY_CXT.comparer = db->comparer;
    kbyte = SvPV_const(key, ksize);
    RETVAL = vlvnum( vlptr(db), kbyte, (int)ksize );
OUTPUT:
    RETVAL

bool
delete_list(QDBM_File db, datum_key key)
PREINIT:
    STRLEN ksize;
    const char* kbyte;
    dMY_CXT;
CODE:
    SAVESPTR(MY_CXT.comparer);
    MY_CXT.comparer = db->comparer;
    kbyte = SvPV_const(key, ksize);
    RETVAL = vloutlist( vlptr(db), kbyte, (int)ksize );
OUTPUT:
    RETVAL

void
fetch_list(QDBM_File db, datum_key key)
PREINIT:
    int i;
    STRLEN ksize;
    const char* kbyte;
    int vsize;
    const char* value;
    CBLIST* list;
    SV* value_sv;
    dMY_CXT;
PPCODE:
    SAVESPTR(MY_CXT.comparer);
    MY_CXT.comparer = db->comparer;
    kbyte = SvPV_const(key, ksize);
    list = vlgetlist( vlptr(db), kbyte, (int)ksize );

    if (NULL != list) {
        for (i = 0; i < cblistnum(list); i++) {
            value = cblistval(list, i, &vsize);
            value_sv = newSVpvn(value, (STRLEN)vsize);
            DBM_ckFilter(value_sv, filter_fetch_value, "filter_fetch_value");
            XPUSHs( sv_2mortal(value_sv) );
        }
        cblistclose(list);
    }
    else {
        XSRETURN_EMPTY;
    }

bool
store_list(QDBM_File db, datum_key key, ...)
PREINIT:
    int i;
    STRLEN ksize;
    const char* kbyte;
    STRLEN vsize;
    const char* vbyte;
    CBLIST* list;
    dMY_CXT;
CODE:
    SAVESPTR(MY_CXT.comparer);
    MY_CXT.comparer = db->comparer;
    list = cblistopen();
    for (i = 2; i < items; i++) {
        DBM_ckFilter( ST(i), filter_store_value, "filter_store_value" );
        SvGETMAGIC( ST(i) );
        sv_utf8_downgrade( ST(i), 0 );
        vbyte = SvPV_const( ST(i), vsize );
        cblistpush(list, vbyte, (int)vsize);
    }
    kbyte = SvPV_const(key, ksize);
    RETVAL = vlputlist( vlptr(db), kbyte, (int)ksize, list );
OUTPUT:
    RETVAL
CLEANUP:
    cblistclose(list);

bool
init_iterator(QDBM_File db)
PREINIT:
    dMY_CXT;
CODE:
    SAVESPTR(MY_CXT.comparer);
    MY_CXT.comparer = db->comparer;
    RETVAL = vlcurfirst( vlptr(db) );
OUTPUT:
    RETVAL

bool
move_first(QDBM_File db)
PREINIT:

QDBM_File.xs view on Meta::CPAN

    }
    else {
        XSRETURN_UNDEF;
    }
OUTPUT:
    RETVAL

int
get_record_size(QDBM_File db, datum_key key)
PREINIT:
    STRLEN ksize;
    const char* kbyte;
    dMY_CXT;
CODE:
    SAVESPTR(MY_CXT.comparer);
    MY_CXT.comparer = db->comparer;
    kbyte = SvPV_const(key, ksize);
    RETVAL = vstvsiz( vstptr(db), kbyte, (int)ksize );
OUTPUT:
    RETVAL

int
count_match_records(QDBM_File db, datum_key key)
PREINIT:
    STRLEN ksize;
    const char* kbyte;
    dMY_CXT;
CODE:
    SAVESPTR(MY_CXT.comparer);
    MY_CXT.comparer = db->comparer;
    kbyte = SvPV_const(key, ksize);
    RETVAL = vstvnum( vstptr(db), kbyte, (int)ksize );
OUTPUT:
    RETVAL

bool
delete_list(QDBM_File db, datum_key key)
PREINIT:
    STRLEN ksize;
    const char* kbyte;
    dMY_CXT;
CODE:
    SAVESPTR(MY_CXT.comparer);
    MY_CXT.comparer = db->comparer;
    kbyte = SvPV_const(key, ksize);
    RETVAL = vstoutlist( vstptr(db), kbyte, (int)ksize );
OUTPUT:
    RETVAL

void
fetch_list(QDBM_File db, datum_key key)
PREINIT:
    int i;
    STRLEN ksize;
    const char* kbyte;
    int vsize;
    const char* value;
    CBLIST* list;
    SV* value_sv;
    dMY_CXT;
PPCODE:
    SAVESPTR(MY_CXT.comparer);
    MY_CXT.comparer = db->comparer;
    kbyte = SvPV_const(key, ksize);
    list = vstgetlist( vstptr(db), kbyte, (int)ksize );

    if (NULL != list) {
        for (i = 0; i < cblistnum(list); i++) {
            value = cblistval(list, i, &vsize);
            value_sv = newSVpvn(value, (STRLEN)vsize);
            DBM_ckFilter(value_sv, filter_fetch_value, "filter_fetch_value");
            XPUSHs( sv_2mortal(value_sv) );
        }
        cblistclose(list);
    }
    else {
        XSRETURN_EMPTY;
    }

bool
store_list(QDBM_File db, datum_key key, ...)
PREINIT:
    int i;
    STRLEN ksize;
    const char* kbyte;
    STRLEN vsize;
    const char* vbyte;
    CBLIST* list;
    dMY_CXT;
CODE:
    SAVESPTR(MY_CXT.comparer);
    MY_CXT.comparer = db->comparer;
    list = cblistopen();
    for (i = 2; i < items; i++) {
        DBM_ckFilter( ST(i), filter_store_value, "filter_store_value" );
        SvGETMAGIC( ST(i) );
        sv_utf8_downgrade( ST(i), 0 );
        vbyte = SvPV_const( ST(i), vsize );
        cblistpush(list, vbyte, (int)vsize);
    }
    kbyte = SvPV_const(key, ksize);
    RETVAL = vstputlist( vstptr(db), kbyte, (int)ksize, list );
OUTPUT:
    RETVAL
CLEANUP:
    cblistclose(list);

bool
init_iterator(QDBM_File db)
PREINIT:
    dMY_CXT;
CODE:
    SAVESPTR(MY_CXT.comparer);
    MY_CXT.comparer = db->comparer;
    RETVAL = vstcurfirst( vstptr(db) );
OUTPUT:
    RETVAL

bool
move_first(QDBM_File db)
PREINIT:

QDBM_File.xs view on Meta::CPAN

delete_document_by_uri(ODEUM* db, const char* uri)
CODE:
    RETVAL = odout(db, uri);
OUTPUT:
    RETVAL

bool
delete_document_by_id(ODEUM* db, int id)
CODE:
    RETVAL = odoutbyid(db, id);
OUTPUT:
    RETVAL

ODDOC*
get_document_by_uri(ODEUM* db, const char* uri)
CODE:
    RETVAL = odget(db, uri);
    if (NULL == RETVAL) {
        XSRETURN_UNDEF;
    }
OUTPUT:
    RETVAL

ODDOC*
get_document_by_id(ODEUM* db, int id)
CODE:
    RETVAL = odgetbyid(db, id);
    if (NULL == RETVAL) {
        XSRETURN_UNDEF;
    }
OUTPUT:
    RETVAL

int
get_document_id(ODEUM* db, const char* uri)
CODE:
    RETVAL = odgetidbyuri(db, uri);
OUTPUT:
    RETVAL

bool
exists_document_by_uri(ODEUM* db, const char* uri)
CODE:
    RETVAL = ( -1 != odgetidbyuri(db, uri) );
OUTPUT:
    RETVAL

bool
exists_document_by_id(ODEUM* db, int id)
CODE:
    RETVAL = odcheck(db, id);
OUTPUT:
    RETVAL

void
search_document(ODEUM* db, const char* word, int max = -1)
PREINIT:
    int i;
    int length;
    ODPAIR* pair;
PPCODE:
    pair = odsearch(db, word, max, &length);
    if (NULL != pair) {
        for (i = 0; i < length; i++) {
            mXPUSHi(pair[i].id);
        }
        cbfree(pair);
    }
    else {
        XSRETURN_EMPTY;
    }

int
search_document_count(ODEUM* db, const char* word)
CODE:
    RETVAL = odsearchdnum(db, word);
OUTPUT:
    RETVAL

bool
init_iterator(ODEUM* db)
CODE:
    RETVAL = oditerinit(db);
OUTPUT:
    RETVAL

ODDOC*
get_next_document(ODEUM* db)
CODE:
    RETVAL = oditernext(db);
    if (NULL == RETVAL) {
        XSRETURN_UNDEF;
    }
OUTPUT:
    RETVAL

bool
sync(ODEUM* db)
CODE:
    RETVAL = odsync(db);
OUTPUT:
    RETVAL

bool
optimize(ODEUM* db)
CODE:
    RETVAL = odoptimize(db);
OUTPUT:
    RETVAL

SV*
get_name(ODEUM* db)
PREINIT:
    char* name;
CODE:
    name = odname(db);
    if (NULL != name) {
        RETVAL = newSVpv(name, 0);
        cbfree(name);
    }
    else {

QDBM_File.xs view on Meta::CPAN

bool
is_writable(ODEUM* db)
CODE:
    RETVAL = odwritable(db);
OUTPUT:
    RETVAL

bool
is_fatal_error(ODEUM* db)
CODE:
    RETVAL = odfatalerror(db);
OUTPUT:
    RETVAL

const char*
get_error(SV* package)
CODE:
    RETVAL = dperrmsg(dpecode);
OUTPUT:
    RETVAL

time_t
get_mtime(ODEUM* db)
CODE:
    RETVAL = odmtime(db);
OUTPUT:
    RETVAL

bool
merge(SV* package, const char* name, ...)
PREINIT:
    int i;
    STRLEN elemsize;
    const char* elembyte;
    CBLIST* elemnames;
CODE:
    if ( sv_isobject(package) ) {
        warn("qdbm merge warning: called via instance method\n");
    }
    else {
        elemnames = cblistopen();
        for (i = 2; i < items; i++) {
            SvGETMAGIC( ST(i) );
            sv_utf8_downgrade( ST(i), 0 );
            elembyte = SvPV_const( ST(i), elemsize );
            cblistpush(elemnames, elembyte, (int)elemsize);
        }
        RETVAL = odmerge(name, elemnames);
    }
OUTPUT:
    RETVAL

void
_get_scores(ODEUM* db, ODDOC* doc, int max)
PREINIT:
    const char* key;
    const char* value;
    int ksize;
    int vsize;
    CBMAP* scores;
PPCODE:
    scores = oddocscores(doc, max, db);
    if ( 0 == cbmaprnum(scores) ) {
        cbmapclose(scores);
        XSRETURN_EMPTY;
    }
    else {
        cbmapiterinit(scores);
        while ( NULL != ( key = cbmapiternext(scores, &ksize) ) ) {
            value = cbmapiterval(key, &vsize);
            XPUSHs( sv_2mortal( newSVpvn(key, (STRLEN)ksize) ) );
            XPUSHs( sv_2mortal( newSVpvn(value, (STRLEN)vsize) ) );
        }
        cbmapclose(scores);
    }

void
set_tuning(SV* package, int index_buckets, int inverted_index_division_num, int dirty_buffer_buckets, int dirty_buffer_size)
CODE:
    if ( sv_isobject(package) ) {
        warn("qdbm set_tuning warning: called via instance method\n");
    }
    else {
        odsettuning(
            index_buckets,
            inverted_index_division_num,
            dirty_buffer_buckets,
            dirty_buffer_size
        );
    }

void
set_char_class(ODEUM* db, const char* space, const char* delimiter, const char* glue)
CODE:
    odsetcharclass(db, space, delimiter, glue);

void
analyze_text(SV* self, const char* text)
PREINIT:
    ODEUM* db;
    int i;
    const char* value;
    int vsize;
    CBLIST* appearance_words;
PPCODE:
    if ( sv_isobject(self) && sv_derived_from(self, "QDBM_File::InvertedIndex") ) {
        db = (ODEUM*)SvIV( (SV*)SvRV(self) );
        appearance_words = cblistopen();
        odanalyzetext(db, text, appearance_words, NULL);
    }
    else {
        appearance_words = odbreaktext(text);
    }
    if ( 0 == cblistnum(appearance_words) ) {
        cblistclose(appearance_words);
        XSRETURN_EMPTY;
    }
    else {
        for (i = 0; i < cblistnum(appearance_words); i++) {
            value = cblistval(appearance_words, i, &vsize);
            XPUSHs( sv_2mortal( newSVpvn(value, (STRLEN)vsize) ) );
        }
        cblistclose(appearance_words);
    }

char*
normalize_word(SV* package, const char* asis)
PREINIT:
    char* normalized_word;
CODE:
    if ( sv_isobject(package) ) {
        warn("qdbm normalize_word warning: called via instance method\n");
    }
    else {
        normalized_word = odnormalizeword(asis);
        RETVAL = normalized_word;
    }
OUTPUT:
    RETVAL
CLEANUP:
    cbfree(normalized_word);

void
query(ODEUM *db, const char* query)
PREINIT:
    int i;
    int length;
    int vsize;
    const char* value;
    ODPAIR* pair;
    SV* errsv;
    CBLIST* errors;
PPCODE:
    errors = cblistopen();
    pair = odquery(db, query, &length, errors);
    if (NULL == pair) {
        errsv = newSVpvn("", (STRLEN)0);
        SAVEMORTALIZESV(errsv);
        for (i = 0; i < cblistnum(errors); i++) {
            value = cblistval(errors, i, &vsize);
            sv_catpv(errsv, "qdbm query warning: ");
            sv_catpv(errsv, value);
            sv_catpv(errsv, "\n");
        }
        cblistclose(errors);
        warn( SvPV_nolen(errsv) );
        XSRETURN_EMPTY;
    }
    else {
        for (i = 0; i < length; i++) {
            mXPUSHi(pair[i].id);
        }
        cblistclose(errors);
        cbfree(pair);
    }

MODULE = QDBM_File    PACKAGE = QDBM_File::InvertedIndex::Document

ODDOC*
new(char* package, char* uri)
CODE:
    RETVAL = oddocopen(uri);
OUTPUT:
    RETVAL

void
set_attribute(ODDOC* doc, const char* name, const char* value)
CODE:
    oddocaddattr(doc, name, value);

const char*
get_attribute(ODDOC* doc, const char* name)
CODE:
    RETVAL = oddocgetattr(doc, name);
    if (NULL == RETVAL) {
        XSRETURN_UNDEF;
    }
OUTPUT:
    RETVAL

void
add_word(ODDOC* doc, const char* normal, const char* asis)
CODE:
    oddocaddword(doc, normal, asis);

int
get_id(ODDOC* doc)
CODE:
    RETVAL = oddocid(doc);
OUTPUT:
    RETVAL

const char*
get_uri(ODDOC* doc)
CODE:
    RETVAL = oddocuri(doc);
OUTPUT:
    RETVAL

void
get_normalized_words(ODDOC* doc)
PREINIT:
    int i;
    const char* value;
    int vsize;
    const CBLIST* words;
PPCODE:
    words = oddocnwords(doc);
    if ( 0 < cblistnum(words) ) {
        for (i = 0; i < cblistnum(words); i++) {
            value = cblistval(words, i, &vsize);
            XPUSHs( sv_2mortal( newSVpvn(value, (STRLEN)vsize) ) );
        }
    }
    else {
        XSRETURN_EMPTY;
    }

void
get_appearance_words(ODDOC* doc)
PREINIT:
    int i;
    const char* value;
    int vsize;
    const CBLIST* words;
PPCODE:
    words = oddocawords(doc);
    if ( 0 < cblistnum(words) ) {
        for (i = 0; i < cblistnum(words); i++) {
            value = cblistval(words, i, &vsize);
            XPUSHs( sv_2mortal( newSVpvn(value, (STRLEN)vsize) ) );
        }
    }
    else {
        XSRETURN_EMPTY;
    }

void
_get_scores(ODDOC* doc, int max, ODEUM* db = NULL)
PREINIT:
    const char* key;
    const char* value;
    int ksize;
    int vsize;
    CBMAP* scores;
PPCODE:
    scores = oddocscores(doc, max, db);
    if ( 0 == cbmaprnum(scores) ) {
        cbmapclose(scores);
        XSRETURN_EMPTY;
    }
    else {
        cbmapiterinit(scores);
        while ( NULL != ( key = cbmapiternext(scores, &ksize) ) ) {
            value = cbmapiterval(key, &vsize);
            XPUSHs( sv_2mortal( newSVpvn(key, (STRLEN)ksize) ) );
            XPUSHs( sv_2mortal( newSVpvn(value, (STRLEN)vsize) ) );
        }
        cbmapclose(scores);
    }

void
DESTROY(ODDOC* doc)
CODE:
    if (doc) {
        oddocclose(doc);
    }

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