|
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
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
// 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();
void push_back(const value_type& x);
%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);
}
int32_t size() const {
return $self->size();
}
void removeRange(int32_t from, int32_t to) {
$self->erase($self->begin()+from, $self->begin()+to);
}
}
};
|
|
45
46
47
48
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
80
81
82
83
84
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
|
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);
}
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();
}
}
};
|
|
114
115
|
}
|
|
116
117
118
|
%rename(_MorphInterpretation) morfeusz::MorphInterpretation;
%rename(_ResultsIterator) morfeusz::ResultsIterator;
|
|
119
|
%rename(_dictionarySearchPaths) morfeusz::Morfeusz::dictionarySearchPaths;
|
|
120
121
|
%rename(_getAvailableAgglOptions) morfeusz::Morfeusz::getAvailableAgglOptions;
%rename(_getAvailablePraetOptions) morfeusz::Morfeusz::getAvailablePraetOptions;
|
|
122
|
%rename(_setDictionary) morfeusz::Morfeusz::setDictionary;
|
|
123
|
|
|
124
|
%rename(_getLabels) morfeusz::IdResolver::getLabels;
|
|
125
126
127
|
%rename(_getLabels) morfeusz::MorphInterpretation::getLabels;
|
|
128
|
%ignore morfeusz::FileFormatException;
|
|
129
|
|
|
130
|
%javaexception("java.io.IOException") morfeusz::Morfeusz::setDictionary {
|
|
131
132
133
|
try {
$action
}
|
|
134
|
catch(morfeusz::FileFormatException & e) {
|
|
135
136
137
138
|
jclass clazz = jenv->FindClass("java/io/IOException");
jenv->ThrowNew(clazz, "Invalid file format");
return $null;
}
|
|
139
|
catch(morfeusz::MorfeuszException & e) {
|
|
140
|
jclass clazz = jenv->FindClass("pl/sgjp/morfeusz/MorfeuszException");
|
|
141
142
143
|
jenv->ThrowNew(clazz, e.what());
return $null;
}
|
|
144
145
146
147
148
|
catch(std::ios_base::failure & e) {
jclass clazz = jenv->FindClass("java/io/IOException");
jenv->ThrowNew(clazz, e.what());
return $null;
}
|
|
149
150
151
152
153
|
catch(...) {
jclass clazz = jenv->FindClass("java/lang/RuntimeException");
jenv->ThrowNew(clazz, "Unknown exception");
return $null;
}
|
|
154
155
|
}
|
|
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
%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) {
|
|
172
|
jclass clazz = jenv->FindClass("pl/sgjp/morfeusz/MorfeuszException");
|
|
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
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;
}
|
|
191
192
|
}
|
|
193
194
|
//%typemap(javainterfaces) morfeusz::ResultsIterator "java.util.Iterator<_MorphInterpretation>"
%typemap(javabase) std::vector<morfeusz::MorphInterpretation> "java.util.AbstractList<_MorphInterpretation>"
|
|
195
196
197
198
|
%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"
|
|
199
|
|
|
200
201
|
%typemap(javacode) morfeusz::Morfeusz %{
|
|
202
|
/**
|
|
203
204
205
206
207
208
209
210
211
212
213
214
215
|
* 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));
}
/**
|
|
216
217
|
* Analyze given text and return the results as list.
*
|
|
218
219
|
* NOT THREAD-SAFE (must have exclusive access to this instance).
*
|
|
220
221
222
|
* @param text text for morphological analysis.
* @return list containing the results of morphological analysis
*/
|
|
223
|
public List<MorphInterpretation> analyseAsList(String text) {
|
|
224
225
226
|
InterpsList interpsList = new InterpsList();
analyse(text, interpsList);
return MorphInterpretation.createList(interpsList);
|
|
227
|
}
|
|
228
229
230
231
|
/**
* Perform morphological synthesis on a given lemma.
*
|
|
232
233
|
* NOT THREAD-SAFE (must have exclusive access to this instance).
*
|
|
234
235
|
* @param lemma lemma to be synthesized
* @return list containing results of the morphological synthesis
|
|
236
|
* @throws MorfeuszException when given parameter contains whitespaces
|
|
237
238
|
*/
public List<MorphInterpretation> generate(String lemma) {
|
|
239
240
241
|
InterpsList interpsList = new InterpsList();
generate(lemma, interpsList);
return MorphInterpretation.createList(interpsList);
|
|
242
|
}
|
|
243
244
245
246
247
|
/**
* Perform morphological synthesis on a given lemma.
* Limit results to interpretations with the specified tag.
*
|
|
248
249
|
* NOT THREAD-SAFE (must have exclusive access to this instance).
*
|
|
250
|
* @param lemma lemma to be analysed
|
|
251
252
|
* @param tagnum tag number of result interpretations
* @return list containing results of the morphological synthesis
|
|
253
|
* @throws MorfeuszException when given parameter contains whitespaces
|
|
254
255
|
*/
public List<MorphInterpretation> generate(String lemma, int tagnum) {
|
|
256
257
258
|
InterpsList interpsList = new InterpsList();
generate(lemma, tagnum, interpsList);
return MorphInterpretation.createList(interpsList);
|
|
259
260
261
|
}
/**
|
|
262
263
264
|
* Get list of paths for dictionaries searching.
* It is neccessary to modify this list
* to search for dictionaries under non-default paths.
|
|
265
|
*
|
|
266
267
|
* The returned list is NOT THREAD-SAFE (must have exclusive acces to modify it).
*
|
|
268
269
|
* @return modifiable list of paths
*/
|
|
270
271
|
public static List<String> getDictionarySearchPaths() {
return get_dictionarySearchPaths();
|
|
272
|
}
|
|
273
274
275
276
|
/**
* Get list of possible agglutination rules.
*
|
|
277
278
|
* NOT THREAD-SAFE (must have exclusive access to this instance).
*
|
|
279
280
281
282
283
284
285
286
287
|
* @return modifiable list of paths
*/
public List<String> getAvailableAgglOptions() {
return java.util.Collections.unmodifiableList(_getAvailableAgglOptions());
}
/**
* Get list of possible past-tense segmentation rules.
*
|
|
288
289
|
* NOT THREAD-SAFE (must have exclusive access to this instance).
*
|
|
290
291
292
293
294
|
* @return modifiable list of paths
*/
public List<String> getAvailablePraetOptions() {
return java.util.Collections.unmodifiableList(_getAvailablePraetOptions());
}
|
|
295
296
297
298
299
300
301
|
/**
* Set dictionary to be used with this instance.
*
* NOT THREAD-SAFE (must have exclusive access to this instance).
*
* @param dictName new dictionary name
|
|
302
303
|
* @throws IOException when IO error occurs when trying to read dictionary
* @throws MorfeuszException when there is no such dictionary
|
|
304
305
306
307
308
309
310
311
|
*/
public void setDictionary(String dictName) throws IOException {
synchronized (Morfeusz.class) {
_setDictionary(dictName);
}
}
|
|
312
313
|
%}
|
|
314
315
316
317
318
319
320
|
%typemap(javacode) morfeusz::IdResolver %{
public java.util.Collection<java.lang.String> getLabels(int labelsId) {
return _getLabels(labelsId);
}
%}
|
|
321
322
|
%typemap(javafinalize) SWIGTYPE %{
protected void finalize() {
|
|
323
324
325
326
327
328
329
330
331
332
|
delete();
}
public synchronized void delete() {
if (swigCPtr != 0) {
if (swigCMemOwn) {
swigCMemOwn = false;
$moduleJNI.delete_$javaclassname(getCPtr(this));
}
swigCPtr = 0;
|
|
333
334
335
336
337
338
|
}
}
%}
%typemap(javadestruct, methodname="delete", methodmodifiers="private") SWIGTYPE "";
|
|
339
|
%javamethodmodifiers morfeusz::Morfeusz::analyse(const std::string&, std::vector<MorphInterpretation>&) const "private";
|
|
340
341
342
|
%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";
|
|
343
344
|
// should be overwritten by getDictionarySearchPaths() in typemap(javacode)
%javamethodmodifiers morfeusz::Morfeusz::dictionarySearchPaths "private";
|
|
345
346
|
%javamethodmodifiers morfeusz::Morfeusz::getAvailableAgglOptions "private";
%javamethodmodifiers morfeusz::Morfeusz::getAvailablePraetOptions "private";
|
|
347
|
%javamethodmodifiers morfeusz::Morfeusz::setDictionary "private";
|
|
348
349
350
351
|
// should be overwritten by getLabels() in typemap(javacode)
%javamethodmodifiers morfeusz::IdResolver::getLabels "private";
|
|
352
|
%typemap(javaclassmodifiers) std::vector "class"
|
|
353
354
|
%typemap(javaclassmodifiers) std::list "class"
%typemap(javaclassmodifiers) std::set "class"
|
|
355
356
|
%typemap(javaclassmodifiers) morfeusz::MorphInterpretation "class"
%typemap(javaclassmodifiers) morfeusz::ResultsIterator "class"
|
|
357
358
359
360
361
362
|
%include "enums.swg"
/* Force the generated Java code to use the C enum values rather than making a JNI call */
%javaconst(1);
|
|
363
364
365
366
|
%pragma(java) jniclassclassmodifiers="class"
%pragma(java) moduleclassmodifiers="class"
|
|
367
368
369
370
371
|
%pragma(java) jniclasscode=%{
static {
System.loadLibrary("jmorfeusz");
}
%}
|
|
372
373
374
375
|
%pragma(java) jniclassimports=%{
import java.io.IOException;
%}
|
|
376
377
378
379
380
381
382
|
%include "std_vector.i"
%include "std_string.i"
%include "std_except.i"
%include "exception.i"
%include "typemaps.i"
|