trunk/perl/HyperEstraierWrapper.cpp

/**
 * HyperEstraierWrapper.cpp - C++ wrapper for Hyper Estraier
 */
#include <estraier.h>
#include <estmtdb.h>
#include <cabin.h>
#include <cstdlib>
#include <string>
#include <vector>
#include <map>
#include <cassert>

/* backward compatibility for 0.5.4 */
#ifndef ESTCONDAGITO
#define ESTCONDAGITO ESTCONDAGIT
#endif

namespace estraier {
        class Condition {
        public:
                enum {                                                          // enumeration for options 
                        SURE    = ESTCONDSURE,          // check every N-gram key
                        USUAL   = ESTCONDUSUAL,         // check N-gram keys skipping by one
                        FAST    = ESTCONDFAST,          // check N-gram keys skipping by two
                        AGITO   = ESTCONDAGITO,         // check N-gram keys skipping by three
                        NOIDF   = ESTCONDNOIDF,         // without TF-IDF tuning
                        SIMPLE  = ESTCONDSIMPLE,        // with the simplefied phrase
                };
                ESTCOND * cond;
                Condition() {
                        /**
                         * constructor
                         */
                        cond = est_cond_new();
                }
                ~Condition() {
                        /**
                         * destructor
                         */
                        est_cond_delete(cond);
                }
                void set_phrase(const char *phrase) {
                        /**
                         * set the search phrase
                         */
                        est_cond_set_phrase(cond, phrase);
                }
                void add_attr(const char *expr) {
                        /**
                         * set the attribute expression
                         */
                        est_cond_add_attr(cond, expr);
                }
                void set_order(const char *expr) {
                        /**
                         * set the order of a condition object
                         */
                        est_cond_set_order(cond, expr);
                }
                void set_max(int _max) {
                        /**
                         * set the maximum number of retrieval of a condition object
                         */
                        est_cond_set_max(cond, _max);
                }
                void set_options(int options) {
                        /**
                         * set options of retrieval of a condition object
                         */
                        est_cond_set_options(cond, options);
                }
        };

        class Document {
        private:
                std::string text_buf;
        public:
                ESTDOC *doc;

                Document() {
                        /**
                         * constructor
                         */
                        doc = est_doc_new();
                }
                Document(const char* draft) {
                        /**
                         * constructor
                         */
                        doc = est_doc_new_from_draft(draft);
                }
                Document(ESTDOC *_doc) {
                        /**
                         * constructor
                         */
                        doc = _doc;
                }
                ~Document() {
                        /**
                         * destructor
                         */
                        est_doc_delete(doc);
                }
                void add_attr(const char * name, const char*value) {
                        /**
                         * add an attribute to a document object
                         */
                        est_doc_add_attr(doc, name, value);
                }
                void add_text(const char *text) {
                        /**
                         * add a sentence of text to a document object
                         */
                        est_doc_add_text(doc, text);
                }
                void add_hidden_text(const char * text) {
                        /**
                         * add a hidden sentence to a document object
                         */
                        est_doc_add_hidden_text(doc, text);
                }
                int id() {
                        /**
                         * get the ID number of a document object
                         */
                        return est_doc_id(doc);
                }
                std::vector<std::string> * attr_names() {
                        /**
                         * get a list of attribute names of a document object
                         */
                        std::vector<std::string> * vs = new std::vector<std::string>;
                        CBLIST * attr_names = est_doc_attr_names(doc);
                        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) {
                        /**
                         * get the value of an attribute of a document object
                         */
                        return est_doc_attr(doc, name);
                }
                const char * cat_texts() {
                        /**
                         * get a list of sentences of the text of a document object
                         */
                        // return est_doc_cat_texts(doc);
                        return "This is mockup!";
                }
                std::vector<std::string>* texts() {
                        /**
                         * get a list of sentences of the text of a document object
                         */
                        std::vector<std::string> * vs = new std::vector<std::string>;
                        const CBLIST *texts;
                        texts = est_doc_texts(doc);
                        for(int i = 0; i < cblistnum(texts); i++) {
                                vs->push_back(cblistval(texts, i, NULL));
                        }
                        return vs;
                }
                const char * dump_draft() {
                        /**
                         * dump draft data of a document object
                         */
                        return est_doc_dump_draft(doc);
                }
                const char * make_snippet(std::vector<std::string> _words, int wwidth, int hwidth, int awidth) {
                        /**
                         * make a snippet of the body text of a document object
                         */
                        CBLIST * words;
                        std::vector<std::string>::iterator iter;

                        words = cblistopen();

                        for (iter = _words.begin(); _words.end() != iter; iter++) {
                                cblistpush(words, iter->c_str(), -1);
                        }

                        const char *result = est_doc_make_snippet(doc, words, wwidth, hwidth, awidth); 

                        cblistclose(words);

                        return result;
                }
        };

