/[hyperestraier_wrappers]/0.0.13/HyperEstraierWrapper.cpp
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Annotation of /0.0.13/HyperEstraierWrapper.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 14 - (hide annotations)
Fri Sep 9 15:26:39 2005 UTC (14 years, 1 month ago) by dpavlin
File size: 11650 byte(s)
import of 0.0.13
1 dpavlin 1 /**
2     * HyperEstraierWrapper.cpp - C++ wrapper for Hyper Estraier
3     */
4     #include <estraier.h>
5     #include <estmtdb.h>
6     #include <cabin.h>
7     #include <cstdlib>
8     #include <string>
9     #include <vector>
10     #include <map>
11     #include <cassert>
12     #include <stdexcept>
13    
14     namespace estraier {
15    
16     class IOError : public std::runtime_error {
17     public:
18     explicit IOError (const std::string& w) : std::runtime_error(w) {}
19     };
20    
21     class Condition {
22     public:
23     enum { // enumeration for options
24     SURE = ESTCONDSURE, // check every N-gram key
25     USUAL = ESTCONDUSUAL, // check N-gram keys skipping by one
26     FAST = ESTCONDFAST, // check N-gram keys skipping by two
27     AGITO = ESTCONDAGITO, // check N-gram keys skipping by three
28     NOIDF = ESTCONDNOIDF, // without TF-IDF tuning
29     SIMPLE = ESTCONDSIMPLE, // with the simplefied phrase
30     };
31     ESTCOND * cond;
32     Condition() {
33     /**
34     * constructor
35     */
36     cond = est_cond_new();
37     }
38     ~Condition() {
39     /**
40     * destructor
41     */
42     est_cond_delete(cond);
43     }
44     void set_phrase(const char *phrase) {
45     /**
46     * set the search phrase
47     */
48     est_cond_set_phrase(cond, phrase);
49     }
50     void add_attr(const char *expr) {
51     /**
52     * set the attribute expression
53     */
54     est_cond_add_attr(cond, expr);
55     }
56     void set_order(const char *expr) {
57     /**
58     * set the order of a condition object
59     */
60     est_cond_set_order(cond, expr);
61     }
62     void set_max(int _max) {
63     /**
64     * set the maximum number of retrieval of a condition object
65     */
66     est_cond_set_max(cond, _max);
67     }
68     void set_options(int options) {
69     /**
70     * set options of retrieval of a condition object
71     */
72     est_cond_set_options(cond, options);
73     }
74     };
75    
76     class Document {
77     private:
78     std::string text_buf;
79     public:
80     ESTDOC *doc;
81     Document() {
82     /**
83     * constructor
84     */
85     doc = est_doc_new();
86     }
87     Document(const char* draft) {
88     /**
89     * constructor
90     */
91     doc = est_doc_new_from_draft(draft);
92     }
93     Document(ESTDOC *_doc) {
94     /**
95     * constructor
96     */
97     doc = _doc;
98     }
99     ~Document() {
100     /**
101     * destructor
102     */
103     est_doc_delete(doc);
104     }
105     void add_attr(const char * name, const char*value) {
106     /**
107     * add an attribute to a document object
108     */
109     est_doc_add_attr(doc, name, value);
110     }
111     void add_text(const char *text) {
112     /**
113     * add a sentence of text to a document object
114     */
115     est_doc_add_text(doc, text);
116     }
117     void add_hidden_text(const char * text) {
118     /**
119     * add a hidden sentence to a document object
120     */
121     est_doc_add_hidden_text(doc, text);
122     }
123     int id() {
124     /**
125     * get the ID number of a document object
126     */
127     return est_doc_id(doc);
128     }
129     std::vector<std::string> * attr_names() {
130     /**
131     * get a list of attribute names of a document object
132     */
133     std::vector<std::string> * vs = new std::vector<std::string>;
134     CBLIST * attr_names = est_doc_attr_names(doc);
135     for (int i=0; i < cblistnum(attr_names); i++) {
136     vs->push_back(cblistval(attr_names, i, NULL));
137     }
138     cblistclose(attr_names);
139     return vs;
140     }
141     const char * attr(const char *name) {
142     /**
143     * get the value of an attribute of a document object
144     */
145     return est_doc_attr(doc, name);
146     }
147     const char * cat_texts() {
148     /**
149     * get a list of sentences of the text of a document object
150     */
151     return est_doc_cat_texts(doc);
152     }
153     std::vector<std::string>* texts() {
154     /**
155     * get a list of sentences of the text of a document object
156     */
157     std::vector<std::string> * vs = new std::vector<std::string>;
158     const CBLIST *texts;
159     texts = est_doc_texts(doc);
160     for(int i = 0; i < cblistnum(texts); i++) {
161     vs->push_back(cblistval(texts, i, NULL));
162     }
163     return vs;
164     }
165     const char * dump_draft() {
166     /**
167     * dump draft data of a document object
168     */
169     return est_doc_dump_draft(doc);
170     }
171     const char * make_snippet(std::vector<std::string> _words, int wwidth, int hwidth, int awidth) {
172     /**
173     * make a snippet of the body text of a document object
174     */
175     CBLIST * words;
176     std::vector<std::string>::iterator iter;
177     words = cblistopen();
178     for (iter = _words.begin(); _words.end() != iter; iter++) {
179     cblistpush(words, iter->c_str(), -1);
180     }
181     const char *result = est_doc_make_snippet(doc, words, wwidth, hwidth, awidth);
182     cblistclose(words);
183     return result;
184     }
185     const char * hidden_texts() {
186     /**
187     * get the hidden texts of a document object.
188     */
189     return est_doc_hidden_texts(doc);
190     }
191     };
192    
193     class Database {
194     private:
195     ESTMTDB *db;
196     int ecode;
197     public:
198     enum { // enumeration for error codes
199     ERRNOERR = ESTENOERR, // no error
200     ERRINVAL = ESTEINVAL, // invalid argument
201     ERRACCES = ESTEACCES, // access forbidden
202     ERRLOCK = ESTELOCK, // lock failure
203     ERRDB = ESTEDB, // database problem
204     ERRIO = ESTEIO, // I/O problem
205     ERRNOITEM = ESTENOITEM, // no item
206     ERRMISC = ESTEMISC // miscellaneous
207     };
208     enum { // enumeration for open modes
209     DBREADER = ESTDBREADER, // open as a reader
210     DBWRITER = ESTDBWRITER, // open as a writer
211     DBCREAT = ESTDBCREAT, // a writer creating
212     DBTRUNC = ESTDBTRUNC, // a writer truncating
213     DBNOLCK = ESTDBNOLCK, // open without locking
214     DBLCKNB = ESTDBLCKNB, // lock without blocking
215     DBPERFNG = ESTDBPERFNG // use perfect N-gram analyzer
216     };
217     enum { // enumeration for options of document registration
218     PDCLEAN = ESTPDCLEAN // clean up dispensable regions
219     };
220     enum { // enumeration for options of document deletion
221     ODCLEAN = ESTODCLEAN // clean up dispensable regions
222     };
223     enum { // enumeration for options of optimization
224     OPTNOPURGE = ESTOPTNOPURGE, // omit purging dispensable region of deleted
225     OPTNODBOPT = ESTOPTNODBOPT // omit optimizization of the database files
226     };
227     enum { // enumeration for options of document retrieval
228     GDNOATTR = ESTGDNOATTR, // no attributes
229     GDNOTEXT = ESTGDNOTEXT // no text
230     };
231     Database() {
232     /**
233     * constructor(dummy)
234     */
235     db = NULL;
236     ecode = ERRNOERR;
237     }
238     ~Database() {
239     if (db) close();
240     }
241     bool open(const char * dbname, int mode) {
242     /**
243     * open the database
244     */
245     if (db) close();
246     int ec;
247     db = est_mtdb_open(dbname, mode, &ec);
248     if (!db) ecode = ec;
249     return db;
250     }
251     bool close() {
252     /**
253     * close the database
254     */
255     if (!db) throw IOError("closed database");
256     int ec;
257     bool result = est_mtdb_close(db, &ec);
258     if (!result) ecode = ec;
259     db = NULL;
260     return result;
261     }
262     bool put_doc(Document *doc, int options) {
263     /**
264     * add a document to a database
265     */
266     if (!db) throw IOError("closed database");
267     bool result = est_mtdb_put_doc(db, doc->doc, options);
268     if (!result) ecode = est_mtdb_error(db);
269     return result;
270     }
271     std::vector<int> * search(Condition * cond, int options) {
272     /**
273     * search documents corresponding a condition for a database
274     */
275     if (!db) throw IOError("closed database");
276     int resnum;
277     int * result = est_mtdb_search(db, cond->cond, &resnum, NULL);
278     std::vector<int> *numbers = new std::vector<int>;
279     for (int i=0; i<resnum; i++) {
280     numbers->push_back(result[i]);
281     }
282     return numbers;
283     }
284     static const char * err_msg(int ecode) {
285     /**
286     * get the string of an error
287     */
288     return est_err_msg(ecode);
289     }
290     int error() {
291     /**
292     * get the last happended error code of a database
293     */
294     return ecode;
295     }
296     bool fatal() {
297     /**
298     * check whether a database has a fatal error
299     */
300     if (!db) throw IOError("closed database");
301     return est_mtdb_fatal(db);
302     }
303     bool flush(int _max) {
304     /**
305     * flush index words in the cache of a database
306     */
307     if (!db) throw IOError("closed database");
308     bool result = est_mtdb_flush(db, _max);
309     if (!result) ecode = est_mtdb_error(db);
310     return result;
311     }
312     bool sync() {
313     /**
314     * synchronize updating contents of a database
315     */
316     if (!db) throw IOError("closed database");
317     bool result = est_mtdb_sync(db);
318     if (!result) ecode = est_mtdb_error(db);
319     return result;
320     }
321     bool optimize(int options) {
322     /**
323     * optimize a database
324     */
325     if (!db) throw IOError("closed database");
326     bool result = est_mtdb_optimize(db, options);
327     if (!result) ecode = est_mtdb_error(db);
328     return result;
329     }
330     bool out_doc(int id, int options) {
331     /**
332     * remove a document from a database
333     */
334     if (!db) throw IOError("closed database");
335     bool result = est_mtdb_out_doc(db, id, options);
336     if (!result) ecode = est_mtdb_error(db);
337     return result;
338     }
339     bool edit_doc(Document *doc) {
340     /**
341     * edit an attribute of a document in a database
342     */
343     if (!db) throw IOError("closed database");
344     bool result = est_mtdb_edit_doc(db, doc->doc);
345     if (!result) ecode = est_mtdb_error(db);
346     return result;
347     }
348     Document * get_doc(int id, int options) {
349     /**
350     * retrieve a document in a database
351     */
352     if (!db) throw IOError("closed database");
353     ESTDOC *doc = est_mtdb_get_doc(db, id, options);
354     if (!doc) {
355     ecode = est_mtdb_error(db);
356     throw est_err_msg(est_mtdb_error(db));
357     } else {
358     return new Document(doc);
359     }
360     }
361     int uri_to_id(const char *uri) {
362     /**
363     * get the ID of a document spacified by URI
364     */
365     if (!db) throw IOError("closed database");
366     int result = est_mtdb_uri_to_id(db, uri);
367     if(result == -1) ecode = est_mtdb_error(db);
368     return result;
369     }
370     std::map<std::string, std::string> * etch_doc(Document * doc, int max) {
371     /**
372     * extract keywords of a document object
373     */
374     if (!db) throw IOError("closed database");
375     std::map<std::string, std::string> * mss = new std::map<std::string, std::string>;
376     CBMAP * keys = est_mtdb_etch_doc(db, doc->doc, max);
377     cbmapiterinit(keys);
378     int ksiz;
379     while (const char *key = cbmapiternext(keys, &ksiz)) {
380     mss->insert(std::make_pair(key, cbmapget(keys, key, ksiz, NULL)));
381     }
382     return mss;
383     }
384     const char * name() {
385     /**
386     * get the name of a database
387     */
388     if (!db) throw IOError("closed database");
389     return est_mtdb_name(db);
390     }
391     int doc_num() {
392     /**
393     * get the number of documents in a database
394     */
395     if (!db) throw IOError("closed database");
396     return est_mtdb_doc_num(db);
397     }
398     int word_num() {
399     /**
400     * get the number of unique words in a database
401     */
402     if (!db) throw IOError("closed database");
403     return est_mtdb_word_num(db);
404     }
405     double size() {
406     /**
407     * get the size of a database
408     */
409     if (!db) throw IOError("closed database");
410     return est_mtdb_size(db);
411     }
412     void set_cache_size(size_t size, int anum, int tnum) {
413     /**
414     * set the maximum size of the cache memory of a database
415     */
416     if (!db) throw IOError("closed database");
417     est_mtdb_set_cache_size(db, size, anum, tnum);
418     }
419     void set_special_cache(const char *name, int num) {
420     /**
421     * Set the special cache for narrowing and sorting
422     * with document attributes
423     */
424     est_mtdb_set_special_cache(db, name, num);
425     }
426     };
427    
428     static std::vector<std::string> * break_text(const char *text, bool norm, bool tail) {
429     std::vector<std::string> * vs = new std::vector<std::string>;
430     CBLIST *list;
431     list = cblistopen();
432     est_break_text(text, list, norm, tail);
433     for (int i=0; i < cblistnum(list); i++) {
434     vs->push_back(cblistval(list, i, NULL));
435     }
436     cblistclose(list);
437     return vs;
438     }
439    
440     static std::vector<std::string> * break_text_perfng(const char *text, bool norm, bool tail) {
441     std::vector<std::string> * vs = new std::vector<std::string>;
442     CBLIST *list;
443     list = cblistopen();
444     est_break_text_perfng(text, list, norm, tail);
445     for (int i=0; i < cblistnum(list); i++) {
446     vs->push_back(cblistval(list, i, NULL));
447     }
448     cblistclose(list);
449     return vs;
450     }
451    
452     };

  ViewVC Help
Powered by ViewVC 1.1.26