version without global variables, one class for

the vectore-based Index now.

diff --git a/src/lexindex_stub.cpp b/src/lexindex_stub.cpp
index 315be7f..0a9df0f 100644 (file)
--- a/src/lexindex_stub.cpp
+++ b/src/lexindex_stub.cpp
@@ -1,4 +1,4 @@
-#include <cstring>
+a#include <cstring>
 #include <utility>
 #include <algorithm>
 #include <vector>
@@ -10,22 +10,25 @@
 // #include <algorithm>
 using namespace std;
 
-vector<int32_t> myvector;           
-vector<int32_t>::iterator it=myvector.begin();
-vector<int32_t> myvector2;           
-vector<int32_t>::iterator it2=myvector2.begin();
-xml_tree * tree;
-xml_tree::tag_t tag;
-xml_tree::tag_t tag2;
+struct myclass {
+  xml_tree * tree;
+  bool operator() (int32_t i,int32_t j) { 
+  return (strcmp((const char*) tree->get_text(i),
+                (const char*) tree->get_text(j))<0);}
+} myobject;
 
 //define a type for the lexicographic index
 
 class lex_index {
 public:
-  //The tag ID
+  //The tag IDs
   xml_tree::tag_t tag;
+  xml_tree::tag_t tag2;
   //The text data
-  std::vector<std::pair<std::string, xml_tree::node_t> > data;
+  vector<int32_t> tagVector;           
+  vector<int32_t>::iterator tagVectorIt;
+  vector<int32_t> tag2Vector;           
+  vector<int32_t>::iterator tag2VectorIt;
 };
 
 // class prefix_treeNode {
@@ -37,7 +40,6 @@ public:
 
 using namespace SXSI;
 
-
 static xml_tree*& XMLTREE(value v)
 {
   return Obj_val<xml_tree*>(v);
@@ -58,20 +60,17 @@ static xml_tree::tag_t TAG(value i)
   return static_cast<xml_tree::tag_t>(Int_val(i));
 }
 
-void preorderTraverse(xml_tree::tag_t parent_tag, xml_tree::node_t node){  
+void preorderTraverse(xml_tree * tree, xml_tree::tag_t parent_tag, xml_tree::node_t node, lex_index* lindex){  
   if (tree->tag(node)==tree->PCDATA_OPEN_TAG_ID)
-  if (parent_tag==tag) it = myvector.insert(it, tree->text_id(node));
-  else if (parent_tag==tag2) it2 = myvector2.insert(it2, tree->text_id(node));
-  if (tree->tag(tree->first_child(node))!=0) preorderTraverse(tree->tag(node), tree->first_child(node));
-  if (tree->tag(tree->next_sibling(node))!=0) preorderTraverse(parent_tag, tree->next_sibling(node));
-}
-
-bool myfunction (int32_t i,int32_t j) { 
-  return (strcmp((const char*) tree->get_text(i),
-                (const char*) tree->get_text(j))<0);
+  if (parent_tag==lindex->tag) lindex->tagVectorIt = 
+                               lindex->tagVector.insert(lindex->tagVectorIt, tree->text_id(node));
+  else if (parent_tag==lindex->tag2) lindex->tag2VectorIt = 
+                                     lindex->tag2Vector.insert(lindex->tag2VectorIt, tree->text_id(node));
+  if (tree->tag(tree->first_child(node))!=0) preorderTraverse(tree,tree->tag(node),tree->first_child(node),lindex);
+  if (tree->tag(tree->next_sibling(node))!=0) preorderTraverse(tree,parent_tag,tree->next_sibling(node),lindex);
 }
 
-vector<int32_t> mergeJoin(vector<int32_t> v1, vector<int32_t> v2){
+vector<int32_t> mergeJoin(xml_tree * tree, vector<int32_t> v1, vector<int32_t> v2){
   vector<int32_t> v;
   vector<int32_t>::iterator i=v.begin();
   vector<int32_t>::iterator i1=v1.begin();
@@ -95,7 +94,7 @@ vector<int32_t> mergeJoin(vector<int32_t> v1, vector<int32_t> v2){
   return(v);
 }
 
-void printIndex(const char * label, vector<int32_t> v){
+void printVector(const char * label, vector<int32_t> v){
   vector<int32_t>::iterator i=v.begin();
   if (i!=v.end()) {
       printf("%s-vector: [%i", label, *i);
@@ -109,21 +108,32 @@ ML_BINDING value caml_build_lex_index(value vtree, value vtag, value vtag2)
 {
   CAMLparam2(vtree, vtag);
   CAMLlocal1(vindex);
-  const char * s;
   vindex = sxsi_alloc_custom<lex_index*>();
-  tree = XMLTREE(vtree);
-  tag = TAG(vtag);
-  tag2 = TAG(vtag2);
+  xml_tree * tree = XMLTREE(vtree);
+  myobject.tree = tree;
+
+  //allocate a lex index
+  lex_index* mylindex = new lex_index();
+
+  //take the tag parameter given by ocaml and convert
+  //it to a C++ tag and store it in the tag field of mylindex
+  if ((TAG(vtag)==-1) || (TAG(vtag2)==-1)) caml_failwith("<INVALID TAG>");
+  mylindex->tag = TAG(vtag);
+  mylindex->tag2 = TAG(vtag2);
+
+  //initialize iterators for the two vectors 
+  mylindex->tagVectorIt=mylindex->tagVector.begin();
+  mylindex->tag2VectorIt=mylindex->tag2Vector.begin();
+
+  preorderTraverse(tree, 0, tree->first_child(tree->ROOT), mylindex);
+  sort(mylindex->tagVector.begin(), mylindex->tagVector.end(), myobject); 
+  sort(mylindex->tag2Vector.begin(), mylindex->tag2Vector.end(), myobject); 
+  printVector(tree->get_tag_name_by_ref(mylindex->tag), mylindex->tagVector);
+  printVector(tree->get_tag_name_by_ref(mylindex->tag2), mylindex->tag2Vector);
+  printVector("Result" , mergeJoin(tree, mylindex->tagVector, mylindex->tag2Vector));
+
   //Uncomment the following and comment the failwith line
-  //LEXINDEX(vindex) = ... return a lex_index* ....
-
-  if ((tag==-1) || (tag2==-1)) caml_failwith("<INVALID TAG>");
-  preorderTraverse(0, tree->first_child(tree->ROOT));
-  sort(myvector.begin(), myvector.end(), myfunction); 
-  sort(myvector2.begin(), myvector2.end(), myfunction); 
-  printIndex(tree->get_tag_name_by_ref(tag), myvector);
-  printIndex(tree->get_tag_name_by_ref(tag2), myvector2);
-  printIndex("Result" , mergeJoin(myvector, myvector2));
+  //LEXINDEX(vindex) = ... return a lex_index* ....  
 }
 
 ML_BINDING value caml_print_lex_index(value vindex)