|
1
2
3
4
5
|
%include "morfeusz_javadoc.i"
%include <stdint.i>
%include <std_except.i>
|
|
6
|
%include <std_common.i>
|
|
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
// make vector compatible with java.util.List interface
namespace std {
template<class T> class vector {
public:
typedef size_t size_type;
typedef T value_type;
typedef const value_type& const_reference;
// vector();
// vector(size_type n);
// vector(const vector& o);
size_type capacity() const;
void reserve(size_type n);
%rename(isEmpty) empty;
bool empty() const;
void clear();
|
|
24
|
//void push_back(const value_type& x);
|
|
25
26
27
28
29
30
31
32
33
34
35
36
|
%extend {
const_reference get(int32_t i) const throw (std::out_of_range) {
return $self->at(i);
}
value_type set(int32_t i, const value_type& VECTOR_VALUE_IN) throw (std::out_of_range) {
const T old = $self->at(i);
$self->at(i) = VECTOR_VALUE_IN;
return old;
}
void add(int32_t i, const value_type& VECTOR_VALUE_IN) {
$self->insert($self->begin() + i, VECTOR_VALUE_IN);
}
|
|
37
38
39
40
|
bool add(const value_type& VECTOR_VALUE_IN) {
$self->push_back(VECTOR_VALUE_IN);
return true;
}
|
|
41
42
43
44
45
46
47
48
|
int32_t size() const {
return $self->size();
}
void removeRange(int32_t from, int32_t to) {
$self->erase($self->begin()+from, $self->begin()+to);
}
}
};
|
|
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
template<class T> class list {
public:
typedef size_t size_type;
typedef T value_type;
typedef const value_type& const_reference;
%rename(isEmpty) empty;
bool empty() const;
void clear();
%extend {
const_reference get(int32_t i) const throw (std::out_of_range) {
std::list<T>::const_iterator it = $self->begin();
std::advance(it, i);
return *it;
}
value_type set(int32_t i, const value_type& VECTOR_VALUE_IN) throw (std::out_of_range) {
std::list<T>::iterator it = $self->begin();
std::advance(it, i);
std::string old = *it;
*it = VECTOR_VALUE_IN;
return old;
}
void add(int32_t i, const value_type& VECTOR_VALUE_IN) {
std::list<T>::iterator it = $self->begin();
std::advance(it, i);
$self->insert(it, VECTOR_VALUE_IN);
|
|
80
81
82
83
84
|
}
bool add(const value_type& VECTOR_VALUE_IN) {
$self->push_back(VECTOR_VALUE_IN);
return true;
|
|
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
}
value_type remove(int32_t i, const value_type& VECTOR_VALUE_IN) throw (std::out_of_range) {
std::list<T>::iterator it = $self->begin();
std::advance(it, i);
std::string old = *it;
$self->erase(it);
return old;
}
int32_t size() const {
return $self->size();
}
}
};
template<class T> class set {
public:
typedef size_t size_type;
typedef T value_type;
typedef const value_type& const_reference;
%rename(isEmpty) empty;
bool empty() const;
%extend {
const_reference get(int32_t i) const throw (std::out_of_range) {
std::set<T>::const_iterator it = $self->begin();
std::advance(it, i);
return *it;
}
int32_t size() const {
return $self->size();
}
}
};
|
|
123
124
|
}
|
|
125
126
127
|
%rename(_MorphInterpretation) morfeusz::MorphInterpretation;
%rename(_ResultsIterator) morfeusz::ResultsIterator;
|
|
128
|
%rename(_dictionarySearchPaths) morfeusz::Morfeusz::dictionarySearchPaths;
|
|
129
130
|
%rename(_getAvailableAgglOptions) morfeusz::Morfeusz::getAvailableAgglOptions;
%rename(_getAvailablePraetOptions) morfeusz::Morfeusz::getAvailablePraetOptions;
|
|
131
|
%rename(_setDictionary) morfeusz::Morfeusz::setDictionary;
|
|
132
|
|
|
133
|
%rename(_getLabels) morfeusz::IdResolver::getLabels;
|
|
134
135
136
|
%rename(_getLabels) morfeusz::MorphInterpretation::getLabels;
|
|
137
|
%ignore morfeusz::FileFormatException;
|
|
138
|
|
|
139
|
%javaexception("java.io.IOException") morfeusz::Morfeusz::setDictionary {
|
|
140
141
142
|
try {
$action
}
|
|
143
|
catch(morfeusz::FileFormatException & e) {
|
|
144
145
146
147
|
jclass clazz = jenv->FindClass("java/io/IOException");
jenv->ThrowNew(clazz, "Invalid file format");
return $null;
}
|
|
148
|
catch(morfeusz::MorfeuszException & e) {
|
|
149
|
jclass clazz = jenv->FindClass("pl/sgjp/morfeusz/MorfeuszException");
|
|
150
151
152
|
jenv->ThrowNew(clazz, e.what());
return $null;
}
|
|
153
154
155
156
157
|
catch(std::ios_base::failure & e) {
jclass clazz = jenv->FindClass("java/io/IOException");
jenv->ThrowNew(clazz, e.what());
return $null;
}
|
|
158
159
160
161
162
|
catch(...) {
jclass clazz = jenv->FindClass("java/lang/RuntimeException");
jenv->ThrowNew(clazz, "Unknown exception");
return $null;
}
|
|
163
164
|
}
|
|
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
%javaexception("java.util.NoSuchElementException") morfeusz::ResultsIterator::next {
try {
$action
}
catch(std::out_of_range & e) {
jclass clazz = jenv->FindClass("java/util/NoSuchElementException");
jenv->ThrowNew(clazz, e.what());
return $null;
}
}
%exception {
try{
$action
}
catch(const morfeusz::MorfeuszException& e) {
|
|
181
|
jclass clazz = jenv->FindClass("pl/sgjp/morfeusz/MorfeuszException");
|
|
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
jenv->ThrowNew(clazz, e.what());
return $null;
}
catch(const std::exception& e) {
jclass clazz = jenv->FindClass("java/lang/RuntimeException");
jenv->ThrowNew(clazz, e.what());
return $null;
}
catch(const std::string& e) {
jclass clazz = jenv->FindClass("java/lang/RuntimeException");
jenv->ThrowNew(clazz, e.c_str());
return $null;
}
catch(...) {
jclass clazz = jenv->FindClass("java/lang/RuntimeException");
jenv->ThrowNew(clazz, "Unknown exception");
return $null;
}
|
|
200
201
|
}
|
|
202
203
|
//%typemap(javainterfaces) morfeusz::ResultsIterator "java.util.Iterator<_MorphInterpretation>"
%typemap(javabase) std::vector<morfeusz::MorphInterpretation> "java.util.AbstractList<_MorphInterpretation>"
|
|
204
205
206
207
|
%typemap(javabase) std::vector<std::string> "java.util.AbstractList<java.lang.String>"
%typemap(javabase) std::list<std::string> "java.util.AbstractList<java.lang.String>"
%typemap(javabase) std::set<std::string> "java.util.AbstractList<java.lang.String>"
%typemap(javabase) morfeusz::MorfeuszException "java.lang.RuntimeException"
|
|
208
|
|
|
209
210
|
%typemap(javacode) morfeusz::Morfeusz %{
|
|
211
|
/**
|
|
212
213
214
215
216
217
218
219
220
221
222
223
224
|
* Analyze given text and return the results as iterator.
* It does not store results for whole text at once, so may be less memory-consuming for analysis of big texts.
*
* NOT THREAD-SAFE (must have exclusive access to this instance).
*
* @param text text for morphological analysis.
* @return iterator over morphological analysis results
*/
public ResultsIterator analyseAsIterator(String text) {
return new ResultsIterator(_analyseAsIterator(text));
}
/**
|
|
225
226
|
* Analyze given text and return the results as list.
*
|
|
227
228
|
* NOT THREAD-SAFE (must have exclusive access to this instance).
*
|
|
229
230
231
|
* @param text text for morphological analysis.
* @return list containing the results of morphological analysis
*/
|
|
232
|
public List<MorphInterpretation> analyseAsList(String text) {
|
|
233
234
235
|
InterpsList interpsList = new InterpsList();
analyse(text, interpsList);
return MorphInterpretation.createList(interpsList);
|
|
236
|
}
|
|
237
238
239
240
|
/**
* Perform morphological synthesis on a given lemma.
*
|
|
241
242
|
* NOT THREAD-SAFE (must have exclusive access to this instance).
*
|
|
243
244
|
* @param lemma lemma to be synthesized
* @return list containing results of the morphological synthesis
|
|
245
|
* @throws MorfeuszException when given parameter contains whitespaces
|
|
246
247
|
*/
public List<MorphInterpretation> generate(String lemma) {
|
|
248
249
250
|
InterpsList interpsList = new InterpsList();
generate(lemma, interpsList);
return MorphInterpretation.createList(interpsList);
|
|
251
|
}
|
|
252
253
254
255
256
|
/**
* Perform morphological synthesis on a given lemma.
* Limit results to interpretations with the specified tag.
*
|
|
257
258
|
* NOT THREAD-SAFE (must have exclusive access to this instance).
*
|
|
259
|
* @param lemma lemma to be analysed
|
|
260
261
|
* @param tagnum tag number of result interpretations
* @return list containing results of the morphological synthesis
|
|
262
|
* @throws MorfeuszException when given parameter contains whitespaces
|
|
263
264
|
*/
public List<MorphInterpretation> generate(String lemma, int tagnum) {
|
|
265
266
267
|
InterpsList interpsList = new InterpsList();
generate(lemma, tagnum, interpsList);
return MorphInterpretation.createList(interpsList);
|
|
268
269
270
|
}
/**
|
|
271
272
273
|
* Get list of paths for dictionaries searching.
* It is neccessary to modify this list
* to search for dictionaries under non-default paths.
|
|
274
|
*
|
|
275
276
|
* The returned list is NOT THREAD-SAFE (must have exclusive acces to modify it).
*
|
|
277
278
|
* @return modifiable list of paths
*/
|
|
279
280
|
public static List<String> getDictionarySearchPaths() {
return get_dictionarySearchPaths();
|
|
281
|
}
|
|
282
283
284
285
|
/**
* Get list of possible agglutination rules.
*
|
|
286
287
|
* NOT THREAD-SAFE (must have exclusive access to this instance).
*
|
|
288
289
290
291
292
293
294
295
296
|
* @return modifiable list of paths
*/
public List<String> getAvailableAgglOptions() {
return java.util.Collections.unmodifiableList(_getAvailableAgglOptions());
}
/**
* Get list of possible past-tense segmentation rules.
*
|
|
297
298
|
* NOT THREAD-SAFE (must have exclusive access to this instance).
*
|
|
299
300
301
302
303
|
* @return modifiable list of paths
*/
public List<String> getAvailablePraetOptions() {
return java.util.Collections.unmodifiableList(_getAvailablePraetOptions());
}
|
|
304
305
306
307
308
309
310
|
/**
* Set dictionary to be used with this instance.
*
* NOT THREAD-SAFE (must have exclusive access to this instance).
*
* @param dictName new dictionary name
|
|
311
312
|
* @throws IOException when IO error occurs when trying to read dictionary
* @throws MorfeuszException when there is no such dictionary
|
|
313
314
315
316
317
318
319
320
|
*/
public void setDictionary(String dictName) throws IOException {
synchronized (Morfeusz.class) {
_setDictionary(dictName);
}
}
|
|
321
322
|
%}
|
|
323
324
325
326
327
328
329
|
%typemap(javacode) morfeusz::IdResolver %{
public java.util.Collection<java.lang.String> getLabels(int labelsId) {
return _getLabels(labelsId);
}
%}
|
|
330
331
|
%typemap(javafinalize) SWIGTYPE %{
protected void finalize() {
|
|
332
333
334
335
336
337
338
339
340
341
|
delete();
}
public synchronized void delete() {
if (swigCPtr != 0) {
if (swigCMemOwn) {
swigCMemOwn = false;
$moduleJNI.delete_$javaclassname(getCPtr(this));
}
swigCPtr = 0;
|
|
342
343
344
345
346
347
|
}
}
%}
%typemap(javadestruct, methodname="delete", methodmodifiers="private") SWIGTYPE "";
|
|
348
|
%javamethodmodifiers morfeusz::Morfeusz::analyse(const std::string&, std::vector<MorphInterpretation>&) const "private";
|
|
349
350
351
|
%javamethodmodifiers morfeusz::Morfeusz::generate(const std::string&, std::vector<MorphInterpretation>&) const "private";
%javamethodmodifiers morfeusz::Morfeusz::generate(const std::string&, int, std::vector<MorphInterpretation>&) const "private";
|
|
352
353
|
// should be overwritten by getDictionarySearchPaths() in typemap(javacode)
%javamethodmodifiers morfeusz::Morfeusz::dictionarySearchPaths "private";
|
|
354
355
|
%javamethodmodifiers morfeusz::Morfeusz::getAvailableAgglOptions "private";
%javamethodmodifiers morfeusz::Morfeusz::getAvailablePraetOptions "private";
|
|
356
|
%javamethodmodifiers morfeusz::Morfeusz::setDictionary "private";
|
|
357
358
359
360
|
// should be overwritten by getLabels() in typemap(javacode)
%javamethodmodifiers morfeusz::IdResolver::getLabels "private";
|
|
361
|
%typemap(javaclassmodifiers) std::vector "class"
|
|
362
363
|
%typemap(javaclassmodifiers) std::list "class"
%typemap(javaclassmodifiers) std::set "class"
|
|
364
365
|
%typemap(javaclassmodifiers) morfeusz::MorphInterpretation "class"
%typemap(javaclassmodifiers) morfeusz::ResultsIterator "class"
|
|
366
367
368
369
370
371
|
%include "enums.swg"
/* Force the generated Java code to use the C enum values rather than making a JNI call */
%javaconst(1);
|
|
372
373
374
375
|
%pragma(java) jniclassclassmodifiers="class"
%pragma(java) moduleclassmodifiers="class"
|
|
376
377
378
379
380
|
%pragma(java) jniclasscode=%{
static {
System.loadLibrary("jmorfeusz");
}
%}
|
|
381
382
383
384
|
%pragma(java) jniclassimports=%{
import java.io.IOException;
%}
|
|
385
386
387
388
389
390
391
|
%include "std_vector.i"
%include "std_string.i"
%include "std_except.i"
%include "exception.i"
%include "typemaps.i"
|