1 %module db_java
2
3 %include "various.i"
4 %include "typemaps.i"
5
6 %include "java_util.i"
7 %include "java_except.i"
8 %include "java_typemaps.i"
9 %include "java_stat.i"
10 %include "java_callbacks.i"
11
12 /*
13 * SWIG 2.0 changed the defaults for pointer constructors and
14 * the getCPtr() function visibility from protected to public. This
15 * affects our post-processing script in a bad way. Revert that change.
16 */
17 SWIG_JAVABODY_METHODS(protected, protected, SWIGTYPE)
18 %pragma(java) jniclassclassmodifiers = "class"
19
20 /*
21 * No finalize methods in general - most classes have "destructor" methods
22 * that applications must call explicitly.
23 */
24 %typemap(javafinalize) SWIGTYPE ""
25
26 /*
27 * These are the exceptions - when there is no "close" method, we need to free
28 * the native part at finalization time. These are exactly the cases where C
29 * applications manage the memory for the handles.
30 */
31 %typemap(javafinalize) struct DbLsn, struct DbLock %{
finalizeDbLock32 protected void finalize() {
33 try {
34 delete();
35 } catch(Exception e) {
36 System.err.println("Exception during finalization: " + e);
37 e.printStackTrace(System.err);
38 }
39 }
40 %}
41
42 %typemap(javaimports) SWIGTYPE %{
43 import com.sleepycat.db.*;
44 import java.util.Comparator;
45 %}
46
47 /* Class names */
48 %rename(LogSequenceNumber) DbLsn;
49
50 /* Destructors */
51 %rename(close0) close;
52 %rename(remove0) remove;
53 %rename(rename0) rename;
54 %rename(verify0) verify;
55 %rename(abort0) abort;
56 %rename(discard0) discard;
57
58 /* Special case methods */
59 %rename(set_tx_timestamp0) set_tx_timestamp;
60
61 /* Extra code in the Java classes */
62 %typemap(javacode) struct DbEnv %{
63 /* package */ static final int GIGABYTE = 1 << 30;
64 /*
65 * Internally, the JNI layer creates a global reference to each DbEnv,
66 * which can potentially be different to this. We keep a copy here so
67 * we can clean up after destructors.
68 */
69 private long dbenv_ref;
70 public Environment wrapper;
71
72 private LogRecordHandler app_dispatch_handler;
73 private EventHandler event_notify_handler;
74 private FeedbackHandler env_feedback_handler;
75 private ErrorHandler error_handler;
76 private String errpfx;
77 private MessageHandler message_handler;
78 private String msgpfx;
79 private PanicHandler panic_handler;
80 private ReplicationViewHandler rep_view_handler;
81 private ReplicationManagerMessageDispatch repmgr_msg_dispatch_handler;
82 private ReplicationTransport rep_transport_handler;
83 private java.io.OutputStream error_stream;
84 private java.io.OutputStream message_stream;
85 private ThreadLocal errBuf;
86 /*
87 * Because of how SWIG creates things, we need 3 separate objects here.
88 * We will only ever use backup_open_handler, however.
89 */
90 private BackupHandler backup_close_handler;
91 private BackupHandler backup_open_handler;
92 private BackupHandler backup_write_handler;
93 public static class RepProcessMessage {
94 public int envid;
95 }
96
97 /*
98 * Called by the public DbEnv constructor and for private environments
99 * by the Db constructor and by sub-slice environments.
100 */
initializeDbEnv101 void initialize() {
102 dbenv_ref = db_java.initDbEnvRef0(this, this);
103 errBuf = new ThreadLocal();
104 /* Start with System.err as the default error stream. */
105 set_error_stream(System.err);
106 set_message_stream(System.out);
107 }
108
109
110 /* Initialize a sub-slice environment. */
slice_initDbEnv111 public void slice_init() {
112 initialize();
113 }
114
cleanupDbEnv115 void cleanup() {
116 swigCPtr = 0;
117 db_java.deleteRef0(dbenv_ref);
118 dbenv_ref = 0L;
119 }
120
closeDbEnv121 public synchronized void close(int flags) throws DatabaseException {
122 try {
123 close0(flags);
124 } finally {
125 cleanup();
126 }
127 }
128
handle_app_dispatchDbEnv129 private final int handle_app_dispatch(DatabaseEntry dbt,
130 LogSequenceNumber lsn,
131 int recops) {
132 return app_dispatch_handler.handleLogRecord(wrapper, dbt, lsn,
133 RecoveryOperation.fromFlag(recops));
134 }
135
get_app_dispatchDbEnv136 public LogRecordHandler get_app_dispatch() {
137 return app_dispatch_handler;
138 }
139
handle_panic_event_notifyDbEnv140 private final void handle_panic_event_notify() {
141 event_notify_handler.handlePanicEvent();
142 }
143
handle_rep_autotakeover_event_notifyDbEnv144 private final void handle_rep_autotakeover_event_notify() {
145 event_notify_handler.handleRepAutoTakeoverEvent();
146 }
147
handle_rep_autotakeover_failed_event_notifyDbEnv148 private final void handle_rep_autotakeover_failed_event_notify() {
149 event_notify_handler.handleRepAutoTakeoverFailedEvent();
150 }
151
handle_rep_client_event_notifyDbEnv152 private final void handle_rep_client_event_notify() {
153 event_notify_handler.handleRepClientEvent();
154 }
155
handle_rep_connect_broken_event_notifyDbEnv156 private final void handle_rep_connect_broken_event_notify() {
157 event_notify_handler.handleRepConnectBrokenEvent();
158 }
159
handle_rep_connect_established_event_notifyDbEnv160 private final void handle_rep_connect_established_event_notify() {
161 event_notify_handler.handleRepConnectEstablishedEvent();
162 }
163
handle_rep_connect_try_failed_event_notifyDbEnv164 private final void handle_rep_connect_try_failed_event_notify() {
165 event_notify_handler.handleRepConnectTryFailedEvent();
166 }
167
handle_rep_dupmaster_event_notifyDbEnv168 private final void handle_rep_dupmaster_event_notify() {
169 event_notify_handler.handleRepDupmasterEvent();
170 }
171
handle_rep_elected_event_notifyDbEnv172 private final void handle_rep_elected_event_notify() {
173 event_notify_handler.handleRepElectedEvent();
174 }
175
handle_rep_election_failed_event_notifyDbEnv176 private final void handle_rep_election_failed_event_notify() {
177 event_notify_handler.handleRepElectionFailedEvent();
178 }
179
handle_rep_init_done_event_notifyDbEnv180 private final void handle_rep_init_done_event_notify() {
181 event_notify_handler.handleRepInitDoneEvent();
182 }
183
handle_rep_inqueue_full_event_notifyDbEnv184 private final void handle_rep_inqueue_full_event_notify() {
185 event_notify_handler.handleRepInQueueFullEvent();
186 }
187
handle_rep_join_failure_event_notifyDbEnv188 private final void handle_rep_join_failure_event_notify() {
189 event_notify_handler.handleRepJoinFailureEvent();
190 }
191
handle_rep_local_site_removed_event_notifyDbEnv192 private final void handle_rep_local_site_removed_event_notify() {
193 event_notify_handler.handleRepLocalSiteRemovedEvent();
194 }
195
handle_rep_master_event_notifyDbEnv196 private final void handle_rep_master_event_notify() {
197 event_notify_handler.handleRepMasterEvent();
198 }
199
handle_rep_master_failure_event_notifyDbEnv200 private final void handle_rep_master_failure_event_notify() {
201 event_notify_handler.handleRepMasterFailureEvent();
202 }
203
handle_rep_new_master_event_notifyDbEnv204 private final void handle_rep_new_master_event_notify(int envid) {
205 event_notify_handler.handleRepNewMasterEvent(envid);
206 }
207
handle_rep_perm_failed_event_notifyDbEnv208 private final void handle_rep_perm_failed_event_notify() {
209 event_notify_handler.handleRepPermFailedEvent();
210 }
211
handle_rep_site_added_event_notifyDbEnv212 private final void handle_rep_site_added_event_notify() {
213 event_notify_handler.handleRepSiteAddedEvent();
214 }
215
handle_rep_site_removed_event_notifyDbEnv216 private final void handle_rep_site_removed_event_notify() {
217 event_notify_handler.handleRepSiteRemovedEvent();
218 }
219
handle_rep_startup_done_event_notifyDbEnv220 private final void handle_rep_startup_done_event_notify() {
221 event_notify_handler.handleRepStartupDoneEvent();
222 }
223
handle_write_failed_event_notifyDbEnv224 private final void handle_write_failed_event_notify(int errno) {
225 event_notify_handler.handleWriteFailedEvent(errno);
226 }
227
get_event_notifyDbEnv228 public EventHandler get_event_notify() {
229 return event_notify_handler;
230 }
231
handle_env_feedbackDbEnv232 private final void handle_env_feedback(int opcode, int percent) {
233 if (opcode == DbConstants.DB_RECOVER)
234 env_feedback_handler.recoveryFeedback(wrapper, percent);
235 /* No other environment feedback type supported. */
236 }
237
get_feedbackDbEnv238 public FeedbackHandler get_feedback() {
239 return env_feedback_handler;
240 }
241
set_errpfxDbEnv242 public void set_errpfx(String errpfx) {
243 this.errpfx = errpfx;
244 }
245
get_errpfxDbEnv246 public String get_errpfx() {
247 return errpfx;
248 }
249
handle_errorDbEnv250 private final void handle_error(String msg) {
251 com.sleepycat.util.ErrorBuffer ebuf = (com.sleepycat.util.ErrorBuffer)errBuf.get();
252 if (ebuf == null) {
253 /*
254 * Populate the errBuf ThreadLocal on demand, since the
255 * callback can be made from different threads.
256 */
257 ebuf = new com.sleepycat.util.ErrorBuffer(3);
258 errBuf.set(ebuf);
259 }
260 ebuf.append(msg);
261 error_handler.error(wrapper, this.errpfx, msg);
262 }
263
get_err_msgDbEnv264 private final String get_err_msg(String orig_msg) {
265 com.sleepycat.util.ErrorBuffer ebuf = (com.sleepycat.util.ErrorBuffer)errBuf.get();
266 String ret = null;
267 if (ebuf != null) {
268 ret = ebuf.get();
269 ebuf.clear();
270 }
271 if (ret != null && ret.length() > 0)
272 return orig_msg + ": " + ret;
273 return orig_msg;
274 }
275
get_errcallDbEnv276 public ErrorHandler get_errcall() {
277 return error_handler;
278 }
279
set_msgpfxDbEnv280 public void set_msgpfx(String msgpfx) {
281 this.msgpfx = msgpfx;
282 }
283
get_msgpfxDbEnv284 public String get_msgpfx() {
285 return msgpfx;
286 }
287
handle_messageDbEnv288 private final void handle_message(String msg) {
289 message_handler.message(wrapper, this.msgpfx, msg);
290 }
291
handle_repmgr_message_dispatchDbEnv292 private final void handle_repmgr_message_dispatch(ReplicationChannel chan, DatabaseEntry[] msgs, int flags)
293 throws DatabaseException {
294 java.util.List l = java.util.Arrays.asList(msgs);
295 java.util.Set msgSet = new java.util.HashSet(l);
296 boolean need_response = flags == DbConstants.DB_REPMGR_NEED_RESPONSE;
297 repmgr_msg_dispatch_handler.dispatch(chan, msgSet, need_response);
298 }
299
get_msgcallDbEnv300 public MessageHandler get_msgcall() {
301 return message_handler;
302 }
303
handle_panicDbEnv304 private final void handle_panic(DatabaseException e) {
305 panic_handler.panic(wrapper, e);
306 }
307
get_paniccallDbEnv308 public PanicHandler get_paniccall() {
309 return panic_handler;
310 }
311
handle_rep_viewDbEnv312 public final boolean handle_rep_view(String name, int flags) {
313 return rep_view_handler.partial_view(wrapper, name, flags);
314 }
315
handle_rep_transportDbEnv316 private final int handle_rep_transport(DatabaseEntry control,
317 DatabaseEntry rec,
318 LogSequenceNumber lsn,
319 int envid, int flags)
320 throws DatabaseException {
321 return rep_transport_handler.send(wrapper,
322 control, rec, lsn, envid,
323 (flags & DbConstants.DB_REP_NOBUFFER) != 0,
324 (flags & DbConstants.DB_REP_PERMANENT) != 0,
325 (flags & DbConstants.DB_REP_ANYWHERE) != 0,
326 (flags & DbConstants.DB_REP_REREQUEST) != 0);
327 }
328
lock_vecDbEnv329 public void lock_vec(/*u_int32_t*/ int locker, int flags,
330 LockRequest[] list, int offset, int count)
331 throws DatabaseException {
332 db_javaJNI.DbEnv_lock_vec(swigCPtr, this, locker, flags, list,
333 offset, count);
334 }
335
removeDbEnv336 public synchronized void remove(String db_home, int flags)
337 throws DatabaseException, java.io.FileNotFoundException {
338 try {
339 remove0(db_home, flags);
340 } finally {
341 cleanup();
342 }
343 }
344
345 public void set_error_stream(java.io.OutputStream stream) {
346 error_stream = stream;
347 final java.io.PrintWriter pw = new java.io.PrintWriter(stream);
348 set_errcall(new ErrorHandler() {
349 public void error(Environment env,
350 String prefix, String buf) /* no exception */ {
351 if (prefix != null)
352 pw.print(prefix + ": ");
353 pw.println(buf);
354 pw.flush();
355 }
356 });
357 }
358
get_error_streamDbEnv359 public java.io.OutputStream get_error_stream() {
360 return error_stream;
361 }
362
363 public void set_message_stream(java.io.OutputStream stream) {
364 message_stream = stream;
365 final java.io.PrintWriter pw = new java.io.PrintWriter(stream);
366 set_msgcall(new MessageHandler() {
367 public void message(Environment env,
368 String prefix, String buf) /* no exception */ {
369 if (prefix != null)
370 pw.print(prefix + ": ");
371 pw.println(buf);
372 pw.flush();
373 }
374 });
375 }
376
get_message_streamDbEnv377 public java.io.OutputStream get_message_stream() {
378 return message_stream;
379 }
380
381 public void set_tx_timestamp(java.util.Date timestamp) {
382 set_tx_timestamp0(timestamp.getTime()/1000);
383 }
384
385 /*
386 * See comment at top explaining why backup_open_handler is used
387 * for all 3 backup callbacks.
388 */
get_backup_handlerDbEnv389 public BackupHandler get_backup_handler() {
390 return backup_open_handler;
391 }
392
handle_backup_closeDbEnv393 private final int handle_backup_close(String dbname) {
394 return backup_open_handler.close(dbname);
395 }
396
handle_backup_openDbEnv397 private final int handle_backup_open(String dbname, String target) {
398 return backup_open_handler.open(target, dbname);
399 }
400
handle_backup_writeDbEnv401 private final int handle_backup_write(int file_pos_gbytes, int file_pos_bytes, int len, byte[] buf) {
402 /*
403 * Offset in buf is always 0. We include it anyways to match
404 * the OutputStream.write() signature.
405 */
406 long file_pos = file_pos_gbytes * GIGABYTE + file_pos_bytes;
407 return backup_open_handler.write(file_pos, buf, 0, len);
408 }
409 %}
410
411 %typemap(javacode) struct Db %{
412 /* package */ static final int GIGABYTE = 1 << 30;
413 /*
414 * Internally, the JNI layer creates a global reference to each Db,
415 * which can potentially be different to this. We keep a copy here so
416 * we can clean up after destructors.
417 */
418 private long db_ref;
419 private DbEnv dbenv;
420 private boolean private_dbenv;
421
422 public Database wrapper;
423 private RecordNumberAppender append_recno_handler;
424 private Comparator bt_compare_handler;
425 private BtreeCompressor bt_compress_handler;
426 private BtreeCompressor bt_decompress_handler;
427 private BtreePrefixCalculator bt_prefix_handler;
428 private Comparator dup_compare_handler;
429 private FeedbackHandler db_feedback_handler;
430 private Comparator h_compare_handler;
431 private Hasher h_hash_handler;
432 private PartitionHandler partition_handler;
433 private SecondaryKeyCreator seckey_create_handler;
434 private SecondaryMultiKeyCreator secmultikey_create_handler;
435 private ForeignKeyNullifier foreignkey_nullify_handler;
436 private ForeignMultiKeyNullifier foreignmultikey_nullify_handler;
437 private Slice slice_handler;
438
439 /* Called by the Db constructor and sub-slice databases */
initialize(DbEnv dbenv)440 void initialize(DbEnv dbenv) {
441 if (dbenv == null) {
442 private_dbenv = true;
443 dbenv = db_java.getDbEnv0(this);
444 dbenv.initialize();
445 }
446 this.dbenv = dbenv;
447 db_ref = db_java.initDbRef0(this, this);
448 }
449
450 /* Initialize a sub-slice database. */
slice_init()451 public void slice_init() {
452 initialize(null);
453 }
454
cleanup()455 private void cleanup() {
456 swigCPtr = 0;
457 db_java.deleteRef0(db_ref);
458 db_ref = 0L;
459 if (private_dbenv)
460 dbenv.cleanup();
461 dbenv = null;
462 }
463
getPrivateDbEnv()464 public boolean getPrivateDbEnv() {
465 return private_dbenv;
466 }
467
close(int flags)468 public synchronized void close(int flags) throws DatabaseException {
469 try {
470 close0(flags);
471 } finally {
472 cleanup();
473 }
474 }
475
get_env()476 public DbEnv get_env() throws DatabaseException {
477 return dbenv;
478 }
479
handle_append_recno(DatabaseEntry data,int recno)480 private final void handle_append_recno(DatabaseEntry data, int recno)
481 throws DatabaseException {
482 append_recno_handler.appendRecordNumber(wrapper, data, recno);
483 }
484
get_append_recno()485 public RecordNumberAppender get_append_recno() {
486 return append_recno_handler;
487 }
488
handle_bt_compare(byte[]arr1,byte[]arr2)489 private final int handle_bt_compare(byte[] arr1, byte[] arr2) {
490 return bt_compare_handler.compare(arr1, arr2);
491 }
492
handle_bt_compress(DatabaseEntry dbt1,DatabaseEntry dbt2,DatabaseEntry dbt3,DatabaseEntry dbt4,DatabaseEntry dbt5)493 private final int handle_bt_compress(DatabaseEntry dbt1,
494 DatabaseEntry dbt2, DatabaseEntry dbt3, DatabaseEntry dbt4,
495 DatabaseEntry dbt5) {
496 return bt_compress_handler.compress(wrapper, dbt1, dbt2,
497 dbt3, dbt4, dbt5) ? 0 : DbConstants.DB_BUFFER_SMALL;
498 }
499
handle_bt_decompress(DatabaseEntry dbt1,DatabaseEntry dbt2,DatabaseEntry dbt3,DatabaseEntry dbt4,DatabaseEntry dbt5)500 private final int handle_bt_decompress(DatabaseEntry dbt1,
501 DatabaseEntry dbt2, DatabaseEntry dbt3, DatabaseEntry dbt4,
502 DatabaseEntry dbt5) {
503 return bt_compress_handler.decompress(wrapper, dbt1, dbt2,
504 dbt3, dbt4, dbt5) ? 0 : DbConstants.DB_BUFFER_SMALL;
505 }
506
get_bt_compare()507 public Comparator get_bt_compare() {
508 return bt_compare_handler;
509 }
510
get_bt_compress()511 public BtreeCompressor get_bt_compress() {
512 return bt_compress_handler;
513 }
514
get_bt_decompress()515 public BtreeCompressor get_bt_decompress() {
516 return bt_decompress_handler;
517 }
518
handle_bt_prefix(DatabaseEntry dbt1,DatabaseEntry dbt2)519 private final int handle_bt_prefix(DatabaseEntry dbt1,
520 DatabaseEntry dbt2) {
521 return bt_prefix_handler.prefix(wrapper, dbt1, dbt2);
522 }
523
get_bt_prefix()524 public BtreePrefixCalculator get_bt_prefix() {
525 return bt_prefix_handler;
526 }
527
handle_db_feedback(int opcode,int percent)528 private final void handle_db_feedback(int opcode, int percent) {
529 if (opcode == DbConstants.DB_UPGRADE)
530 db_feedback_handler.upgradeFeedback(wrapper, percent);
531 else if (opcode == DbConstants.DB_VERIFY)
532 db_feedback_handler.upgradeFeedback(wrapper, percent);
533 /* No other database feedback types known. */
534 }
535
get_feedback()536 public FeedbackHandler get_feedback() {
537 return db_feedback_handler;
538 }
539
handle_h_compare(byte[]arr1,byte[]arr2)540 private final int handle_h_compare(byte[] arr1, byte[] arr2) {
541 return h_compare_handler.compare(arr1, arr2);
542 }
543
get_h_compare()544 public Comparator get_h_compare() {
545 return h_compare_handler;
546 }
547
handle_dup_compare(byte[]arr1,byte[]arr2)548 private final int handle_dup_compare(byte[] arr1, byte[] arr2) {
549 return dup_compare_handler.compare(arr1, arr2);
550 }
551
get_dup_compare()552 public Comparator get_dup_compare() {
553 return dup_compare_handler;
554 }
555
handle_h_hash(byte[]data,int len)556 private final int handle_h_hash(byte[] data, int len) {
557 return h_hash_handler.hash(wrapper, data, len);
558 }
559
get_h_hash()560 public Hasher get_h_hash() {
561 return h_hash_handler;
562 }
563
handle_foreignkey_nullify(DatabaseEntry key,DatabaseEntry data,DatabaseEntry seckey)564 private final boolean handle_foreignkey_nullify(
565 DatabaseEntry key,
566 DatabaseEntry data,
567 DatabaseEntry seckey)
568 throws DatabaseException {
569 if (foreignmultikey_nullify_handler != null)
570 return foreignmultikey_nullify_handler.nullifyForeignKey(
571 (SecondaryDatabase)wrapper, key, data, seckey);
572 else
573 return foreignkey_nullify_handler.nullifyForeignKey(
574 (SecondaryDatabase)wrapper, data);
575 }
576
handle_seckey_create(DatabaseEntry key,DatabaseEntry data)577 private final DatabaseEntry[] handle_seckey_create(
578 DatabaseEntry key,
579 DatabaseEntry data)
580 throws DatabaseException {
581
582 if (secmultikey_create_handler != null) {
583 java.util.HashSet keySet = new java.util.HashSet();
584 secmultikey_create_handler.createSecondaryKeys(
585 (SecondaryDatabase)wrapper, key, data, keySet);
586 if (!keySet.isEmpty())
587 return (DatabaseEntry[])keySet.toArray(
588 new DatabaseEntry[keySet.size()]);
589 } else {
590 DatabaseEntry result = new DatabaseEntry();
591 if (seckey_create_handler.createSecondaryKey(
592 (SecondaryDatabase)wrapper, key, data, result)) {
593 DatabaseEntry[] results = { result };
594 return results;
595 }
596 }
597
598 return null;
599 }
600
get_seckey_create()601 public SecondaryKeyCreator get_seckey_create() {
602 return seckey_create_handler;
603 }
604
get_secmultikey_create()605 public SecondaryMultiKeyCreator get_secmultikey_create() {
606 return secmultikey_create_handler;
607 }
608
set_secmultikey_create(SecondaryMultiKeyCreator secmultikey_create_handler)609 public void set_secmultikey_create(
610 SecondaryMultiKeyCreator secmultikey_create_handler) {
611 this.secmultikey_create_handler = secmultikey_create_handler;
612 }
613
set_foreignmultikey_nullifier(ForeignMultiKeyNullifier nullify)614 public void set_foreignmultikey_nullifier(ForeignMultiKeyNullifier nullify){
615 this.foreignmultikey_nullify_handler = nullify;
616 }
617
handle_partition(DatabaseEntry dbt1)618 private final int handle_partition(DatabaseEntry dbt1) {
619 return partition_handler.partition(wrapper, dbt1);
620 }
621
get_partition_callback()622 public PartitionHandler get_partition_callback() {
623 return partition_handler;
624 }
625
remove(String file,String database,int flags)626 public synchronized void remove(String file, String database, int flags)
627 throws DatabaseException, java.io.FileNotFoundException {
628 try {
629 remove0(file, database, flags);
630 } finally {
631 cleanup();
632 }
633 }
634
rename(String file,String database,String newname,int flags)635 public synchronized void rename(String file, String database,
636 String newname, int flags)
637 throws DatabaseException, java.io.FileNotFoundException {
638 try {
639 rename0(file, database, newname, flags);
640 } finally {
641 cleanup();
642 }
643 }
644
handle_slice(DatabaseEntry dbt1,DatabaseEntry dbt2)645 private final int handle_slice(
646 DatabaseEntry dbt1, DatabaseEntry dbt2)
647 throws DatabaseException {
648 return slice_handler.slice(wrapper, dbt1, dbt2) ? 0 : 1;
649 }
650
651
get_slice()652 public Slice get_slice() {
653 return slice_handler;
654 }
655
656 public synchronized boolean verify(String file, String database,
657 java.io.OutputStream outfile, int flags)
658 throws DatabaseException, java.io.FileNotFoundException {
659 try {
660 return verify0(file, database, outfile, flags);
661 } finally {
662 cleanup();
663 }
664 }
665
get_errcall()666 public ErrorHandler get_errcall() {
667 return dbenv.get_errcall();
668 }
669
set_errcall(ErrorHandler db_errcall_fcn)670 public void set_errcall(ErrorHandler db_errcall_fcn) {
671 dbenv.set_errcall(db_errcall_fcn);
672 }
673
get_error_stream()674 public java.io.OutputStream get_error_stream() {
675 return dbenv.get_error_stream();
676 }
677
678 public void set_error_stream(java.io.OutputStream stream) {
679 dbenv.set_error_stream(stream);
680 }
681
set_errpfx(String errpfx)682 public void set_errpfx(String errpfx) {
683 dbenv.set_errpfx(errpfx);
684 }
685
get_errpfx()686 public String get_errpfx() {
687 return dbenv.get_errpfx();
688 }
689
get_message_stream()690 public java.io.OutputStream get_message_stream() {
691 return dbenv.get_message_stream();
692 }
693
694 public void set_message_stream(java.io.OutputStream stream) {
695 dbenv.set_message_stream(stream);
696 }
697
set_msgpfx(String msgpfx)698 public void set_msgpfx(String msgpfx) {
699 dbenv.set_msgpfx(msgpfx);
700 }
701
get_msgpfx()702 public String get_msgpfx() {
703 return dbenv.get_msgpfx();
704 }
705
get_msgcall()706 public MessageHandler get_msgcall() {
707 return dbenv.get_msgcall();
708 }
709
set_msgcall(MessageHandler db_msgcall_fcn)710 public void set_msgcall(MessageHandler db_msgcall_fcn) {
711 dbenv.set_msgcall(db_msgcall_fcn);
712 }
713
set_paniccall(PanicHandler db_panic_fcn)714 public void set_paniccall(PanicHandler db_panic_fcn)
715 throws DatabaseException {
716 dbenv.set_paniccall(db_panic_fcn);
717 }
718
get_paniccall()719 public PanicHandler get_paniccall() {
720 return dbenv.get_paniccall();
721 }
722 %}
723
724 %typemap(javacode) struct Dbc %{
closeDbc725 public synchronized void close() throws DatabaseException {
726 try {
727 close0();
728 } finally {
729 swigCPtr = 0;
730 }
731 }
732 %}
733
734 %typemap(javacode) struct DbLock %{
735 public Lock wrapper;
736 %}
737
738 %typemap(javacode) struct DbLogc %{
closeDbLogc739 public synchronized void close(int flags) throws DatabaseException {
740 try {
741 close0(flags);
742 } finally {
743 swigCPtr = 0;
744 }
745 }
746 %}
747
748 %typemap(javacode) struct DbSequence %{
749 public Sequence wrapper;
750
close(int flags)751 public synchronized void close(int flags) throws DatabaseException {
752 try {
753 close0(flags);
754 } finally {
755 swigCPtr = 0;
756 }
757 }
758
remove(DbTxn txn,int flags)759 public synchronized void remove(DbTxn txn, int flags)
760 throws DatabaseException {
761 try {
762 remove0(txn, flags);
763 } finally {
764 swigCPtr = 0;
765 }
766 }
767 %}
768
769 %typemap(javacode) struct DbSite %{
770 public ReplicationManagerSite wrapper;
closeDbSite771 public synchronized void close() throws DatabaseException {
772 try {
773 close0();
774 } finally {
775 swigCPtr = 0;
776 }
777 }
778
removeDbSite779 public synchronized void remove() throws DatabaseException {
780 try {
781 remove0();
782 } finally {
783 swigCPtr = 0;
784 }
785 }
786 %}
787
788 %typemap(javacode) struct DbStream %{
close(int flags)789 public synchronized void close(int flags) throws DatabaseException {
790 try {
791 close0(flags);
792 } finally {
793 swigCPtr = 0;
794 }
795 }
796 %}
797
798 %typemap(javacode) struct DbChannel %{
closeDbChannel799 public synchronized void close(int flags) throws DatabaseException {
800 try {
801 close0(flags);
802 } finally {
803 swigCPtr = 0;
804 }
805 }
806 %}
807
808 %typemap(javacode) struct DbTxn %{
809 public byte[] commitToken;
abort()810 public void abort() throws DatabaseException {
811 try {
812 abort0();
813 } finally {
814 swigCPtr = 0;
815 }
816 }
817
commit(int flags)818 public void commit(int flags) throws DatabaseException {
819 try {
820 db_javaJNI.DbTxn_commit(swigCPtr, this, flags);
821 } finally {
822 swigCPtr = 0;
823 }
824 }
825
discard(int flags)826 public void discard(int flags) throws DatabaseException {
827 try {
828 discard0(flags);
829 } finally {
830 swigCPtr = 0;
831 }
832 }
833
834 /*
835 * We override Object.equals because it is possible for the Java API to
836 * create multiple DbTxns that reference the same underlying object.
837 * This can happen for example during DbEnv.txn_recover().
838 */
equals(Object obj)839 public boolean equals(Object obj)
840 {
841 if (this == obj)
842 return true;
843
844 if (obj != null && (obj instanceof DbTxn)) {
845 DbTxn that = (DbTxn)obj;
846 return (this.swigCPtr == that.swigCPtr);
847 }
848 return false;
849 }
850
851 /*
852 * We must override Object.hashCode whenever we override
853 * Object.equals() to enforce the maxim that equal objects have the
854 * same hashcode.
855 */
hashCode()856 public int hashCode()
857 {
858 return ((int)swigCPtr ^ (int)(swigCPtr >> 32));
859 }
860 %}
861
862 %native(initDbEnvRef0) jlong initDbEnvRef0(DB_ENV *self, void *handle);
863 %native(initDbRef0) jlong initDbRef0(DB *self, void *handle);
864 %native(deleteRef0) void deleteRef0(jlong ref);
865 %native(getDbEnv0) DB_ENV *getDbEnv0(DB *self);
866
867 %{
868 SWIGEXPORT jlong JNICALL
Java_com_sleepycat_db_internal_db_1javaJNI_initDbEnvRef0(JNIEnv * jenv,jclass jcls,jlong jarg1,jobject jarg1_,jobject jarg2)869 Java_com_sleepycat_db_internal_db_1javaJNI_initDbEnvRef0(
870 JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
871 DB_ENV *self = *(DB_ENV **)(void *)&jarg1;
872 jlong ret;
873 COMPQUIET(jcls, NULL);
874 COMPQUIET(jarg1_, NULL);
875
876 DB_ENV_INTERNAL(self) = (void *)(*jenv)->NewGlobalRef(jenv, jarg2);
877 *(jobject *)(void *)&ret = (jobject)DB_ENV_INTERNAL(self);
878 return (ret);
879 }
880
881 SWIGEXPORT jlong JNICALL
Java_com_sleepycat_db_internal_db_1javaJNI_initDbRef0(JNIEnv * jenv,jclass jcls,jlong jarg1,jobject jarg1_,jobject jarg2)882 Java_com_sleepycat_db_internal_db_1javaJNI_initDbRef0(
883 JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
884 DB *self = *(DB **)(void *)&jarg1;
885 jlong ret;
886 COMPQUIET(jcls, NULL);
887 COMPQUIET(jarg1_, NULL);
888
889 DB_INTERNAL(self) = (void *)(*jenv)->NewGlobalRef(jenv, jarg2);
890 *(jobject *)(void *)&ret = (jobject)DB_INTERNAL(self);
891 return (ret);
892 }
893
894 SWIGEXPORT void JNICALL
Java_com_sleepycat_db_internal_db_1javaJNI_deleteRef0(JNIEnv * jenv,jclass jcls,jlong jarg1)895 Java_com_sleepycat_db_internal_db_1javaJNI_deleteRef0(
896 JNIEnv *jenv, jclass jcls, jlong jarg1) {
897 jobject jref = *(jobject *)(void *)&jarg1;
898 COMPQUIET(jcls, NULL);
899
900 if (jref != 0L)
901 (*jenv)->DeleteGlobalRef(jenv, jref);
902 }
903
904 SWIGEXPORT jlong JNICALL
Java_com_sleepycat_db_internal_db_1javaJNI_getDbEnv0(JNIEnv * jenv,jclass jcls,jlong jarg1,jobject jarg1_)905 Java_com_sleepycat_db_internal_db_1javaJNI_getDbEnv0(
906 JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
907 DB *self = *(DB **)(void *)&jarg1;
908 jlong ret;
909
910 COMPQUIET(jenv, NULL);
911 COMPQUIET(jcls, NULL);
912 COMPQUIET(jarg1_, NULL);
913
914 *(DB_ENV **)(void *)&ret = self->dbenv;
915 return (ret);
916 }
917
918 SWIGEXPORT jboolean JNICALL
Java_com_sleepycat_db_internal_DbUtil_is_1big_1endian(JNIEnv * jenv,jclass clazz)919 Java_com_sleepycat_db_internal_DbUtil_is_1big_1endian(
920 JNIEnv *jenv, jclass clazz)
921 {
922 COMPQUIET(jenv, NULL);
923 COMPQUIET(clazz, NULL);
924
925 return (__db_isbigendian() ? JNI_TRUE : JNI_FALSE);
926 }
927 %}
928