KinoSearch

 view release on metacpan or  search on metacpan

clownfish/lib/Clownfish/Binding/Perl.pm  view on Meta::CPAN

#include "Charmonizer/Test.h"
#include "Charmonizer/Test/AllTests.h"

$generated_xs

MODULE = KinoSearch   PACKAGE = KinoSearch::Autobinding

void
init_autobindings()
PPCODE:
{
    char* file = __FILE__;
    CHY_UNUSED_VAR(cv); 
    CHY_UNUSED_VAR(items); $xs_init
}

$hand_rolled_xs

END_STUFF
}

lib/KinoSearch/Analysis/Stemmer.pm  view on Meta::CPAN

__END__

__BINDING__

my $xs = <<'END_XS';
MODULE = KinoSearch    PACKAGE = KinoSearch::Analysis::Stemmer

void
_copy_snowball_symbols()
PPCODE:
{
    SV **const new_sv_ptr = hv_fetch(PL_modglobal,
        "Lingua::Stem::Snowball::sb_stemmer_new", 38, 0);
    SV **const delete_sv_ptr = hv_fetch(PL_modglobal,
        "Lingua::Stem::Snowball::sb_stemmer_delete", 41, 0);
    SV **const stem_sv_ptr = hv_fetch(PL_modglobal,
        "Lingua::Stem::Snowball::sb_stemmer_stem", 39, 0);
    SV **const length_sv_ptr = hv_fetch(PL_modglobal,
        "Lingua::Stem::Snowball::sb_stemmer_length", 41, 0);
    if (!new_sv_ptr || !delete_sv_ptr || !stem_sv_ptr || !length_sv_ptr) {

lib/KinoSearch/Analysis/Token.pm  view on Meta::CPAN

    kino_Token *self;
CODE:
    RETVAL = newSVpvn(Kino_Token_Get_Text(self), Kino_Token_Get_Len(self));
    SvUTF8_on(RETVAL);
OUTPUT: RETVAL

void
set_text(self, sv)
    kino_Token *self;
    SV *sv;
PPCODE:
{
    STRLEN len;
    char *ptr = SvPVutf8(sv, len);
    Kino_Token_Set_Text(self, ptr, len);
}
END_XS

Clownfish::Binding::Perl::Class->register(
    parcel       => "KinoSearch",
    class_name   => "KinoSearch::Analysis::Token",

lib/KinoSearch/Index/IndexReader.pm  view on Meta::CPAN

__END__

__BINDING__

my $xs_code = <<'END_XS_CODE';
MODULE = KinoSearch    PACKAGE = KinoSearch::Index::IndexReader

void
set_race_condition_debug1(val_sv)
    SV *val_sv;
PPCODE:
    KINO_DECREF(kino_PolyReader_race_condition_debug1);
    kino_PolyReader_race_condition_debug1 = (kino_CharBuf*)
        XSBind_maybe_sv_to_cfish_obj(val_sv, KINO_CHARBUF, NULL);
    if (kino_PolyReader_race_condition_debug1)
        (void)KINO_INCREF(kino_PolyReader_race_condition_debug1);

int32_t
debug1_num_passes()
CODE: 
    RETVAL = kino_PolyReader_debug1_num_passes;

lib/KinoSearch/Index/Indexer.pm  view on Meta::CPAN

int32_t
TRUNCATE(...)
CODE:
    CHY_UNUSED_VAR(items);
    RETVAL = kino_Indexer_TRUNCATE;
OUTPUT: RETVAL

void
add_doc(self, ...)
    kino_Indexer *self;
PPCODE:
{
    kino_Doc *doc = NULL;
    SV *doc_sv = NULL;
    float boost = 1.0;

    if (items == 2) {
        doc_sv = ST(1);
    }
    else if (items > 2) {
        SV* boost_sv = NULL; 

lib/KinoSearch/Index/PostingListWriter.pm  view on Meta::CPAN

__END__

__BINDING__

my $xs_code = <<'END_XS';
MODULE = KinoSearch    PACKAGE = KinoSearch::Index::PostingListWriter

void
set_default_mem_thresh(mem_thresh)
    size_t mem_thresh;
PPCODE:
    kino_PListWriter_set_default_mem_thresh(mem_thresh);
END_XS

Clownfish::Binding::Perl::Class->register(
    parcel            => "KinoSearch",
    class_name        => "KinoSearch::Index::PostingListWriter",
    xs_code           => $xs_code,
    bind_constructors => ["new"],
);

lib/KinoSearch/Index/SortWriter.pm  view on Meta::CPAN

__END__

__BINDING__

my $xs_code = <<'END_XS';
MODULE = KinoSearch    PACKAGE = KinoSearch::Index::SortWriter

void
set_default_mem_thresh(mem_thresh)
    size_t mem_thresh;
PPCODE:
    kino_SortWriter_set_default_mem_thresh(mem_thresh);
END_XS

Clownfish::Binding::Perl::Class->register(
    parcel            => "KinoSearch",
    class_name        => "KinoSearch::Index::SortWriter",
    xs_code           => $xs_code,
    bind_constructors => ["new"],
);

lib/KinoSearch/Object/Hash.pm  view on Meta::CPAN

    const kino_CharBuf *key;
CODE:
    RETVAL = CFISH_OBJ_TO_SV(kino_Hash_fetch(self, (kino_Obj*)key));
OUTPUT: RETVAL

void
store(self, key, value);
    kino_Hash          *self; 
    const kino_CharBuf *key;
    kino_Obj           *value;
PPCODE:
{
    if (value) { KINO_INCREF(value); }
    kino_Hash_store(self, (kino_Obj*)key, value);
}

void
next(self)
    kino_Hash *self;
PPCODE:
{
    kino_Obj *key;
    kino_Obj *val;

    if (Kino_Hash_Next(self, &key, &val)) {
        SV *key_sv = (SV*)Kino_Obj_To_Host(key);
        SV *val_sv = (SV*)Kino_Obj_To_Host(val);

        XPUSHs(sv_2mortal( key_sv ));
        XPUSHs(sv_2mortal( val_sv ));

lib/KinoSearch/Object/Host.pm  view on Meta::CPAN

    RETVAL = (SV*)Kino_BB_To_Host(test_obj);
    SvSetSV_nosteal(pack_var, RETVAL);
    KINO_DECREF(test_obj);
    CHY_UNUSED_VAR(items);
}
OUTPUT: RETVAL

void
_callback(obj)
    kino_Obj *obj;
PPCODE:
{
    kino_ZombieCharBuf *blank = CFISH_ZCB_BLANK(); 
    kino_Host_callback(obj, "_test", 2, 
        CFISH_ARG_OBJ("nothing", (kino_CharBuf*)blank),
        CFISH_ARG_I32("foo", 3));
}

int64_t
_callback_i64(obj)
    kino_Obj *obj;

lib/KinoSearch/Object/Obj.pm  view on Meta::CPAN

CODE:
{
    kino_VTable *target = kino_VTable_fetch_vtable(class_name);
    RETVAL = Kino_Obj_Is_A(self, target);
}
OUTPUT: RETVAL

void
STORABLE_freeze(self, ...)
    kino_Obj *self;
PPCODE:
{
    CHY_UNUSED_VAR(self);
    if (items < 2 || !SvTRUE(ST(1))) {
        SV *retval;
        kino_ByteBuf *serialized_bb;
        kino_RAMFileHandle *file_handle = kino_RAMFH_open(NULL, 
            KINO_FH_WRITE_ONLY | KINO_FH_CREATE, NULL);
        kino_OutStream *target = kino_OutStream_open((kino_Obj*)file_handle);

        Kino_Obj_Serialize(self, target);

lib/KinoSearch/Object/Obj.pm  view on Meta::CPAN

abstract method, it will confess() unless implemented.

=end comment
=cut

void
STORABLE_thaw(blank_obj, cloning, serialized_sv)
    SV *blank_obj;
    SV *cloning;
    SV *serialized_sv;
PPCODE:
{
    char *class_name = HvNAME(SvSTASH(SvRV(blank_obj)));
    kino_ZombieCharBuf *klass 
        = CFISH_ZCB_WRAP_STR(class_name, strlen(class_name));
    kino_VTable *vtable = (kino_VTable*)kino_VTable_singleton(
        (kino_CharBuf*)klass, NULL);
    STRLEN len;
    char *ptr = SvPV(serialized_sv, len);
    kino_ViewByteBuf *contents = kino_ViewBB_new(ptr, len);
    kino_RAMFile *ram_file = kino_RAMFile_new((kino_ByteBuf*)contents, true);

lib/KinoSearch/Object/Obj.pm  view on Meta::CPAN

    // Catch bad deserialize() override. 
    if (deserialized != self) {
        THROW(KINO_ERR, "Error when deserializing obj of class %o", klass);
    }
}

void
DESTROY(self)
    kino_Obj *self;
PPCODE:
    /*
    {
        char *perl_class = HvNAME(SvSTASH(SvRV(ST(0))));
        warn("Destroying: 0x%x %s", (unsigned)self, perl_class);
    }
    */
    Kino_Obj_Destroy(self);
END_XS_CODE

my $synopsis = <<'END_SYNOPSIS';

lib/KinoSearch/Object/VArray.pm  view on Meta::CPAN

    uint32_t    tick;
CODE:
    RETVAL = CFISH_OBJ_TO_SV_NOINC(Kino_VA_Delete(self, tick));
OUTPUT: RETVAL

void
store(self, tick, value);
    kino_VArray *self; 
    uint32_t     tick;
    kino_Obj    *value;
PPCODE:
{
    if (value) { KINO_INCREF(value); }
    kino_VA_store(self, tick, value);
}

SV*
fetch(self, tick)
    kino_VArray *self;
    uint32_t     tick;
CODE:

lib/KinoSearch/Store/InStream.pm  view on Meta::CPAN

__BINDING__

my $xs_code = <<'END_XS_CODE';
MODULE = KinoSearch    PACKAGE = KinoSearch::Store::InStream

void
read(self, buffer_sv, len, ...)
    kino_InStream *self;
    SV *buffer_sv;
    size_t len;
PPCODE:
{
    UV offset = items == 4 ? SvUV(ST(3)) : 0;
    char *ptr;
    size_t total_len = offset + len;
    SvUPGRADE(buffer_sv, SVt_PV);
    if (!SvPOK(buffer_sv)) { SvCUR_set(buffer_sv, 0); }
    ptr = SvGROW(buffer_sv, total_len + 1);
    Kino_InStream_Read_Bytes(self, ptr + offset, len);
    SvPOK_on(buffer_sv);
    if (SvCUR(buffer_sv) < total_len) {

lib/KinoSearch/Store/OutStream.pm  view on Meta::CPAN

__END__

__BINDING__

my $xs_code = <<'END_XS_CODE';
MODULE = KinoSearch     PACKAGE = KinoSearch::Store::OutStream

void
print(self, ...)
    kino_OutStream *self;
PPCODE:
{
    int i;
    for (i = 1; i < items; i++) {
        STRLEN len;
        char *ptr = SvPV( ST(i), len);
        Kino_OutStream_Write_Bytes(self, ptr, len);
    }
}

void 
write_string(self, aSV)
    kino_OutStream *self;
    SV *aSV;
PPCODE:
{
    STRLEN len = 0;
    char *ptr = SvPVutf8(aSV, len);
    Kino_OutStream_Write_C32(self, len);
    Kino_OutStream_Write_Bytes(self, ptr, len);
}
END_XS_CODE

my $synopsis = <<'END_SYNOPSIS';    # Don't use this yet.
    my $outstream = $folder->open_out($filename) or die $@;

lib/KinoSearch/Test.pm  view on Meta::CPAN

doc_set()
CODE:
    RETVAL = CFISH_OBJ_TO_SV_NOINC(kino_TestUtils_doc_set());
OUTPUT: RETVAL

MODULE = KinoSearch   PACKAGE = KinoSearch::Test

void
run_tests(package)
    char *package;
PPCODE:
{
    // KinoSearch::Analysis 
    if (strEQ(package, "TestAnalyzer")) {
        kino_TestAnalyzer_run_tests();
    }
    else if (strEQ(package, "TestCaseFolder")) {
        kino_TestCaseFolder_run_tests();
    }
    else if (strEQ(package, "TestPolyAnalyzer")) {
        kino_TestPolyAnalyzer_run_tests();

lib/KinoSearch/Test.pm  view on Meta::CPAN

    else {
        THROW(KINO_ERR, "Unknown test id: %s", package);
    }
}

MODULE = KinoSearch   PACKAGE = KinoSearch::Test::TestQueryParserSyntax

void
run_tests(index);
    kino_Folder *index;
PPCODE:
    kino_TestQPSyntax_run_tests(index);
END_XS_CODE

my $charm_xs_code = <<'END_XS_CODE';
MODULE = KinoSearch   PACKAGE = KinoSearch::Test::TestCharmonizer

void
run_tests(which)
    char *which;
PPCODE:
{
    chaz_TestBatch *batch = NULL;
    chaz_Test_init();

    if (strcmp(which, "dirmanip") == 0) {
        batch = chaz_TestDirManip_prepare();
    }
    else if (strcmp(which, "integers") == 0) {
        batch = chaz_TestIntegers_prepare();
    }

lib/KinoSearch/Util/Debug.pm  view on Meta::CPAN

__BINDING__

my $xs_code = <<'END_XS_CODE';
MODULE = KinoSearch   PACKAGE = KinoSearch::Util::Debug

#include "KinoSearch/Util/Debug.h"

void
DEBUG_PRINT(message)
    char *message;
PPCODE:
    KINO_DEBUG_PRINT("%s", message);

void
DEBUG(message)
    char *message;
PPCODE:
    KINO_DEBUG("%s", message);

chy_bool_t
DEBUG_ENABLED()
CODE:
    RETVAL = KINO_DEBUG_ENABLED;
OUTPUT: RETVAL

=for comment

Keep track of any KinoSearch objects that have been assigned to global Perl
variables.  This is useful when accounting how many objects should have been
destroyed and diagnosing memory leaks.

=cut

void
track_globals(...)
PPCODE:
{
    CHY_UNUSED_VAR(items);
    KINO_IFDEF_DEBUG(kino_Debug_num_globals++;);
}

void
set_env_cache(str)
    char *str;
PPCODE:
    kino_Debug_set_env_cache(str);

void
ASSERT(maybe)
    int maybe;
PPCODE:
    KINO_ASSERT(maybe, "XS ASSERT binding test");

IV
num_allocated()
CODE:
    RETVAL = kino_Debug_num_allocated;
OUTPUT: RETVAL

IV
num_freed()

lib/KinoSearch/Util/StringHelper.pm  view on Meta::CPAN

=for comment 

Turn an SV's UTF8 flag on.  Equivalent to Encode::_utf8_on, but we don't have
to load Encode.

=cut

void
utf8_flag_on(sv)
    SV *sv;
PPCODE:
    SvUTF8_on(sv);

=for comment

Turn an SV's UTF8 flag off.

=cut

void
utf8_flag_off(sv)
    SV *sv;
PPCODE:
    SvUTF8_off(sv);

SV*
to_base36(num)
    uint64_t num;
CODE:
{
    char base36[kino_StrHelp_MAX_BASE36_BYTES];
    size_t size = kino_StrHelp_to_base36(num, &base36);
    RETVAL = newSVpvn(base36, size);

lib/KinoSearch/Util/StringHelper.pm  view on Meta::CPAN

=for comment

Upgrade a SV to UTF8, converting Latin1 if necessary. Equivalent to
utf::upgrade().

=cut

void
utf8ify(sv)
    SV *sv;
PPCODE:
    sv_utf8_upgrade(sv);

chy_bool_t
utf8_valid(sv)
    SV *sv;
CODE:
{
    STRLEN len;
    char *ptr = SvPV(sv, len);
    RETVAL = kino_StrHelp_utf8_valid(ptr, len);

lib/KinoSearch/Util/StringHelper.pm  view on Meta::CPAN

Concatenate one scalar onto the end of the other, ignoring UTF-8 status of the
second scalar.  This is necessary because $not_utf8 . $utf8 results in a
scalar which has been infected by the UTF-8 flag of the second argument.

=cut

void
cat_bytes(sv, catted)
    SV *sv;
    SV *catted;
PPCODE:
{
    STRLEN len;
    char *ptr = SvPV(catted, len);
    if (SvUTF8(sv)) { CFISH_THROW(KINO_ERR, "Can't cat_bytes onto a UTF-8 SV"); }
    sv_catpvn(sv, ptr, len);
}
END_XS_CODE

Clownfish::Binding::Perl::Class->register(
    parcel     => "KinoSearch",