KinoSearch1
view release on metacpan or search on metacpan
lib/KinoSearch1/Analysis/TokenBatch.pm view on Meta::CPAN
__XS__
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Analysis::TokenBatch
void
new(either_sv)
SV *either_sv;
PREINIT:
const char *class;
TokenBatch *batch;
PPCODE:
/* determine the class */
class = sv_isobject(either_sv)
? sv_reftype(either_sv, 0)
: SvPV_nolen(either_sv);
/* build object */
batch = Kino1_TokenBatch_new();
ST(0) = sv_newmortal();
sv_setref_pv(ST(0), class, (void*)batch);
XSRETURN(1);
lib/KinoSearch1/Analysis/TokenBatch.pm view on Meta::CPAN
append(batch, text_sv, start_offset, end_offset, ...)
TokenBatch *batch;
SV *text_sv;
I32 start_offset;
I32 end_offset;
PREINIT:
char *text;
STRLEN len;
I32 pos_inc = 1;
Token *token;
PPCODE:
text = SvPV(text_sv, len);
if (items == 5)
pos_inc = SvIV( ST(4) );
else if (items > 5)
Kino1_confess("Too many arguments: %d", items);
token = Kino1_Token_new(text, len, start_offset, end_offset, pos_inc);
Kino1_TokenBatch_append(batch, token);
=for comment
lib/KinoSearch1/Analysis/TokenBatch.pm view on Meta::CPAN
SV *string_sv;
AV *starts_av;
AV *ends_av;
PREINIT:
char *string_start;
STRLEN len, start_offset, end_offset;
I32 i, max;
SV **start_sv_ptr;
SV **end_sv_ptr;
Token *token;
PPCODE:
{
string_start = SvPV(string_sv, len);
max = av_len(starts_av);
for (i = 0; i <= max; i++) {
/* retrieve start */
start_sv_ptr = av_fetch(starts_av, i, 0);
if (start_sv_ptr == NULL)
Kino1_confess("Failed to retrieve @starts array element");
start_offset = SvIV(*start_sv_ptr);
lib/KinoSearch1/Analysis/TokenBatch.pm view on Meta::CPAN
term length
=end comment
=cut
void
build_posting_list(batch, doc_num, field_num)
TokenBatch *batch;
U32 doc_num;
U16 field_num;
PPCODE:
Kino1_TokenBatch_build_plist(batch, doc_num, field_num);
void
set_all_texts(batch, texts_av)
TokenBatch *batch;
AV *texts_av;
PREINIT:
Token *token;
I32 i, max;
SV **sv_ptr;
char *text;
STRLEN len;
PPCODE:
{
token = batch->first;
max = av_len(texts_av);
for (i = 0; i <= max; i++) {
if (token == NULL) {
Kino1_confess("Batch size %d doesn't match array size %d",
batch->size, (max + 1));
}
sv_ptr = av_fetch(texts_av, i, 0);
if (sv_ptr == NULL) {
lib/KinoSearch1/Analysis/TokenBatch.pm view on Meta::CPAN
token = token->next;
}
}
void
get_all_texts(batch)
TokenBatch *batch;
PREINIT:
Token *token;
AV *out_av;
PPCODE:
{
out_av = newAV();
token = batch->first;
while (token != NULL) {
SV *text = newSVpvn(token->text, token->len);
av_push(out_av, text);
token = token->next;
}
XPUSHs(sv_2mortal( newRV_noinc((SV*)out_av) ));
XSRETURN(1);
lib/KinoSearch1/Analysis/TokenBatch.pm view on Meta::CPAN
case 14: RETVAL = newSVsv(batch->tv_string);
break;
KINO_END_SET_OR_GET_SWITCH
}
OUTPUT: RETVAL
void
reset(batch)
TokenBatch *batch;
PPCODE:
Kino1_TokenBatch_reset(batch);
I32
next(batch)
TokenBatch *batch;
CODE:
RETVAL = Kino1_TokenBatch_next(batch);
OUTPUT: RETVAL
void
DESTROY(batch)
TokenBatch *batch;
PPCODE:
Kino1_TokenBatch_destroy(batch);
__H__
#ifndef H_KINOSEARCH_ANALYSIS_TOKENBATCH
#define H_KINOSEARCH_ANALYSIS_TOKENBATCH 1
#include "EXTERN.h"
#include "perl.h"
lib/KinoSearch1/Document/Field.pm view on Meta::CPAN
Return ref to a hash where the keys are term texts and the values are encoded
positional data.
=cut
void
_extract_tv_cache(tv_string_sv)
SV *tv_string_sv;
PREINIT:
HV *tv_cache_hv;
PPCODE:
tv_cache_hv = Kino1_Field_extract_tv_cache(tv_string_sv);
XPUSHs( sv_2mortal( newRV_noinc( (SV*)tv_cache_hv ) ) );
XSRETURN(1);
=for comment
Decompress positional data.
=cut
void
_unpack_posdata(posdata_sv)
SV *posdata_sv;
PREINIT:
AV *positions_av, *starts_av, *ends_av;
PPCODE:
positions_av = newAV();
starts_av = newAV();
ends_av = newAV();
Kino1_Field_unpack_posdata(posdata_sv, positions_av, starts_av, ends_av);
XPUSHs(sv_2mortal( newRV_noinc((SV*)positions_av) ));
XPUSHs(sv_2mortal( newRV_noinc((SV*)starts_av) ));
XPUSHs(sv_2mortal( newRV_noinc((SV*)ends_av) ));
XSRETURN(3);
lib/KinoSearch1/Index/MultiTermDocs.pm view on Meta::CPAN
__XS__
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Index::MultiTermDocs
void
_init_child(term_docs, sub_term_docs_avref, starts_av)
TermDocs *term_docs;
SV *sub_term_docs_avref;
AV *starts_av;
PPCODE:
Kino1_MultiTermDocs_init_child(term_docs, sub_term_docs_avref, starts_av);
=for comment
Helper for seek().
=cut
void
_reset_pointer(term_docs)
TermDocs *term_docs;
PREINIT:
MultiTermDocsChild *child;
PPCODE:
child = (MultiTermDocsChild*)term_docs->child;
child->base = 0;
child->pointer = 0;
child->current = NULL;
SV*
_set_or_get(term_docs, ...)
TermDocs *term_docs;
ALIAS:
lib/KinoSearch1/Index/PostingsWriter.pm view on Meta::CPAN
__XS__
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Index::PostingsWriter
void
_write_postings (sort_pool, tinfos_writer, frq_out, prx_out)
SortExternal *sort_pool;
TermInfosWriter *tinfos_writer;
OutStream *frq_out;
OutStream *prx_out;
PPCODE:
Kino1_PostWriter_write_postings(sort_pool, tinfos_writer, frq_out,
prx_out);
void
_add_segment(sort_pool, term_enum, term_docs, doc_map_ref)
SortExternal *sort_pool;
SegTermEnum *term_enum;
TermDocs *term_docs;
SV *doc_map_ref;
PPCODE:
Kino1_PostWriter_add_segment(sort_pool, term_enum, term_docs,
doc_map_ref);
__H__
#ifndef H_KINOSEARCH_INDEX_POSTINGS_WRITER
#define H_KINOSEARCH_INDEX_POSTINGS_WRITER 1
#include "EXTERN.h"
#include "perl.h"
lib/KinoSearch1/Index/SegTermDocs.pm view on Meta::CPAN
1;
__END__
__XS__
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Index::SegTermDocs
void
_init_child(term_docs)
TermDocs *term_docs;
PPCODE:
Kino1_SegTermDocs_init_child(term_docs);
SV*
_set_or_get(term_docs, ...)
TermDocs *term_docs;
ALIAS:
_set_count = 1
_get_count = 2
_set_freq_stream = 3
_get_freq_stream = 4
lib/KinoSearch1/Index/SegTermEnum.pm view on Meta::CPAN
=for comment
fill_cache() loads the entire Enum into memory. This should only be called
for index Enums -- never for primary Enums.
=cut
void
fill_cache(obj)
SegTermEnum *obj;
PPCODE:
Kino1_SegTermEnum_fill_cache(obj);
=begin comment
scan_to() iterates through the Enum until the Enum's state is ge the target.
This is called on the main Enum, after seek() has gotten it close. You don't
want to scan through the entire main Enum, just through a small part.
Scanning through an Enum is an involved process, due to the heavy data
lib/KinoSearch1/Index/SegTermEnum.pm view on Meta::CPAN
=end comment
=cut
void
scan_to(obj, target_termstring_sv)
SegTermEnum *obj;
SV *target_termstring_sv;
PREINIT:
char *ptr;
STRLEN len;
PPCODE:
ptr = SvPV(target_termstring_sv, len);
if (len < 2)
Kino1_confess("length of termstring < 2: %"UVuf, (UV)len);
Kino1_SegTermEnum_scan_to(obj, ptr, len);
=for comment
Reset the Enum to the top, so that after next() is called, the Enum is located
at the first term in the segment.
=cut
void
reset(obj)
SegTermEnum *obj;
PPCODE:
Kino1_SegTermEnum_reset(obj);
=for comment
next() advances the state of the Enum one term. If the current position of
the Enum is valid, it returns 1; when the Enum is exhausted, it returns 0.
=cut
lib/KinoSearch1/Index/SegTermEnum.pm view on Meta::CPAN
break;
KINO_END_SET_OR_GET_SWITCH
}
OUTPUT: RETVAL
void
DESTROY(obj)
SegTermEnum* obj;
PPCODE:
Kino1_SegTermEnum_destroy(obj);
__H__
#ifndef H_KINOSEARCH_INDEX_SEG_TERM_ENUM
#define H_KINOSEARCH_INDEX_SEG_TERM_ENUM 1
#include "EXTERN.h"
#include "perl.h"
#include "KinoSearch1IndexTermBuffer.h"
lib/KinoSearch1/Index/SegWriter.pm view on Meta::CPAN
__XS__
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Index::SegWriter
void
_write_remapped_norms(outstream, doc_map_ref, norms_ref)
OutStream *outstream;
SV *doc_map_ref;
SV *norms_ref;
PPCODE:
Kino1_SegWriter_write_remapped_norms(outstream, doc_map_ref, norms_ref);
__H__
#ifndef H_KINOSEARCH_SEG_WRITER
#define H_KINOSEARCH_SEG_WRITER 1
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
lib/KinoSearch1/Index/TermBuffer.pm view on Meta::CPAN
__XS__
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Index::TermBuffer
void
_new(class, finfos_size)
char *class;
I32 finfos_size;
PREINIT:
TermBuffer *term_buf;
PPCODE:
term_buf = Kino1_TermBuf_new(finfos_size);
ST(0) = sv_newmortal();
sv_setref_pv(ST(0), class, (void*)term_buf);
XSRETURN(1);
void
DESTROY(term_buf)
TermBuffer *term_buf;
PPCODE:
Kino1_TermBuf_destroy(term_buf);
__H__
#ifndef H_KINOSEARCH_INDEX_TERM_BUFFER
#define H_KINOSEARCH_INDEX_TERM_BUFFER 1
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
lib/KinoSearch1/Index/TermDocs.pm view on Meta::CPAN
__XS__
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Index::TermDocs
void
new(either_sv)
SV *either_sv;
PREINIT:
const char *class;
TermDocs *term_docs;
PPCODE:
/* determine the class */
class = sv_isobject(either_sv)
? sv_reftype(either_sv, 0)
: SvPV_nolen(either_sv);
/* build object */
term_docs = Kino1_TermDocs_new();
ST(0) = sv_newmortal();
sv_setref_pv(ST(0), class, (void*)term_docs);
XSRETURN(1);
void
seek_tinfo(term_docs, maybe_tinfo_sv)
TermDocs *term_docs;
SV *maybe_tinfo_sv;
PREINIT:
TermInfo *tinfo = NULL;
PPCODE:
/* if maybe_tinfo_sv is undef, tinfo is NULL */
if (SvOK(maybe_tinfo_sv)) {
Kino1_extract_struct(maybe_tinfo_sv, tinfo,
TermInfo*, "KinoSearch1::Index::TermInfo");
}
term_docs->seek_tinfo(term_docs, tinfo);
=begin comment
lib/KinoSearch1/Index/TermDocs.pm view on Meta::CPAN
: newSVuv(num);
break;
KINO_END_SET_OR_GET_SWITCH
}
OUTPUT: RETVAL
void
DESTROY(term_docs)
TermDocs *term_docs;
PPCODE:
term_docs->destroy(term_docs);
__H__
#ifndef H_KINO_TERM_DOCS
#define H_KINO_TERM_DOCS 1
#define KINO_TERM_DOCS_SENTINEL 0xFFFFFFFF
lib/KinoSearch1/Index/TermInfo.pm view on Meta::CPAN
OUTPUT: RETVAL
=for comment
Zero out the TermInfo object.
=cut
void
reset(tinfo)
TermInfo *tinfo;
PPCODE:
Kino1_TInfo_reset(tinfo);
=begin comment
Setters and getters.
=end comment
=cut
lib/KinoSearch1/Index/TermInfosWriter.pm view on Meta::CPAN
=cut
void
add(obj, termstring_sv, tinfo)
TermInfosWriter *obj;
SV *termstring_sv;
TermInfo *tinfo;
PREINIT:
ByteBuf bb;
STRLEN len;
PPCODE:
bb.ptr = SvPV(termstring_sv, len);
bb.size = len;
Kino1_TInfosWriter_add(obj, &bb, tinfo);
=for comment
Export the FORMAT constant to Perl.
=cut
lib/KinoSearch1/Index/TermInfosWriter.pm view on Meta::CPAN
break;
KINO_END_SET_OR_GET_SWITCH
}
OUTPUT: RETVAL
void
DESTROY(obj)
TermInfosWriter *obj;
PPCODE:
Kino1_TInfosWriter_destroy(obj);
__H__
#ifndef H_KINO_TERM_INFOS_WRITER
#define H_KINO_TERM_INFOS_WRITER 1
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
lib/KinoSearch1/Search/BooleanScorer.pm view on Meta::CPAN
__END__
__XS__
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Search::BooleanScorer
void
_init_child(scorer)
Scorer *scorer;
PPCODE:
Kino1_BoolScorer_init_child(scorer);
=for comment
Add a scorer for a sub-query of the BooleanQuery.
=cut
void
add_subscorer(scorer, subscorer_sv, occur)
Scorer *scorer;
SV *subscorer_sv;
char *occur;
PREINIT:
BoolScorerChild* child;
Scorer *subscorer;
SV *subscorer_sv_copy;
PPCODE:
child = (BoolScorerChild*)scorer->child;
Kino1_extract_struct(subscorer_sv, subscorer,
Scorer*, "KinoSearch1::Search::Scorer");
subscorer_sv_copy = newSVsv(subscorer_sv);
av_push(child->subscorers_av, subscorer_sv_copy);
Kino1_BoolScorer_add_subscorer(scorer, subscorer, occur);
SV*
_boolean_scorer_set_or_get(scorer, ...)
Scorer* scorer;
lib/KinoSearch1/Search/BooleanScorer.pm view on Meta::CPAN
case 2: RETVAL = newRV((SV*)child->subscorers_av);
break;
KINO_END_SET_OR_GET_SWITCH
}
OUTPUT: RETVAL
void
DESTROY(scorer)
Scorer *scorer;
PPCODE:
Kino1_BoolScorer_destroy(scorer);
__H__
#ifndef H_KINO_BOOLEAN_SCORER
#define H_KINO_BOOLEAN_SCORER 1
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
lib/KinoSearch1/Search/HitCollector.pm view on Meta::CPAN
__XS__
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Search::HitCollector
void
new(either_sv)
SV *either_sv;
PREINIT:
const char *class;
HitCollector *hc;
PPCODE:
hc = Kino1_HC_new();
class = sv_isobject(either_sv)
? sv_reftype(either_sv, 0)
: SvPV_nolen(either_sv);
ST(0) = sv_newmortal();
sv_setref_pv(ST(0), class, (void*)hc);
XSRETURN(1);
=begin comment
lib/KinoSearch1/Search/HitCollector.pm view on Meta::CPAN
called from Perl, as collecting hits is an extremely data-intensive operation.
=end comment
=cut
void
collect(hc, doc_num, score)
HitCollector *hc;
U32 doc_num;
float score;
PPCODE:
hc->collect(hc, doc_num, score);
SV*
_set_or_get(hc, ...)
HitCollector *hc;
ALIAS:
_set_storage = 1
get_storage = 2
_set_i = 3
get_i = 4
lib/KinoSearch1/Search/HitCollector.pm view on Meta::CPAN
case 8: RETVAL = newSVsv(hc->filter_bits_ref);
break;
KINO_END_SET_OR_GET_SWITCH
}
OUTPUT: RETVAL
void
DESTROY(hc)
HitCollector *hc;
PPCODE:
Kino1_HC_destroy(hc);
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Search::HitQueueCollector
void
_define_collect(hc)
HitCollector *hc;
PPCODE:
hc->collect = Kino1_HC_collect_HitQueue;
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Search::BitCollector
void
_define_collect(hc)
HitCollector *hc;
PPCODE:
hc->collect = Kino1_HC_collect_BitVec;
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Search::FilteredCollector
void
_define_collect(hc);
HitCollector *hc;
PPCODE:
hc->collect = Kino1_HC_collect_filtered;
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Search::OffsetCollector
void
_define_collect(hc);
HitCollector *hc;
PPCODE:
hc->collect = Kino1_HC_collect_offset;
__H__
#ifndef H_KINO_HIT_COLLECTOR
#define H_KINO_HIT_COLLECTOR 1
#include "EXTERN.h"
lib/KinoSearch1/Search/HitQueue.pm view on Meta::CPAN
1;
__END__
__XS__
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Search::HitQueue
void
define_less_than(hitq)
PriorityQueue *hitq;
PPCODE:
hitq->less_than = &Kino1_HitQ_less_than;
__H__
#ifndef H_KINOSEARCH_SEARCH_HIT_QUEUE
#define H_KINOSEARCH_SEARCH_HIT_QUEUE 1
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
lib/KinoSearch1/Search/PhraseScorer.pm view on Meta::CPAN
__END__
__XS__
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Search::PhraseScorer
void
_init_child(scorer)
Scorer *scorer;
PPCODE:
Kino1_PhraseScorer_init_child(scorer);
void
_init_elements(scorer, term_docs_av, phrase_offsets_av)
Scorer *scorer;
AV *term_docs_av;
AV *phrase_offsets_av;
PREINIT:
PhraseScorerChild *child;
I32 i;
SV **sv_ptr;
IV tmp;
PPCODE:
{
child = (PhraseScorerChild*)scorer->child;
SvREFCNT_inc(term_docs_av);
SvREFCNT_dec(child->term_docs_av);
child->term_docs_av = term_docs_av;
child->num_elements = av_len(term_docs_av) + 1;
Kino1_New(0, child->term_docs, child->num_elements, TermDocs*);
Kino1_New(0, child->phrase_offsets, child->num_elements, U32);
lib/KinoSearch1/Search/PhraseScorer.pm view on Meta::CPAN
case 6: RETVAL = newSVsv(child->norms_sv);
break;
KINO_END_SET_OR_GET_SWITCH
}
OUTPUT: RETVAL
void
DESTROY(scorer)
Scorer *scorer;
PPCODE:
Kino1_PhraseScorer_destroy(scorer);
__H__
#ifndef H_KINO_PHRASE_SCORER
#define H_KINO_PHRASE_SCORER 1
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
lib/KinoSearch1/Search/Scorer.pm view on Meta::CPAN
__XS__
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Search::Scorer
void
_construct_parent(class)
char *class;
PREINIT:
Scorer *scorer;
PPCODE:
scorer = Kino1_Scorer_new();
ST(0) = sv_newmortal();
sv_setref_pv(ST(0), class, (void*)scorer);
XSRETURN(1);
SV*
_scorer_set_or_get(scorer, ...)
Scorer *scorer;
ALIAS:
set_similarity = 1
lib/KinoSearch1/Search/Scorer.pm view on Meta::CPAN
=end comment
=cut
void
score_batch(scorer, ...)
Scorer *scorer;
PREINIT:
HV *args_hash;
U32 start, end;
HitCollector *hc;
PPCODE:
/* process hash-style params */
Kino1_Verify_build_args_hash(args_hash,
"KinoSearch1::Search::Scorer::score_batch_args", 1);
Kino1_extract_struct_from_hv(args_hash, hc, "hit_collector", 13,
HitCollector*, "KinoSearch1::Search::HitCollector");
start = (U32)SvUV( Kino1_Verify_extract_arg(args_hash, "start", 5) );
end = (U32)SvUV( Kino1_Verify_extract_arg(args_hash, "end", 3) );
/* execute scoring loop */
while (scorer->next(scorer)) {
lib/KinoSearch1/Search/Scorer.pm view on Meta::CPAN
Scorer* scorer;
U32 target_doc_num;
CODE:
RETVAL = scorer->skip_to(scorer, target_doc_num);
OUTPUT: RETVAL
void
DESTROY(scorer)
Scorer *scorer;
PPCODE:
Kino1_Scorer_destroy(scorer);
__H__
#ifndef H_KINO_SCORER
#define H_KINO_SCORER 1
#include "EXTERN.h"
#include "perl.h"
lib/KinoSearch1/Search/Similarity.pm view on Meta::CPAN
Rather than attempt to serialize a Similarity, we just create a new one.
=end comment
=cut
void
STORABLE_thaw(blank_obj, cloning, serialized)
SV *blank_obj;
SV *cloning;
SV *serialized;
PPCODE:
{
Similarity *sim = Kino1_Sim_new();
SV *deep_obj = SvRV(blank_obj);
sv_setiv(deep_obj, PTR2IV(sim));
}
void
new(either_sv)
SV *either_sv;
PREINIT:
const char *class;
Similarity *sim;
PPCODE:
/* determine the class */
class = sv_isobject(either_sv)
? sv_reftype(either_sv, 0)
: SvPV_nolen(either_sv);
/* build object */
sim = Kino1_Sim_new();
ST(0) = sv_newmortal();
sv_setref_pv(ST(0), class, (void*)sim);
XSRETURN(1);
lib/KinoSearch1/Search/Similarity.pm view on Meta::CPAN
Similarity *sim;
U32 overlap;
U32 max_overlap;
CODE:
RETVAL = sim->coord(sim, overlap, max_overlap);
OUTPUT: RETVAL
void
_use_title_tf(sim)
Similarity *sim;
PPCODE:
sim->tf = Kino1_Sim_title_tf;
void
DESTROY(sim)
Similarity *sim;
PPCODE:
Kino1_Sim_destroy(sim);
__H__
#ifndef H_KINO_SIMILARITY
#define H_KINO_SIMILARITY 1
#include "EXTERN.h"
#include "perl.h"
lib/KinoSearch1/Search/TermScorer.pm view on Meta::CPAN
__END__
__XS__
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Search::TermScorer
void
_init_child(scorer)
Scorer *scorer;
PPCODE:
Kino1_TermScorer_init_child(scorer);
=for comment
Build up a cache of scores for common (i.e. low) freqs, so they don't have to
be continually recalculated.
=cut
void
_fill_score_cache(scorer)
Scorer* scorer;
PPCODE:
Kino1_TermScorer_fill_score_cache(scorer);
void
score_batch(scorer, ...)
Scorer *scorer;
PREINIT:
HV *args_hash;
U32 start, end;
HitCollector *hc;
PPCODE:
/* process hash-style params */
Kino1_Verify_build_args_hash(args_hash,
"KinoSearch1::Search::TermScorer::score_batch_args", 1);
Kino1_extract_struct_from_hv(args_hash, hc, "hit_collector", 13,
HitCollector*, "KinoSearch1::Search::HitCollector");
start = (U32)SvUV( Kino1_Verify_extract_arg(args_hash, "start", 5) );
end = (U32)SvUV( Kino1_Verify_extract_arg(args_hash, "end", 3) );
Kino1_TermScorer_score_batch(scorer, start, end, hc);
lib/KinoSearch1/Search/TermScorer.pm view on Meta::CPAN
case 8: RETVAL = newSVsv(child->norms_sv);
break;
KINO_END_SET_OR_GET_SWITCH
}
OUTPUT: RETVAL
void
DESTROY(scorer)
Scorer *scorer;
PPCODE:
Kino1_TermScorer_destroy(scorer);
__H__
#ifndef H_KINO_TERM_SCORER
#define H_KINO_TERM_SCORER 1
#define KINO_SCORE_CACHE_SIZE 32
#define KINO_TERM_SCORER_SENTINEL 0xFFFFFFFF
lib/KinoSearch1/Store/InStream.pm view on Meta::CPAN
=for comment
Seek to target plus the object's start offset.
=cut
void
seek(instream, target)
InStream *instream;
double target;
PPCODE:
instream->seek(instream, target);
=for comment
Return the filehandle's position minus the offset.
=cut
double
tell(instream)
InStream *instream;
lib/KinoSearch1/Store/InStream.pm view on Meta::CPAN
char *template; /* ptr to a spot in the template */
char *tpt_end; /* ptr to the end of the template */
int repeat_count; /* number of times to repeat sym */
char sym; /* the current symbol in the template */
char countsym; /* used when calculating repeat counts */
IV aIV;
SV *aSV;
char aChar;
char* string;
STRLEN len;
PPCODE:
{
/* prepare template string pointers */
template = SvPV(template_sv, tpt_len);
tpt_end = SvEND(template_sv);
repeat_count = 0;
while (1) {
if (repeat_count == 0) {
/* fast-forward past space characters */
while (*template == ' ' && template < tpt_end) {
lib/KinoSearch1/Store/InStream.pm view on Meta::CPAN
/* Put a scalar on the stack, use up one symbol or repeater */
XPUSHs( sv_2mortal(aSV) );
repeat_count -= 1;
}
}
void
DESTROY(instream)
InStream *instream;
PPCODE:
Kino1_InStream_destroy(instream);
__H__
#ifndef H_KINOSEARCH_STORE_INSTREAM
#define H_KINOSEARCH_STORE_INSTREAM 1
#include "EXTERN.h"
#include "perl.h"
lib/KinoSearch1/Store/OutStream.pm view on Meta::CPAN
char *class;
SV *fh_sv;
CODE:
RETVAL = Kino1_OutStream_new(class, fh_sv);
OUTPUT: RETVAL
void
seek(outstream, target)
OutStream *outstream;
double target;
PPCODE:
outstream->seek(outstream, target);
double
tell(outstream)
OutStream *outstream;
CODE:
RETVAL = outstream->tell(outstream);
OUTPUT: RETVAL
double
length(outstream)
OutStream *outstream;
CODE:
RETVAL = Kino1_OutStream_length(outstream);
OUTPUT: RETVAL
void
flush(outstream);
OutStream *outstream;
PPCODE:
Kino1_OutStream_flush(outstream);
=for comment
Write the entire contents of an instream to an outstream.
=cut
void
absorb(outstream, instream)
OutStream *outstream;
InStream *instream;
PPCODE:
Kino1_OutStream_absorb(outstream, instream);
SV*
_set_or_get(outstream, ...)
OutStream *outstream;
ALIAS:
set_fh = 1
get_fh = 2
CODE:
{
lib/KinoSearch1/Store/OutStream.pm view on Meta::CPAN
int repeat_count; /* number of times to repeat sym */
int item_count; /* current place in @_ */
char sym; /* the current symbol in the template */
char countsym; /* used when calculating repeat counts */
I32 aI32;
U32 aU32;
double aDouble;
SV *aSV;
char *string;
STRLEN string_len;
PPCODE:
{
/* require an object, a template, and at least 1 item */
if (items < 2) {
Kino1_confess("lu_write error: too few arguments");
}
/* prepare the template and get pointers */
template = SvPV(template_sv, tpt_len);
tpt_end = template + tpt_len;
lib/KinoSearch1/Store/OutStream.pm view on Meta::CPAN
/* use up one repeat_count and one item from the stack */
repeat_count--;
item_count++;
}
}
void
DESTROY(outstream)
OutStream *outstream;
PPCODE:
Kino1_OutStream_destroy(outstream);
__H__
#ifndef H_KINOIO
#define H_KINOIO 1
#include "EXTERN.h"
#include "perl.h"
lib/KinoSearch1/Util/BitVector.pm view on Meta::CPAN
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Util::BitVector
void
new(either_sv, ...)
SV *either_sv;
PREINIT:
const char *class;
HV *args_hash;
U32 capacity;
BitVector *bit_vec;
PPCODE:
/* determine the class */
class = sv_isobject(either_sv)
? sv_reftype(either_sv, 0)
: SvPV_nolen(either_sv);
/* process hash-style params */
Kino1_Verify_build_args_hash(args_hash,
"KinoSearch1::Util::BitVector::instance_vars", 1);
capacity = (U32)SvUV( Kino1_Verify_extract_arg(args_hash, "capacity", 8) );
lib/KinoSearch1/Util/BitVector.pm view on Meta::CPAN
=for comment
Set the bit at $num to 1.
=cut
void
set(bit_vec, ...)
BitVector *bit_vec;
PREINIT:
U32 i, num;
PPCODE:
for (i = 1; i < items; i++) {
num = (U32)( SvUV( ST(i) ) );
Kino1_BitVec_set(bit_vec, num);
}
=for comment
Clear the bit at $num (i.e. set it to 0).
=cut
void
clear(bit_vec, num)
BitVector *bit_vec;
U32 num;
PPCODE:
Kino1_BitVec_clear(bit_vec, num);
=for comment
Set all the bits bounded by $first and $last, inclusive, to 1.
=cut
void
bulk_set(bit_vec, first, last)
BitVector *bit_vec;
U32 first;
U32 last;
PPCODE:
Kino1_BitVec_bulk_set(bit_vec, first, last);
=for comment
Clear all the bits bounded by $first and $last, inclusive.
=cut
void
bulk_clear(bit_vec, first, last)
BitVector *bit_vec;
U32 first;
U32 last;
PPCODE:
Kino1_BitVec_bulk_clear(bit_vec, first, last);
=for comment
Given $num, return either $num (if it is set), the next set bit above it, or
if no such bit exists, undef (from Perl) or a sentinel (0xFFFFFFFF) from C.
=cut
SV*
next_set_bit(bit_vec, num)
lib/KinoSearch1/Util/BitVector.pm view on Meta::CPAN
Modify the BitVector so that only bits which remain set are those which 1)
were already set in this BitVector, and 2) were also set in the other
BitVector.
=cut
void
logical_and(bit_vec, other)
BitVector *bit_vec;
BitVector *other;
PPCODE:
Kino1_BitVec_logical_and(bit_vec, other);
=for comment
Return a count of the number of set bits in the BitVector.
=cut
U32
count(bit_vec)
lib/KinoSearch1/Util/BitVector.pm view on Meta::CPAN
=for comment
Return an arrayref of the with each element the number of a set bit.
=cut
void
to_arrayref(bit_vec)
BitVector *bit_vec;
PREINIT:
AV *out_av;
PPCODE:
out_av = Kino1_BitVec_to_array(bit_vec);
XPUSHs( sv_2mortal(newRV_noinc( (SV*)out_av )) );
XSRETURN(1);
=for comment
Setters and getters. A quirk: set_bits automatically adjusts capacity
upwards to the appropriate multiple of 8 if necessary.
=cut
lib/KinoSearch1/Util/BitVector.pm view on Meta::CPAN
break;
KINO_END_SET_OR_GET_SWITCH
}
OUTPUT: RETVAL
void
DESTROY(bit_vec)
BitVector *bit_vec;
PPCODE:
Kino1_BitVec_destroy(bit_vec);
__H__
#ifndef H_KINO_BIT_VECTOR
#define H_KINO_BIT_VECTOR 1
#include "limits.h"
#include "EXTERN.h"
lib/KinoSearch1/Util/PriorityQueue.pm view on Meta::CPAN
MODULE = KinoSearch1 PACKAGE = KinoSearch1::Util::PriorityQueue
void
new(either_sv, ...)
SV *either_sv;
PREINIT:
const char *class;
HV *args_hash;
U32 max_size;
PriorityQueue *pq;
PPCODE:
/* determine the class */
class = sv_isobject(either_sv)
? sv_reftype(either_sv, 0)
: SvPV_nolen(either_sv);
/* process hash-style params */
Kino1_Verify_build_args_hash(args_hash,
"KinoSearch1::Util::PriorityQueue::instance_vars", 1);
max_size = (U32)SvUV( Kino1_Verify_extract_arg(args_hash, "max_size", 8) );
lib/KinoSearch1/Util/PriorityQueue.pm view on Meta::CPAN
Add an element to the Queue if either...
a) the queue isn't full, or
b) the element belongs in the queue and should displace another
=cut
void
insert(pq, element)
PriorityQueue *pq;
SV *element;
PPCODE:
Kino1_PriQ_insert(pq, element);
=for comment
Pop the *least* item off of the priority queue.
=cut
SV*
lib/KinoSearch1/Util/PriorityQueue.pm view on Meta::CPAN
Empty the queue into an array, with the highest priority item at index 0.
=cut
void
pop_all(pq)
PriorityQueue *pq;
PREINIT:
AV* out_av;
PPCODE:
out_av = Kino1_PriQ_pop_all(pq);
XPUSHs( sv_2mortal(newRV_noinc( (SV*)out_av )) );
SV*
_set_or_get(pq, ...)
PriorityQueue *pq;
ALIAS:
get_size = 2
get_max_size = 4
lib/KinoSearch1/Util/PriorityQueue.pm view on Meta::CPAN
break;
KINO_END_SET_OR_GET_SWITCH
}
OUTPUT: RETVAL
void
DESTROY(pq)
PriorityQueue *pq;
PPCODE:
Kino1_PriQ_destroy(pq);
__H__
#ifndef H_KINOSEARCH_UTIL_PRIORITY_QUEUE
#define H_KINOSEARCH_UTIL_PRIORITY_QUEUE 1
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
lib/KinoSearch1/Util/SortExternal.pm view on Meta::CPAN
void
_new(class, outstream_sv, invindex_sv, seg_name_sv, mem_threshold)
char *class;
SV *outstream_sv;
SV *invindex_sv;
SV *seg_name_sv;
I32 mem_threshold;
PREINIT:
SortExternal *sortex;
PPCODE:
sortex = Kino1_SortEx_new(outstream_sv, invindex_sv, seg_name_sv,
mem_threshold);
ST(0) = sv_newmortal();
sv_setref_pv( ST(0), class, (void*)sortex );
XSRETURN(1);
=for comment
Add one or more items to the sort pool.
=cut
void
feed(sortex, ...)
SortExternal *sortex;
PREINIT:
I32 i;
PPCODE:
for (i = 1; i < items; i++) {
SV const * item_sv = ST(i);
if (!SvPOK(item_sv))
continue;
sortex->feed(sortex, SvPVX(item_sv), SvCUR(item_sv));
}
=for comment
Fetch the next sorted item from the sort pool. sort_all must be called first.
lib/KinoSearch1/Util/SortExternal.pm view on Meta::CPAN
=for comment
Sort all items currently in memory.
=cut
void
_sort_cache(sortex)
SortExternal *sortex;
PPCODE:
Kino1_SortEx_sort_cache(sortex);
=for comment
Sort everything in memory and write the sorted elements to disk, creating a
SortExRun C object.
=cut
void
_sort_run(sortex);
SortExternal *sortex;
PPCODE:
Kino1_SortEx_sort_run(sortex);
=for comment
Turn on fetching.
=cut
void
_enable_fetch(sortex)
SortExternal *sortex;
PPCODE:
Kino1_SortEx_enable_fetch(sortex);
SV*
_set_or_get(sortex, ...)
SortExternal *sortex;
ALIAS:
_set_outstream = 1
_get_outstream = 2
_set_instream = 3
_get_instream = 4
lib/KinoSearch1/Util/SortExternal.pm view on Meta::CPAN
case 10: RETVAL = newSVsv(sortex->seg_name_sv);
break;
KINO_END_SET_OR_GET_SWITCH
}
OUTPUT: RETVAL
void
DESTROY(sortex)
SortExternal *sortex;
PPCODE:
Kino1_SortEx_destroy(sortex);
__H__
#ifndef H_KINOSEARCH_UTIL_SORT_EXTERNAL
#define H_KINOSEARCH_UTIL_SORT_EXTERNAL 1
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
( run in 1.231 second using v1.01-cache-2.11-cpan-5511b514fd6 )