/[hyperestraier_wrappers]/trunk/perl/HyperEstraierWrapper.cpp

This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!

Diff of /trunk/perl/HyperEstraierWrapper.cpp

Parent Directory | Revision Log | View Patch Patch

-revision 6 by dpavlin,
Sat Sep  3 20:00:11 2005 UTC
+revision 12 by dpavlin,
Thu Sep  8 22:51:10 2005 UTC
 Line 10
  #include <map>
  #include <cassert>
  #include <stdexcept>
+ #include <estnode.h>
  /* backward compatibility for 0.5.4 */
  #ifndef ESTCONDAGITO
-Line 454 
 namespace estraier {
+Line 455 
 namespace estraier {
                  return vs;
          }
+         class ResultDocument {
+         public:
+                 ESTRESDOC *rdoc;
+                 ResultDocument(ESTRESDOC *_rdoc) {
+                         rdoc = _rdoc;
+                 }
+                 const char *uri(void) {
+                         return est_resdoc_uri(rdoc);
+                 }
+                 std::vector<std::string> * attr_names() {
+                         std::vector<std::string> * vs = new std::vector<std::string>;
+                         CBLIST * attr_names = est_resdoc_attr_names(rdoc);
+                         for (int i=0; i < cblistnum(attr_names); i++) {
+                                 vs->push_back(cblistval(attr_names, i, NULL));
+                         }
+                         cblistclose(attr_names);
+                         return vs;
+                 }
+                 const char *attr(const char *name) {
+                         return est_resdoc_attr(rdoc, name);
+                 }
+                 const char *snippet(void) {
+                         return est_resdoc_snippet(rdoc);
+                 }
+         };
+         class NodeRes {
+         private:
+                 ESTNODERES *nres;
+         public:
+                 NodeRes(ESTNODE *node, Condition *cond, int depth) {
+                         nres = est_node_search(node, cond->cond, depth);
+                 }
+                 ~NodeRes() {
+                         est_noderes_delete(nres);
+                 }
+                 std::map<std::string, std::string> * hints(void) {
+                         std::map<std::string, std::string> * hints = new std::map<std::string, std::string>;
+                         CBMAP * keys = est_noderes_hints(nres);
+                         cbmapiterinit(keys);
+                         int ksiz;
+                         while (const char *key = cbmapiternext(keys, &ksiz)) {
+                                 hints->insert(std::make_pair(key, cbmapget(keys, key, ksiz, NULL)));
+                         }
+                         return hints;
+                 }
+                 int doc_num(void) {
+                         return est_noderes_doc_num(nres);
+                 }
+                 ResultDocument * get_doc(int index) {
+                         ESTRESDOC *rdoc = est_noderes_get_doc(nres, index);
+                         if (rdoc) {
+                                 return new ResultDocument(rdoc);
+                         } else {
+                                 throw IOError("wtf? no document?");
+                                 return NULL;
+                         }
+                 }
+         };
+         class Node {
+         private:
+                 ESTNODE *node;
+                 int netenv_ok;
+         public:
+                 Node(const char *url) {
+                         netenv_ok = est_init_net_env();
+                         if (! netenv_ok) throw IOError("can't init net env");
+                         node = est_node_new(url);
+                         if (! node) throw IOError("can't create node");
+                 }
+                 ~Node() {
+                         est_node_delete(node);
+                         est_free_net_env();
+                 }
+                 void set_proxy(const char *host, int port) {
+                         est_node_set_proxy(node, host, port);
+                 }
+                 void set_timeout(int sec) {
+                         est_node_set_timeout(node, sec);
+                 }
+                 void set_auth(const char *name, const char *passwd) {
+                         est_node_set_auth(node, name, passwd);
+                 }
+                 int status(void) {
+                         return est_node_status(node);
+                 }
+                 bool put_doc(Document *doc) {
+                         return est_node_put_doc(node, doc->doc);
+                 }
+                 bool out_doc(int id) {
+                         return est_node_out_doc(node, id);
+                 }
+                 bool out_doc_by_uri(const char *uri) {
+                         return est_node_out_doc_by_uri(node, uri);
+                 }
+ #ifdef est_node_edit_doc
+                 bool edit_doc(Document *doc) {
+                         return est_node_edit_doc(node, doc->doc);
+                 }
+ #endif
+                 Document * get_doc(int id) {
+                         ESTDOC *doc = est_node_get_doc(node, id);
+                         if (!doc) {
+                                 return NULL;
+                         } else {
+                                 return new Document(doc);
+                         }
+                 }
+                 Document * get_doc_by_uri(const char *uri) {
+                         ESTDOC *doc = est_node_get_doc_by_uri(node, uri);
+                         if (!doc) {
+                                 return NULL;
+                         } else {
+                                 return new Document(doc);
+                         }
+                 }
+                 char * get_doc_attr(int id, const char *name) {
+                         /* is this leeking memory? shouldn't I create
+                          * object and free memory region returned?
+                          */
+                         return est_node_get_doc_attr(node, id, name);
+                 }
+                 char * get_doc_attr_by_uri(const char *uri, const char *name) {
+                         return est_node_get_doc_attr_by_uri(node, uri, name);
+                 }
+                 int uri_to_id(const char *uri) {
+                         return est_node_uri_to_id(node, uri);
+                 }
+                 const char * name(void) {
+                         return est_node_name(node);
+                 }
+                 const char * label(void) {
+                         return est_node_label(node);
+                 }
+                 int doc_num(void) {
+                         return est_node_doc_num(node);
+                 }
+                 int word_num(void) {
+                         return est_node_word_num(node);
+                 }
+                 double size(void) {
+                         return est_node_size(node);
+                 }
+                 NodeRes * search(Condition *cond, int depth) {
+                         return new NodeRes(node, cond, depth);
+                 }
+                 int set_user(const char *name, int mode) {
+                         return est_node_set_user(node, name, mode);
+                 }
+                 int set_link(const char *url, const char *label, int credit) {
+                         return est_node_set_link(node, url, label, credit);
+                 }
+         };
  };

 Legend:



Removed from v.6
 


changed lines


 
Added in v.12
 Legend:



Removed from v.6
 


changed lines


 
Added in v.12
-Removed from v.6
+Added in v.12

	ViewVC Help
Powered by ViewVC 1.1.26