1 /**************************************
4 * An Ocaml Driver which calls the C++ methods and
5 * adds a C wrapper interface with OCaml code.
13 * functions never doing any allocation (non caml_alloc*, caml_copy_string,...)
14 * have NOALLOC in the comment and their external declaration can have "noalloc"
18 #include <unordered_set>
22 #include "XMLTreeBuilder.h"
24 #include "common_stub.hpp"
26 #define CAMLRAISEMSG(msg) (sxsi_raise_msg((char*) (msg)))
28 #define XMLTREE(x) (Obj_val<XMLTree*>(x))
30 #define HSET(x) (Obj_val<TagIdSet*>(x))
32 #define XMLTREEBUILDER(x) (Obj_val<XMLTreeBuilder*>(x))
35 #define TREENODEVAL(i) ((treeNode) (Int_val(i)))
36 #define TAGVAL(i) ((TagType) (Int_val(i)))
37 #define XMLTREE_ROOT 0
42 #include <sys/resource.h>
47 /** XMLTreeBuilder bindings
51 extern "C" value caml_xml_tree_builder_create(value unit)
55 result = sxsi_alloc_custom<XMLTreeBuilder*>();
56 Obj_val<XMLTreeBuilder*>(result) = new XMLTreeBuilder();
61 extern "C" value caml_xml_tree_builder_open_document(value vbuilder,
67 CAMLparam5(vbuilder, vet, vsrate, vdtc, vidxtype);
68 bool empty_text = Bool_val(vet);
69 int sample_rate = Int_val(vsrate);
70 bool disable_tc = Bool_val(vdtc);
71 TextCollectionBuilder::index_type_t idx_type;
72 switch (Int_val(vidxtype)){
74 idx_type = TextCollectionBuilder::index_type_default;
77 idx_type = TextCollectionBuilder::index_type_swcsa;
80 idx_type = TextCollectionBuilder::index_type_rlcsa;
83 CAMLRAISEMSG("Invalid Index Type");
85 int res = XMLTREEBUILDER(vbuilder)->OpenDocument(empty_text,
90 CAMLRAISEMSG("OpenDocument");
92 CAMLreturn (Val_unit);
95 extern "C" value caml_xml_tree_builder_close_document(value vbuilder)
99 XMLTree * tree = XMLTREEBUILDER(vbuilder)->CloseDocument();
101 CAMLRAISEMSG("CloseDocument");
102 result = sxsi_alloc_custom<XMLTree*>();
103 Obj_val<XMLTree*>(result) = tree;
107 extern "C" value caml_xml_tree_builder_new_open_tag(value vbuilder, value vtag)
109 CAMLparam2(vbuilder, vtag);
110 const char * tag = String_val(vtag);
111 if (XMLTREEBUILDER(vbuilder)->NewOpenTag(std::string(tag)) == NULLT)
112 CAMLRAISEMSG("NewOpenTag");
114 CAMLreturn (Val_unit);
117 extern "C" value caml_xml_tree_builder_new_closing_tag(value vbuilder, value vtag)
119 CAMLparam2(vbuilder, vtag);
120 const char * tag = String_val(vtag);
121 if (XMLTREEBUILDER(vbuilder)->NewClosingTag(std::string(tag)) == NULLT)
122 CAMLRAISEMSG("NewClosingTag");
124 CAMLreturn (Val_unit);
127 extern "C" value caml_xml_tree_builder_new_text(value vbuilder, value vtext)
129 CAMLparam2(vbuilder, vtext);
130 const char * text = String_val(vtext);
131 if (XMLTREEBUILDER(vbuilder)->NewText(std::string(text)) == NULLT)
132 CAMLRAISEMSG("NewText");
134 CAMLreturn (Val_unit);
138 /*************************************************************************/
142 * All of the functions here call the _unsafe version and implement the logics themselves
143 * (test for NULLT and so on). This avoids one indirection + one call when the tests fails.
147 extern "C" value caml_xml_tree_save(value tree,value fd, value name){
148 CAMLparam3(tree, fd, name);
149 XMLTREE(tree)->Save(Int_val(fd), String_val(name));
150 CAMLreturn (Val_unit);
153 extern "C" value caml_xml_tree_load(value fd, value name, value load_tc,value sf){
154 CAMLparam4(fd, name, load_tc, sf);
155 CAMLlocal2(result,tmp);
159 tree = XMLTree::Load(Int_val(fd),Bool_val(load_tc),Int_val(sf), String_val(name));
160 result = sxsi_alloc_custom<XMLTree*>();
162 Obj_val<XMLTree*>(result) = tree;
163 tmp = sxsi_alloc_custom<long>();
164 Obj_val<long>(tmp) = 3l;
167 catch (const std::exception& e){ CAMLRAISEMSG(e.what()); }
168 catch (std::string msg){ CAMLRAISEMSG(msg.c_str()); }
169 catch (char const * msg){ CAMLRAISEMSG(msg); };
175 NoAlloc extern "C" value caml_xml_tree_root(value tree){
176 return (Val_int(XMLTREE_ROOT));
179 NoAlloc extern "C" value caml_xml_tree_size(value tree){
180 return (Val_int(XMLTREE(tree)->Size()));
183 NoAlloc extern "C" value caml_xml_tree_num_tags(value tree){
184 return (Val_int(XMLTREE(tree)->NumTags()));
187 NoAlloc extern "C" value caml_xml_tree_subtree_size(value tree, value node){
188 return (Val_int(XMLTREE(tree)->SubtreeSize(TREENODEVAL(node))));
191 NoAlloc extern "C" value caml_xml_tree_subtree_tags(value tree, value node, value tag){
192 return (Val_int(XMLTREE(tree)->SubtreeTags(TREENODEVAL(node), TAGVAL(tag))));
195 NoAlloc extern "C" value caml_xml_tree_subtree_elements(value tree, value node){
196 return (Val_int(XMLTREE(tree)->SubtreeElements(TREENODEVAL(node))));
199 NoAlloc extern "C" value caml_xml_tree_is_leaf(value tree, value node){
200 return (Val_bool(XMLTREE(tree)->IsLeaf(TREENODEVAL(node))));
203 NoAlloc extern "C" value caml_xml_tree_is_ancestor(value tree, value node1,value node2){
204 return (Val_bool(XMLTREE(tree)->IsAncestor(TREENODEVAL(node1),TREENODEVAL(node2))));
207 NoAlloc extern "C" value caml_xml_tree_is_child(value tree, value node1,value node2){
208 return (Val_bool(XMLTREE(tree)->IsChild(TREENODEVAL(node1),TREENODEVAL(node2))));
211 NoAlloc extern "C" value caml_xml_tree_is_first_child(value tree, value node){
212 return (Val_bool(XMLTREE(tree)->IsFirstChild(TREENODEVAL(node))));
214 NoAlloc extern "C" value caml_xml_tree_is_right_descendant(value tree, value x, value y){
215 return (Val_bool(XMLTREE(tree)->IsRightDescendant(TREENODEVAL(x), TREENODEVAL(y))));
217 NoAlloc extern "C" value caml_xml_tree_num_children(value tree, value node){
218 return (Val_int(XMLTREE(tree)->NumChildren(TREENODEVAL(node))));
221 NoAlloc extern "C" value caml_xml_tree_child_number(value tree, value node){
222 return (Val_int(XMLTREE(tree)->ChildNumber(TREENODEVAL(node))));
225 NoAlloc extern "C" value caml_xml_tree_depth(value tree, value node){
226 return (Val_int(XMLTREE(tree)->Depth(TREENODEVAL(node))));
229 NoAlloc extern "C" value caml_xml_tree_preorder(value tree, value node){
230 return (Val_int(XMLTREE(tree)->Preorder(TREENODEVAL(node))));
233 NoAlloc extern "C" value caml_xml_tree_postorder(value tree, value node){
234 return (Val_int(XMLTREE(tree)->Postorder(TREENODEVAL(node))));
237 NoAlloc extern "C" value caml_xml_tree_tag(value tree, value node) throw () {
238 return (Val_int(XMLTREE(tree)->Tag(TREENODEVAL(node))));
241 extern "C" value caml_xml_tree_doc_ids(value tree, value node){
242 CAMLparam2(tree,node);
245 tuple = caml_alloc(2,0);
246 ids = XMLTREE(tree)->DocIds(Int_val(node));
247 Store_field(tuple,0,Val_int(ids.min));
248 Store_field(tuple,1,Val_int(ids.max));
252 NoAlloc extern "C" value caml_xml_tree_parent(value tree, value node){
253 return (Val_int(XMLTREE(tree)->Parent(TREENODEVAL(node))));
256 NoAlloc extern "C" value caml_xml_tree_binary_parent(value tree, value node){
257 return (Val_int(XMLTREE(tree)->BinaryParent(TREENODEVAL(node))));
260 NoAlloc extern "C" value caml_xml_tree_child(value tree, value node,value idx){
261 return (Val_int(XMLTREE(tree)->Child(TREENODEVAL(node),Int_val(idx))));
264 NoAlloc extern "C" value caml_xml_tree_first_child(value tree, value node){
265 return (Val_int(XMLTREE(tree)->FirstChild(TREENODEVAL(node))));
268 NoAlloc extern "C" value caml_xml_tree_first_element(value tree, value node){
269 return (Val_int(XMLTREE(tree)->FirstElement(TREENODEVAL(node))));
272 NoAlloc extern "C" value caml_xml_tree_last_child(value tree, value node){
273 return (Val_int(XMLTREE(tree)->LastChild(TREENODEVAL(node))));
276 NoAlloc extern "C" value caml_xml_tree_next_sibling(value tree, value node){
277 return (Val_int(XMLTREE(tree)->NextSibling(TREENODEVAL(node))));
280 NoAlloc extern "C" value caml_xml_tree_next_element(value tree, value node){
281 return (Val_int(XMLTREE(tree)->NextElement(TREENODEVAL(node))));
284 NoAlloc extern "C" value caml_xml_tree_next_node_before(value tree, value node, value ctx){
285 return (Val_int(XMLTREE(tree)->NextNodeBefore(TREENODEVAL(node), TREENODEVAL(ctx))));
288 NoAlloc extern "C" value caml_xml_tree_prev_sibling(value tree, value node){
289 return (Val_int(XMLTREE(tree)->PrevSibling(TREENODEVAL(node))));
292 NoAlloc extern "C" value caml_xml_tree_tagged_child(value tree, value node,value tag){
293 return (Val_int(XMLTREE(tree)->TaggedChild(TREENODEVAL(node),TAGVAL(tag))));
296 NoAlloc extern "C" value caml_xml_tree_select_child(value tree, value node,value tags){
297 return (Val_int(XMLTREE(tree)->SelectChild(TREENODEVAL(node), HSET(tags))));
300 NoAlloc extern "C" value caml_xml_tree_tagged_following_sibling(value tree, value node,value tag){
301 return (Val_int(XMLTREE(tree)->TaggedFollowingSibling(TREENODEVAL(node),TAGVAL(tag))));
304 NoAlloc extern "C" value caml_xml_tree_select_following_sibling(value tree, value node,value tags){
305 return (Val_int(XMLTREE(tree)->SelectFollowingSibling(TREENODEVAL(node), HSET(tags))));
308 NoAlloc extern "C" value caml_xml_tree_tagged_descendant(value tree, value node, value tag){
309 return (Val_int(XMLTREE(tree)->TaggedDescendant(TREENODEVAL(node), TAGVAL(tag))));
312 NoAlloc extern "C" value caml_xml_tree_tagged_next(value tree, value node, value tag){
313 return (Val_int(XMLTREE(tree)->TaggedNext(TREENODEVAL(node), TAGVAL(tag))));
316 NoAlloc extern "C" value caml_xml_tree_select_descendant(value tree, value node, value tags){
317 return (Val_int(XMLTREE(tree)->SelectDescendant(TREENODEVAL(node), HSET(tags))));
320 NoAlloc extern "C" value caml_xml_tree_tagged_preceding(value tree, value node, value tag){
321 return (Val_int(XMLTREE(tree)->TaggedPreceding(TREENODEVAL(node), TAGVAL(tag))));
324 NoAlloc extern "C" value caml_xml_tree_tagged_following(value tree, value node, value tag){
325 return (Val_int(XMLTREE(tree)->TaggedFollowing(TREENODEVAL(node), TAGVAL(tag))));
328 NoAlloc extern "C" value caml_xml_tree_tagged_following_below(value tree, value node, value tag, value ancestor){
329 return (Val_int(XMLTREE(tree)->TaggedFollowingBelow(TREENODEVAL(node), TAGVAL(tag), TREENODEVAL(ancestor))));
332 NoAlloc extern "C" value caml_xml_tree_select_following_below(value tree, value node, value tags, value ancestor){
333 return (Val_int(XMLTREE(tree)->SelectFollowingBelow(TREENODEVAL(node), HSET(tags), TREENODEVAL(ancestor))));
336 NoAlloc extern "C" value caml_xml_tree_tagged_following_before(value tree, value node, value tag, value closing){
337 return (Val_int(XMLTREE(tree)->TaggedFollowingBefore(TREENODEVAL(node), TAGVAL(tag), TREENODEVAL(closing))));
340 NoAlloc extern "C" value caml_xml_tree_select_following_before(value tree, value node, value tags, value closing){
341 return (Val_int(XMLTREE(tree)->SelectFollowingBefore(TREENODEVAL(node), HSET(tags), TREENODEVAL(closing))));
344 NoAlloc extern "C" value caml_xml_tree_tagged_ancestor(value tree, value node, value tag){
345 return (Val_int(XMLTREE(tree)->TaggedAncestor(TREENODEVAL(node), TAGVAL(tag))));
348 NoAlloc extern "C" value caml_xml_tree_my_text(value tree, value node){
349 return (Val_int(XMLTREE(tree)->MyText(TREENODEVAL(node))));
352 NoAlloc extern "C" value caml_xml_tree_my_text_unsafe(value tree, value node){
353 return (Val_int(XMLTREE(tree)->MyTextUnsafe(TREENODEVAL(node))));
356 NoAlloc extern "C" value caml_xml_tree_text_xml_id(value tree, value docid){
357 return (Val_int(XMLTREE(tree)->TextXMLId(Int_val(docid))));
360 NoAlloc extern "C" value caml_xml_tree_node_xml_id(value tree, value node){
361 return (Val_int(XMLTREE(tree)->NodeXMLId(TREENODEVAL(node))));
364 NoAlloc extern "C" value caml_xml_tree_parent_node(value tree, value docid){
365 return (Val_int(XMLTREE(tree)->ParentNode(Int_val(docid))));
368 NoAlloc extern "C" value caml_xml_tree_prev_node(value tree, value docid){
369 return (Val_int(XMLTREE(tree)->PrevNode(Int_val(docid))));
372 extern "C" value caml_xml_tree_get_tag_id(value tree, value tagname){
373 CAMLparam2(tree,tagname);
375 unsigned char* ctagname = (unsigned char*) strdup(String_val(tagname));
376 res = Val_int(XMLTREE(tree)->GetTagId(ctagname));
381 extern "C" value caml_xml_tree_get_tag_name(value tree, value tag){
382 CAMLparam2(tree,tag);
384 res = caml_copy_string((const char*) XMLTREE(tree)->GetTagNameByRef(TAGVAL(tag)));
388 extern "C" value caml_xml_tree_register_tag(value tree, value tagname){
389 CAMLparam2(tree,tagname);
391 unsigned char* ctagname = (unsigned char*) strdup(String_val(tagname));
392 res = Val_int(XMLTREE(tree)->RegisterTag(ctagname));
398 NoAlloc extern "C" value caml_xml_tree_get_text_collection(value tree){
399 return((value) XMLTREE(tree)->getTextCollection());
402 NoAlloc extern "C" value caml_xml_tree_closing(value tree, value node){
403 return (Val_int(XMLTREE(tree)->Closing(TREENODEVAL(node))));
406 NoAlloc extern "C" value caml_xml_tree_is_open(value tree, value node){
407 return (Val_bool(XMLTREE(tree)->IsOpen(TREENODEVAL(node))));
412 NoAlloc extern "C" value caml_xml_tree_nullt(value unit){
417 NoAlloc extern "C" value caml_unordered_set_length(value hset){
418 return (Val_int((HSET(hset))->size()));
421 extern "C" value caml_unordered_set_alloc(value unit){
424 hset = sxsi_alloc_custom<TagIdSet*>();
425 Obj_val<TagIdSet*>(hset) = new TagIdSet();
429 NoAlloc extern "C" value caml_unordered_set_set(value set, value v){
430 HSET(set)->insert((int) Int_val(v));
434 // NoAlloc extern "C" value caml_result_set_create(value size){
435 // results* res = (results*) malloc(sizeof(results));
436 // results r = createResults (Int_val(size));
439 // res->tree = r.tree;
440 // return ((value) (res));
443 // NoAlloc extern "C" value caml_result_set_set(value result,value p){
444 // setResult ( *((results*) result), Int_val(p));
445 // return (Val_unit);
448 // NoAlloc extern "C" value caml_result_set_clear(value result,value p1,value p2){
449 // clearRange ( *((results*) result), Int_val(p1), Int_val(p2));
450 // return (Val_unit);
453 // NoAlloc extern "C" value caml_result_set_next(value result,value p){
455 // r = *( (results *) result);
456 // return (Val_int(nextResult(r, Int_val(p))));
459 // NoAlloc extern "C" value caml_result_set_count(value result){
461 // r = *( (results *) result);
462 // return (Val_int(countResult(r)));
465 NoAlloc extern "C" value caml_xml_tree_print(value tree,value node,value fd){
466 CAMLparam3(tree,node,fd);
467 XMLTREE(tree)->Print(Int_val(fd),TREENODEVAL(node), false);
468 CAMLreturn(Val_unit);
471 NoAlloc extern "C" value caml_xml_tree_flush(value tree, value fd){
473 XMLTREE(tree)->Flush(Int_val(fd));
474 CAMLreturn(Val_unit);
477 // NoAlloc extern "C" value caml_set_tag_bits(value result, value tag, value tree, value node)
480 // XMLTree *t = XMLTREE(Field(tree,0));
481 // treeNode opening = TREENODEVAL(node);
482 // treeNode closing = t->Closing(opening);
483 // TagType target_tag = Int_val(tag);
484 // treeNode first = t->TaggedDescendant(opening,target_tag);
485 // r = *( (results *) result);
487 // while (opening != NULLT){
488 // setResult(r,opening);
489 // opening = t->TaggedFollowingBefore(opening,target_tag,closing);
491 // return(Val_int(first));
495 NoAlloc extern "C" value caml_bit_vector_create(value size){
496 return (value) (new vector<bool>(Int_val(size),false));
499 NoAlloc extern "C" value caml_bit_vector_free(value vect){
500 delete ((vector<bool>*) vect);
504 NoAlloc extern "C" value caml_bit_vector_get(value vect,value idx){
505 return Val_bool (((vector<bool>*)vect)->at(Int_val(idx)));
508 NoAlloc extern "C" value caml_bit_vector_set(value vect,value idx,value b){
509 (((vector<bool>*)vect)->at(Int_val(idx))) = (bool) Bool_val(b);
513 NoAlloc extern "C" value caml_bit_vector_next(value vect,value idx){
514 vector<bool>* bv = (vector<bool>*) vect;
515 int i = Int_val(idx);
517 while (i < l && !((*bv)[i]))
521 NoAlloc extern "C" value caml_bit_vector_prev(value vect,value idx){
522 int i = Int_val(idx);
523 while (i >= 0 && !((*((vector<bool>*) vect))[i]))
528 extern "C" value caml_bit_vector_node_array(value vect){
531 vector<bool>* bv = (vector<bool>*) vect;
536 if ((*bv)[i]) vr.push_back(i);
540 res = caml_alloc_tuple(l);
542 caml_initialize(&Field(res,i),Val_int(vr[i]));
547 int iterjump(XMLTree* tree, treeNode node, TagType tag, treeNode anc){
553 + iterjump(tree,tree->TaggedDescendant(node,tag),tag,node)
554 + iterjump(tree,tree->TaggedFollowingBelow(node,tag,anc),tag,anc);
558 extern "C" value caml_benchmark_jump(value tree,value tag){
560 treeNode root = XMLTREE(tree)->FirstChild(0);
561 root = XMLTREE(tree)->FirstChild(root);
562 count = iterjump(XMLTREE(tree), root , Int_val(tag),0);
563 return Val_int(count);
566 int iterfcns(XMLTree* tree, treeNode node){
571 tmp += iterfcns(tree,tree->FirstChild(node));
572 tmp += iterfcns(tree,tree->NextSibling(node));
578 int iterfene(XMLTree* tree, treeNode node){
583 tmp += iterfene(tree,tree->FirstElement(node));
584 tmp += iterfene(tree,tree->NextElement(node));
590 extern "C" value caml_benchmark_fcns(value tree){
591 int i = iterfcns(XMLTREE(tree),0);
595 extern "C" value caml_benchmark_fene(value tree){
596 int i = iterfene(XMLTREE(tree),0);
600 int iterlcps(XMLTree* tree, treeNode node){
604 int x = tree->Tag(node);
605 x += iterlcps(tree,tree->LastChild(node));
606 x += iterlcps(tree,tree->PrevSibling(node));
611 int fulliterative(XMLTree* tree){
612 treeNode current = tree->Root();
613 treeNode next = NULLT;
614 int count = 1; //the root
618 while ((next = tree->FirstChild(current)) != NULLT) {
623 while ( (next = tree->NextSibling(current)) == NULLT){
624 current = tree->Parent(current);
625 if (current == NULLT) return count;
633 extern "C" value caml_benchmark_iter(value tree){
634 return Val_int(fulliterative(XMLTREE(tree)));
637 extern "C" value caml_benchmark_lcps(value tree){
639 iterlcps(XMLTREE(tree),0);
646 typedef struct dummy_node_ {
647 struct dummy_node_* first;
648 struct dummy_node_* next;
652 dummy_node * new_dummy_node () {
654 dummy_node * node = (dummy_node*) malloc(sizeof(dummy_node));
656 printf("%s","Cannot allocate memory\n");
661 void free_tree(dummy_node * node){
663 free_tree(node->first);
664 free_tree(node->next);
670 dummy_node * create_tree(XMLTree* tree, treeNode i, int mode){
674 dummy_node * f, *n, *r;
677 if (mode == 0) r = new_dummy_node();
678 f = create_tree(tree,tree->FirstChild(i), mode);
679 if (mode == 1) r = new_dummy_node();
680 n = create_tree(tree,tree->NextSibling(i), mode);
681 if (mode == 2) r = new_dummy_node();
688 int iter_tree(dummy_node * n){
692 return 1 + iter_tree (n->first) + iter_tree (n->next);
695 extern "C" value caml_build_pointers(value tree, value mode){
696 return ((value) create_tree(XMLTREE(Field(tree,0)),0, Int_val(mode)));
699 extern "C" value caml_iter_pointers (value node){
700 return Val_int(iter_tree((dummy_node*) node));
704 extern "C" value caml_free_pointers(value node){
705 free_tree((dummy_node*) node);
709 * Interface to the TextCollection
716 extern "C" value caml_text_collection_get_text(value tree, value id){
719 uchar* txt = XMLTREE(tree)->GetText((DocID) Int_val(id));
720 str = caml_copy_string((const char*)txt);
725 extern "C" value caml_text_collection_empty_text(value tree,value id){
727 CAMLreturn ( Val_int((XMLTREE(tree))->EmptyText((DocID) Int_val(id))));
730 bool docId_comp(DocID x, DocID y) { return x < y; }
733 * Existential queries
736 extern "C" value caml_text_collection_is_prefix(value tree,value str){
737 CAMLparam2(tree,str);
738 uchar * cstr = (uchar *) String_val(str);
739 CAMLreturn (Val_bool((int) XMLTREE(tree)->IsPrefix(cstr)));
742 extern "C" value caml_text_collection_is_suffix(value tree,value str){
743 CAMLparam2(tree,str);
744 uchar * cstr = (uchar *) String_val(str);
745 CAMLreturn (Val_bool((int) XMLTREE(tree)->IsSuffix(cstr)));
747 extern "C" value caml_text_collection_is_equal(value tree,value str){
748 CAMLparam2(tree,str);
749 uchar * cstr = (uchar *) String_val(str);
750 CAMLreturn (Val_bool((int) XMLTREE(tree)->IsEqual(cstr)));
752 extern "C" value caml_text_collection_is_contains(value tree,value str){
753 CAMLparam2(tree,str);
754 uchar * cstr = (uchar *) String_val(str);
755 CAMLreturn ( Val_bool((int) XMLTREE(tree)->IsContains(cstr)));
758 extern "C" value caml_text_collection_is_lessthan(value tree,value str){
759 CAMLparam2(tree,str);
760 uchar * cstr = (uchar *) String_val(str);
761 CAMLreturn ( Val_bool((int) XMLTREE(tree)->IsLessThan(cstr)));
772 extern "C" value caml_text_collection_count(value tree,value str){
773 CAMLparam2(tree,str);
774 uchar * cstr = (uchar *) String_val(str);
775 CAMLreturn (Val_int((XMLTREE(tree)->Count(cstr))));
778 extern "C" value caml_text_collection_count_prefix(value tree,value str){
779 CAMLparam2(tree,str);
780 uchar * cstr = (uchar *) String_val(str);
781 CAMLreturn (Val_int((XMLTREE(tree)->CountPrefix(cstr))));
784 extern "C" value caml_text_collection_count_suffix(value tree,value str){
785 CAMLparam2(tree,str);
786 uchar * cstr = (uchar *) String_val(str);
787 CAMLreturn (Val_int((XMLTREE(tree)->CountSuffix(cstr))));
790 extern "C" value caml_text_collection_count_equal(value tree,value str){
791 CAMLparam2(tree,str);
792 uchar * cstr = (uchar *) String_val(str);
793 CAMLreturn (Val_int((XMLTREE(tree)->CountEqual(cstr))));
796 extern "C" value caml_text_collection_count_contains(value tree,value str){
797 CAMLparam2(tree,str);
798 uchar * cstr = (uchar *) String_val(str);
799 CAMLreturn (Val_int((XMLTREE(tree)->CountContains(cstr))));
802 extern "C" value caml_text_collection_count_lessthan(value tree,value str){
803 CAMLparam2(tree,str);
804 uchar * cstr = (uchar *) String_val(str);
805 CAMLreturn (Val_int((XMLTREE(tree)->CountLessThan(cstr))));
808 static value sort_alloc_array(std::vector<DocID> results, value resarray){
809 std::sort(results.begin(), results.end(), docId_comp);
810 size_t s = results.size();
811 resarray = caml_alloc_tuple(s);
812 for (size_t i = 0; i < s ;i++){
813 caml_initialize(&Field(resarray,i),Val_int(results[i]));
820 * Full reporting queries
823 extern "C" value caml_text_collection_prefix(value tree,value str){
824 CAMLparam2(tree,str);
825 CAMLlocal1(resarray);
826 uchar * cstr = (uchar *) String_val(str);
827 std::vector<DocID> results = XMLTREE(tree)->Prefix(cstr);
828 CAMLreturn (sort_alloc_array(results,resarray));
831 extern "C" value caml_text_collection_suffix(value tree,value str){
832 CAMLparam2(tree,str);
833 CAMLlocal1(resarray);
834 uchar * cstr = (uchar *) String_val(str);
835 std::vector<DocID> results = XMLTREE(tree)->Suffix(cstr);
836 CAMLreturn (sort_alloc_array(results,resarray));
839 extern "C" value caml_text_collection_equals(value tree,value str){
840 CAMLparam2(tree,str);
841 CAMLlocal1(resarray);
842 uchar * cstr = (uchar *) strdup(String_val(str));
843 std::vector<DocID> results = XMLTREE(tree)->Equals(cstr);
845 CAMLreturn (sort_alloc_array(results,resarray));
848 extern "C" value caml_text_collection_contains(value tree,value str){
849 CAMLparam2(tree,str);
850 CAMLlocal1(resarray);
851 uchar * cstr = (uchar *) String_val(str);
852 std::vector<DocID> results = XMLTREE(tree)->Contains(cstr);
853 CAMLreturn (sort_alloc_array(results,resarray));
856 extern "C" value caml_text_collection_lessthan(value tree,value str){
857 CAMLparam2(tree,str);
858 CAMLlocal1(resarray);
859 uchar * cstr = (uchar *) String_val(str);
860 std::vector<DocID> results = XMLTREE(tree)->LessThan(cstr);
861 CAMLreturn (sort_alloc_array(results,resarray));
864 /** Full reporting into a bit vector
867 #define BV_QUERY(pref, Pref) \
868 extern "C" value caml_text_collection_## pref ##_bv(value tree, value str){ \
869 CAMLparam2(tree, str); \
870 CAMLlocal3(res, res_bv, res_array); \
872 uchar * cstr = (uchar *) strdup(String_val(str)); \
873 std::vector<DocID> results = XMLTREE(tree)->Pref(cstr); \
874 res_bv = caml_alloc_string((XMLTREE(tree)->Size() / 4) + 2); \
875 unsigned long slen = caml_string_length(res_bv); \
876 memset(&(Byte(res_bv,0)), 0, slen); \
877 res_array = caml_alloc_shr(results.size(), 0); \
878 for (unsigned int i = 0; i < results.size(); ++i) { \
879 j = XMLTREE(tree)->ParentNode(results[i]); \
880 Byte(res_bv, j >> 3) |= (1 << (j & 7)); \
881 caml_initialize(&Field(res_array, i), Val_int(j)); \
884 res = caml_alloc(2, 0); \
885 Store_field(res, 0, res_bv); \
886 Store_field(res, 1, res_array); \
891 BV_QUERY(prefix, Prefix)
892 BV_QUERY(suffix, Suffix)
893 BV_QUERY(equals, Equals)
894 BV_QUERY(contains, Contains)
895 BV_QUERY(lessthan, LessThan)