        class Database {
        private:
                ESTMTDB *db;
        public:
                enum {                                                          // enumeration for error codes
                        ERRNOERR        = ESTENOERR,            // no error
                        ERRINVAL        = ESTEINVAL,            // invalid argument
                        ERRACCES        = ESTEACCES,            // access forbidden
                        ERRLOCK         = ESTELOCK,                     // lock failure
                        ERRDB           = ESTEDB,                       // database problem
                        ERRIO           = ESTEIO,                       // I/O problem
                        ERRNOITEM       = ESTENOITEM,           // no item
                        ERRMISC         = ESTEMISC                      // miscellaneous
                };
                enum {                                                          // enumeration for open modes
                        DBREADER        = ESTDBREADER,          // open as a reader
                        DBWRITER        = ESTDBWRITER,          // open as a writer
                        DBCREAT         = ESTDBCREAT,           // a writer creating
                        DBTRUNC         = ESTDBTRUNC,           // a writer truncating
                        DBNOLCK         = ESTDBNOLCK,           // open without locking
                        DBLCKNB         = ESTDBLCKNB,           // lock without blocking
                        DBPERFNG        = ESTDBPERFNG           // use perfect N-gram analyzer
                };
                enum {                                                          // enumeration for options of document registration
                        PDCLEAN         = ESTPDCLEAN            // clean up dispensable regions
                };
                enum {                                                          // enumeration for options of document deletion
                        ODCLEAN         = ESTODCLEAN            // clean up dispensable regions
                };
                enum {                                                          // enumeration for options of optimization
                        OPTNOPURGE      = ESTOPTNOPURGE,        // omit purging dispensable region of deleted
                        OPTNODBOPT      = ESTOPTNODBOPT         // omit optimizization of the database files
                };
                enum {                                                          // enumeration for options of document retrieval
                        GDNOATTR        = ESTGDNOATTR,          // no attributes
                        GDNOTEXT        = ESTGDNOTEXT           // no text
                };
                Database() {
                        /**
                         * constructor(dummy)
                         */
                }
                ~Database() {
                        close();
                }
                bool open(const char * dbname, int mode) {
                        /**
                         * open the database
                         */
                        int ecode;
                        db = est_mtdb_open(dbname, mode, &ecode);
                        return db;
                }
                bool close() {
                        /**
                         * close the database
                         */
                        if (db) {
                                int ecode;
                                bool result = est_mtdb_close(db, &ecode);
                                db = NULL;
                                return result;
                        } else {
                                return false;
                        }
                }
                bool put_doc(Document *doc, int options) {
                        /**
                         * add a document to a database
                         */
                        return est_mtdb_put_doc(db, doc->doc, options);
                }
                std::vector<int> * search(Condition * cond, int options) {
                        /**
                         * search documents corresponding a condition for a database
                         */
                        int resnum;
                        int * result = est_mtdb_search(db, cond->cond, &resnum, NULL);
                        std::vector<int> *numbers = new std::vector<int>;       
                        for (int i=0; i<resnum; i++) {
                                numbers->push_back(result[i]);
                        }
                        return numbers;
                }
                static const char * err_msg(int ecode) {
                        /**
                         * get the string of an error
                         */
                        return est_err_msg(ecode);
                }
                int error() {
                        /**
                         * get the last happended error code of a database
                         */
                        return est_mtdb_error(db);
                }
                bool fatal() {
                        /**
                         * check whether a database has a fatal error
                         */
                        return est_mtdb_fatal(db);
                }
                bool flush(int _max) {
                        /**
                         * flush index words in the cache of a database
                         */
                        return est_mtdb_flush(db, _max);
                }
                bool sync() {
                        /**
                         * synchronize updating contents of a database
                         */
                        return est_mtdb_sync(db);
                }
                bool optimize(int options) {
                        /**
                         * optimize a database
                         */
                        return est_mtdb_optimize(db, options);
                }
                bool out_doc(int id, int options) {
                        /**
                         * remove a document from a database
                         */
                        return est_mtdb_out_doc(db, id, options);
                }
                Document * get_doc(int id, int options) {
                        /**
                         * retrieve a document in a database
                         */
                        ESTDOC *doc = est_mtdb_get_doc(db, id, options);
                        if (!doc) {
                                throw est_err_msg(est_mtdb_error(db));
                        } else {
                                return new Document(doc);
                        }
                }
                int uri_to_id(const char *uri) {
                        /**
                         * get the ID of a document spacified by URI
                         */
                        return est_mtdb_uri_to_id(db, uri);
                }
                std::map<std::string, std::string> * etch_doc(Document * doc, int max) {
                        /**
                         * extract keywords of a document object
                         */
                        std::map<std::string, std::string> * mss = new std::map<std::string, std::string>;

                        CBMAP * keys = est_mtdb_etch_doc(db, doc->doc, max);

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