1#include "db_config.h" 2/* ---------------------------------------------------------------------------- 3 * This file was automatically generated by SWIG (http://www.swig.org). 4 * Version 1.3.40 5 * 6 * This file is not intended to be easily readable and contains a number of 7 * coding conventions designed to improve portability and efficiency. Do not make 8 * changes to this file unless you know what you are doing--modify the SWIG 9 * interface file instead. 10 * ----------------------------------------------------------------------------- */ 11 12#define SWIGJAVA 13 14/* ----------------------------------------------------------------------------- 15 * This section contains generic SWIG labels for method/variable 16 * declarations/attributes, and other compiler dependent labels. 17 * ----------------------------------------------------------------------------- */ 18 19/* template workaround for compilers that cannot correctly implement the C++ standard */ 20#ifndef SWIGTEMPLATEDISAMBIGUATOR 21# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) 22# define SWIGTEMPLATEDISAMBIGUATOR template 23# elif defined(__HP_aCC) 24/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ 25/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ 26# define SWIGTEMPLATEDISAMBIGUATOR template 27# else 28# define SWIGTEMPLATEDISAMBIGUATOR 29# endif 30#endif 31 32/* inline attribute */ 33#ifndef SWIGINLINE 34# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) 35# define SWIGINLINE inline 36# else 37# define SWIGINLINE 38# endif 39#endif 40 41/* attribute recognised by some compilers to avoid 'unused' warnings */ 42#ifndef SWIGUNUSED 43# if defined(__GNUC__) 44# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) 45# define SWIGUNUSED __attribute__ ((__unused__)) 46# else 47# define SWIGUNUSED 48# endif 49# elif defined(__ICC) 50# define SWIGUNUSED __attribute__ ((__unused__)) 51# else 52# define SWIGUNUSED 53# endif 54#endif 55 56#ifndef SWIG_MSC_UNSUPPRESS_4505 57# if defined(_MSC_VER) 58# pragma warning(disable : 4505) /* unreferenced local function has been removed */ 59# endif 60#endif 61 62#ifndef SWIGUNUSEDPARM 63# ifdef __cplusplus 64# define SWIGUNUSEDPARM(p) 65# else 66# define SWIGUNUSEDPARM(p) p SWIGUNUSED 67# endif 68#endif 69 70/* internal SWIG method */ 71#ifndef SWIGINTERN 72# define SWIGINTERN static SWIGUNUSED 73#endif 74 75/* internal inline SWIG method */ 76#ifndef SWIGINTERNINLINE 77# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE 78#endif 79 80/* exporting methods */ 81#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) 82# ifndef GCC_HASCLASSVISIBILITY 83# define GCC_HASCLASSVISIBILITY 84# endif 85#endif 86 87#ifndef SWIGEXPORT 88# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) 89# if defined(STATIC_LINKED) 90# define SWIGEXPORT 91# else 92# define SWIGEXPORT __declspec(dllexport) 93# endif 94# else 95# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) 96# define SWIGEXPORT __attribute__ ((visibility("default"))) 97# else 98# define SWIGEXPORT 99# endif 100# endif 101#endif 102 103/* calling conventions for Windows */ 104#ifndef SWIGSTDCALL 105# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) 106# define SWIGSTDCALL __stdcall 107# else 108# define SWIGSTDCALL 109# endif 110#endif 111 112/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ 113#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) 114# undef _CRT_SECURE_NO_DEPRECATE 115# define _CRT_SECURE_NO_DEPRECATE 116#endif 117 118/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ 119#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) 120# define _SCL_SECURE_NO_DEPRECATE 121#endif 122 123 124 125/* Fix for jlong on some versions of gcc on Windows */ 126#if defined(__GNUC__) && !defined(__INTEL_COMPILER) 127 typedef long long __int64; 128#endif 129 130/* Fix for jlong on 64-bit x86 Solaris */ 131#if defined(__x86_64) 132# ifdef _LP64 133# undef _LP64 134# endif 135#endif 136 137#include <jni.h> 138#include <stdlib.h> 139#include <string.h> 140 141 142/* Support for throwing Java exceptions */ 143typedef enum { 144 SWIG_JavaOutOfMemoryError = 1, 145 SWIG_JavaIOException, 146 SWIG_JavaRuntimeException, 147 SWIG_JavaIndexOutOfBoundsException, 148 SWIG_JavaArithmeticException, 149 SWIG_JavaIllegalArgumentException, 150 SWIG_JavaNullPointerException, 151 SWIG_JavaDirectorPureVirtual, 152 SWIG_JavaUnknownError 153} SWIG_JavaExceptionCodes; 154 155typedef struct { 156 SWIG_JavaExceptionCodes code; 157 const char *java_exception; 158} SWIG_JavaExceptions_t; 159 160 161static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) { 162 jclass excep; 163 static const SWIG_JavaExceptions_t java_exceptions[] = { 164 { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" }, 165 { SWIG_JavaIOException, "java/io/IOException" }, 166 { SWIG_JavaRuntimeException, "java/lang/RuntimeException" }, 167 { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" }, 168 { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" }, 169 { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" }, 170 { SWIG_JavaNullPointerException, "java/lang/NullPointerException" }, 171 { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" }, 172 { SWIG_JavaUnknownError, "java/lang/UnknownError" }, 173 { (SWIG_JavaExceptionCodes)0, "java/lang/UnknownError" } 174 }; 175 const SWIG_JavaExceptions_t *except_ptr = java_exceptions; 176 177 while (except_ptr->code != code && except_ptr->code) 178 except_ptr++; 179 180 (*jenv)->ExceptionClear(jenv); 181 excep = (*jenv)->FindClass(jenv, except_ptr->java_exception); 182 if (excep) 183 (*jenv)->ThrowNew(jenv, excep, msg); 184} 185 186 187/* Contract support */ 188 189#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else 190 191 192#include "db_int.h" 193#include "dbinc/txn.h" 194 195#ifdef HAVE_CRYPTO 196#define CRYPTO_ONLY(x) (x); 197#else 198#define CRYPTO_ONLY(x) 199#endif 200 201 202/* don't use SWIG's array handling - save code space */ 203#define SWIG_NOINCLUDE 1 204 205#define DB_ENV_INTERNAL(dbenv) ((dbenv)->api2_internal) 206#define DB_INTERNAL(db) ((db)->api_internal) 207 208#define DB_PKG "com/sleepycat/db/" 209 210/* Forward declarations */ 211static int __dbj_throw(JNIEnv *jenv, 212 int err, const char *msg, jobject obj, jobject jdbenv); 213 214/* Global data - JVM handle, classes, fields and methods */ 215static JavaVM *javavm; 216 217static jclass db_class, dbc_class, dbenv_class, dbt_class, dblsn_class; 218static jclass dbpreplist_class, dbtxn_class; 219static jclass keyrange_class; 220static jclass bt_stat_class, compact_class, h_stat_class, lock_stat_class; 221static jclass log_stat_class, mpool_stat_class, mpool_fstat_class; 222static jclass mutex_stat_class, qam_stat_class, rep_stat_class; 223static jclass repmgr_stat_class, repmgr_siteinfo_class, rephost_class; 224static jclass seq_stat_class, txn_stat_class; 225static jclass txn_active_class; 226static jclass lock_class, lockreq_class; 227static jclass dbex_class, deadex_class, lockex_class, memex_class; 228static jclass repdupmasterex_class, rephandledeadex_class; 229static jclass repholdelectionex_class, repjoinfailex_class; 230static jclass repleaseexpiredex_class, repleasetimeoutex_class; 231static jclass replockoutex_class, repunavailex_class; 232static jclass runrecex_class, versionex_class; 233static jclass filenotfoundex_class, illegalargex_class, outofmemerr_class; 234static jclass bytearray_class, string_class, outputstream_class; 235 236static jfieldID dbc_cptr_fid; 237static jfieldID dblsn_file_fid, dblsn_offset_fid; 238static jfieldID dbt_data_fid, dbt_data_nio_fid, dbt_size_fid, dbt_ulen_fid; 239static jfieldID dbt_dlen_fid, dbt_doff_fid, dbt_flags_fid, dbt_offset_fid; 240static jfieldID kr_less_fid, kr_equal_fid, kr_greater_fid; 241static jfieldID lock_cptr_fid; 242static jfieldID lockreq_op_fid, lockreq_modeflag_fid, lockreq_timeout_fid; 243static jfieldID lockreq_obj_fid, lockreq_lock_fid; 244static jfieldID repmgr_siteinfo_status_fid; 245 246/* BEGIN-STAT-FIELD-DECLS */ 247static jfieldID bt_stat_bt_magic_fid; 248static jfieldID bt_stat_bt_version_fid; 249static jfieldID bt_stat_bt_metaflags_fid; 250static jfieldID bt_stat_bt_nkeys_fid; 251static jfieldID bt_stat_bt_ndata_fid; 252static jfieldID bt_stat_bt_pagecnt_fid; 253static jfieldID bt_stat_bt_pagesize_fid; 254static jfieldID bt_stat_bt_minkey_fid; 255static jfieldID bt_stat_bt_re_len_fid; 256static jfieldID bt_stat_bt_re_pad_fid; 257static jfieldID bt_stat_bt_levels_fid; 258static jfieldID bt_stat_bt_int_pg_fid; 259static jfieldID bt_stat_bt_leaf_pg_fid; 260static jfieldID bt_stat_bt_dup_pg_fid; 261static jfieldID bt_stat_bt_over_pg_fid; 262static jfieldID bt_stat_bt_empty_pg_fid; 263static jfieldID bt_stat_bt_free_fid; 264static jfieldID bt_stat_bt_int_pgfree_fid; 265static jfieldID bt_stat_bt_leaf_pgfree_fid; 266static jfieldID bt_stat_bt_dup_pgfree_fid; 267static jfieldID bt_stat_bt_over_pgfree_fid; 268static jfieldID compact_compact_fillpercent_fid; 269static jfieldID compact_compact_timeout_fid; 270static jfieldID compact_compact_pages_fid; 271static jfieldID compact_compact_pages_free_fid; 272static jfieldID compact_compact_pages_examine_fid; 273static jfieldID compact_compact_levels_fid; 274static jfieldID compact_compact_deadlock_fid; 275static jfieldID compact_compact_pages_truncated_fid; 276static jfieldID compact_compact_truncate_fid; 277static jfieldID h_stat_hash_magic_fid; 278static jfieldID h_stat_hash_version_fid; 279static jfieldID h_stat_hash_metaflags_fid; 280static jfieldID h_stat_hash_nkeys_fid; 281static jfieldID h_stat_hash_ndata_fid; 282static jfieldID h_stat_hash_pagecnt_fid; 283static jfieldID h_stat_hash_pagesize_fid; 284static jfieldID h_stat_hash_ffactor_fid; 285static jfieldID h_stat_hash_buckets_fid; 286static jfieldID h_stat_hash_free_fid; 287static jfieldID h_stat_hash_bfree_fid; 288static jfieldID h_stat_hash_bigpages_fid; 289static jfieldID h_stat_hash_big_bfree_fid; 290static jfieldID h_stat_hash_overflows_fid; 291static jfieldID h_stat_hash_ovfl_free_fid; 292static jfieldID h_stat_hash_dup_fid; 293static jfieldID h_stat_hash_dup_free_fid; 294static jfieldID lock_stat_st_id_fid; 295static jfieldID lock_stat_st_cur_maxid_fid; 296static jfieldID lock_stat_st_maxlocks_fid; 297static jfieldID lock_stat_st_maxlockers_fid; 298static jfieldID lock_stat_st_maxobjects_fid; 299static jfieldID lock_stat_st_partitions_fid; 300static jfieldID lock_stat_st_nmodes_fid; 301static jfieldID lock_stat_st_nlockers_fid; 302static jfieldID lock_stat_st_nlocks_fid; 303static jfieldID lock_stat_st_maxnlocks_fid; 304static jfieldID lock_stat_st_maxhlocks_fid; 305static jfieldID lock_stat_st_locksteals_fid; 306static jfieldID lock_stat_st_maxlsteals_fid; 307static jfieldID lock_stat_st_maxnlockers_fid; 308static jfieldID lock_stat_st_nobjects_fid; 309static jfieldID lock_stat_st_maxnobjects_fid; 310static jfieldID lock_stat_st_maxhobjects_fid; 311static jfieldID lock_stat_st_objectsteals_fid; 312static jfieldID lock_stat_st_maxosteals_fid; 313static jfieldID lock_stat_st_nrequests_fid; 314static jfieldID lock_stat_st_nreleases_fid; 315static jfieldID lock_stat_st_nupgrade_fid; 316static jfieldID lock_stat_st_ndowngrade_fid; 317static jfieldID lock_stat_st_lock_wait_fid; 318static jfieldID lock_stat_st_lock_nowait_fid; 319static jfieldID lock_stat_st_ndeadlocks_fid; 320static jfieldID lock_stat_st_locktimeout_fid; 321static jfieldID lock_stat_st_nlocktimeouts_fid; 322static jfieldID lock_stat_st_txntimeout_fid; 323static jfieldID lock_stat_st_ntxntimeouts_fid; 324static jfieldID lock_stat_st_part_wait_fid; 325static jfieldID lock_stat_st_part_nowait_fid; 326static jfieldID lock_stat_st_part_max_wait_fid; 327static jfieldID lock_stat_st_part_max_nowait_fid; 328static jfieldID lock_stat_st_objs_wait_fid; 329static jfieldID lock_stat_st_objs_nowait_fid; 330static jfieldID lock_stat_st_lockers_wait_fid; 331static jfieldID lock_stat_st_lockers_nowait_fid; 332static jfieldID lock_stat_st_region_wait_fid; 333static jfieldID lock_stat_st_region_nowait_fid; 334static jfieldID lock_stat_st_hash_len_fid; 335static jfieldID lock_stat_st_regsize_fid; 336static jfieldID log_stat_st_magic_fid; 337static jfieldID log_stat_st_version_fid; 338static jfieldID log_stat_st_mode_fid; 339static jfieldID log_stat_st_lg_bsize_fid; 340static jfieldID log_stat_st_lg_size_fid; 341static jfieldID log_stat_st_wc_bytes_fid; 342static jfieldID log_stat_st_wc_mbytes_fid; 343static jfieldID log_stat_st_record_fid; 344static jfieldID log_stat_st_w_bytes_fid; 345static jfieldID log_stat_st_w_mbytes_fid; 346static jfieldID log_stat_st_wcount_fid; 347static jfieldID log_stat_st_wcount_fill_fid; 348static jfieldID log_stat_st_rcount_fid; 349static jfieldID log_stat_st_scount_fid; 350static jfieldID log_stat_st_region_wait_fid; 351static jfieldID log_stat_st_region_nowait_fid; 352static jfieldID log_stat_st_cur_file_fid; 353static jfieldID log_stat_st_cur_offset_fid; 354static jfieldID log_stat_st_disk_file_fid; 355static jfieldID log_stat_st_disk_offset_fid; 356static jfieldID log_stat_st_maxcommitperflush_fid; 357static jfieldID log_stat_st_mincommitperflush_fid; 358static jfieldID log_stat_st_regsize_fid; 359static jfieldID mpool_fstat_file_name_fid; 360static jfieldID mpool_fstat_st_pagesize_fid; 361static jfieldID mpool_fstat_st_map_fid; 362static jfieldID mpool_fstat_st_cache_hit_fid; 363static jfieldID mpool_fstat_st_cache_miss_fid; 364static jfieldID mpool_fstat_st_page_create_fid; 365static jfieldID mpool_fstat_st_page_in_fid; 366static jfieldID mpool_fstat_st_page_out_fid; 367static jfieldID mpool_stat_st_gbytes_fid; 368static jfieldID mpool_stat_st_bytes_fid; 369static jfieldID mpool_stat_st_ncache_fid; 370static jfieldID mpool_stat_st_max_ncache_fid; 371static jfieldID mpool_stat_st_mmapsize_fid; 372static jfieldID mpool_stat_st_maxopenfd_fid; 373static jfieldID mpool_stat_st_maxwrite_fid; 374static jfieldID mpool_stat_st_maxwrite_sleep_fid; 375static jfieldID mpool_stat_st_pages_fid; 376static jfieldID mpool_stat_st_map_fid; 377static jfieldID mpool_stat_st_cache_hit_fid; 378static jfieldID mpool_stat_st_cache_miss_fid; 379static jfieldID mpool_stat_st_page_create_fid; 380static jfieldID mpool_stat_st_page_in_fid; 381static jfieldID mpool_stat_st_page_out_fid; 382static jfieldID mpool_stat_st_ro_evict_fid; 383static jfieldID mpool_stat_st_rw_evict_fid; 384static jfieldID mpool_stat_st_page_trickle_fid; 385static jfieldID mpool_stat_st_page_clean_fid; 386static jfieldID mpool_stat_st_page_dirty_fid; 387static jfieldID mpool_stat_st_hash_buckets_fid; 388static jfieldID mpool_stat_st_pagesize_fid; 389static jfieldID mpool_stat_st_hash_searches_fid; 390static jfieldID mpool_stat_st_hash_longest_fid; 391static jfieldID mpool_stat_st_hash_examined_fid; 392static jfieldID mpool_stat_st_hash_nowait_fid; 393static jfieldID mpool_stat_st_hash_wait_fid; 394static jfieldID mpool_stat_st_hash_max_nowait_fid; 395static jfieldID mpool_stat_st_hash_max_wait_fid; 396static jfieldID mpool_stat_st_region_nowait_fid; 397static jfieldID mpool_stat_st_region_wait_fid; 398static jfieldID mpool_stat_st_mvcc_frozen_fid; 399static jfieldID mpool_stat_st_mvcc_thawed_fid; 400static jfieldID mpool_stat_st_mvcc_freed_fid; 401static jfieldID mpool_stat_st_alloc_fid; 402static jfieldID mpool_stat_st_alloc_buckets_fid; 403static jfieldID mpool_stat_st_alloc_max_buckets_fid; 404static jfieldID mpool_stat_st_alloc_pages_fid; 405static jfieldID mpool_stat_st_alloc_max_pages_fid; 406static jfieldID mpool_stat_st_io_wait_fid; 407static jfieldID mpool_stat_st_sync_interrupted_fid; 408static jfieldID mpool_stat_st_regsize_fid; 409static jfieldID mutex_stat_st_mutex_align_fid; 410static jfieldID mutex_stat_st_mutex_tas_spins_fid; 411static jfieldID mutex_stat_st_mutex_cnt_fid; 412static jfieldID mutex_stat_st_mutex_free_fid; 413static jfieldID mutex_stat_st_mutex_inuse_fid; 414static jfieldID mutex_stat_st_mutex_inuse_max_fid; 415static jfieldID mutex_stat_st_region_wait_fid; 416static jfieldID mutex_stat_st_region_nowait_fid; 417static jfieldID mutex_stat_st_regsize_fid; 418static jfieldID qam_stat_qs_magic_fid; 419static jfieldID qam_stat_qs_version_fid; 420static jfieldID qam_stat_qs_metaflags_fid; 421static jfieldID qam_stat_qs_nkeys_fid; 422static jfieldID qam_stat_qs_ndata_fid; 423static jfieldID qam_stat_qs_pagesize_fid; 424static jfieldID qam_stat_qs_extentsize_fid; 425static jfieldID qam_stat_qs_pages_fid; 426static jfieldID qam_stat_qs_re_len_fid; 427static jfieldID qam_stat_qs_re_pad_fid; 428static jfieldID qam_stat_qs_pgfree_fid; 429static jfieldID qam_stat_qs_first_recno_fid; 430static jfieldID qam_stat_qs_cur_recno_fid; 431static jfieldID rep_stat_st_log_queued_fid; 432static jfieldID rep_stat_st_startup_complete_fid; 433static jfieldID rep_stat_st_status_fid; 434static jfieldID rep_stat_st_next_lsn_fid; 435static jfieldID rep_stat_st_waiting_lsn_fid; 436static jfieldID rep_stat_st_max_perm_lsn_fid; 437static jfieldID rep_stat_st_next_pg_fid; 438static jfieldID rep_stat_st_waiting_pg_fid; 439static jfieldID rep_stat_st_dupmasters_fid; 440static jfieldID rep_stat_st_env_id_fid; 441static jfieldID rep_stat_st_env_priority_fid; 442static jfieldID rep_stat_st_bulk_fills_fid; 443static jfieldID rep_stat_st_bulk_overflows_fid; 444static jfieldID rep_stat_st_bulk_records_fid; 445static jfieldID rep_stat_st_bulk_transfers_fid; 446static jfieldID rep_stat_st_client_rerequests_fid; 447static jfieldID rep_stat_st_client_svc_req_fid; 448static jfieldID rep_stat_st_client_svc_miss_fid; 449static jfieldID rep_stat_st_gen_fid; 450static jfieldID rep_stat_st_egen_fid; 451static jfieldID rep_stat_st_log_duplicated_fid; 452static jfieldID rep_stat_st_log_queued_max_fid; 453static jfieldID rep_stat_st_log_queued_total_fid; 454static jfieldID rep_stat_st_log_records_fid; 455static jfieldID rep_stat_st_log_requested_fid; 456static jfieldID rep_stat_st_master_fid; 457static jfieldID rep_stat_st_master_changes_fid; 458static jfieldID rep_stat_st_msgs_badgen_fid; 459static jfieldID rep_stat_st_msgs_processed_fid; 460static jfieldID rep_stat_st_msgs_recover_fid; 461static jfieldID rep_stat_st_msgs_send_failures_fid; 462static jfieldID rep_stat_st_msgs_sent_fid; 463static jfieldID rep_stat_st_newsites_fid; 464static jfieldID rep_stat_st_nsites_fid; 465static jfieldID rep_stat_st_nthrottles_fid; 466static jfieldID rep_stat_st_outdated_fid; 467static jfieldID rep_stat_st_pg_duplicated_fid; 468static jfieldID rep_stat_st_pg_records_fid; 469static jfieldID rep_stat_st_pg_requested_fid; 470static jfieldID rep_stat_st_txns_applied_fid; 471static jfieldID rep_stat_st_startsync_delayed_fid; 472static jfieldID rep_stat_st_elections_fid; 473static jfieldID rep_stat_st_elections_won_fid; 474static jfieldID rep_stat_st_election_cur_winner_fid; 475static jfieldID rep_stat_st_election_gen_fid; 476static jfieldID rep_stat_st_election_lsn_fid; 477static jfieldID rep_stat_st_election_nsites_fid; 478static jfieldID rep_stat_st_election_nvotes_fid; 479static jfieldID rep_stat_st_election_priority_fid; 480static jfieldID rep_stat_st_election_status_fid; 481static jfieldID rep_stat_st_election_tiebreaker_fid; 482static jfieldID rep_stat_st_election_votes_fid; 483static jfieldID rep_stat_st_election_sec_fid; 484static jfieldID rep_stat_st_election_usec_fid; 485static jfieldID rep_stat_st_max_lease_sec_fid; 486static jfieldID rep_stat_st_max_lease_usec_fid; 487static jfieldID repmgr_stat_st_perm_failed_fid; 488static jfieldID repmgr_stat_st_msgs_queued_fid; 489static jfieldID repmgr_stat_st_msgs_dropped_fid; 490static jfieldID repmgr_stat_st_connection_drop_fid; 491static jfieldID repmgr_stat_st_connect_fail_fid; 492static jfieldID seq_stat_st_wait_fid; 493static jfieldID seq_stat_st_nowait_fid; 494static jfieldID seq_stat_st_current_fid; 495static jfieldID seq_stat_st_value_fid; 496static jfieldID seq_stat_st_last_value_fid; 497static jfieldID seq_stat_st_min_fid; 498static jfieldID seq_stat_st_max_fid; 499static jfieldID seq_stat_st_cache_size_fid; 500static jfieldID seq_stat_st_flags_fid; 501static jfieldID txn_stat_st_nrestores_fid; 502static jfieldID txn_stat_st_last_ckp_fid; 503static jfieldID txn_stat_st_time_ckp_fid; 504static jfieldID txn_stat_st_last_txnid_fid; 505static jfieldID txn_stat_st_maxtxns_fid; 506static jfieldID txn_stat_st_naborts_fid; 507static jfieldID txn_stat_st_nbegins_fid; 508static jfieldID txn_stat_st_ncommits_fid; 509static jfieldID txn_stat_st_nactive_fid; 510static jfieldID txn_stat_st_nsnapshot_fid; 511static jfieldID txn_stat_st_maxnactive_fid; 512static jfieldID txn_stat_st_maxnsnapshot_fid; 513static jfieldID txn_stat_st_txnarray_fid; 514static jfieldID txn_stat_st_region_wait_fid; 515static jfieldID txn_stat_st_region_nowait_fid; 516static jfieldID txn_stat_st_regsize_fid; 517static jfieldID txn_active_txnid_fid; 518static jfieldID txn_active_parentid_fid; 519static jfieldID txn_active_pid_fid; 520static jfieldID txn_active_lsn_fid; 521static jfieldID txn_active_read_lsn_fid; 522static jfieldID txn_active_mvcc_ref_fid; 523static jfieldID txn_active_status_fid; 524static jfieldID txn_active_gid_fid; 525static jfieldID txn_active_name_fid; 526/* END-STAT-FIELD-DECLS */ 527 528static jmethodID dbenv_construct, dbt_construct, dblsn_construct; 529static jmethodID dbpreplist_construct, dbtxn_construct; 530static jmethodID bt_stat_construct, get_err_msg_method, h_stat_construct; 531static jmethodID lock_stat_construct, log_stat_construct; 532static jmethodID mpool_stat_construct, mpool_fstat_construct; 533static jmethodID mutex_stat_construct, qam_stat_construct; 534static jmethodID rep_stat_construct, repmgr_stat_construct, seq_stat_construct; 535static jmethodID txn_stat_construct, txn_active_construct; 536static jmethodID dbex_construct, deadex_construct, lockex_construct; 537static jmethodID memex_construct, memex_update_method; 538static jmethodID repdupmasterex_construct, rephandledeadex_construct; 539static jmethodID repholdelectionex_construct, repjoinfailex_construct; 540static jmethodID repmgr_siteinfo_construct, rephost_construct, repleaseexpiredex_construct; 541static jmethodID repleasetimeoutex_construct, replockoutex_construct; 542static jmethodID repunavailex_construct; 543static jmethodID runrecex_construct, versionex_construct; 544static jmethodID filenotfoundex_construct, illegalargex_construct; 545static jmethodID outofmemerr_construct; 546static jmethodID lock_construct; 547 548static jmethodID app_dispatch_method, errcall_method, env_feedback_method; 549static jmethodID msgcall_method, paniccall_method, rep_transport_method; 550static jmethodID panic_event_notify_method, rep_client_event_notify_method; 551static jmethodID rep_elected_event_notify_method; 552static jmethodID rep_master_event_notify_method; 553static jmethodID rep_new_master_event_notify_method; 554static jmethodID rep_perm_failed_event_notify_method; 555static jmethodID rep_startup_done_event_notify_method; 556static jmethodID write_failed_event_notify_method; 557 558static jmethodID append_recno_method, bt_compare_method, bt_compress_method; 559static jmethodID bt_decompress_method, bt_prefix_method; 560static jmethodID db_feedback_method, dup_compare_method; 561static jmethodID foreignkey_nullify_method, h_compare_method, h_hash_method; 562static jmethodID partition_method, seckey_create_method; 563 564static jmethodID outputstream_write_method; 565 566const struct { 567 jclass *cl; 568 const char *name; 569} all_classes[] = { 570 { &dbenv_class, DB_PKG "internal/DbEnv" }, 571 { &db_class, DB_PKG "internal/Db" }, 572 { &dbc_class, DB_PKG "internal/Dbc" }, 573 { &dbt_class, DB_PKG "DatabaseEntry" }, 574 { &dblsn_class, DB_PKG "LogSequenceNumber" }, 575 { &dbpreplist_class, DB_PKG "PreparedTransaction" }, 576 { &dbtxn_class, DB_PKG "internal/DbTxn" }, 577 578 { &bt_stat_class, DB_PKG "BtreeStats" }, 579 { &compact_class, DB_PKG "CompactStats" }, 580 { &h_stat_class, DB_PKG "HashStats" }, 581 { &lock_stat_class, DB_PKG "LockStats" }, 582 { &log_stat_class, DB_PKG "LogStats" }, 583 { &mpool_fstat_class, DB_PKG "CacheFileStats" }, 584 { &mpool_stat_class, DB_PKG "CacheStats" }, 585 { &mutex_stat_class, DB_PKG "MutexStats" }, 586 { &qam_stat_class, DB_PKG "QueueStats" }, 587 { &rep_stat_class, DB_PKG "ReplicationStats" }, 588 { &repmgr_stat_class, DB_PKG "ReplicationManagerStats" }, 589 { &seq_stat_class, DB_PKG "SequenceStats" }, 590 { &txn_stat_class, DB_PKG "TransactionStats" }, 591 { &txn_active_class, DB_PKG "TransactionStats$Active" }, 592 593 { &keyrange_class, DB_PKG "KeyRange" }, 594 { &lock_class, DB_PKG "internal/DbLock" }, 595 { &lockreq_class, DB_PKG "LockRequest" }, 596 597 { &dbex_class, DB_PKG "DatabaseException" }, 598 { &deadex_class, DB_PKG "DeadlockException" }, 599 { &lockex_class, DB_PKG "LockNotGrantedException" }, 600 { &memex_class, DB_PKG "MemoryException" }, 601 { &repdupmasterex_class, DB_PKG "ReplicationDuplicateMasterException" }, 602 { &rephandledeadex_class, DB_PKG "ReplicationHandleDeadException" }, 603 { &repholdelectionex_class, DB_PKG "ReplicationHoldElectionException" }, 604 { &rephost_class, DB_PKG "ReplicationHostAddress" }, 605 { &repmgr_siteinfo_class, DB_PKG "ReplicationManagerSiteInfo" }, 606 { &repjoinfailex_class, DB_PKG "ReplicationJoinFailureException" }, 607 { &repleaseexpiredex_class, DB_PKG "ReplicationLeaseExpiredException" }, 608 { &repleasetimeoutex_class, DB_PKG "ReplicationLeaseTimeoutException" }, 609 { &replockoutex_class, DB_PKG "ReplicationLockoutException" }, 610 { &repunavailex_class, DB_PKG "ReplicationSiteUnavailableException" }, 611 { &runrecex_class, DB_PKG "RunRecoveryException" }, 612 { &versionex_class, DB_PKG "VersionMismatchException" }, 613 { &filenotfoundex_class, "java/io/FileNotFoundException" }, 614 { &illegalargex_class, "java/lang/IllegalArgumentException" }, 615 { &outofmemerr_class, "java/lang/OutOfMemoryError" }, 616 617 { &bytearray_class, "[B" }, 618 { &string_class, "java/lang/String" }, 619 { &outputstream_class, "java/io/OutputStream" } 620}; 621 622const struct { 623 jfieldID *fid; 624 jclass *cl; 625 const char *name; 626 const char *sig; 627} all_fields[] = { 628 { &dbc_cptr_fid, &dbc_class, "swigCPtr", "J" }, 629 630 { &dblsn_file_fid, &dblsn_class, "file", "I" }, 631 { &dblsn_offset_fid, &dblsn_class, "offset", "I" }, 632 633 { &dbt_data_fid, &dbt_class, "data", "[B" }, 634 { &dbt_data_nio_fid, &dbt_class, "data_nio", "Ljava/nio/ByteBuffer;" }, 635 { &dbt_size_fid, &dbt_class, "size", "I" }, 636 { &dbt_ulen_fid, &dbt_class, "ulen", "I" }, 637 { &dbt_dlen_fid, &dbt_class, "dlen", "I" }, 638 { &dbt_doff_fid, &dbt_class, "doff", "I" }, 639 { &dbt_flags_fid, &dbt_class, "flags", "I" }, 640 { &dbt_offset_fid, &dbt_class, "offset", "I" }, 641 642 { &kr_less_fid, &keyrange_class, "less", "D" }, 643 { &kr_equal_fid, &keyrange_class, "equal", "D" }, 644 { &kr_greater_fid, &keyrange_class, "greater", "D" }, 645 646 { &lock_cptr_fid, &lock_class, "swigCPtr", "J" }, 647 648 { &lockreq_op_fid, &lockreq_class, "op", "I" }, 649 { &lockreq_modeflag_fid, &lockreq_class, "modeFlag", "I" }, 650 { &lockreq_timeout_fid, &lockreq_class, "timeout", "I" }, 651 { &lockreq_obj_fid, &lockreq_class, "obj", 652 "L" DB_PKG "DatabaseEntry;" }, 653 { &lockreq_lock_fid, &lockreq_class, "lock", 654 "L" DB_PKG "internal/DbLock;" }, 655 656/* BEGIN-STAT-FIELDS */ 657 { &bt_stat_bt_magic_fid, &bt_stat_class, "bt_magic", "I" }, 658 { &bt_stat_bt_version_fid, &bt_stat_class, "bt_version", "I" }, 659 { &bt_stat_bt_metaflags_fid, &bt_stat_class, "bt_metaflags", "I" }, 660 { &bt_stat_bt_nkeys_fid, &bt_stat_class, "bt_nkeys", "I" }, 661 { &bt_stat_bt_ndata_fid, &bt_stat_class, "bt_ndata", "I" }, 662 { &bt_stat_bt_pagecnt_fid, &bt_stat_class, "bt_pagecnt", "I" }, 663 { &bt_stat_bt_pagesize_fid, &bt_stat_class, "bt_pagesize", "I" }, 664 { &bt_stat_bt_minkey_fid, &bt_stat_class, "bt_minkey", "I" }, 665 { &bt_stat_bt_re_len_fid, &bt_stat_class, "bt_re_len", "I" }, 666 { &bt_stat_bt_re_pad_fid, &bt_stat_class, "bt_re_pad", "I" }, 667 { &bt_stat_bt_levels_fid, &bt_stat_class, "bt_levels", "I" }, 668 { &bt_stat_bt_int_pg_fid, &bt_stat_class, "bt_int_pg", "I" }, 669 { &bt_stat_bt_leaf_pg_fid, &bt_stat_class, "bt_leaf_pg", "I" }, 670 { &bt_stat_bt_dup_pg_fid, &bt_stat_class, "bt_dup_pg", "I" }, 671 { &bt_stat_bt_over_pg_fid, &bt_stat_class, "bt_over_pg", "I" }, 672 { &bt_stat_bt_empty_pg_fid, &bt_stat_class, "bt_empty_pg", "I" }, 673 { &bt_stat_bt_free_fid, &bt_stat_class, "bt_free", "I" }, 674 { &bt_stat_bt_int_pgfree_fid, &bt_stat_class, "bt_int_pgfree", "J" }, 675 { &bt_stat_bt_leaf_pgfree_fid, &bt_stat_class, "bt_leaf_pgfree", "J" }, 676 { &bt_stat_bt_dup_pgfree_fid, &bt_stat_class, "bt_dup_pgfree", "J" }, 677 { &bt_stat_bt_over_pgfree_fid, &bt_stat_class, "bt_over_pgfree", "J" }, 678 { &compact_compact_fillpercent_fid, &compact_class, "compact_fillpercent", "I" }, 679 { &compact_compact_timeout_fid, &compact_class, "compact_timeout", "I" }, 680 { &compact_compact_pages_fid, &compact_class, "compact_pages", "I" }, 681 { &compact_compact_pages_free_fid, &compact_class, "compact_pages_free", "I" }, 682 { &compact_compact_pages_examine_fid, &compact_class, "compact_pages_examine", "I" }, 683 { &compact_compact_levels_fid, &compact_class, "compact_levels", "I" }, 684 { &compact_compact_deadlock_fid, &compact_class, "compact_deadlock", "I" }, 685 { &compact_compact_pages_truncated_fid, &compact_class, "compact_pages_truncated", "I" }, 686 { &compact_compact_truncate_fid, &compact_class, "compact_truncate", "I" }, 687 { &h_stat_hash_magic_fid, &h_stat_class, "hash_magic", "I" }, 688 { &h_stat_hash_version_fid, &h_stat_class, "hash_version", "I" }, 689 { &h_stat_hash_metaflags_fid, &h_stat_class, "hash_metaflags", "I" }, 690 { &h_stat_hash_nkeys_fid, &h_stat_class, "hash_nkeys", "I" }, 691 { &h_stat_hash_ndata_fid, &h_stat_class, "hash_ndata", "I" }, 692 { &h_stat_hash_pagecnt_fid, &h_stat_class, "hash_pagecnt", "I" }, 693 { &h_stat_hash_pagesize_fid, &h_stat_class, "hash_pagesize", "I" }, 694 { &h_stat_hash_ffactor_fid, &h_stat_class, "hash_ffactor", "I" }, 695 { &h_stat_hash_buckets_fid, &h_stat_class, "hash_buckets", "I" }, 696 { &h_stat_hash_free_fid, &h_stat_class, "hash_free", "I" }, 697 { &h_stat_hash_bfree_fid, &h_stat_class, "hash_bfree", "J" }, 698 { &h_stat_hash_bigpages_fid, &h_stat_class, "hash_bigpages", "I" }, 699 { &h_stat_hash_big_bfree_fid, &h_stat_class, "hash_big_bfree", "J" }, 700 { &h_stat_hash_overflows_fid, &h_stat_class, "hash_overflows", "I" }, 701 { &h_stat_hash_ovfl_free_fid, &h_stat_class, "hash_ovfl_free", "J" }, 702 { &h_stat_hash_dup_fid, &h_stat_class, "hash_dup", "I" }, 703 { &h_stat_hash_dup_free_fid, &h_stat_class, "hash_dup_free", "J" }, 704 { &lock_stat_st_id_fid, &lock_stat_class, "st_id", "I" }, 705 { &lock_stat_st_cur_maxid_fid, &lock_stat_class, "st_cur_maxid", "I" }, 706 { &lock_stat_st_maxlocks_fid, &lock_stat_class, "st_maxlocks", "I" }, 707 { &lock_stat_st_maxlockers_fid, &lock_stat_class, "st_maxlockers", "I" }, 708 { &lock_stat_st_maxobjects_fid, &lock_stat_class, "st_maxobjects", "I" }, 709 { &lock_stat_st_partitions_fid, &lock_stat_class, "st_partitions", "I" }, 710 { &lock_stat_st_nmodes_fid, &lock_stat_class, "st_nmodes", "I" }, 711 { &lock_stat_st_nlockers_fid, &lock_stat_class, "st_nlockers", "I" }, 712 { &lock_stat_st_nlocks_fid, &lock_stat_class, "st_nlocks", "I" }, 713 { &lock_stat_st_maxnlocks_fid, &lock_stat_class, "st_maxnlocks", "I" }, 714 { &lock_stat_st_maxhlocks_fid, &lock_stat_class, "st_maxhlocks", "I" }, 715 { &lock_stat_st_locksteals_fid, &lock_stat_class, "st_locksteals", "J" }, 716 { &lock_stat_st_maxlsteals_fid, &lock_stat_class, "st_maxlsteals", "J" }, 717 { &lock_stat_st_maxnlockers_fid, &lock_stat_class, "st_maxnlockers", "I" }, 718 { &lock_stat_st_nobjects_fid, &lock_stat_class, "st_nobjects", "I" }, 719 { &lock_stat_st_maxnobjects_fid, &lock_stat_class, "st_maxnobjects", "I" }, 720 { &lock_stat_st_maxhobjects_fid, &lock_stat_class, "st_maxhobjects", "I" }, 721 { &lock_stat_st_objectsteals_fid, &lock_stat_class, "st_objectsteals", "J" }, 722 { &lock_stat_st_maxosteals_fid, &lock_stat_class, "st_maxosteals", "J" }, 723 { &lock_stat_st_nrequests_fid, &lock_stat_class, "st_nrequests", "J" }, 724 { &lock_stat_st_nreleases_fid, &lock_stat_class, "st_nreleases", "J" }, 725 { &lock_stat_st_nupgrade_fid, &lock_stat_class, "st_nupgrade", "J" }, 726 { &lock_stat_st_ndowngrade_fid, &lock_stat_class, "st_ndowngrade", "J" }, 727 { &lock_stat_st_lock_wait_fid, &lock_stat_class, "st_lock_wait", "J" }, 728 { &lock_stat_st_lock_nowait_fid, &lock_stat_class, "st_lock_nowait", "J" }, 729 { &lock_stat_st_ndeadlocks_fid, &lock_stat_class, "st_ndeadlocks", "J" }, 730 { &lock_stat_st_locktimeout_fid, &lock_stat_class, "st_locktimeout", "I" }, 731 { &lock_stat_st_nlocktimeouts_fid, &lock_stat_class, "st_nlocktimeouts", "J" }, 732 { &lock_stat_st_txntimeout_fid, &lock_stat_class, "st_txntimeout", "I" }, 733 { &lock_stat_st_ntxntimeouts_fid, &lock_stat_class, "st_ntxntimeouts", "J" }, 734 { &lock_stat_st_part_wait_fid, &lock_stat_class, "st_part_wait", "J" }, 735 { &lock_stat_st_part_nowait_fid, &lock_stat_class, "st_part_nowait", "J" }, 736 { &lock_stat_st_part_max_wait_fid, &lock_stat_class, "st_part_max_wait", "J" }, 737 { &lock_stat_st_part_max_nowait_fid, &lock_stat_class, "st_part_max_nowait", "J" }, 738 { &lock_stat_st_objs_wait_fid, &lock_stat_class, "st_objs_wait", "J" }, 739 { &lock_stat_st_objs_nowait_fid, &lock_stat_class, "st_objs_nowait", "J" }, 740 { &lock_stat_st_lockers_wait_fid, &lock_stat_class, "st_lockers_wait", "J" }, 741 { &lock_stat_st_lockers_nowait_fid, &lock_stat_class, "st_lockers_nowait", "J" }, 742 { &lock_stat_st_region_wait_fid, &lock_stat_class, "st_region_wait", "J" }, 743 { &lock_stat_st_region_nowait_fid, &lock_stat_class, "st_region_nowait", "J" }, 744 { &lock_stat_st_hash_len_fid, &lock_stat_class, "st_hash_len", "I" }, 745 { &lock_stat_st_regsize_fid, &lock_stat_class, "st_regsize", "I" }, 746 { &log_stat_st_magic_fid, &log_stat_class, "st_magic", "I" }, 747 { &log_stat_st_version_fid, &log_stat_class, "st_version", "I" }, 748 { &log_stat_st_mode_fid, &log_stat_class, "st_mode", "I" }, 749 { &log_stat_st_lg_bsize_fid, &log_stat_class, "st_lg_bsize", "I" }, 750 { &log_stat_st_lg_size_fid, &log_stat_class, "st_lg_size", "I" }, 751 { &log_stat_st_wc_bytes_fid, &log_stat_class, "st_wc_bytes", "I" }, 752 { &log_stat_st_wc_mbytes_fid, &log_stat_class, "st_wc_mbytes", "I" }, 753 { &log_stat_st_record_fid, &log_stat_class, "st_record", "J" }, 754 { &log_stat_st_w_bytes_fid, &log_stat_class, "st_w_bytes", "I" }, 755 { &log_stat_st_w_mbytes_fid, &log_stat_class, "st_w_mbytes", "I" }, 756 { &log_stat_st_wcount_fid, &log_stat_class, "st_wcount", "J" }, 757 { &log_stat_st_wcount_fill_fid, &log_stat_class, "st_wcount_fill", "J" }, 758 { &log_stat_st_rcount_fid, &log_stat_class, "st_rcount", "J" }, 759 { &log_stat_st_scount_fid, &log_stat_class, "st_scount", "J" }, 760 { &log_stat_st_region_wait_fid, &log_stat_class, "st_region_wait", "J" }, 761 { &log_stat_st_region_nowait_fid, &log_stat_class, "st_region_nowait", "J" }, 762 { &log_stat_st_cur_file_fid, &log_stat_class, "st_cur_file", "I" }, 763 { &log_stat_st_cur_offset_fid, &log_stat_class, "st_cur_offset", "I" }, 764 { &log_stat_st_disk_file_fid, &log_stat_class, "st_disk_file", "I" }, 765 { &log_stat_st_disk_offset_fid, &log_stat_class, "st_disk_offset", "I" }, 766 { &log_stat_st_maxcommitperflush_fid, &log_stat_class, "st_maxcommitperflush", "I" }, 767 { &log_stat_st_mincommitperflush_fid, &log_stat_class, "st_mincommitperflush", "I" }, 768 { &log_stat_st_regsize_fid, &log_stat_class, "st_regsize", "I" }, 769 { &mpool_fstat_file_name_fid, &mpool_fstat_class, "file_name", "Ljava/lang/String;" }, 770 { &mpool_fstat_st_pagesize_fid, &mpool_fstat_class, "st_pagesize", "I" }, 771 { &mpool_fstat_st_map_fid, &mpool_fstat_class, "st_map", "I" }, 772 { &mpool_fstat_st_cache_hit_fid, &mpool_fstat_class, "st_cache_hit", "J" }, 773 { &mpool_fstat_st_cache_miss_fid, &mpool_fstat_class, "st_cache_miss", "J" }, 774 { &mpool_fstat_st_page_create_fid, &mpool_fstat_class, "st_page_create", "J" }, 775 { &mpool_fstat_st_page_in_fid, &mpool_fstat_class, "st_page_in", "J" }, 776 { &mpool_fstat_st_page_out_fid, &mpool_fstat_class, "st_page_out", "J" }, 777 { &mpool_stat_st_gbytes_fid, &mpool_stat_class, "st_gbytes", "I" }, 778 { &mpool_stat_st_bytes_fid, &mpool_stat_class, "st_bytes", "I" }, 779 { &mpool_stat_st_ncache_fid, &mpool_stat_class, "st_ncache", "I" }, 780 { &mpool_stat_st_max_ncache_fid, &mpool_stat_class, "st_max_ncache", "I" }, 781 { &mpool_stat_st_mmapsize_fid, &mpool_stat_class, "st_mmapsize", "I" }, 782 { &mpool_stat_st_maxopenfd_fid, &mpool_stat_class, "st_maxopenfd", "I" }, 783 { &mpool_stat_st_maxwrite_fid, &mpool_stat_class, "st_maxwrite", "I" }, 784 { &mpool_stat_st_maxwrite_sleep_fid, &mpool_stat_class, "st_maxwrite_sleep", "I" }, 785 { &mpool_stat_st_pages_fid, &mpool_stat_class, "st_pages", "I" }, 786 { &mpool_stat_st_map_fid, &mpool_stat_class, "st_map", "I" }, 787 { &mpool_stat_st_cache_hit_fid, &mpool_stat_class, "st_cache_hit", "J" }, 788 { &mpool_stat_st_cache_miss_fid, &mpool_stat_class, "st_cache_miss", "J" }, 789 { &mpool_stat_st_page_create_fid, &mpool_stat_class, "st_page_create", "J" }, 790 { &mpool_stat_st_page_in_fid, &mpool_stat_class, "st_page_in", "J" }, 791 { &mpool_stat_st_page_out_fid, &mpool_stat_class, "st_page_out", "J" }, 792 { &mpool_stat_st_ro_evict_fid, &mpool_stat_class, "st_ro_evict", "J" }, 793 { &mpool_stat_st_rw_evict_fid, &mpool_stat_class, "st_rw_evict", "J" }, 794 { &mpool_stat_st_page_trickle_fid, &mpool_stat_class, "st_page_trickle", "J" }, 795 { &mpool_stat_st_page_clean_fid, &mpool_stat_class, "st_page_clean", "I" }, 796 { &mpool_stat_st_page_dirty_fid, &mpool_stat_class, "st_page_dirty", "I" }, 797 { &mpool_stat_st_hash_buckets_fid, &mpool_stat_class, "st_hash_buckets", "I" }, 798 { &mpool_stat_st_pagesize_fid, &mpool_stat_class, "st_pagesize", "I" }, 799 { &mpool_stat_st_hash_searches_fid, &mpool_stat_class, "st_hash_searches", "I" }, 800 { &mpool_stat_st_hash_longest_fid, &mpool_stat_class, "st_hash_longest", "I" }, 801 { &mpool_stat_st_hash_examined_fid, &mpool_stat_class, "st_hash_examined", "J" }, 802 { &mpool_stat_st_hash_nowait_fid, &mpool_stat_class, "st_hash_nowait", "J" }, 803 { &mpool_stat_st_hash_wait_fid, &mpool_stat_class, "st_hash_wait", "J" }, 804 { &mpool_stat_st_hash_max_nowait_fid, &mpool_stat_class, "st_hash_max_nowait", "J" }, 805 { &mpool_stat_st_hash_max_wait_fid, &mpool_stat_class, "st_hash_max_wait", "J" }, 806 { &mpool_stat_st_region_nowait_fid, &mpool_stat_class, "st_region_nowait", "J" }, 807 { &mpool_stat_st_region_wait_fid, &mpool_stat_class, "st_region_wait", "J" }, 808 { &mpool_stat_st_mvcc_frozen_fid, &mpool_stat_class, "st_mvcc_frozen", "J" }, 809 { &mpool_stat_st_mvcc_thawed_fid, &mpool_stat_class, "st_mvcc_thawed", "J" }, 810 { &mpool_stat_st_mvcc_freed_fid, &mpool_stat_class, "st_mvcc_freed", "J" }, 811 { &mpool_stat_st_alloc_fid, &mpool_stat_class, "st_alloc", "J" }, 812 { &mpool_stat_st_alloc_buckets_fid, &mpool_stat_class, "st_alloc_buckets", "J" }, 813 { &mpool_stat_st_alloc_max_buckets_fid, &mpool_stat_class, "st_alloc_max_buckets", "J" }, 814 { &mpool_stat_st_alloc_pages_fid, &mpool_stat_class, "st_alloc_pages", "J" }, 815 { &mpool_stat_st_alloc_max_pages_fid, &mpool_stat_class, "st_alloc_max_pages", "J" }, 816 { &mpool_stat_st_io_wait_fid, &mpool_stat_class, "st_io_wait", "J" }, 817 { &mpool_stat_st_sync_interrupted_fid, &mpool_stat_class, "st_sync_interrupted", "J" }, 818 { &mpool_stat_st_regsize_fid, &mpool_stat_class, "st_regsize", "I" }, 819 { &mutex_stat_st_mutex_align_fid, &mutex_stat_class, "st_mutex_align", "I" }, 820 { &mutex_stat_st_mutex_tas_spins_fid, &mutex_stat_class, "st_mutex_tas_spins", "I" }, 821 { &mutex_stat_st_mutex_cnt_fid, &mutex_stat_class, "st_mutex_cnt", "I" }, 822 { &mutex_stat_st_mutex_free_fid, &mutex_stat_class, "st_mutex_free", "I" }, 823 { &mutex_stat_st_mutex_inuse_fid, &mutex_stat_class, "st_mutex_inuse", "I" }, 824 { &mutex_stat_st_mutex_inuse_max_fid, &mutex_stat_class, "st_mutex_inuse_max", "I" }, 825 { &mutex_stat_st_region_wait_fid, &mutex_stat_class, "st_region_wait", "J" }, 826 { &mutex_stat_st_region_nowait_fid, &mutex_stat_class, "st_region_nowait", "J" }, 827 { &mutex_stat_st_regsize_fid, &mutex_stat_class, "st_regsize", "I" }, 828 { &qam_stat_qs_magic_fid, &qam_stat_class, "qs_magic", "I" }, 829 { &qam_stat_qs_version_fid, &qam_stat_class, "qs_version", "I" }, 830 { &qam_stat_qs_metaflags_fid, &qam_stat_class, "qs_metaflags", "I" }, 831 { &qam_stat_qs_nkeys_fid, &qam_stat_class, "qs_nkeys", "I" }, 832 { &qam_stat_qs_ndata_fid, &qam_stat_class, "qs_ndata", "I" }, 833 { &qam_stat_qs_pagesize_fid, &qam_stat_class, "qs_pagesize", "I" }, 834 { &qam_stat_qs_extentsize_fid, &qam_stat_class, "qs_extentsize", "I" }, 835 { &qam_stat_qs_pages_fid, &qam_stat_class, "qs_pages", "I" }, 836 { &qam_stat_qs_re_len_fid, &qam_stat_class, "qs_re_len", "I" }, 837 { &qam_stat_qs_re_pad_fid, &qam_stat_class, "qs_re_pad", "I" }, 838 { &qam_stat_qs_pgfree_fid, &qam_stat_class, "qs_pgfree", "I" }, 839 { &qam_stat_qs_first_recno_fid, &qam_stat_class, "qs_first_recno", "I" }, 840 { &qam_stat_qs_cur_recno_fid, &qam_stat_class, "qs_cur_recno", "I" }, 841 { &rep_stat_st_log_queued_fid, &rep_stat_class, "st_log_queued", "J" }, 842 { &rep_stat_st_startup_complete_fid, &rep_stat_class, "st_startup_complete", "I" }, 843 { &rep_stat_st_status_fid, &rep_stat_class, "st_status", "I" }, 844 { &rep_stat_st_next_lsn_fid, &rep_stat_class, "st_next_lsn", "L" DB_PKG "LogSequenceNumber;" }, 845 { &rep_stat_st_waiting_lsn_fid, &rep_stat_class, "st_waiting_lsn", "L" DB_PKG "LogSequenceNumber;" }, 846 { &rep_stat_st_max_perm_lsn_fid, &rep_stat_class, "st_max_perm_lsn", "L" DB_PKG "LogSequenceNumber;" }, 847 { &rep_stat_st_next_pg_fid, &rep_stat_class, "st_next_pg", "I" }, 848 { &rep_stat_st_waiting_pg_fid, &rep_stat_class, "st_waiting_pg", "I" }, 849 { &rep_stat_st_dupmasters_fid, &rep_stat_class, "st_dupmasters", "I" }, 850 { &rep_stat_st_env_id_fid, &rep_stat_class, "st_env_id", "I" }, 851 { &rep_stat_st_env_priority_fid, &rep_stat_class, "st_env_priority", "I" }, 852 { &rep_stat_st_bulk_fills_fid, &rep_stat_class, "st_bulk_fills", "J" }, 853 { &rep_stat_st_bulk_overflows_fid, &rep_stat_class, "st_bulk_overflows", "J" }, 854 { &rep_stat_st_bulk_records_fid, &rep_stat_class, "st_bulk_records", "J" }, 855 { &rep_stat_st_bulk_transfers_fid, &rep_stat_class, "st_bulk_transfers", "J" }, 856 { &rep_stat_st_client_rerequests_fid, &rep_stat_class, "st_client_rerequests", "J" }, 857 { &rep_stat_st_client_svc_req_fid, &rep_stat_class, "st_client_svc_req", "J" }, 858 { &rep_stat_st_client_svc_miss_fid, &rep_stat_class, "st_client_svc_miss", "J" }, 859 { &rep_stat_st_gen_fid, &rep_stat_class, "st_gen", "I" }, 860 { &rep_stat_st_egen_fid, &rep_stat_class, "st_egen", "I" }, 861 { &rep_stat_st_log_duplicated_fid, &rep_stat_class, "st_log_duplicated", "J" }, 862 { &rep_stat_st_log_queued_max_fid, &rep_stat_class, "st_log_queued_max", "J" }, 863 { &rep_stat_st_log_queued_total_fid, &rep_stat_class, "st_log_queued_total", "J" }, 864 { &rep_stat_st_log_records_fid, &rep_stat_class, "st_log_records", "J" }, 865 { &rep_stat_st_log_requested_fid, &rep_stat_class, "st_log_requested", "J" }, 866 { &rep_stat_st_master_fid, &rep_stat_class, "st_master", "I" }, 867 { &rep_stat_st_master_changes_fid, &rep_stat_class, "st_master_changes", "J" }, 868 { &rep_stat_st_msgs_badgen_fid, &rep_stat_class, "st_msgs_badgen", "J" }, 869 { &rep_stat_st_msgs_processed_fid, &rep_stat_class, "st_msgs_processed", "J" }, 870 { &rep_stat_st_msgs_recover_fid, &rep_stat_class, "st_msgs_recover", "J" }, 871 { &rep_stat_st_msgs_send_failures_fid, &rep_stat_class, "st_msgs_send_failures", "J" }, 872 { &rep_stat_st_msgs_sent_fid, &rep_stat_class, "st_msgs_sent", "J" }, 873 { &rep_stat_st_newsites_fid, &rep_stat_class, "st_newsites", "J" }, 874 { &rep_stat_st_nsites_fid, &rep_stat_class, "st_nsites", "I" }, 875 { &rep_stat_st_nthrottles_fid, &rep_stat_class, "st_nthrottles", "J" }, 876 { &rep_stat_st_outdated_fid, &rep_stat_class, "st_outdated", "J" }, 877 { &rep_stat_st_pg_duplicated_fid, &rep_stat_class, "st_pg_duplicated", "J" }, 878 { &rep_stat_st_pg_records_fid, &rep_stat_class, "st_pg_records", "J" }, 879 { &rep_stat_st_pg_requested_fid, &rep_stat_class, "st_pg_requested", "J" }, 880 { &rep_stat_st_txns_applied_fid, &rep_stat_class, "st_txns_applied", "J" }, 881 { &rep_stat_st_startsync_delayed_fid, &rep_stat_class, "st_startsync_delayed", "J" }, 882 { &rep_stat_st_elections_fid, &rep_stat_class, "st_elections", "J" }, 883 { &rep_stat_st_elections_won_fid, &rep_stat_class, "st_elections_won", "J" }, 884 { &rep_stat_st_election_cur_winner_fid, &rep_stat_class, "st_election_cur_winner", "I" }, 885 { &rep_stat_st_election_gen_fid, &rep_stat_class, "st_election_gen", "I" }, 886 { &rep_stat_st_election_lsn_fid, &rep_stat_class, "st_election_lsn", "L" DB_PKG "LogSequenceNumber;" }, 887 { &rep_stat_st_election_nsites_fid, &rep_stat_class, "st_election_nsites", "I" }, 888 { &rep_stat_st_election_nvotes_fid, &rep_stat_class, "st_election_nvotes", "I" }, 889 { &rep_stat_st_election_priority_fid, &rep_stat_class, "st_election_priority", "I" }, 890 { &rep_stat_st_election_status_fid, &rep_stat_class, "st_election_status", "I" }, 891 { &rep_stat_st_election_tiebreaker_fid, &rep_stat_class, "st_election_tiebreaker", "I" }, 892 { &rep_stat_st_election_votes_fid, &rep_stat_class, "st_election_votes", "I" }, 893 { &rep_stat_st_election_sec_fid, &rep_stat_class, "st_election_sec", "I" }, 894 { &rep_stat_st_election_usec_fid, &rep_stat_class, "st_election_usec", "I" }, 895 { &rep_stat_st_max_lease_sec_fid, &rep_stat_class, "st_max_lease_sec", "I" }, 896 { &rep_stat_st_max_lease_usec_fid, &rep_stat_class, "st_max_lease_usec", "I" }, 897 { &repmgr_stat_st_perm_failed_fid, &repmgr_stat_class, "st_perm_failed", "J" }, 898 { &repmgr_stat_st_msgs_queued_fid, &repmgr_stat_class, "st_msgs_queued", "J" }, 899 { &repmgr_stat_st_msgs_dropped_fid, &repmgr_stat_class, "st_msgs_dropped", "J" }, 900 { &repmgr_stat_st_connection_drop_fid, &repmgr_stat_class, "st_connection_drop", "J" }, 901 { &repmgr_stat_st_connect_fail_fid, &repmgr_stat_class, "st_connect_fail", "J" }, 902 { &seq_stat_st_wait_fid, &seq_stat_class, "st_wait", "J" }, 903 { &seq_stat_st_nowait_fid, &seq_stat_class, "st_nowait", "J" }, 904 { &seq_stat_st_current_fid, &seq_stat_class, "st_current", "J" }, 905 { &seq_stat_st_value_fid, &seq_stat_class, "st_value", "J" }, 906 { &seq_stat_st_last_value_fid, &seq_stat_class, "st_last_value", "J" }, 907 { &seq_stat_st_min_fid, &seq_stat_class, "st_min", "J" }, 908 { &seq_stat_st_max_fid, &seq_stat_class, "st_max", "J" }, 909 { &seq_stat_st_cache_size_fid, &seq_stat_class, "st_cache_size", "I" }, 910 { &seq_stat_st_flags_fid, &seq_stat_class, "st_flags", "I" }, 911 { &txn_stat_st_nrestores_fid, &txn_stat_class, "st_nrestores", "I" }, 912 { &txn_stat_st_last_ckp_fid, &txn_stat_class, "st_last_ckp", "L" DB_PKG "LogSequenceNumber;" }, 913 { &txn_stat_st_time_ckp_fid, &txn_stat_class, "st_time_ckp", "J" }, 914 { &txn_stat_st_last_txnid_fid, &txn_stat_class, "st_last_txnid", "I" }, 915 { &txn_stat_st_maxtxns_fid, &txn_stat_class, "st_maxtxns", "I" }, 916 { &txn_stat_st_naborts_fid, &txn_stat_class, "st_naborts", "J" }, 917 { &txn_stat_st_nbegins_fid, &txn_stat_class, "st_nbegins", "J" }, 918 { &txn_stat_st_ncommits_fid, &txn_stat_class, "st_ncommits", "J" }, 919 { &txn_stat_st_nactive_fid, &txn_stat_class, "st_nactive", "I" }, 920 { &txn_stat_st_nsnapshot_fid, &txn_stat_class, "st_nsnapshot", "I" }, 921 { &txn_stat_st_maxnactive_fid, &txn_stat_class, "st_maxnactive", "I" }, 922 { &txn_stat_st_maxnsnapshot_fid, &txn_stat_class, "st_maxnsnapshot", "I" }, 923 { &txn_stat_st_txnarray_fid, &txn_stat_class, "st_txnarray", "[L" DB_PKG "TransactionStats$Active;" }, 924 { &txn_stat_st_region_wait_fid, &txn_stat_class, "st_region_wait", "J" }, 925 { &txn_stat_st_region_nowait_fid, &txn_stat_class, "st_region_nowait", "J" }, 926 { &txn_stat_st_regsize_fid, &txn_stat_class, "st_regsize", "I" }, 927 { &txn_active_txnid_fid, &txn_active_class, "txnid", "I" }, 928 { &txn_active_parentid_fid, &txn_active_class, "parentid", "I" }, 929 { &txn_active_pid_fid, &txn_active_class, "pid", "I" }, 930 { &txn_active_lsn_fid, &txn_active_class, "lsn", "L" DB_PKG "LogSequenceNumber;" }, 931 { &txn_active_read_lsn_fid, &txn_active_class, "read_lsn", "L" DB_PKG "LogSequenceNumber;" }, 932 { &txn_active_mvcc_ref_fid, &txn_active_class, "mvcc_ref", "I" }, 933 { &txn_active_status_fid, &txn_active_class, "status", "I" }, 934 { &txn_active_gid_fid, &txn_active_class, "gid", "[B" }, 935 { &txn_active_name_fid, &txn_active_class, "name", "Ljava/lang/String;" }, 936/* END-STAT-FIELDS */ 937 938 { &repmgr_siteinfo_status_fid, &repmgr_siteinfo_class, "status", "I" } 939}; 940 941const struct { 942 jmethodID *mid; 943 jclass *cl; 944 const char *name; 945 const char *sig; 946} all_methods[] = { 947 { &dbenv_construct, &dbenv_class, "<init>", "(JZ)V" }, 948 { &dbt_construct, &dbt_class, "<init>", "()V" }, 949 { &dblsn_construct, &dblsn_class, "<init>", "(II)V" }, 950 { &dbpreplist_construct, &dbpreplist_class, "<init>", 951 "(L" DB_PKG "internal/DbTxn;[B)V" }, 952 { &dbtxn_construct, &dbtxn_class, "<init>", "(JZ)V" }, 953 954 { &bt_stat_construct, &bt_stat_class, "<init>", "()V" }, 955 { &get_err_msg_method, &dbenv_class, "get_err_msg", 956 "(Ljava/lang/String;)Ljava/lang/String;" }, 957 { &h_stat_construct, &h_stat_class, "<init>", "()V" }, 958 { &lock_stat_construct, &lock_stat_class, "<init>", "()V" }, 959 { &log_stat_construct, &log_stat_class, "<init>", "()V" }, 960 { &mpool_stat_construct, &mpool_stat_class, "<init>", "()V" }, 961 { &mpool_fstat_construct, &mpool_fstat_class, "<init>", "()V" }, 962 { &mutex_stat_construct, &mutex_stat_class, "<init>", "()V" }, 963 { &qam_stat_construct, &qam_stat_class, "<init>", "()V" }, 964 { &rep_stat_construct, &rep_stat_class, "<init>", "()V" }, 965 { &repmgr_stat_construct, &repmgr_stat_class, "<init>", "()V" }, 966 { &seq_stat_construct, &seq_stat_class, "<init>", "()V" }, 967 { &txn_stat_construct, &txn_stat_class, "<init>", "()V" }, 968 { &txn_active_construct, &txn_active_class, "<init>", "()V" }, 969 { &rephost_construct, &rephost_class, "<init>", "(Ljava/lang/String;I)V" }, 970 { &repmgr_siteinfo_construct, &repmgr_siteinfo_class, "<init>", 971 "(L" DB_PKG "ReplicationHostAddress;I)V" }, 972 973 { &dbex_construct, &dbex_class, "<init>", 974 "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, 975 { &deadex_construct, &deadex_class, "<init>", 976 "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, 977 { &lockex_construct, &lockex_class, "<init>", 978 "(Ljava/lang/String;IIL" DB_PKG "DatabaseEntry;L" 979 DB_PKG "internal/DbLock;IL" DB_PKG "internal/DbEnv;)V" }, 980 { &memex_construct, &memex_class, "<init>", 981 "(Ljava/lang/String;L" DB_PKG "DatabaseEntry;IL" 982 DB_PKG "internal/DbEnv;)V" }, 983 { &memex_update_method, &memex_class, "updateDatabaseEntry", 984 "(L" DB_PKG "DatabaseEntry;)V" }, 985 { &repdupmasterex_construct, &repdupmasterex_class, "<init>", 986 "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, 987 { &rephandledeadex_construct, &rephandledeadex_class, "<init>", 988 "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, 989 { &repholdelectionex_construct, &repholdelectionex_class, "<init>", 990 "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, 991 { &repjoinfailex_construct, &repjoinfailex_class, "<init>", 992 "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, 993 { &repleaseexpiredex_construct, &repleaseexpiredex_class, "<init>", 994 "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, 995 { &repleasetimeoutex_construct, &repleasetimeoutex_class, "<init>", 996 "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, 997 { &replockoutex_construct, &replockoutex_class, "<init>", 998 "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, 999 { &repunavailex_construct, &repunavailex_class, "<init>", 1000 "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, 1001 { &runrecex_construct, &runrecex_class, "<init>", 1002 "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, 1003 { &versionex_construct, &versionex_class, "<init>", 1004 "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, 1005 { &filenotfoundex_construct, &filenotfoundex_class, "<init>", 1006 "(Ljava/lang/String;)V" }, 1007 { &illegalargex_construct, &illegalargex_class, "<init>", 1008 "(Ljava/lang/String;)V" }, 1009 { &outofmemerr_construct, &outofmemerr_class, "<init>", 1010 "(Ljava/lang/String;)V" }, 1011 1012 { &lock_construct, &lock_class, "<init>", "(JZ)V" }, 1013 1014 { &app_dispatch_method, &dbenv_class, "handle_app_dispatch", 1015 "(L" DB_PKG "DatabaseEntry;L" DB_PKG "LogSequenceNumber;I)I" }, 1016 { &panic_event_notify_method, &dbenv_class, "handle_panic_event_notify", 1017 "()V" }, 1018 { &rep_client_event_notify_method, &dbenv_class, 1019 "handle_rep_client_event_notify", "()V" }, 1020 { &rep_elected_event_notify_method, &dbenv_class, 1021 "handle_rep_elected_event_notify" ,"()V" }, 1022 { &rep_master_event_notify_method, &dbenv_class, 1023 "handle_rep_master_event_notify", "()V" }, 1024 { &rep_new_master_event_notify_method, &dbenv_class, 1025 "handle_rep_new_master_event_notify", "(I)V" }, 1026 { &rep_perm_failed_event_notify_method, &dbenv_class, 1027 "handle_rep_perm_failed_event_notify", "()V" }, 1028 { &rep_startup_done_event_notify_method, &dbenv_class, 1029 "handle_rep_startup_done_event_notify", "()V" }, 1030 { &write_failed_event_notify_method, &dbenv_class, 1031 "handle_write_failed_event_notify", "(I)V" }, 1032 { &env_feedback_method, &dbenv_class, "handle_env_feedback", "(II)V" }, 1033 { &errcall_method, &dbenv_class, "handle_error", 1034 "(Ljava/lang/String;)V" }, 1035 { &msgcall_method, &dbenv_class, "handle_message", 1036 "(Ljava/lang/String;)V" }, 1037 { &paniccall_method, &dbenv_class, "handle_panic", 1038 "(L" DB_PKG "DatabaseException;)V" }, 1039 { &rep_transport_method, &dbenv_class, "handle_rep_transport", 1040 "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" 1041 DB_PKG "LogSequenceNumber;II)I" }, 1042 1043 { &append_recno_method, &db_class, "handle_append_recno", 1044 "(L" DB_PKG "DatabaseEntry;I)V" }, 1045 { &bt_compare_method, &db_class, "handle_bt_compare", 1046 "([B[B)I" }, 1047 { &bt_compress_method, &db_class, "handle_bt_compress", 1048 "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" DB_PKG 1049 "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" DB_PKG 1050 "DatabaseEntry;)I" }, 1051 { &bt_decompress_method, &db_class, "handle_bt_decompress", 1052 "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" DB_PKG 1053 "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" DB_PKG 1054 "DatabaseEntry;)I" }, 1055 { &bt_prefix_method, &db_class, "handle_bt_prefix", 1056 "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;)I" }, 1057 { &db_feedback_method, &db_class, "handle_db_feedback", "(II)V" }, 1058 { &dup_compare_method, &db_class, "handle_dup_compare", 1059 "([B[B)I" }, 1060 { &foreignkey_nullify_method, &db_class, "handle_foreignkey_nullify", 1061 "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" DB_PKG 1062 "DatabaseEntry;)Z" }, 1063 { &h_compare_method, &db_class, "handle_h_compare", 1064 "([B[B)I" }, 1065 { &h_hash_method, &db_class, "handle_h_hash", "([BI)I" }, 1066 { &partition_method, &db_class, "handle_partition", 1067 "(L" DB_PKG "DatabaseEntry;)I" }, 1068 { &seckey_create_method, &db_class, "handle_seckey_create", 1069 "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;)[L" 1070 DB_PKG "DatabaseEntry;" }, 1071 1072 { &outputstream_write_method, &outputstream_class, "write", "([BII)V" } 1073}; 1074 1075#define NELEM(x) (sizeof (x) / sizeof (x[0])) 1076 1077SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_initialize( 1078 JNIEnv *jenv, jclass clazz) 1079{ 1080 jclass cl; 1081 unsigned int i, j; 1082 1083 COMPQUIET(clazz, NULL); 1084 1085 if ((*jenv)->GetJavaVM(jenv, &javavm) != 0) { 1086 __db_errx(NULL, "Cannot get Java VM"); 1087 return; 1088 } 1089 1090 for (i = 0; i < NELEM(all_classes); i++) { 1091 cl = (*jenv)->FindClass(jenv, all_classes[i].name); 1092 if (cl == NULL) { 1093 fprintf(stderr, 1094 "Failed to load class %s - check CLASSPATH\n", 1095 all_classes[i].name); 1096 return; 1097 } 1098 1099 /* 1100 * Wrap classes in GlobalRefs so we keep the reference between 1101 * calls. 1102 */ 1103 *all_classes[i].cl = (jclass)(*jenv)->NewGlobalRef(jenv, cl); 1104 1105 if (*all_classes[i].cl == NULL) { 1106 fprintf(stderr, 1107 "Failed to create a global reference for %s\n", 1108 all_classes[i].name); 1109 return; 1110 } 1111 } 1112 1113 /* Get field IDs */ 1114 for (i = 0; i < NELEM(all_fields); i++) { 1115 *all_fields[i].fid = (*jenv)->GetFieldID(jenv, 1116 *all_fields[i].cl, all_fields[i].name, all_fields[i].sig); 1117 1118 if (*all_fields[i].fid == NULL) { 1119 fprintf(stderr, 1120 "Failed to look up field %s with sig %s\n", 1121 all_fields[i].name, all_fields[i].sig); 1122 return; 1123 } 1124 } 1125 1126 /* Get method IDs */ 1127 for (i = 0; i < NELEM(all_methods); i++) { 1128 *all_methods[i].mid = (*jenv)->GetMethodID(jenv, 1129 *all_methods[i].cl, all_methods[i].name, 1130 all_methods[i].sig); 1131 1132 if (*all_methods[i].mid == NULL) { 1133 for (j = 0; j < NELEM(all_classes); j++) 1134 if (all_methods[i].cl == all_classes[j].cl) 1135 break; 1136 fprintf(stderr, 1137 "Failed to look up method %s.%s with sig %s\n", 1138 all_classes[j].name, all_methods[i].name, 1139 all_methods[i].sig); 1140 return; 1141 } 1142 } 1143} 1144 1145static JNIEnv *__dbj_get_jnienv(int *needDetach) 1146{ 1147 /* 1148 * Note: Different versions of the JNI disagree on the signature for 1149 * AttachCurrentThreadAsDaemon. The most recent documentation seems to 1150 * say that (JNIEnv **) is correct, but newer JNIs seem to use 1151 * (void **), oddly enough. 1152 */ 1153#ifdef JNI_VERSION_1_2 1154 void *jenv = 0; 1155#else 1156 JNIEnv *jenv = 0; 1157#endif 1158 1159 *needDetach = 0; 1160 if ((*javavm)->GetEnv(javavm, &jenv, JNI_VERSION_1_2) == JNI_OK) 1161 return ((JNIEnv *)jenv); 1162 1163 /* 1164 * This should always succeed, as we are called via some Java activity. 1165 * I think therefore I am (a thread). 1166 */ 1167 if ((*javavm)->AttachCurrentThread(javavm, &jenv, 0) != 0) 1168 return (0); 1169 1170 *needDetach = 1; 1171 return ((JNIEnv *)jenv); 1172} 1173 1174static void __dbj_detach() 1175{ 1176 (void)(*javavm)->DetachCurrentThread(javavm); 1177} 1178 1179static jobject __dbj_wrap_DB_LSN(JNIEnv *jenv, DB_LSN *lsn) 1180{ 1181 return (*jenv)->NewObject(jenv, dblsn_class, dblsn_construct, 1182 lsn->file, lsn->offset); 1183} 1184 1185 1186/* 1187 * Macros to find the Java DbEnv object for methods in various classes. 1188 * Note that "arg1" is from the code SWIG generates for the "this"/"self". 1189 */ 1190#define JDBENV (arg1 ? (jobject)DB_ENV_INTERNAL(arg1) : NULL) 1191#define DB2JDBENV ((jobject)DB_ENV_INTERNAL(arg1->dbenv)) 1192#define DBC2JDBENV ((jobject)DB_ENV_INTERNAL(arg1->dbp->dbenv)) 1193#define TXN2JDBENV ((jobject)DB_ENV_INTERNAL(arg1->mgrp->env->dbenv)) 1194 1195 1196static jthrowable __dbj_get_except(JNIEnv *jenv, 1197 int err, const char *msg, jobject obj, jobject jdbenv) { 1198 jobject jmsg; 1199 1200 if (msg == NULL) 1201 msg = db_strerror(err); 1202 1203 jmsg = (*jenv)->NewStringUTF(jenv, msg); 1204 1205 /* Retrieve error message logged by DB */ 1206 if (jdbenv != NULL) { 1207 jmsg = (jstring) (*jenv)->CallNonvirtualObjectMethod(jenv, 1208 jdbenv, dbenv_class, get_err_msg_method, jmsg); 1209 } 1210 1211 switch (err) { 1212 case EINVAL: 1213 return (jthrowable)(*jenv)->NewObject(jenv, 1214 illegalargex_class, illegalargex_construct, jmsg); 1215 1216 case ENOENT: 1217 return (jthrowable)(*jenv)->NewObject(jenv, 1218 filenotfoundex_class, filenotfoundex_construct, jmsg); 1219 1220 case ENOMEM: 1221 return (jthrowable)(*jenv)->NewObject(jenv, 1222 outofmemerr_class, outofmemerr_construct, jmsg); 1223 1224 case DB_BUFFER_SMALL: 1225 return (jthrowable)(*jenv)->NewObject(jenv, memex_class, 1226 memex_construct, jmsg, obj, err, jdbenv); 1227 1228 case DB_REP_DUPMASTER: 1229 return (jthrowable)(*jenv)->NewObject(jenv, 1230 repdupmasterex_class, repdupmasterex_construct, 1231 jmsg, err, jdbenv); 1232 1233 case DB_REP_HANDLE_DEAD: 1234 return (jthrowable)(*jenv)->NewObject(jenv, 1235 rephandledeadex_class, rephandledeadex_construct, 1236 jmsg, err, jdbenv); 1237 1238 case DB_REP_HOLDELECTION: 1239 return (jthrowable)(*jenv)->NewObject(jenv, 1240 repholdelectionex_class, repholdelectionex_construct, 1241 jmsg, err, jdbenv); 1242 1243 case DB_REP_JOIN_FAILURE: 1244 return (jthrowable)(*jenv)->NewObject(jenv, 1245 repjoinfailex_class, repjoinfailex_construct, 1246 jmsg, err, jdbenv); 1247 1248 case DB_REP_LEASE_EXPIRED: 1249 return (jthrowable)(*jenv)->NewObject(jenv, 1250 repleaseexpiredex_class, repleaseexpiredex_construct, 1251 jmsg, err, jdbenv); 1252 1253 case DB_REP_LEASE_TIMEOUT: 1254 return (jthrowable)(*jenv)->NewObject(jenv, 1255 repleasetimeoutex_class, repleasetimeoutex_construct, 1256 jmsg, err, jdbenv); 1257 1258 case DB_REP_LOCKOUT: 1259 return (jthrowable)(*jenv)->NewObject(jenv, 1260 replockoutex_class, replockoutex_construct, 1261 jmsg, err, jdbenv); 1262 1263 case DB_REP_UNAVAIL: 1264 return (jthrowable)(*jenv)->NewObject(jenv, 1265 repunavailex_class, repunavailex_construct, 1266 jmsg, err, jdbenv); 1267 1268 case DB_RUNRECOVERY: 1269 return (jthrowable)(*jenv)->NewObject(jenv, runrecex_class, 1270 runrecex_construct, jmsg, err, jdbenv); 1271 1272 case DB_LOCK_DEADLOCK: 1273 return (jthrowable)(*jenv)->NewObject(jenv, deadex_class, 1274 deadex_construct, jmsg, err, jdbenv); 1275 1276 case DB_LOCK_NOTGRANTED: 1277 return (jthrowable)(*jenv)->NewObject(jenv, lockex_class, 1278 lockex_construct, jmsg, err, 0, NULL, NULL, 0, jdbenv); 1279 1280 case DB_VERSION_MISMATCH: 1281 return (jthrowable)(*jenv)->NewObject(jenv, versionex_class, 1282 versionex_construct, jmsg, err, jdbenv); 1283 1284 default: 1285 return (jthrowable)(*jenv)->NewObject(jenv, dbex_class, 1286 dbex_construct, jmsg, err, jdbenv); 1287 } 1288} 1289 1290static int __dbj_throw(JNIEnv *jenv, 1291 int err, const char *msg, jobject obj, jobject jdbenv) 1292{ 1293 jthrowable t; 1294 1295 /* If an exception is pending, ignore requests to throw a new one. */ 1296 if ((*jenv)->ExceptionOccurred(jenv) == NULL) { 1297 t = __dbj_get_except(jenv, err, msg, obj, jdbenv); 1298 if (t == NULL) { 1299 /* 1300 * This is a problem - something went wrong creating an 1301 * exception. We have to assume there is an exception 1302 * created by the JVM that is pending as a result 1303 * (e.g., OutOfMemoryError), but we don't want to lose 1304 * this error, so we just call __db_errx here. 1305 */ 1306 if (msg == NULL) 1307 msg = db_strerror(err); 1308 1309 __db_errx(NULL, "Couldn't create exception for: '%s'", 1310 msg); 1311 } else 1312 (*jenv)->Throw(jenv, t); 1313 } 1314 1315 return (err); 1316} 1317 1318 1319typedef struct __dbt_locked { 1320 JNIEnv *jenv; 1321 jobject jdbt; 1322 DBT dbt; 1323 jobject jdata_nio; 1324 jbyteArray jarr; 1325 jint offset; 1326 int reuse; 1327 u_int32_t orig_size; 1328 jsize array_len; 1329} DBT_LOCKED; 1330 1331static int __dbj_dbt_memcopy(DBT *dbt, u_int32_t offset, void *buf, u_int32_t size, u_int32_t flags) { 1332 DBT_LOCKED *ldbt = dbt->app_data; 1333 JNIEnv *jenv = ldbt->jenv; 1334 1335 if (size == 0) 1336 return (0); 1337 else if (!F_ISSET(dbt, DB_DBT_USERCOPY)) { 1338 /* 1339 * For simplicity, the Java API calls this function directly, 1340 * so it needs to work with regular DBTs. 1341 */ 1342 switch (flags) { 1343 case DB_USERCOPY_GETDATA: 1344 memcpy(buf, (u_int8_t *)dbt->data + offset, size); 1345 return (0); 1346 case DB_USERCOPY_SETDATA: 1347 memcpy((u_int8_t *)dbt->data + offset, buf, size); 1348 return (0); 1349 default: 1350 return (EINVAL); 1351 } 1352 } 1353 1354 switch (flags) { 1355 case DB_USERCOPY_GETDATA: 1356 (*jenv)->GetByteArrayRegion(jenv, ldbt->jarr, ldbt->offset + 1357 offset, size, buf); 1358 break; 1359 case DB_USERCOPY_SETDATA: 1360 /* 1361 * Check whether this is the first time through the callback by relying 1362 * on the offset being zero. 1363 */ 1364 if (offset == 0 && (!ldbt->reuse || 1365 (jsize)(ldbt->offset + dbt->size) > ldbt->array_len)) { 1366 if (ldbt->jarr != NULL) 1367 (*jenv)->DeleteLocalRef(jenv, ldbt->jarr); 1368 ldbt->jarr = (*jenv)->NewByteArray(jenv, (jsize)dbt->size); 1369 if (ldbt->jarr == NULL) 1370 return (ENOMEM); 1371 (*jenv)->SetObjectField(jenv, ldbt->jdbt, dbt_data_fid, ldbt->jarr); 1372 /* We've allocated a new array, start from the beginning. */ 1373 ldbt->offset = 0; 1374 } 1375 (*jenv)->SetByteArrayRegion(jenv, ldbt->jarr, ldbt->offset + 1376 offset, size, buf); 1377 break; 1378 default: 1379 return (EINVAL); 1380 } 1381 return ((*jenv)->ExceptionOccurred(jenv) ? EINVAL : 0); 1382} 1383 1384static void __dbj_dbt_copyout( 1385 JNIEnv *jenv, const DBT *dbt, jbyteArray *jarr, jobject jdbt) 1386{ 1387 jbyteArray newarr = (*jenv)->NewByteArray(jenv, (jsize)dbt->size); 1388 if (newarr == NULL) 1389 return; /* An exception is pending */ 1390 (*jenv)->SetByteArrayRegion(jenv, newarr, 0, (jsize)dbt->size, 1391 (jbyte *)dbt->data); 1392 (*jenv)->SetObjectField(jenv, jdbt, dbt_data_fid, newarr); 1393 (*jenv)->SetIntField(jenv, jdbt, dbt_offset_fid, 0); 1394 (*jenv)->SetIntField(jenv, jdbt, dbt_size_fid, (jint)dbt->size); 1395 if (jarr != NULL) 1396 *jarr = newarr; 1397 else 1398 (*jenv)->DeleteLocalRef(jenv, newarr); 1399} 1400 1401static int __dbj_dbt_copyin( 1402 JNIEnv *jenv, DBT_LOCKED *ldbt, DBT **dbtp, jobject jdbt, int allow_null) 1403{ 1404 DBT *dbt; 1405 jlong capacity; 1406 1407 memset(ldbt, 0, sizeof (*ldbt)); 1408 ldbt->jenv = jenv; 1409 ldbt->jdbt = jdbt; 1410 1411 if (jdbt == NULL) { 1412 if (allow_null) { 1413 *dbtp = NULL; 1414 return (0); 1415 } else { 1416 return (__dbj_throw(jenv, EINVAL, 1417 "DatabaseEntry must not be null", NULL, NULL)); 1418 } 1419 } 1420 1421 dbt = &ldbt->dbt; 1422 if (dbtp != NULL) 1423 *dbtp = dbt; 1424 1425 ldbt->jdata_nio = (*jenv)->GetObjectField(jenv, jdbt, dbt_data_nio_fid); 1426 if (ldbt->jdata_nio != NULL) 1427 F_SET(dbt, DB_DBT_USERMEM); 1428 else 1429 ldbt->jarr = (jbyteArray)(*jenv)->GetObjectField(jenv, jdbt, dbt_data_fid); 1430 ldbt->offset = (*jenv)->GetIntField(jenv, jdbt, dbt_offset_fid); 1431 dbt->size = (*jenv)->GetIntField(jenv, jdbt, dbt_size_fid); 1432 ldbt->orig_size = dbt->size; 1433 dbt->flags = (*jenv)->GetIntField(jenv, jdbt, dbt_flags_fid); 1434 1435 if (F_ISSET(dbt, DB_DBT_USERMEM)) 1436 dbt->ulen = (*jenv)->GetIntField(jenv, jdbt, dbt_ulen_fid); 1437 if (F_ISSET(dbt, DB_DBT_PARTIAL)) { 1438 dbt->dlen = (*jenv)->GetIntField(jenv, jdbt, dbt_dlen_fid); 1439 dbt->doff = (*jenv)->GetIntField(jenv, jdbt, dbt_doff_fid); 1440 1441 if ((jint)dbt->doff < 0) 1442 return (__dbj_throw(jenv, EINVAL, "DatabaseEntry doff illegal", 1443 NULL, NULL)); 1444 } 1445 1446 /* 1447 * We don't support DB_DBT_REALLOC - map anything that's not USERMEM to 1448 * MALLOC. 1449 */ 1450 if (!F_ISSET(dbt, DB_DBT_USERMEM)) { 1451 ldbt->reuse = !F_ISSET(dbt, DB_DBT_MALLOC); 1452 F_CLR(dbt, DB_DBT_MALLOC | DB_DBT_REALLOC); 1453 } 1454 1455 /* Verify parameters before allocating or locking data. */ 1456 if (ldbt->jdata_nio != NULL) { 1457 capacity = (*jenv)->GetDirectBufferCapacity(jenv, 1458 ldbt->jdata_nio); 1459 if (capacity > (jlong)UINT32_MAX) 1460 return (__dbj_throw(jenv, EINVAL, 1461 "DirectBuffer may not be larger than 4GB", 1462 NULL, NULL)); 1463 ldbt->array_len = (u_int32_t)capacity; 1464 } else if (ldbt->jarr == NULL) { 1465 /* 1466 * Some code makes the assumption that if a DBT's size or ulen 1467 * is non-zero, there is data to copy from dbt->data. 1468 * 1469 * Clean up the dbt fields so we don't run into trouble. 1470 * (Note that doff, dlen, and flags all may contain 1471 * meaningful values.) 1472 */ 1473 dbt->data = NULL; 1474 ldbt->array_len = ldbt->offset = dbt->size = dbt->ulen = 0; 1475 } else 1476 ldbt->array_len = (*jenv)->GetArrayLength(jenv, ldbt->jarr); 1477 1478 if (F_ISSET(dbt, DB_DBT_USERMEM)) { 1479 if (ldbt->offset < 0) 1480 return (__dbj_throw(jenv, EINVAL, 1481 "offset cannot be negative", 1482 NULL, NULL)); 1483 if (dbt->size > dbt->ulen) 1484 return (__dbj_throw(jenv, EINVAL, 1485 "size must be less than or equal to ulen", 1486 NULL, NULL)); 1487 if ((jsize)(ldbt->offset + dbt->ulen) > ldbt->array_len) 1488 return (__dbj_throw(jenv, EINVAL, 1489 "offset + ulen greater than array length", 1490 NULL, NULL)); 1491 } 1492 1493 if (ldbt->jdata_nio) { 1494 dbt->data = (*jenv)->GetDirectBufferAddress(jenv, 1495 ldbt->jdata_nio); 1496 dbt->data = (u_int8_t *)dbt->data + ldbt->offset; 1497 } else if (F_ISSET(dbt, DB_DBT_USERMEM)) { 1498 if (ldbt->jarr != NULL && 1499 (dbt->data = (*jenv)->GetByteArrayElements(jenv, 1500 ldbt->jarr, NULL)) == NULL) 1501 return (EINVAL); /* an exception will be pending */ 1502 dbt->data = (u_int8_t *)dbt->data + ldbt->offset; 1503 } else 1504 F_SET(dbt, DB_DBT_USERCOPY); 1505 dbt->app_data = ldbt; 1506 1507 return (0); 1508} 1509 1510static void __dbj_dbt_release( 1511 JNIEnv *jenv, jobject jdbt, DBT *dbt, DBT_LOCKED *ldbt) { 1512 jthrowable t; 1513 1514 if (dbt == NULL) 1515 return; 1516 1517 if (dbt->size != ldbt->orig_size) 1518 (*jenv)->SetIntField(jenv, jdbt, dbt_size_fid, (jint)dbt->size); 1519 1520 if (F_ISSET(dbt, DB_DBT_USERMEM)) { 1521 if (ldbt->jarr != NULL) 1522 (*jenv)->ReleaseByteArrayElements(jenv, ldbt->jarr, 1523 (jbyte *)dbt->data - ldbt->offset, 0); 1524 1525 if (dbt->size > dbt->ulen && 1526 (t = (*jenv)->ExceptionOccurred(jenv)) != NULL && 1527 (*jenv)->IsInstanceOf(jenv, t, memex_class)) { 1528 (*jenv)->CallNonvirtualVoidMethod(jenv, t, memex_class, 1529 memex_update_method, jdbt); 1530 /* 1531 * We have to rethrow the exception because calling 1532 * into Java clears it. 1533 */ 1534 (*jenv)->Throw(jenv, t); 1535 } 1536 } 1537} 1538 1539 1540struct __dbj_verify_data { 1541 JNIEnv *jenv; 1542 jobject streamobj; 1543 jbyteArray bytes; 1544 int nbytes; 1545}; 1546 1547static int __dbj_verify_callback(void *handle, const void *str_arg) { 1548 char *str; 1549 struct __dbj_verify_data *vd; 1550 int len; 1551 JNIEnv *jenv; 1552 1553 str = (char *)str_arg; 1554 vd = (struct __dbj_verify_data *)handle; 1555 jenv = vd->jenv; 1556 len = (int)strlen(str) + 1; 1557 if (len > vd->nbytes) { 1558 vd->nbytes = len; 1559 if (vd->bytes != NULL) 1560 (*jenv)->DeleteLocalRef(jenv, vd->bytes); 1561 if ((vd->bytes = (*jenv)->NewByteArray(jenv, (jsize)len)) 1562 == NULL) 1563 return (ENOMEM); 1564 } 1565 1566 if (vd->bytes != NULL) { 1567 (*jenv)->SetByteArrayRegion(jenv, vd->bytes, 0, (jsize)len, 1568 (jbyte*)str); 1569 (*jenv)->CallVoidMethod(jenv, vd->streamobj, 1570 outputstream_write_method, vd->bytes, 0, len - 1); 1571 } 1572 1573 if ((*jenv)->ExceptionOccurred(jenv) != NULL) 1574 return (EIO); 1575 1576 return (0); 1577} 1578 1579 1580SWIGEXPORT void JNICALL 1581Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1lock_1vec(JNIEnv *jenv, 1582 jclass jcls, jlong jdbenvp, jobject jdbenv, jint locker, jint flags, 1583 jobjectArray list, jint offset, jint count) { 1584 DB_ENV *dbenv; 1585 DB_LOCKREQ *lockreq; 1586 DB_LOCKREQ *prereq; /* preprocessed requests */ 1587 DB_LOCKREQ *failedreq; 1588 DB_LOCK *lockp; 1589 DBT_LOCKED *locked_dbts; 1590 DBT *obj; 1591 ENV *env; 1592 int err, alloc_err, i; 1593 size_t bytesize, ldbtsize; 1594 jobject jlockreq; 1595 db_lockop_t op; 1596 jobject jobj, jlock; 1597 jlong jlockp; 1598 int completed; 1599 1600 /* 1601 * We can't easily #include "dbinc/db_ext.h" because of name 1602 * clashes, so we declare this explicitly. 1603 */ 1604 extern int __dbt_usercopy __P((ENV *, DBT *)); 1605 extern void __dbt_userfree __P((ENV *, DBT *, DBT *, DBT *)); 1606 1607 COMPQUIET(jcls, NULL); 1608 dbenv = *(DB_ENV **)(void *)&jdbenvp; 1609 env = dbenv->env; 1610 locked_dbts = NULL; 1611 lockreq = NULL; 1612 1613 if (dbenv == NULL) { 1614 __dbj_throw(jenv, EINVAL, "null object", NULL, jdbenv); 1615 return; 1616 } 1617 1618 if ((*jenv)->GetArrayLength(jenv, list) < offset + count) { 1619 __dbj_throw(jenv, EINVAL, 1620 "DbEnv.lock_vec array not large enough", NULL, jdbenv); 1621 return; 1622 } 1623 1624 bytesize = sizeof(DB_LOCKREQ) * count; 1625 if ((err = __os_malloc(env, bytesize, &lockreq)) != 0) { 1626 __dbj_throw(jenv, err, NULL, NULL, jdbenv); 1627 return; 1628 } 1629 memset(lockreq, 0, bytesize); 1630 1631 ldbtsize = sizeof(DBT_LOCKED) * count; 1632 if ((err = __os_malloc(env, ldbtsize, &locked_dbts)) != 0) { 1633 __dbj_throw(jenv, err, NULL, NULL, jdbenv); 1634 goto err; 1635 } 1636 memset(locked_dbts, 0, ldbtsize); 1637 prereq = &lockreq[0]; 1638 1639 /* fill in the lockreq array */ 1640 for (i = 0, prereq = &lockreq[0]; i < count; i++, prereq++) { 1641 jlockreq = (*jenv)->GetObjectArrayElement(jenv, list, 1642 offset + i); 1643 if (jlockreq == NULL) { 1644 __dbj_throw(jenv, EINVAL, 1645 "DbEnv.lock_vec list entry is null", NULL, jdbenv); 1646 goto err; 1647 } 1648 op = (db_lockop_t)(*jenv)->GetIntField( 1649 jenv, jlockreq, lockreq_op_fid); 1650 prereq->op = op; 1651 1652 switch (op) { 1653 case DB_LOCK_GET_TIMEOUT: 1654 /* Needed: mode, timeout, obj. Returned: lock. */ 1655 prereq->op = (db_lockop_t)(*jenv)->GetIntField( 1656 jenv, jlockreq, lockreq_timeout_fid); 1657 /* FALLTHROUGH */ 1658 case DB_LOCK_GET: 1659 /* Needed: mode, obj. Returned: lock. */ 1660 prereq->mode = (db_lockmode_t)(*jenv)->GetIntField( 1661 jenv, jlockreq, lockreq_modeflag_fid); 1662 jobj = (*jenv)->GetObjectField(jenv, jlockreq, 1663 lockreq_obj_fid); 1664 if ((err = __dbj_dbt_copyin(jenv, 1665 &locked_dbts[i], &obj, jobj, 0)) != 0 || 1666 (err = __dbt_usercopy(env, obj)) != 0) 1667 goto err; 1668 prereq->obj = obj; 1669 break; 1670 case DB_LOCK_PUT: 1671 /* Needed: lock. Ignored: mode, obj. */ 1672 jlock = (*jenv)->GetObjectField(jenv, jlockreq, 1673 lockreq_lock_fid); 1674 if (jlock == NULL || 1675 (jlockp = (*jenv)->GetLongField(jenv, jlock, 1676 lock_cptr_fid)) == 0L) { 1677 __dbj_throw(jenv, EINVAL, 1678 "LockRequest lock field is NULL", NULL, 1679 jdbenv); 1680 goto err; 1681 } 1682 lockp = *(DB_LOCK **)(void *)&jlockp; 1683 prereq->lock = *lockp; 1684 break; 1685 case DB_LOCK_PUT_ALL: 1686 case DB_LOCK_TIMEOUT: 1687 /* Needed: (none). Ignored: lock, mode, obj. */ 1688 break; 1689 case DB_LOCK_PUT_OBJ: 1690 /* Needed: obj. Ignored: lock, mode. */ 1691 jobj = (*jenv)->GetObjectField(jenv, jlockreq, 1692 lockreq_obj_fid); 1693 if ((err = __dbj_dbt_copyin(jenv, 1694 &locked_dbts[i], &obj, jobj, 0)) != 0 || 1695 (err = __dbt_usercopy(env, obj)) != 0) 1696 goto err; 1697 prereq->obj = obj; 1698 break; 1699 default: 1700 __dbj_throw(jenv, EINVAL, 1701 "DbEnv.lock_vec bad op value", NULL, jdbenv); 1702 goto err; 1703 } 1704 } 1705 1706 err = dbenv->lock_vec(dbenv, (u_int32_t)locker, (u_int32_t)flags, 1707 lockreq, count, &failedreq); 1708 if (err == 0) 1709 completed = count; 1710 else 1711 completed = (int)(failedreq - lockreq); 1712 1713 /* do post processing for any and all requests that completed */ 1714 for (i = 0; i < completed; i++) { 1715 op = lockreq[i].op; 1716 if (op == DB_LOCK_PUT) { 1717 /* 1718 * After a successful put, the DbLock can no longer be 1719 * used, so we release the storage related to it. 1720 */ 1721 jlockreq = (*jenv)->GetObjectArrayElement(jenv, 1722 list, i + offset); 1723 jlock = (*jenv)->GetObjectField(jenv, jlockreq, 1724 lockreq_lock_fid); 1725 jlockp = (*jenv)->GetLongField(jenv, jlock, 1726 lock_cptr_fid); 1727 lockp = *(DB_LOCK **)(void *)&jlockp; 1728 __os_free(NULL, lockp); 1729 (*jenv)->SetLongField(jenv, jlock, lock_cptr_fid, 1730 (jlong)0); 1731 } else if (op == DB_LOCK_GET_TIMEOUT || op == DB_LOCK_GET) { 1732 /* 1733 * Store the lock that was obtained. We need to create 1734 * storage for it since the lockreq array only exists 1735 * during this method call. 1736 */ 1737 if ((alloc_err = 1738 __os_malloc(env, sizeof(DB_LOCK), &lockp)) != 0) { 1739 __dbj_throw(jenv, alloc_err, NULL, NULL, 1740 jdbenv); 1741 goto err; 1742 } 1743 1744 *lockp = lockreq[i].lock; 1745 *(DB_LOCK **)(void *)&jlockp = lockp; 1746 1747 jlockreq = (*jenv)->GetObjectArrayElement(jenv, 1748 list, i + offset); 1749 jlock = (*jenv)->NewObject(jenv, lock_class, 1750 lock_construct, jlockp, JNI_TRUE); 1751 if (jlock == NULL) 1752 goto err; /* An exception is pending */ 1753 (*jenv)->SetLongField(jenv, jlock, lock_cptr_fid, 1754 jlockp); 1755 (*jenv)->SetObjectField(jenv, jlockreq, 1756 lockreq_lock_fid, jlock); 1757 } 1758 } 1759 1760 /* If one of the locks was not granted, build the exception now. */ 1761 if (err == DB_LOCK_NOTGRANTED && i < count) { 1762 jlockreq = (*jenv)->GetObjectArrayElement(jenv, list, 1763 i + offset); 1764 jobj = (*jenv)->GetObjectField(jenv, jlockreq, lockreq_obj_fid); 1765 jlock = (*jenv)->GetObjectField(jenv, jlockreq, 1766 lockreq_lock_fid); 1767 (*jenv)->Throw(jenv, 1768 (*jenv)->NewObject(jenv, lockex_class, lockex_construct, 1769 (*jenv)->NewStringUTF(jenv, "DbEnv.lock_vec incomplete"), 1770 lockreq[i].op, lockreq[i].mode, jobj, jlock, i, jdbenv)); 1771 } else if (err != 0) 1772 __dbj_throw(jenv, err, NULL, NULL, jdbenv); 1773 1774err: for (i = 0, prereq = &lockreq[0]; i < count; i++, prereq++) 1775 if (prereq->op == DB_LOCK_GET_TIMEOUT || 1776 prereq->op == DB_LOCK_GET || 1777 prereq->op == DB_LOCK_PUT_OBJ) { 1778 jlockreq = (*jenv)->GetObjectArrayElement(jenv, 1779 list, i + offset); 1780 jobj = (*jenv)->GetObjectField(jenv, 1781 jlockreq, lockreq_obj_fid); 1782 __dbt_userfree(env, prereq->obj, NULL, NULL); 1783 __dbj_dbt_release(jenv, jobj, prereq->obj, &locked_dbts[i]); 1784 } 1785 if (locked_dbts != NULL) 1786 __os_free(env, locked_dbts); 1787 if (lockreq != NULL) 1788 __os_free(env, lockreq); 1789} 1790 1791 1792/* 1793 * These macros are used by code generated by the s_java script. 1794 */ 1795#define JAVADB_STAT_INT(jenv, jobj, fid, statp, name) \ 1796 (*jenv)->SetIntField(jenv, jobj, fid, (jint)statp->name) 1797 1798#define JAVADB_STAT_STRING(jenv, jobj, fid, statp, name) \ 1799 (*jenv)->SetObjectField(jenv, jobj, fid, \ 1800 (*jenv)->NewStringUTF(jenv, statp->name)) 1801 1802#define JAVADB_STAT_LSN(jenv, jobj, fid, statp, name) \ 1803 (*jenv)->SetObjectField(jenv, jobj, fid, \ 1804 __dbj_wrap_DB_LSN(jenv, &statp->name)) 1805 1806#define JAVADB_STAT_LONG(jenv, jobj, fid, statp, name) \ 1807 (*jenv)->SetLongField(jenv, jobj, fid, \ 1808 (jlong)statp->name) 1809 1810#define JAVADB_STAT_GID(jenv, jobj, fid, statp, name) { \ 1811 jobject jarr = \ 1812 (*jenv)->NewByteArray(jenv, (jsize)DB_GID_SIZE); \ 1813 (*jenv)->SetByteArrayRegion(jenv, jarr, \ 1814 0, (jsize)DB_GID_SIZE, (jbyte *)statp->name); \ 1815 (*jenv)->SetObjectField(jenv, jobj, fid, jarr); \ 1816 } 1817 1818/* 1819 * We build the active list separately. 1820 */ 1821#define JAVADB_STAT_ACTIVE(jenv, cl, jobj, statp, name) \ 1822 do {} while(0) 1823 1824#include "java_stat_auto.c" 1825 1826 1827static void __dbj_error(const DB_ENV *dbenv, 1828 const char *prefix, const char *msg) 1829{ 1830 int detach; 1831 JNIEnv *jenv = __dbj_get_jnienv(&detach); 1832 jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); 1833 jobject jmsg; 1834 1835 COMPQUIET(prefix, NULL); 1836 1837 if (jdbenv != NULL){ 1838 jmsg = (*jenv)->NewStringUTF(jenv, msg); 1839 (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, dbenv_class, 1840 errcall_method, jmsg); 1841 (*jenv)->DeleteLocalRef(jenv, jmsg); 1842 } 1843 1844 if (detach) 1845 __dbj_detach(); 1846} 1847 1848static void __dbj_env_feedback(DB_ENV *dbenv, int opcode, int percent) 1849{ 1850 int detach; 1851 JNIEnv *jenv = __dbj_get_jnienv(&detach); 1852 jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); 1853 1854 if (jdbenv != NULL) 1855 (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, dbenv_class, 1856 env_feedback_method, opcode, percent); 1857 1858 if (detach) 1859 __dbj_detach(); 1860} 1861 1862static void __dbj_message(const DB_ENV *dbenv, const char *msg) 1863{ 1864 int detach; 1865 JNIEnv *jenv = __dbj_get_jnienv(&detach); 1866 jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); 1867 jobject jmsg; 1868 1869 if (jdbenv != NULL){ 1870 jmsg = (*jenv)->NewStringUTF(jenv, msg); 1871 (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, dbenv_class, 1872 msgcall_method, jmsg); 1873 (*jenv)->DeleteLocalRef(jenv, jmsg); 1874 } 1875 1876 if (detach) 1877 __dbj_detach(); 1878} 1879 1880static void __dbj_panic(DB_ENV *dbenv, int err) 1881{ 1882 int detach; 1883 JNIEnv *jenv = __dbj_get_jnienv(&detach); 1884 jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); 1885 1886 if (jdbenv != NULL) 1887 (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, dbenv_class, 1888 paniccall_method, 1889 __dbj_get_except(jenv, err, NULL, NULL, jdbenv)); 1890 1891 if (detach) 1892 __dbj_detach(); 1893} 1894 1895static int __dbj_app_dispatch(DB_ENV *dbenv, 1896 DBT *dbt, DB_LSN *lsn, db_recops recops) 1897{ 1898 int detach; 1899 JNIEnv *jenv = __dbj_get_jnienv(&detach); 1900 jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); 1901 jobject jdbt, jlsn; 1902 jbyteArray jdbtarr; 1903 int ret; 1904 1905 if (jdbenv == NULL) { 1906 ret = EINVAL; 1907 goto err; 1908 } 1909 1910 jdbt = (*jenv)->NewObject(jenv, dbt_class, dbt_construct); 1911 __dbj_dbt_copyout(jenv, dbt, &jdbtarr, jdbt); 1912 if (jdbt == NULL) { 1913 ret = ENOMEM; /* An exception is pending */ 1914 goto err; 1915 } 1916 1917 jlsn = (lsn == NULL) ? NULL : __dbj_wrap_DB_LSN(jenv, lsn); 1918 1919 ret = (*jenv)->CallNonvirtualIntMethod(jenv, jdbenv, dbenv_class, 1920 app_dispatch_method, jdbt, jlsn, recops); 1921 1922 if ((*jenv)->ExceptionOccurred(jenv)) { 1923 /* The exception will be thrown, so this could be any error. */ 1924 ret = EINVAL; 1925 } 1926 1927 (*jenv)->DeleteLocalRef(jenv, jdbtarr); 1928 (*jenv)->DeleteLocalRef(jenv, jdbt); 1929 if (jlsn != NULL) 1930 (*jenv)->DeleteLocalRef(jenv, jlsn); 1931 1932err: if (detach) 1933 __dbj_detach(); 1934 return (ret); 1935} 1936 1937static void __dbj_event_notify(DB_ENV *dbenv, u_int32_t event_id, void * info) 1938{ 1939 int detach; 1940 JNIEnv *jenv = __dbj_get_jnienv(&detach); 1941 jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); 1942 1943 if (jdbenv == NULL) 1944 goto done; 1945 1946 switch (event_id) { 1947 case DB_EVENT_PANIC: 1948 (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, 1949 dbenv_class, panic_event_notify_method); 1950 break; 1951 case DB_EVENT_REP_CLIENT: 1952 (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, 1953 dbenv_class, rep_client_event_notify_method); 1954 break; 1955 case DB_EVENT_REP_ELECTED: 1956 (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, 1957 dbenv_class, rep_elected_event_notify_method); 1958 break; 1959 case DB_EVENT_REP_MASTER: 1960 (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, 1961 dbenv_class, rep_master_event_notify_method); 1962 break; 1963 case DB_EVENT_REP_NEWMASTER: 1964 (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, 1965 dbenv_class, rep_new_master_event_notify_method, 1966 *(int*)info); 1967 break; 1968 case DB_EVENT_REP_PERM_FAILED: 1969 (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, 1970 dbenv_class, rep_perm_failed_event_notify_method); 1971 break; 1972 case DB_EVENT_REP_STARTUPDONE: 1973 (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, 1974 dbenv_class, rep_startup_done_event_notify_method); 1975 break; 1976 case DB_EVENT_WRITE_FAILED: 1977 (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, 1978 dbenv_class, write_failed_event_notify_method, 1979 *(int*)info); 1980 break; 1981 default: 1982 dbenv->errx(dbenv, "Unhandled event callback in the Java API"); 1983 DB_ASSERT(dbenv->env, 0); 1984 } 1985 1986done: if (detach) 1987 __dbj_detach(); 1988} 1989 1990static int __dbj_rep_transport(DB_ENV *dbenv, 1991 const DBT *control, const DBT *rec, const DB_LSN *lsn, int envid, 1992 u_int32_t flags) 1993{ 1994 int detach; 1995 JNIEnv *jenv = __dbj_get_jnienv(&detach); 1996 jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); 1997 jobject jcontrol, jrec, jlsn; 1998 jbyteArray jcontrolarr, jrecarr; 1999 int ret; 2000 2001 if (jdbenv == NULL) { 2002 ret = EINVAL; 2003 goto err; 2004 } 2005 2006 jcontrol = (*jenv)->NewObject(jenv, dbt_class, dbt_construct); 2007 jrec = (*jenv)->NewObject(jenv, dbt_class, dbt_construct); 2008 if (jcontrol == NULL || jrec == NULL) { 2009 ret = ENOMEM; /* An exception is pending */ 2010 goto err; 2011 } 2012 2013 __dbj_dbt_copyout(jenv, control, &jcontrolarr, jcontrol); 2014 __dbj_dbt_copyout(jenv, rec, &jrecarr, jrec); 2015 jlsn = (lsn == NULL) ? NULL : __dbj_wrap_DB_LSN(jenv, (DB_LSN *)lsn); 2016 2017 if (jcontrolarr == NULL || jrecarr == NULL) { 2018 ret = ENOMEM; /* An exception is pending */ 2019 goto err; 2020 } 2021 2022 ret = (*jenv)->CallNonvirtualIntMethod(jenv, jdbenv, dbenv_class, 2023 rep_transport_method, jcontrol, jrec, jlsn, envid, flags); 2024 2025 if ((*jenv)->ExceptionOccurred(jenv)) { 2026 /* The exception will be thrown, so this could be any error. */ 2027 ret = EINVAL; 2028 } 2029 2030 (*jenv)->DeleteLocalRef(jenv, jrecarr); 2031 (*jenv)->DeleteLocalRef(jenv, jcontrolarr); 2032 (*jenv)->DeleteLocalRef(jenv, jrec); 2033 (*jenv)->DeleteLocalRef(jenv, jcontrol); 2034 if (jlsn != NULL) 2035 (*jenv)->DeleteLocalRef(jenv, jlsn); 2036 2037err: if (detach) 2038 __dbj_detach(); 2039 return (ret); 2040} 2041 2042static int __dbj_foreignkey_nullify(DB *db, 2043 const DBT *key, DBT *data, const DBT *skey, int *changed) 2044{ 2045 int detach; 2046 JNIEnv *jenv = __dbj_get_jnienv(&detach); 2047 DBT_LOCKED lresult; 2048 jobject jdb = (jobject)DB_INTERNAL(db); 2049 jobject jkey, jdata, jskey; 2050 jbyteArray jkeyarr, jdataarr, jskeyarr; 2051 jboolean jresult; 2052 int ret; 2053 2054 if (jdb == NULL) { 2055 ret = EINVAL; 2056 goto err; 2057 } 2058 2059 jkey = (key->app_data != NULL) ? 2060 ((DBT_LOCKED *)key->app_data)->jdbt : 2061 (*jenv)->NewObject(jenv, dbt_class, dbt_construct); 2062 jdata = (data->app_data != NULL) ? 2063 ((DBT_LOCKED *)data->app_data)->jdbt : 2064 (*jenv)->NewObject(jenv, dbt_class, dbt_construct); 2065 jskey = (skey->app_data != NULL) ? 2066 ((DBT_LOCKED *)skey->app_data)->jdbt : 2067 (*jenv)->NewObject(jenv, dbt_class, dbt_construct); 2068 if (jkey == NULL || jdata == NULL || jskey == NULL) { 2069 ret = ENOMEM; /* An exception is pending */ 2070 goto err; 2071 } 2072 2073 if (key->app_data == NULL) { 2074 __dbj_dbt_copyout(jenv, key, &jkeyarr, jkey); 2075 if (jkeyarr == NULL) { 2076 ret = ENOMEM; /* An exception is pending */ 2077 goto err; 2078 } 2079 } 2080 if (data->app_data == NULL) { 2081 __dbj_dbt_copyout(jenv, data, &jdataarr, jdata); 2082 if (jdataarr == NULL) { 2083 ret = ENOMEM; /* An exception is pending */ 2084 goto err; 2085 } 2086 } 2087 if (skey->app_data == NULL) { 2088 __dbj_dbt_copyout(jenv, skey, &jskeyarr, jskey); 2089 if (jskeyarr == NULL) { 2090 ret = ENOMEM; /* An exception is pending */ 2091 goto err; 2092 } 2093 } 2094 2095 jresult = (*jenv)->CallNonvirtualBooleanMethod(jenv, jdb, db_class, foreignkey_nullify_method, jkey, jdata, jskey); 2096 2097 if ((*jenv)->ExceptionOccurred(jenv)) { 2098 /* The exception will be thrown, so this could be any error. */ 2099 ret = EINVAL; 2100 goto err; 2101 } 2102 2103 if (jresult == JNI_FALSE) 2104 *changed = ret = 0; 2105 else{ 2106 *changed = 1; 2107 /* copy jdata into data */ 2108 if ((ret = __dbj_dbt_copyin(jenv, &lresult, NULL, jdata, 0)) != 0) 2109 goto err; 2110 if (lresult.dbt.size != 0){ 2111 data->size = lresult.dbt.size; 2112 if ((ret = __os_umalloc( 2113 NULL, data->size, &data->data)) != 0) 2114 goto err; 2115 if ((ret = __dbj_dbt_memcopy(&lresult.dbt, 0, 2116 data->data, data->size, DB_USERCOPY_GETDATA)) != 0) 2117 goto err; 2118 __dbj_dbt_release(jenv, jdata, &lresult.dbt, &lresult); 2119 (*jenv)->DeleteLocalRef(jenv, lresult.jarr); 2120 F_SET(data, DB_DBT_APPMALLOC); 2121 } 2122 } 2123 2124err: if (key->app_data == NULL) { 2125 (*jenv)->DeleteLocalRef(jenv, jkeyarr); 2126 (*jenv)->DeleteLocalRef(jenv, jkey); 2127 } 2128 if (data->app_data == NULL) { 2129 (*jenv)->DeleteLocalRef(jenv, jdataarr); 2130 (*jenv)->DeleteLocalRef(jenv, jdata); 2131 } 2132 2133 if (detach) 2134 __dbj_detach(); 2135 return ret; 2136} 2137 2138static int __dbj_seckey_create(DB *db, 2139 const DBT *key, const DBT *data, DBT *result) 2140{ 2141 int detach; 2142 JNIEnv *jenv = __dbj_get_jnienv(&detach); 2143 jobject jdb = (jobject)DB_INTERNAL(db); 2144 jobject jkey, jdata, jresult; 2145 jobjectArray jskeys; 2146 jsize i, num_skeys; 2147 jbyteArray jkeyarr, jdataarr; 2148 DBT_LOCKED lresult; 2149 DBT *tresult; 2150 int ret; 2151 2152 if (jdb == NULL) { 2153 ret = EINVAL; 2154 goto err; 2155 } 2156 2157 jkey = (key->app_data != NULL) ? 2158 ((DBT_LOCKED *)key->app_data)->jdbt : 2159 (*jenv)->NewObject(jenv, dbt_class, dbt_construct); 2160 jdata = (data->app_data != NULL) ? 2161 ((DBT_LOCKED *)data->app_data)->jdbt : 2162 (*jenv)->NewObject(jenv, dbt_class, dbt_construct); 2163 if (jkey == NULL || jdata == NULL) { 2164 ret = ENOMEM; /* An exception is pending */ 2165 goto err; 2166 } 2167 2168 if (key->app_data == NULL) { 2169 __dbj_dbt_copyout(jenv, key, &jkeyarr, jkey); 2170 if (jkeyarr == NULL) { 2171 ret = ENOMEM; /* An exception is pending */ 2172 goto err; 2173 } 2174 } 2175 if (data->app_data == NULL) { 2176 __dbj_dbt_copyout(jenv, data, &jdataarr, jdata); 2177 if (jdataarr == NULL) { 2178 ret = ENOMEM; /* An exception is pending */ 2179 goto err; 2180 } 2181 } 2182 2183 jskeys = (jobjectArray)(*jenv)->CallNonvirtualObjectMethod(jenv, 2184 jdb, db_class, seckey_create_method, jkey, jdata); 2185 2186 if (jskeys == NULL || 2187 (num_skeys = (*jenv)->GetArrayLength(jenv, jskeys)) == 0) { 2188 ret = DB_DONOTINDEX; 2189 goto err; 2190 } else if (num_skeys == 1) { 2191 memset(result, 0, sizeof (DBT)); 2192 tresult = result; 2193 } else { 2194 if ((ret = __os_umalloc(db->env, 2195 num_skeys * sizeof (DBT), &result->data)) != 0) 2196 goto err; 2197 memset(result->data, 0, num_skeys * sizeof (DBT)); 2198 result->size = num_skeys; 2199 F_SET(result, DB_DBT_APPMALLOC | DB_DBT_MULTIPLE); 2200 tresult = (DBT *)result->data; 2201 } 2202 2203 if ((*jenv)->ExceptionOccurred(jenv)) { 2204 /* The exception will be thrown, so this could be any error. */ 2205 ret = EINVAL; 2206 goto err; 2207 } 2208 2209 for (i = 0; i < num_skeys; i++, tresult++) { 2210 jresult = (*jenv)->GetObjectArrayElement(jenv, jskeys, i); 2211 2212 if ((ret = 2213 __dbj_dbt_copyin(jenv, &lresult, NULL, jresult, 0)) != 0) 2214 goto err; 2215 2216 if (lresult.dbt.size != 0) { 2217 /* If there's data, we need to take a copy of it. */ 2218 tresult->size = lresult.dbt.size; 2219 if ((ret = __os_umalloc(NULL, 2220 tresult->size, &tresult->data)) != 0) 2221 goto err; 2222 if ((ret = __dbj_dbt_memcopy(&lresult.dbt, 0, 2223 tresult->data, tresult->size, 2224 DB_USERCOPY_GETDATA)) != 0) 2225 goto err; 2226 __dbj_dbt_release(jenv, 2227 jresult, &lresult.dbt, &lresult); 2228 (*jenv)->DeleteLocalRef(jenv, lresult.jarr); 2229 F_SET(tresult, DB_DBT_APPMALLOC); 2230 } 2231 2232 (*jenv)->DeleteLocalRef(jenv, jresult); 2233 } 2234 2235err: if (key->app_data == NULL) { 2236 (*jenv)->DeleteLocalRef(jenv, jkeyarr); 2237 (*jenv)->DeleteLocalRef(jenv, jkey); 2238 } 2239 if (data->app_data == NULL) { 2240 (*jenv)->DeleteLocalRef(jenv, jdataarr); 2241 (*jenv)->DeleteLocalRef(jenv, jdata); 2242 } 2243 if (jskeys != NULL) { 2244 (*jenv)->DeleteLocalRef(jenv, jskeys); 2245 } 2246 2247 if (detach) 2248 __dbj_detach(); 2249 return (ret); 2250} 2251 2252static int __dbj_append_recno(DB *db, DBT *dbt, db_recno_t recno) 2253{ 2254 int detach; 2255 JNIEnv *jenv = __dbj_get_jnienv(&detach); 2256 jobject jdb = (jobject)DB_INTERNAL(db); 2257 jobject jdbt; 2258 DBT_LOCKED lresult; 2259 jbyteArray jdbtarr; 2260 int ret; 2261 2262 if (jdb == NULL) { 2263 ret = EINVAL; 2264 goto err; 2265 } 2266 2267 /* 2268 * The dbt we're passed will be from the application, but we can't 2269 * just reuse it, since we will have already taken a copy of the data. 2270 * Make a new DatabaseEntry object here for the callback. 2271 */ 2272 jdbt = (*jenv)->NewObject(jenv, dbt_class, dbt_construct); 2273 if (jdbt == NULL) { 2274 ret = ENOMEM; /* An exception is pending */ 2275 goto err; 2276 } 2277 2278 __dbj_dbt_copyout(jenv, dbt, &jdbtarr, jdbt); 2279 if (jdbtarr == NULL) { 2280 ret = ENOMEM; /* An exception is pending */ 2281 goto err; 2282 } 2283 2284 ret = 0; 2285 (*jenv)->CallNonvirtualVoidMethod(jenv, jdb, db_class, 2286 append_recno_method, jdbt, recno); 2287 2288 if ((*jenv)->ExceptionOccurred(jenv)) { 2289 /* The exception will be thrown, so this could be any error. */ 2290 ret = EINVAL; 2291 goto err; 2292 } 2293 2294 ret = __dbj_dbt_copyin(jenv, &lresult, NULL, jdbt, 0); 2295 memset(dbt, 0, sizeof (DBT)); 2296 2297 if (ret == 0 && lresult.dbt.size != 0) { 2298 /* If there's data, we need to take a copy of it. */ 2299 dbt->size = lresult.dbt.size; 2300 if ((ret = 2301 __os_umalloc(NULL, dbt->size, &dbt->data)) != 0) 2302 goto err; 2303 if ((ret = __dbj_dbt_memcopy(&lresult.dbt, 0, 2304 dbt->data, dbt->size, 2305 DB_USERCOPY_GETDATA)) != 0) 2306 goto err; 2307 __dbj_dbt_release(jenv, jdbt, &lresult.dbt, &lresult); 2308 (*jenv)->DeleteLocalRef(jenv, lresult.jarr); 2309 F_SET(dbt, DB_DBT_APPMALLOC); 2310 } 2311 2312err: (*jenv)->DeleteLocalRef(jenv, jdbtarr); 2313 (*jenv)->DeleteLocalRef(jenv, jdbt); 2314 2315 if (detach) 2316 __dbj_detach(); 2317 return (ret); 2318} 2319 2320/* 2321 * Shared by __dbj_bt_compare and __dbj_h_compare 2322 */ 2323static int __dbj_am_compare(DB *db, const DBT *dbt1, const DBT *dbt2, 2324 jmethodID compare_method) 2325{ 2326 int detach; 2327 JNIEnv *jenv = __dbj_get_jnienv(&detach); 2328 jobject jdb = (jobject)DB_INTERNAL(db); 2329 jbyteArray jdbtarr1, jdbtarr2; 2330 int ret; 2331 2332 if (jdb == NULL) { 2333 ret = EINVAL; 2334 goto err; 2335 } 2336 2337 if (dbt1->app_data != NULL) 2338 jdbtarr1 = ((DBT_LOCKED *)dbt1->app_data)->jarr; 2339 else { 2340 jdbtarr1 = (*jenv)->NewByteArray(jenv, (jsize)dbt1->size); 2341 if (jdbtarr1 == NULL) { 2342 ret = ENOMEM; 2343 goto err; 2344 } 2345 (*jenv)->SetByteArrayRegion(jenv, jdbtarr1, 0, 2346 (jsize)dbt1->size, (jbyte *)dbt1->data); 2347 } 2348 2349 if (dbt2->app_data != NULL) 2350 jdbtarr2 = ((DBT_LOCKED *)dbt2->app_data)->jarr; 2351 else { 2352 jdbtarr2 = (*jenv)->NewByteArray(jenv, (jsize)dbt2->size); 2353 if (jdbtarr2 == NULL) { 2354 ret = ENOMEM; 2355 goto err; 2356 } 2357 (*jenv)->SetByteArrayRegion(jenv, jdbtarr2, 0, 2358 (jsize)dbt2->size, (jbyte *)dbt2->data); 2359 } 2360 2361 ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, 2362 compare_method, jdbtarr1, jdbtarr2); 2363 2364 if ((*jenv)->ExceptionOccurred(jenv)) { 2365 /* The exception will be thrown, so this could be any error. */ 2366 ret = EINVAL; 2367 } 2368 2369err: if (dbt1->app_data == NULL) 2370 (*jenv)->DeleteLocalRef(jenv, jdbtarr1); 2371 if (dbt2->app_data == NULL) 2372 (*jenv)->DeleteLocalRef(jenv, jdbtarr2); 2373 2374 if (detach) 2375 __dbj_detach(); 2376 return (ret); 2377} 2378 2379static int __dbj_bt_compare(DB *db, const DBT *dbt1, const DBT *dbt2) 2380{ 2381 return __dbj_am_compare(db, dbt1, dbt2, bt_compare_method); 2382} 2383 2384#define DBT_COPYOUT(num) \ 2385 if (dbt##num->app_data != NULL) \ 2386 jdbt##num = ((DBT_LOCKED *)dbt##num->app_data)->jdbt; \ 2387 else { \ 2388 if ((jdbt##num = (*jenv)->NewObject( \ 2389 jenv, dbt_class, dbt_construct)) == NULL) { \ 2390 ret = ENOMEM; /* An exception is pending */ \ 2391 goto err; \ 2392 } \ 2393 __dbj_dbt_copyout(jenv, dbt##num, &jdbtarr##num, jdbt##num);\ 2394 if (jdbtarr##num == NULL) { \ 2395 ret = ENOMEM; /* An exception is pending */ \ 2396 goto err; \ 2397 } \ 2398 } 2399 2400#define DBT_COPIED_FREE(num) \ 2401 if (dbt##num->app_data == NULL) { \ 2402 (*jenv)->DeleteLocalRef(jenv, jdbtarr##num); \ 2403 (*jenv)->DeleteLocalRef(jenv, jdbt##num); \ 2404 } 2405 2406#define DBT_COPYIN_DATA(num) \ 2407 ret = __dbj_dbt_copyin(jenv, &lresult, NULL, jdbt##num, 0); \ 2408 memset(dbt##num, 0, sizeof (DBT)); \ 2409 if (ret == 0 && lresult.dbt.size != 0) { \ 2410 /* If there's data, we need to take a copy of it. */ \ 2411 dbt##num->size = lresult.dbt.size; \ 2412 if ((ret = __os_umalloc( \ 2413 NULL, dbt##num->size, &dbt##num->data)) != 0) \ 2414 goto err; \ 2415 if ((ret = __dbj_dbt_memcopy(&lresult.dbt, 0, \ 2416 dbt##num->data, dbt##num->size, \ 2417 DB_USERCOPY_GETDATA)) != 0) \ 2418 goto err; \ 2419 __dbj_dbt_release(jenv, jdbt##num, &lresult.dbt, &lresult);\ 2420 (*jenv)->DeleteLocalRef(jenv, lresult.jarr); \ 2421 F_SET(dbt##num, DB_DBT_APPMALLOC); \ 2422 } 2423 2424static int __dbj_bt_compress(DB *db, const DBT *dbt1, const DBT *dbt2, 2425 const DBT *dbt3, const DBT *dbt4, DBT *dbt5) 2426{ 2427 int detach; 2428 JNIEnv *jenv = __dbj_get_jnienv(&detach); 2429 jobject jdb = (jobject)DB_INTERNAL(db); 2430 jobject jdbt1, jdbt2, jdbt3, jdbt4, jdbt5; 2431 jbyteArray jdbtarr1, jdbtarr2, jdbtarr3, jdbtarr4, jdbtarr5; 2432 DBT_LOCKED lresult; 2433 int ret; 2434 2435 if (jdb == NULL) { 2436 ret = EINVAL; 2437 goto err; 2438 } 2439 2440 DBT_COPYOUT(1) 2441 DBT_COPYOUT(2) 2442 DBT_COPYOUT(3) 2443 DBT_COPYOUT(4) 2444 DBT_COPYOUT(5) 2445 2446 ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, 2447 bt_compress_method, jdbt1, jdbt2, jdbt3, jdbt4, jdbt5); 2448 2449 if ((*jenv)->ExceptionOccurred(jenv)) { 2450 /* The exception will be thrown, so this could be any error. */ 2451 ret = EINVAL; 2452 goto err; 2453 } 2454 2455 DBT_COPYIN_DATA(5) 2456 2457err: DBT_COPIED_FREE(1) 2458 DBT_COPIED_FREE(2) 2459 DBT_COPIED_FREE(3) 2460 DBT_COPIED_FREE(4) 2461 DBT_COPIED_FREE(5) 2462 if (detach) 2463 __dbj_detach(); 2464 return (ret); 2465} 2466 2467static int __dbj_bt_decompress(DB *db, const DBT *dbt1, const DBT *dbt2, 2468 DBT *dbt3, DBT *dbt4, DBT *dbt5) 2469{ 2470 int detach; 2471 JNIEnv *jenv = __dbj_get_jnienv(&detach); 2472 jobject jdb = (jobject)DB_INTERNAL(db); 2473 jobject jdbt1, jdbt2, jdbt3, jdbt4, jdbt5; 2474 jbyteArray jdbtarr1, jdbtarr2, jdbtarr3, jdbtarr4, jdbtarr5; 2475 DBT_LOCKED lresult; 2476 int ret; 2477 2478 if (jdb == NULL) { 2479 ret = EINVAL; 2480 goto err; 2481 } 2482 2483 DBT_COPYOUT(1) 2484 DBT_COPYOUT(2) 2485 DBT_COPYOUT(3) 2486 DBT_COPYOUT(4) 2487 DBT_COPYOUT(5) 2488 2489 ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, 2490 bt_decompress_method, jdbt1, jdbt2, jdbt3, jdbt4, jdbt5); 2491 2492 if ((*jenv)->ExceptionOccurred(jenv)) { 2493 /* The exception will be thrown, so this could be any error. */ 2494 ret = EINVAL; 2495 goto err; 2496 } 2497 2498 DBT_COPYIN_DATA(3) 2499 DBT_COPYIN_DATA(4) 2500 DBT_COPYIN_DATA(5) 2501 2502err: DBT_COPIED_FREE(1) 2503 DBT_COPIED_FREE(2) 2504 DBT_COPIED_FREE(3) 2505 DBT_COPIED_FREE(4) 2506 DBT_COPIED_FREE(5) 2507 if (detach) 2508 __dbj_detach(); 2509 return (ret); 2510} 2511 2512static size_t __dbj_bt_prefix(DB *db, const DBT *dbt1, const DBT *dbt2) 2513{ 2514 int detach; 2515 JNIEnv *jenv = __dbj_get_jnienv(&detach); 2516 jobject jdb = (jobject)DB_INTERNAL(db); 2517 jobject jdbt1, jdbt2; 2518 jbyteArray jdbtarr1, jdbtarr2; 2519 int ret; 2520 2521 if (jdb == NULL) { 2522 ret = EINVAL; 2523 goto err; 2524 } 2525 2526 if (dbt1->app_data != NULL) 2527 jdbt1 = ((DBT_LOCKED *)dbt1->app_data)->jdbt; 2528 else { 2529 if ((jdbt1 = 2530 (*jenv)->NewObject(jenv, dbt_class, dbt_construct)) == NULL) { 2531 ret = ENOMEM; /* An exception is pending */ 2532 goto err; 2533 } 2534 __dbj_dbt_copyout(jenv, dbt1, &jdbtarr1, jdbt1); 2535 if (jdbtarr1 == NULL) { 2536 ret = ENOMEM; /* An exception is pending */ 2537 goto err; 2538 } 2539 } 2540 2541 if (dbt2->app_data != NULL) 2542 jdbt2 = ((DBT_LOCKED *)dbt2->app_data)->jdbt; 2543 else { 2544 if ((jdbt2 = 2545 (*jenv)->NewObject(jenv, dbt_class, dbt_construct)) == NULL) { 2546 ret = ENOMEM; /* An exception is pending */ 2547 goto err; 2548 } 2549 __dbj_dbt_copyout(jenv, dbt2, &jdbtarr2, jdbt2); 2550 if (jdbtarr2 == NULL) { 2551 ret = ENOMEM; /* An exception is pending */ 2552 goto err; 2553 } 2554 } 2555 2556 ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, 2557 bt_prefix_method, jdbt1, jdbt2); 2558 2559err: if (dbt1->app_data == NULL) { 2560 (*jenv)->DeleteLocalRef(jenv, jdbtarr1); 2561 (*jenv)->DeleteLocalRef(jenv, jdbt1); 2562 } 2563 if (dbt2->app_data == NULL) { 2564 (*jenv)->DeleteLocalRef(jenv, jdbtarr2); 2565 (*jenv)->DeleteLocalRef(jenv, jdbt2); 2566 } 2567 2568 if (detach) 2569 __dbj_detach(); 2570 return (ret); 2571} 2572 2573static int __dbj_dup_compare(DB *db, const DBT *dbt1, const DBT *dbt2) 2574{ 2575 int detach; 2576 JNIEnv *jenv = __dbj_get_jnienv(&detach); 2577 jobject jdb = (jobject)DB_INTERNAL(db); 2578 jbyteArray jdbtarr1, jdbtarr2; 2579 int ret; 2580 2581 if (jdb == NULL) 2582 return (EINVAL); 2583 2584 jdbtarr1 = (*jenv)->NewByteArray(jenv, (jsize)dbt1->size); 2585 if (jdbtarr1 == NULL) 2586 return (ENOMEM); 2587 (*jenv)->SetByteArrayRegion(jenv, jdbtarr1, 0, (jsize)dbt1->size, 2588 (jbyte *)dbt1->data); 2589 2590 jdbtarr2 = (*jenv)->NewByteArray(jenv, (jsize)dbt2->size); 2591 if (jdbtarr2 == NULL) 2592 return (ENOMEM); 2593 (*jenv)->SetByteArrayRegion(jenv, jdbtarr2, 0, (jsize)dbt2->size, 2594 (jbyte *)dbt2->data); 2595 2596 ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, 2597 dup_compare_method, jdbtarr1, jdbtarr2); 2598 2599 if ((*jenv)->ExceptionOccurred(jenv)) { 2600 /* The exception will be thrown, so this could be any error. */ 2601 ret = EINVAL; 2602 } 2603 2604 (*jenv)->DeleteLocalRef(jenv, jdbtarr2); 2605 (*jenv)->DeleteLocalRef(jenv, jdbtarr1); 2606 2607 if (detach) 2608 __dbj_detach(); 2609 return (ret); 2610} 2611 2612static void __dbj_db_feedback(DB *db, int opcode, int percent) 2613{ 2614 int detach; 2615 JNIEnv *jenv = __dbj_get_jnienv(&detach); 2616 jobject jdb = (jobject)DB_INTERNAL(db); 2617 2618 if (jdb != NULL) 2619 (*jenv)->CallNonvirtualVoidMethod(jenv, jdb, db_class, 2620 db_feedback_method, opcode, percent); 2621 2622 if (detach) 2623 __dbj_detach(); 2624} 2625 2626static int __dbj_h_compare(DB *db, const DBT *dbt1, const DBT *dbt2) 2627{ 2628 return __dbj_am_compare(db, dbt1, dbt2, h_compare_method); 2629} 2630 2631static u_int32_t __dbj_h_hash(DB *db, const void *data, u_int32_t len) 2632{ 2633 int detach; 2634 JNIEnv *jenv = __dbj_get_jnienv(&detach); 2635 jobject jdb = (jobject)DB_INTERNAL(db); 2636 jbyteArray jarr = (*jenv)->NewByteArray(jenv, (jsize)len); 2637 int ret; 2638 2639 if (jdb == NULL) 2640 return (EINVAL); 2641 2642 if ((jarr = (*jenv)->NewByteArray(jenv, (jsize)len)) == NULL) 2643 return (ENOMEM); /* An exception is pending */ 2644 2645 (*jenv)->SetByteArrayRegion(jenv, jarr, 0, (jsize)len, (jbyte *)data); 2646 2647 ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, 2648 h_hash_method, jarr, len); 2649 2650 (*jenv)->DeleteLocalRef(jenv, jarr); 2651 2652 if (detach) 2653 __dbj_detach(); 2654 return (ret); 2655} 2656 2657static u_int32_t __dbj_partition(DB *db, DBT *dbt1) 2658{ 2659 int detach, ret; 2660 JNIEnv *jenv = __dbj_get_jnienv(&detach); 2661 jobject jdb = (jobject)DB_INTERNAL(db); 2662 jobject jdbt1; 2663 jbyteArray jdbtarr1; 2664 DBT_LOCKED lresult; 2665 2666 DBT_COPYOUT(1) 2667 2668 ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, 2669 partition_method, jdbt1); 2670 if ((*jenv)->ExceptionOccurred(jenv)) { 2671 /* The exception will be thrown, so this could be any error. */ 2672 ret = EINVAL; 2673 goto err; 2674 } 2675 2676 DBT_COPYIN_DATA(1) 2677err: DBT_COPIED_FREE(1) 2678 2679 if (detach) 2680 __dbj_detach(); 2681 return (ret); 2682} 2683 2684 2685SWIGEXPORT jlong JNICALL 2686Java_com_sleepycat_db_internal_db_1javaJNI_initDbEnvRef0( 2687 JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 2688 DB_ENV *self = *(DB_ENV **)(void *)&jarg1; 2689 jlong ret; 2690 COMPQUIET(jcls, NULL); 2691 COMPQUIET(jarg1_, NULL); 2692 2693 DB_ENV_INTERNAL(self) = (void *)(*jenv)->NewGlobalRef(jenv, jarg2); 2694 *(jobject *)(void *)&ret = (jobject)DB_ENV_INTERNAL(self); 2695 return (ret); 2696} 2697 2698SWIGEXPORT jlong JNICALL 2699Java_com_sleepycat_db_internal_db_1javaJNI_initDbRef0( 2700 JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 2701 DB *self = *(DB **)(void *)&jarg1; 2702 jlong ret; 2703 COMPQUIET(jcls, NULL); 2704 COMPQUIET(jarg1_, NULL); 2705 2706 DB_INTERNAL(self) = (void *)(*jenv)->NewGlobalRef(jenv, jarg2); 2707 *(jobject *)(void *)&ret = (jobject)DB_INTERNAL(self); 2708 return (ret); 2709} 2710 2711SWIGEXPORT void JNICALL 2712Java_com_sleepycat_db_internal_db_1javaJNI_deleteRef0( 2713 JNIEnv *jenv, jclass jcls, jlong jarg1) { 2714 jobject jref = *(jobject *)(void *)&jarg1; 2715 COMPQUIET(jcls, NULL); 2716 2717 if (jref != 0L) 2718 (*jenv)->DeleteGlobalRef(jenv, jref); 2719} 2720 2721SWIGEXPORT jlong JNICALL 2722Java_com_sleepycat_db_internal_db_1javaJNI_getDbEnv0( 2723 JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 2724 DB *self = *(DB **)(void *)&jarg1; 2725 jlong ret; 2726 2727 COMPQUIET(jenv, NULL); 2728 COMPQUIET(jcls, NULL); 2729 COMPQUIET(jarg1_, NULL); 2730 2731 *(DB_ENV **)(void *)&ret = self->dbenv; 2732 return (ret); 2733} 2734 2735SWIGEXPORT jboolean JNICALL 2736Java_com_sleepycat_db_internal_DbUtil_is_1big_1endian( 2737 JNIEnv *jenv, jclass clazz) 2738{ 2739 COMPQUIET(jenv, NULL); 2740 COMPQUIET(clazz, NULL); 2741 2742 return (__db_isbigendian() ? JNI_TRUE : JNI_FALSE); 2743} 2744 2745 2746typedef int db_ret_t; 2747typedef int int_bool; 2748 2749struct __db_lk_conflicts { 2750 u_int8_t *lk_conflicts; 2751 int lk_modes; 2752}; 2753 2754struct __db_out_stream { 2755 void *handle; 2756 int (*callback) __P((void *, const void *)); 2757}; 2758 2759struct __db_repmgr_sites { 2760 DB_REPMGR_SITE *sites; 2761 u_int32_t nsites; 2762}; 2763 2764#define Db __db 2765#define Dbc __dbc 2766#define Dbt __db_dbt 2767#define DbEnv __db_env 2768#define DbLock __db_lock_u 2769#define DbLogc __db_log_cursor 2770#define DbLsn __db_lsn 2771#define DbMpoolFile __db_mpoolfile 2772#define DbSequence __db_sequence 2773#define DbTxn __db_txn 2774 2775/* Suppress a compilation warning for an unused symbol */ 2776void *unused = (void *)SWIG_JavaThrowException; 2777 2778SWIGINTERN struct Db *new_Db(DB_ENV *dbenv,u_int32_t flags){ 2779 DB *self = NULL; 2780 errno = db_create(&self, dbenv, flags); 2781 if (errno == 0 && dbenv == NULL) 2782 self->env->dbt_usercopy = __dbj_dbt_memcopy; 2783 return self; 2784 } 2785SWIGINTERN db_ret_t Db_associate(struct Db *self,DB_TXN *txnid,DB *secondary,int (*callback)(DB *,DBT const *,DBT const *,DBT *),u_int32_t flags){ 2786 return self->associate(self, txnid, secondary, callback, flags); 2787 } 2788SWIGINTERN db_ret_t Db_associate_foreign(struct Db *self,DB *primary,int (*callback)(DB *,DBT const *,DBT *,DBT const *,int *),u_int32_t flags){ 2789 return self->associate_foreign(self, primary, callback, flags); 2790 } 2791SWIGINTERN db_ret_t Db_compact(struct Db *self,DB_TXN *txnid,DBT *start,DBT *stop,DB_COMPACT *c_data,u_int32_t flags,DBT *end){ 2792 return self->compact(self, txnid, start, stop, c_data, flags, 2793 end); 2794 } 2795SWIGINTERN int Db_close(struct Db *self,u_int32_t flags){ 2796 errno = self->close(self, flags); 2797 return errno; 2798 } 2799SWIGINTERN DBC *Db_cursor(struct Db *self,DB_TXN *txnid,u_int32_t flags){ 2800 DBC *cursorp = NULL; 2801 errno = self->cursor(self, txnid, &cursorp, flags); 2802 return cursorp; 2803 } 2804SWIGINTERN int Db_del(struct Db *self,DB_TXN *txnid,DBT *key,u_int32_t flags){ 2805 return self->del(self, txnid, key, flags); 2806 } 2807SWIGINTERN void Db_err(struct Db *self,int error,char const *message){ 2808 self->err(self, error, message); 2809 } 2810SWIGINTERN void Db_errx(struct Db *self,char const *message){ 2811 self->errx(self, message); 2812 } 2813SWIGINTERN int Db_exists(struct Db *self,DB_TXN *txnid,DBT *key,u_int32_t flags){ 2814 return self->exists(self, txnid, key, flags); 2815 } 2816SWIGINTERN int Db_get(struct Db *self,DB_TXN *txnid,DBT *key,DBT *data,u_int32_t flags){ 2817 return self->get(self, txnid, key, data, flags); 2818 } 2819SWIGINTERN int_bool Db_get_byteswapped(struct Db *self){ 2820 int ret = 0; 2821 errno = self->get_byteswapped(self, &ret); 2822 return ret; 2823 } 2824SWIGINTERN jlong Db_get_cachesize(struct Db *self){ 2825 u_int32_t gbytes = 0, bytes = 0; 2826 errno = self->get_cachesize(self, &gbytes, &bytes, NULL); 2827 return (jlong)gbytes * GIGABYTE + bytes; 2828 } 2829SWIGINTERN u_int32_t Db_get_cachesize_ncache(struct Db *self){ 2830 int ret = 0; 2831 errno = self->get_cachesize(self, NULL, NULL, &ret); 2832 return ret; 2833 } 2834SWIGINTERN char const *Db_get_create_dir(struct Db *self){ 2835 const char *ret; 2836 errno = self->get_create_dir(self, &ret); 2837 return ret; 2838 } 2839SWIGINTERN char const *Db_get_filename(struct Db *self){ 2840 const char *ret = NULL; 2841 errno = self->get_dbname(self, &ret, NULL); 2842 return ret; 2843 } 2844SWIGINTERN char const *Db_get_dbname(struct Db *self){ 2845 const char *ret = NULL; 2846 errno = self->get_dbname(self, NULL, &ret); 2847 return ret; 2848 } 2849SWIGINTERN u_int32_t Db_get_encrypt_flags(struct Db *self){ 2850 u_int32_t ret = 0; 2851 CRYPTO_ONLY(errno = self->get_encrypt_flags(self, &ret)) 2852 return ret; 2853 } 2854SWIGINTERN u_int32_t Db_get_flags(struct Db *self){ 2855 u_int32_t ret = 0; 2856 errno = self->get_flags(self, &ret); 2857 return ret; 2858 } 2859SWIGINTERN int Db_get_lorder(struct Db *self){ 2860 int ret = 0; 2861 errno = self->get_lorder(self, &ret); 2862 return ret; 2863 } 2864SWIGINTERN DB_MPOOLFILE *Db_get_mpf(struct Db *self){ 2865 errno = 0; 2866 return self->get_mpf(self); 2867 } 2868SWIGINTERN u_int32_t Db_get_open_flags(struct Db *self){ 2869 u_int32_t ret = 0; 2870 errno = self->get_open_flags(self, &ret); 2871 return ret; 2872 } 2873SWIGINTERN u_int32_t Db_get_pagesize(struct Db *self){ 2874 u_int32_t ret = 0; 2875 errno = self->get_pagesize(self, &ret); 2876 return ret; 2877 } 2878SWIGINTERN u_int32_t Db_get_bt_minkey(struct Db *self){ 2879 u_int32_t ret = 0; 2880 errno = self->get_bt_minkey(self, &ret); 2881 return ret; 2882 } 2883SWIGINTERN u_int32_t Db_get_h_ffactor(struct Db *self){ 2884 u_int32_t ret = 0; 2885 errno = self->get_h_ffactor(self, &ret); 2886 return ret; 2887 } 2888SWIGINTERN u_int32_t Db_get_h_nelem(struct Db *self){ 2889 u_int32_t ret = 0; 2890 errno = self->get_h_nelem(self, &ret); 2891 return ret; 2892 } 2893SWIGINTERN int Db_get_re_delim(struct Db *self){ 2894 int ret = 0; 2895 errno = self->get_re_delim(self, &ret); 2896 return ret; 2897 } 2898SWIGINTERN DB_CACHE_PRIORITY Db_get_priority(struct Db *self){ 2899 DB_CACHE_PRIORITY ret; 2900 errno = self->get_priority(self, &ret); 2901 return ret; 2902 } 2903SWIGINTERN char const **Db_get_partition_dirs(struct Db *self){ 2904 const char **ret; 2905 errno = self->get_partition_dirs(self, &ret); 2906 return ret; 2907 } 2908SWIGINTERN DBT *Db_get_partition_keys(struct Db *self){ 2909 DBT *ret = NULL; 2910 errno = self->get_partition_keys(self, NULL, &ret); 2911 return ret; 2912 } 2913SWIGINTERN int Db_get_partition_parts(struct Db *self){ 2914 int ret = 0; 2915 errno = self->get_partition_keys(self, &ret, NULL); 2916 /* If not partitioned by range, check by callback. */ 2917 if (ret == 0) 2918 errno = self->get_partition_callback(self, &ret, NULL); 2919 return ret; 2920 } 2921SWIGINTERN u_int32_t Db_get_re_len(struct Db *self){ 2922 u_int32_t ret = 0; 2923 errno = self->get_re_len(self, &ret); 2924 return ret; 2925 } 2926SWIGINTERN int Db_get_re_pad(struct Db *self){ 2927 int ret = 0; 2928 errno = self->get_re_pad(self, &ret); 2929 return ret; 2930 } 2931SWIGINTERN char const *Db_get_re_source(struct Db *self){ 2932 const char *ret = NULL; 2933 errno = self->get_re_source(self, &ret); 2934 return ret; 2935 } 2936SWIGINTERN u_int32_t Db_get_q_extentsize(struct Db *self){ 2937 u_int32_t ret = 0; 2938 errno = self->get_q_extentsize(self, &ret); 2939 return ret; 2940 } 2941SWIGINTERN int_bool Db_get_multiple(struct Db *self){ 2942 return self->get_multiple(self); 2943 } 2944SWIGINTERN int_bool Db_get_transactional(struct Db *self){ 2945 return self->get_transactional(self); 2946 } 2947SWIGINTERN DBTYPE Db_get_type(struct Db *self){ 2948 DBTYPE type = (DBTYPE)0; 2949 errno = self->get_type(self, &type); 2950 return type; 2951 } 2952SWIGINTERN DBC *Db_join(struct Db *self,DBC **curslist,u_int32_t flags){ 2953 DBC *dbcp = NULL; 2954 errno = self->join(self, curslist, &dbcp, flags); 2955 return dbcp; 2956 } 2957SWIGINTERN db_ret_t Db_key_range(struct Db *self,DB_TXN *txnid,DBT *key,DB_KEY_RANGE *key_range,u_int32_t flags){ 2958 return self->key_range(self, txnid, key, key_range, flags); 2959 } 2960SWIGINTERN db_ret_t Db_open(struct Db *self,DB_TXN *txnid,char const *file,char const *database,DBTYPE type,u_int32_t flags,int mode){ 2961 return self->open(self, txnid, file, database, 2962 type, flags, mode); 2963 } 2964SWIGINTERN int Db_pget(struct Db *self,DB_TXN *txnid,DBT *key,DBT *pkey,DBT *data,u_int32_t flags){ 2965 return self->pget(self, txnid, key, pkey, data, flags); 2966 } 2967SWIGINTERN int Db_put(struct Db *self,DB_TXN *txnid,DBT *key,DBT *db_put_data,u_int32_t flags){ 2968 return self->put(self, txnid, key, db_put_data, flags); 2969 } 2970SWIGINTERN db_ret_t Db_remove(struct Db *self,char const *file,char const *database,u_int32_t flags){ 2971 return self->remove(self, file, database, flags); 2972 } 2973SWIGINTERN db_ret_t Db_rename(struct Db *self,char const *file,char const *database,char const *newname,u_int32_t flags){ 2974 return self->rename(self, file, database, newname, flags); 2975 } 2976SWIGINTERN db_ret_t Db_set_append_recno(struct Db *self,int (*db_append_recno_fcn)(DB *,DBT *,db_recno_t)){ 2977 return self->set_append_recno(self, db_append_recno_fcn); 2978 } 2979SWIGINTERN db_ret_t Db_set_bt_compare(struct Db *self,int (*bt_compare_fcn)(DB *,DBT const *,DBT const *)){ 2980 return self->set_bt_compare(self, bt_compare_fcn); 2981 } 2982SWIGINTERN db_ret_t Db_set_bt_minkey(struct Db *self,u_int32_t bt_minkey){ 2983 return self->set_bt_minkey(self, bt_minkey); 2984 } 2985SWIGINTERN db_ret_t Db_set_bt_compress(struct Db *self,int (*bt_compress_fcn)(DB *,DBT const *,DBT const *,DBT const *,DBT const *,DBT *),int (*bt_decompress_fcn)(DB *,DBT const *,DBT const *,DBT *,DBT *,DBT *)){ 2986 return self->set_bt_compress( 2987 self, bt_compress_fcn, bt_decompress_fcn); 2988 } 2989SWIGINTERN db_ret_t Db_set_bt_prefix(struct Db *self,size_t (*bt_prefix_fcn)(DB *,DBT const *,DBT const *)){ 2990 return self->set_bt_prefix(self, bt_prefix_fcn); 2991 } 2992SWIGINTERN db_ret_t Db_set_cachesize(struct Db *self,jlong bytes,int ncache){ 2993 return self->set_cachesize(self, 2994 (u_int32_t)(bytes / GIGABYTE), 2995 (u_int32_t)(bytes % GIGABYTE), ncache); 2996 } 2997SWIGINTERN db_ret_t Db_set_create_dir(struct Db *self,char const *dir){ 2998 return self->set_create_dir(self, dir); 2999 } 3000SWIGINTERN db_ret_t Db_set_dup_compare(struct Db *self,int (*dup_compare_fcn)(DB *,DBT const *,DBT const *)){ 3001 return self->set_dup_compare(self, dup_compare_fcn); 3002 } 3003SWIGINTERN db_ret_t Db_set_encrypt(struct Db *self,char const *passwd,u_int32_t flags){ 3004 return self->set_encrypt(self, passwd, flags); 3005 } 3006SWIGINTERN db_ret_t Db_set_feedback(struct Db *self,void (*db_feedback_fcn)(DB *,int,int)){ 3007 return self->set_feedback(self, db_feedback_fcn); 3008 } 3009SWIGINTERN db_ret_t Db_set_flags(struct Db *self,u_int32_t flags){ 3010 return self->set_flags(self, flags); 3011 } 3012SWIGINTERN db_ret_t Db_set_h_compare(struct Db *self,int (*h_compare_fcn)(DB *,DBT const *,DBT const *)){ 3013 return self->set_h_compare(self, h_compare_fcn); 3014 } 3015SWIGINTERN db_ret_t Db_set_h_ffactor(struct Db *self,u_int32_t h_ffactor){ 3016 return self->set_h_ffactor(self, h_ffactor); 3017 } 3018SWIGINTERN db_ret_t Db_set_h_hash(struct Db *self,u_int32_t (*h_hash_fcn)(DB *,void const *,u_int32_t)){ 3019 return self->set_h_hash(self, h_hash_fcn); 3020 } 3021SWIGINTERN db_ret_t Db_set_h_nelem(struct Db *self,u_int32_t h_nelem){ 3022 return self->set_h_nelem(self, h_nelem); 3023 } 3024SWIGINTERN db_ret_t Db_set_lorder(struct Db *self,int lorder){ 3025 return self->set_lorder(self, lorder); 3026 } 3027SWIGINTERN db_ret_t Db_set_pagesize(struct Db *self,u_int32_t pagesize){ 3028 return self->set_pagesize(self, pagesize); 3029 } 3030SWIGINTERN db_ret_t Db_set_partition(struct Db *self,u_int32_t parts,DBT *keys,u_int32_t (*db_partition_fcn)(DB *,DBT *)){ 3031 return self->set_partition(self, parts, keys, db_partition_fcn); 3032 } 3033SWIGINTERN db_ret_t Db_set_partition_dirs(struct Db *self,char const **dirp){ 3034 return self->set_partition_dirs(self, dirp); 3035 } 3036SWIGINTERN db_ret_t Db_set_priority(struct Db *self,DB_CACHE_PRIORITY priority){ 3037 return self->set_priority(self, priority); 3038 } 3039SWIGINTERN db_ret_t Db_set_re_delim(struct Db *self,int re_delim){ 3040 return self->set_re_delim(self, re_delim); 3041 } 3042SWIGINTERN db_ret_t Db_set_re_len(struct Db *self,u_int32_t re_len){ 3043 return self->set_re_len(self, re_len); 3044 } 3045SWIGINTERN db_ret_t Db_set_re_pad(struct Db *self,int re_pad){ 3046 return self->set_re_pad(self, re_pad); 3047 } 3048SWIGINTERN db_ret_t Db_set_re_source(struct Db *self,char *source){ 3049 return self->set_re_source(self, source); 3050 } 3051SWIGINTERN db_ret_t Db_set_q_extentsize(struct Db *self,u_int32_t extentsize){ 3052 return self->set_q_extentsize(self, extentsize); 3053 } 3054SWIGINTERN db_ret_t Db_sort_multiple(struct Db *self,DBT *key,DBT *data){ 3055 return self->sort_multiple(self, key, data, 0); 3056 } 3057SWIGINTERN void *Db_stat(struct Db *self,DB_TXN *txnid,u_int32_t flags){ 3058 void *statp = NULL; 3059 errno = self->stat(self, txnid, &statp, flags); 3060 return statp; 3061 } 3062SWIGINTERN db_ret_t Db_sync(struct Db *self,u_int32_t flags){ 3063 return self->sync(self, flags); 3064 } 3065SWIGINTERN int Db_truncate(struct Db *self,DB_TXN *txnid,u_int32_t flags){ 3066 u_int32_t count = 0; 3067 errno = self->truncate(self, txnid, &count, flags); 3068 return count; 3069 } 3070SWIGINTERN db_ret_t Db_upgrade(struct Db *self,char const *file,u_int32_t flags){ 3071 return self->upgrade(self, file, flags); 3072 } 3073SWIGINTERN int_bool Db_verify(struct Db *self,char const *file,char const *database,struct __db_out_stream outfile,u_int32_t flags){ 3074 /* 3075 * We can't easily #include "dbinc/db_ext.h" because of name 3076 * clashes, so we declare this explicitly. 3077 */ 3078 extern int __db_verify_internal __P((DB *, const char *, const 3079 char *, void *, int (*)(void *, const void *), u_int32_t)); 3080 errno = __db_verify_internal(self, file, database, 3081 outfile.handle, outfile.callback, flags); 3082 if (errno == DB_VERIFY_BAD) { 3083 errno = 0; 3084 return 0; 3085 } else 3086 return 1; 3087 } 3088SWIGINTERN db_ret_t Dbc_close(struct Dbc *self){ 3089 return self->close(self); 3090 } 3091SWIGINTERN int Dbc_cmp(struct Dbc *self,DBC *odbc,u_int32_t flags){ 3092 int result = 0; 3093 errno = self->cmp(self, odbc, &result, flags); 3094 return result; 3095 } 3096SWIGINTERN db_recno_t Dbc_count(struct Dbc *self,u_int32_t flags){ 3097 db_recno_t count = 0; 3098 errno = self->count(self, &count, flags); 3099 return count; 3100 } 3101SWIGINTERN int Dbc_del(struct Dbc *self,u_int32_t flags){ 3102 return self->del(self, flags); 3103 } 3104SWIGINTERN DBC *Dbc_dup(struct Dbc *self,u_int32_t flags){ 3105 DBC *newcurs = NULL; 3106 errno = self->dup(self, &newcurs, flags); 3107 return newcurs; 3108 } 3109SWIGINTERN int Dbc_get(struct Dbc *self,DBT *key,DBT *data,u_int32_t flags){ 3110 return self->get(self, key, data, flags); 3111 } 3112SWIGINTERN DB_CACHE_PRIORITY Dbc_get_priority(struct Dbc *self){ 3113 DB_CACHE_PRIORITY ret; 3114 errno = self->get_priority(self, &ret); 3115 return ret; 3116 } 3117SWIGINTERN int Dbc_pget(struct Dbc *self,DBT *key,DBT *pkey,DBT *data,u_int32_t flags){ 3118 return self->pget(self, key, pkey, data, flags); 3119 } 3120SWIGINTERN int Dbc_put(struct Dbc *self,DBT *key,DBT *db_put_data,u_int32_t flags){ 3121 return self->put(self, key, db_put_data, flags); 3122 } 3123SWIGINTERN db_ret_t Dbc_set_priority(struct Dbc *self,DB_CACHE_PRIORITY priority){ 3124 return self->set_priority(self, priority); 3125 } 3126SWIGINTERN struct DbEnv *new_DbEnv(u_int32_t flags){ 3127 DB_ENV *self = NULL; 3128 errno = db_env_create(&self, flags); 3129 if (errno == 0) 3130 self->env->dbt_usercopy = __dbj_dbt_memcopy; 3131 return self; 3132 } 3133SWIGINTERN db_ret_t DbEnv_close(struct DbEnv *self,u_int32_t flags){ 3134 return self->close(self, flags); 3135 } 3136SWIGINTERN db_ret_t DbEnv_dbremove(struct DbEnv *self,DB_TXN *txnid,char const *file,char const *database,u_int32_t flags){ 3137 return self->dbremove(self, txnid, file, database, flags); 3138 } 3139SWIGINTERN db_ret_t DbEnv_dbrename(struct DbEnv *self,DB_TXN *txnid,char const *file,char const *database,char const *newname,u_int32_t flags){ 3140 return self->dbrename(self, 3141 txnid, file, database, newname, flags); 3142 } 3143SWIGINTERN void DbEnv_err(struct DbEnv *self,int error,char const *message){ 3144 self->err(self, error, message); 3145 } 3146SWIGINTERN void DbEnv_errx(struct DbEnv *self,char const *message){ 3147 self->errx(self, message); 3148 } 3149SWIGINTERN DB_TXN *DbEnv_cdsgroup_begin(struct DbEnv *self){ 3150 DB_TXN *tid = NULL; 3151 errno = self->cdsgroup_begin(self, &tid); 3152 return tid; 3153 } 3154SWIGINTERN db_ret_t DbEnv_fileid_reset(struct DbEnv *self,char const *file,u_int32_t flags){ 3155 return self->fileid_reset(self, file, flags); 3156 } 3157SWIGINTERN char const **DbEnv_get_data_dirs(struct DbEnv *self){ 3158 const char **ret; 3159 errno = self->get_data_dirs(self, &ret); 3160 return ret; 3161 } 3162SWIGINTERN u_int32_t DbEnv_get_encrypt_flags(struct DbEnv *self){ 3163 u_int32_t ret = 0; 3164 CRYPTO_ONLY(errno = self->get_encrypt_flags(self, &ret)) 3165 return ret; 3166 } 3167SWIGINTERN u_int32_t DbEnv_get_flags(struct DbEnv *self){ 3168 u_int32_t ret; 3169 errno = self->get_flags(self, &ret); 3170 return ret; 3171 } 3172SWIGINTERN char const *DbEnv_get_home(struct DbEnv *self){ 3173 const char *ret; 3174 errno = self->get_home(self, &ret); 3175 return ret; 3176 } 3177SWIGINTERN char const *DbEnv_get_intermediate_dir_mode(struct DbEnv *self){ 3178 const char *ret; 3179 errno = self->get_intermediate_dir_mode(self, &ret); 3180 return ret; 3181 } 3182SWIGINTERN u_int32_t DbEnv_get_open_flags(struct DbEnv *self){ 3183 u_int32_t ret; 3184 errno = self->get_open_flags(self, &ret); 3185 return ret; 3186 } 3187SWIGINTERN long DbEnv_get_shm_key(struct DbEnv *self){ 3188 long ret; 3189 errno = self->get_shm_key(self, &ret); 3190 return ret; 3191 } 3192SWIGINTERN char const *DbEnv_get_tmp_dir(struct DbEnv *self){ 3193 const char *ret; 3194 errno = self->get_tmp_dir(self, &ret); 3195 return ret; 3196 } 3197SWIGINTERN int_bool DbEnv_get_verbose(struct DbEnv *self,u_int32_t which){ 3198 int ret; 3199 errno = self->get_verbose(self, which, &ret); 3200 return ret; 3201 } 3202SWIGINTERN int_bool DbEnv_is_bigendian(struct DbEnv *self){ 3203 return self->is_bigendian(); 3204 } 3205SWIGINTERN db_ret_t DbEnv_lsn_reset(struct DbEnv *self,char const *file,u_int32_t flags){ 3206 return self->lsn_reset(self, file, flags); 3207 } 3208SWIGINTERN db_ret_t DbEnv_open(struct DbEnv *self,char const *db_home,u_int32_t flags,int mode){ 3209 return self->open(self, db_home, flags, mode); 3210 } 3211SWIGINTERN db_ret_t DbEnv_remove(struct DbEnv *self,char const *db_home,u_int32_t flags){ 3212 return self->remove(self, db_home, flags); 3213 } 3214SWIGINTERN db_ret_t DbEnv_set_cachesize(struct DbEnv *self,jlong bytes,int ncache){ 3215 return self->set_cachesize(self, 3216 (u_int32_t)(bytes / GIGABYTE), 3217 (u_int32_t)(bytes % GIGABYTE), ncache); 3218 } 3219SWIGINTERN db_ret_t DbEnv_set_cache_max(struct DbEnv *self,jlong bytes){ 3220 return self->set_cache_max(self, 3221 (u_int32_t)(bytes / GIGABYTE), 3222 (u_int32_t)(bytes % GIGABYTE)); 3223 } 3224SWIGINTERN db_ret_t DbEnv_set_create_dir(struct DbEnv *self,char const *dir){ 3225 return self->set_create_dir(self, dir); 3226 } 3227SWIGINTERN db_ret_t DbEnv_set_data_dir(struct DbEnv *self,char const *dir){ 3228 return self->set_data_dir(self, dir); 3229 } 3230SWIGINTERN db_ret_t DbEnv_set_intermediate_dir_mode(struct DbEnv *self,char const *mode){ 3231 return self->set_intermediate_dir_mode(self, mode); 3232 } 3233SWIGINTERN db_ret_t DbEnv_set_encrypt(struct DbEnv *self,char const *passwd,u_int32_t flags){ 3234 return self->set_encrypt(self, passwd, flags); 3235 } 3236SWIGINTERN void DbEnv_set_errcall(struct DbEnv *self,void (*db_errcall_fcn)(DB_ENV const *,char const *,char const *)){ 3237 self->set_errcall(self, db_errcall_fcn); 3238 } 3239SWIGINTERN db_ret_t DbEnv_set_flags(struct DbEnv *self,u_int32_t flags,int_bool onoff){ 3240 return self->set_flags(self, flags, onoff); 3241 } 3242SWIGINTERN db_ret_t DbEnv_set_feedback(struct DbEnv *self,void (*env_feedback_fcn)(DB_ENV *,int,int)){ 3243 return self->set_feedback(self, env_feedback_fcn); 3244 } 3245SWIGINTERN db_ret_t DbEnv_set_mp_max_openfd(struct DbEnv *self,int maxopenfd){ 3246 return self->set_mp_max_openfd(self, maxopenfd); 3247 } 3248SWIGINTERN db_ret_t DbEnv_set_mp_max_write(struct DbEnv *self,int maxwrite,db_timeout_t maxwrite_sleep){ 3249 return self->set_mp_max_write(self, maxwrite, maxwrite_sleep); 3250 } 3251SWIGINTERN db_ret_t DbEnv_set_mp_mmapsize(struct DbEnv *self,size_t mp_mmapsize){ 3252 return self->set_mp_mmapsize(self, mp_mmapsize); 3253 } 3254SWIGINTERN db_ret_t DbEnv_set_mp_pagesize(struct DbEnv *self,size_t mp_pagesize){ 3255 return self->set_mp_pagesize(self, mp_pagesize); 3256 } 3257SWIGINTERN db_ret_t DbEnv_set_mp_tablesize(struct DbEnv *self,size_t mp_tablesize){ 3258 return self->set_mp_tablesize(self, mp_tablesize); 3259 } 3260SWIGINTERN void DbEnv_set_msgcall(struct DbEnv *self,void (*db_msgcall_fcn)(DB_ENV const *,char const *)){ 3261 self->set_msgcall(self, db_msgcall_fcn); 3262 } 3263SWIGINTERN db_ret_t DbEnv_set_paniccall(struct DbEnv *self,void (*db_panic_fcn)(DB_ENV *,int)){ 3264 return self->set_paniccall(self, db_panic_fcn); 3265 } 3266SWIGINTERN db_ret_t DbEnv_set_rpc_server(struct DbEnv *self,char *host,long cl_timeout,long sv_timeout,u_int32_t flags){ 3267 return self->set_rpc_server(self, NULL, host, 3268 cl_timeout, sv_timeout, flags); 3269 } 3270SWIGINTERN db_ret_t DbEnv_set_shm_key(struct DbEnv *self,long shm_key){ 3271 return self->set_shm_key(self, shm_key); 3272 } 3273SWIGINTERN db_ret_t DbEnv_set_timeout(struct DbEnv *self,db_timeout_t timeout,u_int32_t flags){ 3274 return self->set_timeout(self, timeout, flags); 3275 } 3276SWIGINTERN db_ret_t DbEnv_set_tmp_dir(struct DbEnv *self,char const *dir){ 3277 return self->set_tmp_dir(self, dir); 3278 } 3279SWIGINTERN db_ret_t DbEnv_set_tx_max(struct DbEnv *self,u_int32_t max){ 3280 return self->set_tx_max(self, max); 3281 } 3282SWIGINTERN db_ret_t DbEnv_set_app_dispatch(struct DbEnv *self,int (*tx_recover)(DB_ENV *,DBT *,DB_LSN *,db_recops)){ 3283 return self->set_app_dispatch(self, tx_recover); 3284 } 3285SWIGINTERN db_ret_t DbEnv_set_event_notify(struct DbEnv *self,void (*event_notify)(DB_ENV *,u_int32_t,void *)){ 3286 return self->set_event_notify(self, event_notify); 3287 } 3288SWIGINTERN db_ret_t DbEnv_set_tx_timestamp(struct DbEnv *self,time_t *timestamp){ 3289 return self->set_tx_timestamp(self, timestamp); 3290 } 3291SWIGINTERN db_ret_t DbEnv_set_verbose(struct DbEnv *self,u_int32_t which,int_bool onoff){ 3292 return self->set_verbose(self, which, onoff); 3293 } 3294SWIGINTERN struct __db_lk_conflicts DbEnv_get_lk_conflicts(struct DbEnv *self){ 3295 struct __db_lk_conflicts ret; 3296 errno = self->get_lk_conflicts(self, 3297 (const u_int8_t **)&ret.lk_conflicts, &ret.lk_modes); 3298 return ret; 3299 } 3300SWIGINTERN u_int32_t DbEnv_get_lk_detect(struct DbEnv *self){ 3301 u_int32_t ret; 3302 errno = self->get_lk_detect(self, &ret); 3303 return ret; 3304 } 3305SWIGINTERN u_int32_t DbEnv_get_lk_max_locks(struct DbEnv *self){ 3306 u_int32_t ret; 3307 errno = self->get_lk_max_locks(self, &ret); 3308 return ret; 3309 } 3310SWIGINTERN u_int32_t DbEnv_get_lk_max_lockers(struct DbEnv *self){ 3311 u_int32_t ret; 3312 errno = self->get_lk_max_lockers(self, &ret); 3313 return ret; 3314 } 3315SWIGINTERN u_int32_t DbEnv_get_lk_max_objects(struct DbEnv *self){ 3316 u_int32_t ret; 3317 errno = self->get_lk_max_objects(self, &ret); 3318 return ret; 3319 } 3320SWIGINTERN u_int32_t DbEnv_get_lk_partitions(struct DbEnv *self){ 3321 u_int32_t ret; 3322 errno = self->get_lk_partitions(self, &ret); 3323 return ret; 3324 } 3325SWIGINTERN int DbEnv_lock_detect(struct DbEnv *self,u_int32_t flags,u_int32_t atype){ 3326 int aborted; 3327 errno = self->lock_detect(self, flags, atype, &aborted); 3328 return aborted; 3329 } 3330SWIGINTERN DB_LOCK *DbEnv_lock_get(struct DbEnv *self,u_int32_t locker,u_int32_t flags,DBT *object,db_lockmode_t lock_mode){ 3331 DB_LOCK *lock = NULL; 3332 if ((errno = __os_malloc(self->env, sizeof (DB_LOCK), &lock)) == 0) 3333 errno = self->lock_get(self, locker, flags, object, 3334 lock_mode, lock); 3335 return lock; 3336 } 3337SWIGINTERN u_int32_t DbEnv_lock_id(struct DbEnv *self){ 3338 u_int32_t id; 3339 errno = self->lock_id(self, &id); 3340 return id; 3341 } 3342SWIGINTERN db_ret_t DbEnv_lock_id_free(struct DbEnv *self,u_int32_t id){ 3343 return self->lock_id_free(self, id); 3344 } 3345SWIGINTERN db_ret_t DbEnv_lock_put(struct DbEnv *self,DB_LOCK *lock){ 3346 return self->lock_put(self, lock); 3347 } 3348SWIGINTERN DB_LOCK_STAT *DbEnv_lock_stat(struct DbEnv *self,u_int32_t flags){ 3349 DB_LOCK_STAT *statp = NULL; 3350 errno = self->lock_stat(self, &statp, flags); 3351 return statp; 3352 } 3353SWIGINTERN db_ret_t DbEnv_set_lk_conflicts(struct DbEnv *self,struct __db_lk_conflicts conflicts){ 3354 return self->set_lk_conflicts(self, 3355 conflicts.lk_conflicts, conflicts.lk_modes); 3356 } 3357SWIGINTERN db_ret_t DbEnv_set_lk_detect(struct DbEnv *self,u_int32_t detect){ 3358 return self->set_lk_detect(self, detect); 3359 } 3360SWIGINTERN db_ret_t DbEnv_set_lk_max_lockers(struct DbEnv *self,u_int32_t max){ 3361 return self->set_lk_max_lockers(self, max); 3362 } 3363SWIGINTERN db_ret_t DbEnv_set_lk_max_locks(struct DbEnv *self,u_int32_t max){ 3364 return self->set_lk_max_locks(self, max); 3365 } 3366SWIGINTERN db_ret_t DbEnv_set_lk_max_objects(struct DbEnv *self,u_int32_t max){ 3367 return self->set_lk_max_objects(self, max); 3368 } 3369SWIGINTERN db_ret_t DbEnv_set_lk_partitions(struct DbEnv *self,u_int32_t partitions){ 3370 return self->set_lk_partitions(self, partitions); 3371 } 3372SWIGINTERN u_int32_t DbEnv_get_lg_bsize(struct DbEnv *self){ 3373 u_int32_t ret; 3374 errno = self->get_lg_bsize(self, &ret); 3375 return ret; 3376 } 3377SWIGINTERN char const *DbEnv_get_lg_dir(struct DbEnv *self){ 3378 const char *ret; 3379 errno = self->get_lg_dir(self, &ret); 3380 return ret; 3381 } 3382SWIGINTERN int DbEnv_get_lg_filemode(struct DbEnv *self){ 3383 int ret; 3384 errno = self->get_lg_filemode(self, &ret); 3385 return ret; 3386 } 3387SWIGINTERN u_int32_t DbEnv_get_lg_max(struct DbEnv *self){ 3388 u_int32_t ret; 3389 errno = self->get_lg_max(self, &ret); 3390 return ret; 3391 } 3392SWIGINTERN u_int32_t DbEnv_get_lg_regionmax(struct DbEnv *self){ 3393 u_int32_t ret; 3394 errno = self->get_lg_regionmax(self, &ret); 3395 return ret; 3396 } 3397SWIGINTERN char **DbEnv_log_archive(struct DbEnv *self,u_int32_t flags){ 3398 char **list = NULL; 3399 errno = self->log_archive(self, &list, flags); 3400 return list; 3401 } 3402SWIGINTERN int DbEnv_log_compare(DB_LSN const *lsn0,DB_LSN const *lsn1){ 3403 return log_compare(lsn0, lsn1); 3404 } 3405SWIGINTERN DB_LOGC *DbEnv_log_cursor(struct DbEnv *self,u_int32_t flags){ 3406 DB_LOGC *cursor = NULL; 3407 errno = self->log_cursor(self, &cursor, flags); 3408 return cursor; 3409 } 3410SWIGINTERN char *DbEnv_log_file(struct DbEnv *self,DB_LSN *lsn){ 3411 char namebuf[DB_MAXPATHLEN]; 3412 errno = self->log_file(self, lsn, namebuf, sizeof namebuf); 3413 return (errno == 0) ? strdup(namebuf) : NULL; 3414 } 3415SWIGINTERN db_ret_t DbEnv_log_flush(struct DbEnv *self,DB_LSN const *lsn_or_null){ 3416 return self->log_flush(self, lsn_or_null); 3417 } 3418SWIGINTERN int_bool DbEnv_log_get_config(struct DbEnv *self,u_int32_t which){ 3419 int ret; 3420 errno = self->log_get_config(self, which, &ret); 3421 return ret; 3422 } 3423SWIGINTERN db_ret_t DbEnv_log_put(struct DbEnv *self,DB_LSN *lsn,DBT const *data,u_int32_t flags){ 3424 return self->log_put(self, lsn, data, flags); 3425 } 3426SWIGINTERN db_ret_t DbEnv_log_print(struct DbEnv *self,DB_TXN *txn,char const *msg){ 3427 return self->log_printf(self, txn, "%s", msg); 3428 } 3429SWIGINTERN db_ret_t DbEnv_log_set_config(struct DbEnv *self,u_int32_t which,int_bool onoff){ 3430 return self->log_set_config(self, which, onoff); 3431 } 3432SWIGINTERN DB_LOG_STAT *DbEnv_log_stat(struct DbEnv *self,u_int32_t flags){ 3433 DB_LOG_STAT *sp = NULL; 3434 errno = self->log_stat(self, &sp, flags); 3435 return sp; 3436 } 3437SWIGINTERN db_ret_t DbEnv_set_lg_bsize(struct DbEnv *self,u_int32_t lg_bsize){ 3438 return self->set_lg_bsize(self, lg_bsize); 3439 } 3440SWIGINTERN db_ret_t DbEnv_set_lg_dir(struct DbEnv *self,char const *dir){ 3441 return self->set_lg_dir(self, dir); 3442 } 3443SWIGINTERN db_ret_t DbEnv_set_lg_filemode(struct DbEnv *self,int mode){ 3444 return self->set_lg_filemode(self, mode); 3445 } 3446SWIGINTERN db_ret_t DbEnv_set_lg_max(struct DbEnv *self,u_int32_t lg_max){ 3447 return self->set_lg_max(self, lg_max); 3448 } 3449SWIGINTERN db_ret_t DbEnv_set_lg_regionmax(struct DbEnv *self,u_int32_t lg_regionmax){ 3450 return self->set_lg_regionmax(self, lg_regionmax); 3451 } 3452SWIGINTERN jlong DbEnv_get_cachesize(struct DbEnv *self){ 3453 u_int32_t gbytes, bytes; 3454 errno = self->get_cachesize(self, &gbytes, &bytes, NULL); 3455 return (jlong)gbytes * GIGABYTE + bytes; 3456 } 3457SWIGINTERN int DbEnv_get_cachesize_ncache(struct DbEnv *self){ 3458 int ret; 3459 errno = self->get_cachesize(self, NULL, NULL, &ret); 3460 return ret; 3461 } 3462SWIGINTERN jlong DbEnv_get_cache_max(struct DbEnv *self){ 3463 u_int32_t gbytes, bytes; 3464 errno = self->get_cache_max(self, &gbytes, &bytes); 3465 return (jlong)gbytes * GIGABYTE + bytes; 3466 } 3467SWIGINTERN char const *DbEnv_get_create_dir(struct DbEnv *self){ 3468 const char *ret; 3469 errno = self->get_create_dir(self, &ret); 3470 return ret; 3471 } 3472SWIGINTERN int DbEnv_get_mp_max_openfd(struct DbEnv *self){ 3473 int ret; 3474 errno = self->get_mp_max_openfd(self, &ret); 3475 return ret; 3476 } 3477SWIGINTERN int DbEnv_get_mp_max_write(struct DbEnv *self){ 3478 int maxwrite; 3479 db_timeout_t sleep; 3480 errno = self->get_mp_max_write(self, &maxwrite, &sleep); 3481 return maxwrite; 3482 } 3483SWIGINTERN db_timeout_t DbEnv_get_mp_max_write_sleep(struct DbEnv *self){ 3484 int maxwrite; 3485 db_timeout_t sleep; 3486 errno = self->get_mp_max_write(self, &maxwrite, &sleep); 3487 return sleep; 3488 } 3489SWIGINTERN size_t DbEnv_get_mp_mmapsize(struct DbEnv *self){ 3490 size_t ret; 3491 errno = self->get_mp_mmapsize(self, &ret); 3492 return ret; 3493 } 3494SWIGINTERN int DbEnv_get_mp_pagesize(struct DbEnv *self){ 3495 int ret; 3496 errno = self->get_mp_pagesize(self, &ret); 3497 return ret; 3498 } 3499SWIGINTERN int DbEnv_get_mp_tablesize(struct DbEnv *self){ 3500 int ret; 3501 errno = self->get_mp_tablesize(self, &ret); 3502 return ret; 3503 } 3504SWIGINTERN DB_MPOOL_STAT *DbEnv_memp_stat(struct DbEnv *self,u_int32_t flags){ 3505 DB_MPOOL_STAT *mp_stat = NULL; 3506 errno = self->memp_stat(self, &mp_stat, NULL, flags); 3507 return mp_stat; 3508 } 3509SWIGINTERN DB_MPOOL_FSTAT **DbEnv_memp_fstat(struct DbEnv *self,u_int32_t flags){ 3510 DB_MPOOL_FSTAT **mp_fstat = NULL; 3511 errno = self->memp_stat(self, NULL, &mp_fstat, flags); 3512 return mp_fstat; 3513 } 3514SWIGINTERN db_ret_t DbEnv_memp_sync(struct DbEnv *self,DB_LSN *lsn){ 3515 return self->memp_sync(self, lsn); 3516 } 3517SWIGINTERN int DbEnv_memp_trickle(struct DbEnv *self,int percent){ 3518 int ret; 3519 errno = self->memp_trickle(self, percent, &ret); 3520 return ret; 3521 } 3522SWIGINTERN u_int32_t DbEnv_mutex_get_align(struct DbEnv *self){ 3523 u_int32_t ret; 3524 errno = self->mutex_get_align(self, &ret); 3525 return ret; 3526 } 3527SWIGINTERN u_int32_t DbEnv_mutex_get_increment(struct DbEnv *self){ 3528 u_int32_t ret; 3529 errno = self->mutex_get_increment(self, &ret); 3530 return ret; 3531 } 3532SWIGINTERN u_int32_t DbEnv_mutex_get_max(struct DbEnv *self){ 3533 u_int32_t ret; 3534 errno = self->mutex_get_max(self, &ret); 3535 return ret; 3536 } 3537SWIGINTERN u_int32_t DbEnv_mutex_get_tas_spins(struct DbEnv *self){ 3538 u_int32_t ret; 3539 errno = self->mutex_get_tas_spins(self, &ret); 3540 return ret; 3541 } 3542SWIGINTERN db_ret_t DbEnv_mutex_set_align(struct DbEnv *self,u_int32_t align){ 3543 return self->mutex_set_align(self, align); 3544 } 3545SWIGINTERN db_ret_t DbEnv_mutex_set_increment(struct DbEnv *self,u_int32_t increment){ 3546 return self->mutex_set_increment(self, increment); 3547 } 3548SWIGINTERN db_ret_t DbEnv_mutex_set_max(struct DbEnv *self,u_int32_t mutex_max){ 3549 return self->mutex_set_max(self, mutex_max); 3550 } 3551SWIGINTERN db_ret_t DbEnv_mutex_set_tas_spins(struct DbEnv *self,u_int32_t tas_spins){ 3552 return self->mutex_set_tas_spins(self, tas_spins); 3553 } 3554SWIGINTERN DB_MUTEX_STAT *DbEnv_mutex_stat(struct DbEnv *self,u_int32_t flags){ 3555 DB_MUTEX_STAT *statp = NULL; 3556 errno = self->mutex_stat(self, &statp, flags); 3557 return statp; 3558 } 3559SWIGINTERN u_int32_t DbEnv_get_tx_max(struct DbEnv *self){ 3560 u_int32_t ret; 3561 errno = self->get_tx_max(self, &ret); 3562 return ret; 3563 } 3564SWIGINTERN time_t DbEnv_get_tx_timestamp(struct DbEnv *self){ 3565 time_t ret; 3566 errno = self->get_tx_timestamp(self, &ret); 3567 return ret; 3568 } 3569SWIGINTERN db_timeout_t DbEnv_get_timeout(struct DbEnv *self,u_int32_t flag){ 3570 db_timeout_t ret; 3571 errno = self->get_timeout(self, &ret, flag); 3572 return ret; 3573 } 3574SWIGINTERN DB_TXN *DbEnv_txn_begin(struct DbEnv *self,DB_TXN *parent,u_int32_t flags){ 3575 DB_TXN *tid = NULL; 3576 errno = self->txn_begin(self, parent, &tid, flags); 3577 return tid; 3578 } 3579SWIGINTERN db_ret_t DbEnv_txn_checkpoint(struct DbEnv *self,u_int32_t kbyte,u_int32_t min,u_int32_t flags){ 3580 return self->txn_checkpoint(self, kbyte, min, flags); 3581 } 3582SWIGINTERN DB_PREPLIST *DbEnv_txn_recover(struct DbEnv *self,int count,u_int32_t flags){ 3583 DB_PREPLIST *preplist; 3584 u_int32_t retcount; 3585 3586 /* Add a NULL element to terminate the array. */ 3587 if ((errno = __os_malloc(self->env, 3588 (count + 1) * sizeof(DB_PREPLIST), &preplist)) != 0) 3589 return NULL; 3590 3591 if ((errno = self->txn_recover(self, preplist, count, 3592 &retcount, flags)) != 0) { 3593 __os_free(self->env, preplist); 3594 return NULL; 3595 } 3596 3597 preplist[retcount].txn = NULL; 3598 return preplist; 3599 } 3600SWIGINTERN DB_TXN_STAT *DbEnv_txn_stat(struct DbEnv *self,u_int32_t flags){ 3601 DB_TXN_STAT *statp = NULL; 3602 errno = self->txn_stat(self, &statp, flags); 3603 return statp; 3604 } 3605SWIGINTERN jlong DbEnv_rep_get_limit(struct DbEnv *self){ 3606 u_int32_t gbytes, bytes; 3607 errno = self->rep_get_limit(self, &gbytes, &bytes); 3608 return (jlong)gbytes * GIGABYTE + bytes; 3609 } 3610SWIGINTERN db_ret_t DbEnv_rep_elect(struct DbEnv *self,u_int32_t nsites,int nvotes,u_int32_t flags){ 3611 return self->rep_elect(self, nsites, nvotes, flags); 3612 } 3613SWIGINTERN int DbEnv_rep_process_message(struct DbEnv *self,DBT *control,DBT *rec,int envid,DB_LSN *ret_lsn){ 3614 return self->rep_process_message(self, control, rec, envid, 3615 ret_lsn); 3616 } 3617SWIGINTERN db_ret_t DbEnv_rep_flush(struct DbEnv *self){ 3618 return self->rep_flush(self); 3619 } 3620SWIGINTERN db_ret_t DbEnv_rep_set_config(struct DbEnv *self,u_int32_t which,int_bool onoff){ 3621 return self->rep_set_config(self, which, onoff); 3622 } 3623SWIGINTERN db_ret_t DbEnv_rep_set_clockskew(struct DbEnv *self,u_int32_t fast_clock,u_int32_t slow_clock){ 3624 return self->rep_set_clockskew(self, fast_clock, slow_clock); 3625 } 3626SWIGINTERN u_int32_t DbEnv_rep_get_clockskew_fast(struct DbEnv *self){ 3627 u_int32_t fast_clock, slow_clock; 3628 errno = self->rep_get_clockskew(self, &fast_clock, &slow_clock); 3629 return fast_clock; 3630 } 3631SWIGINTERN u_int32_t DbEnv_rep_get_clockskew_slow(struct DbEnv *self){ 3632 u_int32_t fast_clock, slow_clock; 3633 errno = self->rep_get_clockskew(self, &fast_clock, &slow_clock); 3634 return slow_clock; 3635 } 3636SWIGINTERN db_ret_t DbEnv_rep_start(struct DbEnv *self,DBT *cdata,u_int32_t flags){ 3637 return self->rep_start(self, cdata, flags); 3638 } 3639SWIGINTERN db_ret_t DbEnv_rep_sync(struct DbEnv *self,u_int32_t flags){ 3640 return self->rep_sync(self, flags); 3641 } 3642SWIGINTERN int_bool DbEnv_rep_get_config(struct DbEnv *self,u_int32_t which){ 3643 int ret; 3644 errno = self->rep_get_config(self, which, &ret); 3645 return ret; 3646 } 3647SWIGINTERN DB_REP_STAT *DbEnv_rep_stat(struct DbEnv *self,u_int32_t flags){ 3648 DB_REP_STAT *statp = NULL; 3649 errno = self->rep_stat(self, &statp, flags); 3650 return statp; 3651 } 3652SWIGINTERN db_ret_t DbEnv_rep_set_limit(struct DbEnv *self,jlong bytes){ 3653 return self->rep_set_limit(self, 3654 (u_int32_t)(bytes / GIGABYTE), 3655 (u_int32_t)(bytes % GIGABYTE)); 3656 } 3657SWIGINTERN u_int32_t DbEnv_rep_get_request_min(struct DbEnv *self){ 3658 u_int32_t min, max; 3659 errno = self->rep_get_request(self, &min, &max); 3660 return min; 3661 } 3662SWIGINTERN u_int32_t DbEnv_rep_get_request_max(struct DbEnv *self){ 3663 u_int32_t min, max; 3664 errno = self->rep_get_request(self, &min, &max); 3665 return max; 3666 } 3667SWIGINTERN db_ret_t DbEnv_rep_set_request(struct DbEnv *self,u_int32_t min,u_int32_t max){ 3668 return self->rep_set_request(self, min, max); 3669 } 3670SWIGINTERN db_ret_t DbEnv_rep_set_transport(struct DbEnv *self,int envid,int (*send)(DB_ENV *,DBT const *,DBT const *,DB_LSN const *,int,u_int32_t)){ 3671 return self->rep_set_transport(self, envid, send); 3672 } 3673SWIGINTERN u_int32_t DbEnv_rep_get_nsites(struct DbEnv *self){ 3674 u_int32_t ret; 3675 errno = self->rep_get_nsites(self, &ret); 3676 return ret; 3677 } 3678SWIGINTERN u_int32_t DbEnv_rep_get_priority(struct DbEnv *self){ 3679 u_int32_t ret; 3680 errno = self->rep_get_priority(self, &ret); 3681 return ret; 3682 } 3683SWIGINTERN u_int32_t DbEnv_rep_get_timeout(struct DbEnv *self,int which){ 3684 u_int32_t ret; 3685 errno = self->rep_get_timeout(self, which, &ret); 3686 return ret; 3687 } 3688SWIGINTERN db_ret_t DbEnv_rep_set_nsites(struct DbEnv *self,u_int32_t number){ 3689 return self->rep_set_nsites(self, number); 3690 } 3691SWIGINTERN db_ret_t DbEnv_rep_set_priority(struct DbEnv *self,u_int32_t priority){ 3692 return self->rep_set_priority(self, priority); 3693 } 3694SWIGINTERN db_ret_t DbEnv_rep_set_timeout(struct DbEnv *self,int which,db_timeout_t timeout){ 3695 return self->rep_set_timeout(self, which, timeout); 3696 } 3697SWIGINTERN int DbEnv_repmgr_add_remote_site(struct DbEnv *self,char const *host,u_int32_t port,u_int32_t flags){ 3698 int eid; 3699 errno = self->repmgr_add_remote_site(self, host, port, &eid, flags); 3700 return eid; 3701 } 3702SWIGINTERN db_ret_t DbEnv_repmgr_get_ack_policy(struct DbEnv *self){ 3703 int ret; 3704 errno = self->repmgr_get_ack_policy(self, &ret); 3705 return ret; 3706 } 3707SWIGINTERN db_ret_t DbEnv_repmgr_set_ack_policy(struct DbEnv *self,int policy){ 3708 return self->repmgr_set_ack_policy(self, policy); 3709 } 3710SWIGINTERN db_ret_t DbEnv_repmgr_set_local_site(struct DbEnv *self,char const *host,u_int32_t port,u_int32_t flags){ 3711 return self->repmgr_set_local_site(self, host, port, flags); 3712 } 3713SWIGINTERN struct __db_repmgr_sites DbEnv_repmgr_site_list(struct DbEnv *self){ 3714 struct __db_repmgr_sites sites; 3715 errno = self->repmgr_site_list(self, 3716 &sites.nsites, &sites.sites); 3717 return sites; 3718 } 3719SWIGINTERN db_ret_t DbEnv_repmgr_start(struct DbEnv *self,int nthreads,u_int32_t flags){ 3720 return self->repmgr_start(self, nthreads, flags); 3721 } 3722SWIGINTERN DB_REPMGR_STAT *DbEnv_repmgr_stat(struct DbEnv *self,u_int32_t flags){ 3723 DB_REPMGR_STAT *statp = NULL; 3724 errno = self->repmgr_stat(self, &statp, flags); 3725 return statp; 3726 } 3727SWIGINTERN char const *DbEnv_strerror(int error){ 3728 return db_strerror(error); 3729 } 3730SWIGINTERN int DbEnv_get_version_major(){ 3731 return DB_VERSION_MAJOR; 3732 } 3733SWIGINTERN int DbEnv_get_version_minor(){ 3734 return DB_VERSION_MINOR; 3735 } 3736SWIGINTERN int DbEnv_get_version_patch(){ 3737 return DB_VERSION_PATCH; 3738 } 3739SWIGINTERN char const *DbEnv_get_version_string(){ 3740 return DB_VERSION_STRING; 3741 } 3742SWIGINTERN void delete_DbLock(struct DbLock *self){ 3743 __os_free(NULL, self); 3744 } 3745SWIGINTERN db_ret_t DbLogc_close(struct DbLogc *self,u_int32_t flags){ 3746 return self->close(self, flags); 3747 } 3748SWIGINTERN int DbLogc_get(struct DbLogc *self,DB_LSN *lsn,DBT *data,u_int32_t flags){ 3749 return self->get(self, lsn, data, flags); 3750 } 3751SWIGINTERN u_int32_t DbLogc_version(struct DbLogc *self,u_int32_t flags){ 3752 u_int32_t result; 3753 errno = self->version(self, &result, flags); 3754 return result; 3755 } 3756SWIGINTERN DB_CACHE_PRIORITY DbMpoolFile_get_priority(struct DbMpoolFile *self){ 3757 DB_CACHE_PRIORITY ret; 3758 errno = self->get_priority(self, &ret); 3759 return ret; 3760 } 3761SWIGINTERN db_ret_t DbMpoolFile_set_priority(struct DbMpoolFile *self,DB_CACHE_PRIORITY priority){ 3762 return self->set_priority(self, priority); 3763 } 3764SWIGINTERN u_int32_t DbMpoolFile_get_flags(struct DbMpoolFile *self){ 3765 u_int32_t ret; 3766 errno = self->get_flags(self, &ret); 3767 return ret; 3768 } 3769SWIGINTERN db_ret_t DbMpoolFile_set_flags(struct DbMpoolFile *self,u_int32_t flags,int_bool onoff){ 3770 return self->set_flags(self, flags, onoff); 3771 } 3772SWIGINTERN jlong DbMpoolFile_get_maxsize(struct DbMpoolFile *self){ 3773 u_int32_t gbytes, bytes; 3774 errno = self->get_maxsize(self, &gbytes, &bytes); 3775 return (jlong)gbytes * GIGABYTE + bytes; 3776 } 3777SWIGINTERN db_ret_t DbMpoolFile_set_maxsize(struct DbMpoolFile *self,jlong bytes){ 3778 return self->set_maxsize(self, 3779 (u_int32_t)(bytes / GIGABYTE), 3780 (u_int32_t)(bytes % GIGABYTE)); 3781 } 3782SWIGINTERN struct DbSequence *new_DbSequence(DB *db,u_int32_t flags){ 3783 DB_SEQUENCE *self = NULL; 3784 errno = db_sequence_create(&self, db, flags); 3785 return self; 3786 } 3787SWIGINTERN db_ret_t DbSequence_close(struct DbSequence *self,u_int32_t flags){ 3788 return self->close(self, flags); 3789 } 3790SWIGINTERN db_seq_t DbSequence_get(struct DbSequence *self,DB_TXN *txnid,int32_t delta,u_int32_t flags){ 3791 db_seq_t ret = 0; 3792 errno = self->get(self, txnid, delta, &ret, flags); 3793 return ret; 3794 } 3795SWIGINTERN int32_t DbSequence_get_cachesize(struct DbSequence *self){ 3796 int32_t ret = 0; 3797 errno = self->get_cachesize(self, &ret); 3798 return ret; 3799 } 3800SWIGINTERN DB *DbSequence_get_db(struct DbSequence *self){ 3801 DB *ret = NULL; 3802 errno = self->get_db(self, &ret); 3803 return ret; 3804 } 3805SWIGINTERN u_int32_t DbSequence_get_flags(struct DbSequence *self){ 3806 u_int32_t ret = 0; 3807 errno = self->get_flags(self, &ret); 3808 return ret; 3809 } 3810SWIGINTERN db_ret_t DbSequence_get_key(struct DbSequence *self,DBT *key){ 3811 return self->get_key(self, key); 3812 } 3813SWIGINTERN db_seq_t DbSequence_get_range_min(struct DbSequence *self){ 3814 db_seq_t ret = 0; 3815 errno = self->get_range(self, &ret, NULL); 3816 return ret; 3817 } 3818SWIGINTERN db_seq_t DbSequence_get_range_max(struct DbSequence *self){ 3819 db_seq_t ret = 0; 3820 errno = self->get_range(self, NULL, &ret); 3821 return ret; 3822 } 3823SWIGINTERN db_ret_t DbSequence_initial_value(struct DbSequence *self,db_seq_t val){ 3824 return self->initial_value(self, val); 3825 } 3826SWIGINTERN db_ret_t DbSequence_open(struct DbSequence *self,DB_TXN *txnid,DBT *key,u_int32_t flags){ 3827 return self->open(self, txnid, key, flags); 3828 } 3829SWIGINTERN db_ret_t DbSequence_remove(struct DbSequence *self,DB_TXN *txnid,u_int32_t flags){ 3830 return self->remove(self, txnid, flags); 3831 } 3832SWIGINTERN db_ret_t DbSequence_set_cachesize(struct DbSequence *self,int32_t size){ 3833 return self->set_cachesize(self, size); 3834 } 3835SWIGINTERN db_ret_t DbSequence_set_flags(struct DbSequence *self,u_int32_t flags){ 3836 return self->set_flags(self, flags); 3837 } 3838SWIGINTERN db_ret_t DbSequence_set_range(struct DbSequence *self,db_seq_t min,db_seq_t max){ 3839 return self->set_range(self, min, max); 3840 } 3841SWIGINTERN DB_SEQUENCE_STAT *DbSequence_stat(struct DbSequence *self,u_int32_t flags){ 3842 DB_SEQUENCE_STAT *ret = NULL; 3843 errno = self->stat(self, &ret, flags); 3844 return ret; 3845 } 3846SWIGINTERN db_ret_t DbTxn_abort(struct DbTxn *self){ 3847 return self->abort(self); 3848 } 3849SWIGINTERN db_ret_t DbTxn_commit(struct DbTxn *self,u_int32_t flags){ 3850 return self->commit(self, flags); 3851 } 3852SWIGINTERN db_ret_t DbTxn_discard(struct DbTxn *self,u_int32_t flags){ 3853 return self->discard(self, flags); 3854 } 3855SWIGINTERN char const *DbTxn_get_name(struct DbTxn *self){ 3856 const char *name = NULL; 3857 errno = self->get_name(self, &name); 3858 return name; 3859 } 3860SWIGINTERN u_int32_t DbTxn_id(struct DbTxn *self){ 3861 return self->id(self); 3862 } 3863SWIGINTERN db_ret_t DbTxn_prepare(struct DbTxn *self,u_int8_t *gid){ 3864 return self->prepare(self, gid); 3865 } 3866SWIGINTERN db_ret_t DbTxn_set_timeout(struct DbTxn *self,db_timeout_t timeout,u_int32_t flags){ 3867 return self->set_timeout(self, timeout, flags); 3868 } 3869SWIGINTERN db_ret_t DbTxn_set_name(struct DbTxn *self,char const *name){ 3870 return self->set_name(self, name); 3871 } 3872 3873#ifdef __cplusplus 3874extern "C" { 3875#endif 3876 3877SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_new_1Db(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 3878 jlong jresult = 0 ; 3879 DB_ENV *arg1 = (DB_ENV *) 0 ; 3880 u_int32_t arg2 ; 3881 struct Db *result = 0 ; 3882 3883 (void)jenv; 3884 (void)jcls; 3885 (void)jarg1_; 3886 arg1 = *(DB_ENV **)&jarg1; 3887 arg2 = (u_int32_t)jarg2; 3888 3889 errno = 0; 3890 result = (struct Db *)new_Db(arg1,arg2); 3891 if (!DB_RETOK_STD(errno)) { 3892 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 3893 } 3894 3895 *(struct Db **)&jresult = result; 3896 return jresult; 3897} 3898 3899 3900SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1associate(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jboolean jarg4, jint jarg5) { 3901 struct Db *arg1 = (struct Db *) 0 ; 3902 DB_TXN *arg2 = (DB_TXN *) 0 ; 3903 DB *arg3 = (DB *) 0 ; 3904 int (*arg4)(DB *,DBT const *,DBT const *,DBT *) = (int (*)(DB *,DBT const *,DBT const *,DBT *)) 0 ; 3905 u_int32_t arg5 ; 3906 db_ret_t result; 3907 3908 (void)jenv; 3909 (void)jcls; 3910 (void)jarg1_; 3911 (void)jarg2_; 3912 (void)jarg3_; 3913 arg1 = *(struct Db **)&jarg1; 3914 arg2 = *(DB_TXN **)&jarg2; 3915 arg3 = *(DB **)&jarg3; 3916 3917 arg4 = (jarg4 == JNI_TRUE) ? __dbj_seckey_create : NULL; 3918 3919 arg5 = (u_int32_t)jarg5; 3920 3921 if (jarg1 == 0) { 3922 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 3923 return ; 3924 } 3925 3926 result = (db_ret_t)Db_associate(arg1,arg2,arg3,arg4,arg5); 3927 if (!DB_RETOK_STD(result)) { 3928 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 3929 } 3930 3931} 3932 3933 3934SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1associate_1foreign(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jboolean jarg3, jint jarg4) { 3935 struct Db *arg1 = (struct Db *) 0 ; 3936 DB *arg2 = (DB *) 0 ; 3937 int (*arg3)(DB *,DBT const *,DBT *,DBT const *,int *) = (int (*)(DB *,DBT const *,DBT *,DBT const *,int *)) 0 ; 3938 u_int32_t arg4 ; 3939 db_ret_t result; 3940 3941 (void)jenv; 3942 (void)jcls; 3943 (void)jarg1_; 3944 (void)jarg2_; 3945 arg1 = *(struct Db **)&jarg1; 3946 arg2 = *(DB **)&jarg2; 3947 3948 arg3 = (jarg3 == JNI_TRUE) ? __dbj_foreignkey_nullify : NULL; 3949 3950 arg4 = (u_int32_t)jarg4; 3951 3952 if (jarg1 == 0) { 3953 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 3954 return ; 3955 } 3956 3957 result = (db_ret_t)Db_associate_foreign(arg1,arg2,arg3,arg4); 3958 if (!DB_RETOK_STD(result)) { 3959 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 3960 } 3961 3962} 3963 3964 3965SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1compact(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jobject jarg4, jobject jarg5, jint jarg6, jobject jarg7) { 3966 struct Db *arg1 = (struct Db *) 0 ; 3967 DB_TXN *arg2 = (DB_TXN *) 0 ; 3968 DBT *arg3 = (DBT *) 0 ; 3969 DBT *arg4 = (DBT *) 0 ; 3970 DB_COMPACT *arg5 = (DB_COMPACT *) 0 ; 3971 u_int32_t arg6 ; 3972 DBT *arg7 = (DBT *) 0 ; 3973 DBT_LOCKED ldbt3 ; 3974 DBT_LOCKED ldbt4 ; 3975 DB_COMPACT compact5 ; 3976 DBT_LOCKED ldbt7 ; 3977 db_ret_t result; 3978 3979 (void)jenv; 3980 (void)jcls; 3981 (void)jarg1_; 3982 (void)jarg2_; 3983 arg1 = *(struct Db **)&jarg1; 3984 arg2 = *(DB_TXN **)&jarg2; 3985 3986 if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 1) != 0) { 3987 return ; /* An exception will be pending. */ 3988 } 3989 3990 if (__dbj_dbt_copyin(jenv, &ldbt4, &arg4, jarg4, 1) != 0) { 3991 return ; /* An exception will be pending. */ 3992 } 3993 3994 memset(&compact5, 0, sizeof (DB_COMPACT)); 3995 arg5 = &compact5; 3996 arg5->compact_fillpercent = (*jenv)->GetIntField(jenv, jarg5, 3997 compact_compact_fillpercent_fid); 3998 arg5->compact_timeout = (*jenv)->GetIntField(jenv, jarg5, 3999 compact_compact_timeout_fid); 4000 arg5->compact_pages = (*jenv)->GetIntField(jenv, jarg5, 4001 compact_compact_pages_fid); 4002 4003 arg6 = (u_int32_t)jarg6; 4004 4005 if (__dbj_dbt_copyin(jenv, &ldbt7, &arg7, jarg7, 1) != 0) { 4006 return ; /* An exception will be pending. */ 4007 } 4008 4009 if (jarg1 == 0) { 4010 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4011 return ; 4012 } 4013 4014 result = (db_ret_t)Db_compact(arg1,arg2,arg3,arg4,arg5,arg6,arg7); 4015 if (!DB_RETOK_STD(result)) { 4016 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 4017 } 4018 4019 __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); 4020 __dbj_dbt_release(jenv, jarg4, arg4, &ldbt4); 4021 __dbj_fill_compact(jenv, jarg5, arg5); 4022 __dbj_dbt_release(jenv, jarg7, arg7, &ldbt7); 4023} 4024 4025 4026SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1close0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 4027 jint jresult = 0 ; 4028 struct Db *arg1 = (struct Db *) 0 ; 4029 u_int32_t arg2 ; 4030 int result; 4031 4032 (void)jenv; 4033 (void)jcls; 4034 (void)jarg1_; 4035 arg1 = *(struct Db **)&jarg1; 4036 arg2 = (u_int32_t)jarg2; 4037 4038 if (jarg1 == 0) { 4039 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4040 return 0; 4041 } 4042 4043 errno = 0; 4044 result = (int)Db_close(arg1,arg2); 4045 if (!DB_RETOK_STD(errno)) { 4046 __dbj_throw(jenv, errno, NULL, NULL, NULL); 4047 } 4048 4049 jresult = (jint)result; 4050 return jresult; 4051} 4052 4053 4054SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1cursor(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3) { 4055 jlong jresult = 0 ; 4056 struct Db *arg1 = (struct Db *) 0 ; 4057 DB_TXN *arg2 = (DB_TXN *) 0 ; 4058 u_int32_t arg3 ; 4059 DBC *result = 0 ; 4060 4061 (void)jenv; 4062 (void)jcls; 4063 (void)jarg1_; 4064 (void)jarg2_; 4065 arg1 = *(struct Db **)&jarg1; 4066 arg2 = *(DB_TXN **)&jarg2; 4067 arg3 = (u_int32_t)jarg3; 4068 4069 if (jarg1 == 0) { 4070 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4071 return 0; 4072 } 4073 4074 errno = 0; 4075 result = (DBC *)Db_cursor(arg1,arg2,arg3); 4076 if (!DB_RETOK_STD(errno)) { 4077 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4078 } 4079 4080 *(DBC **)&jresult = result; 4081 return jresult; 4082} 4083 4084 4085SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1del(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jint jarg4) { 4086 jint jresult = 0 ; 4087 struct Db *arg1 = (struct Db *) 0 ; 4088 DB_TXN *arg2 = (DB_TXN *) 0 ; 4089 DBT *arg3 = (DBT *) 0 ; 4090 u_int32_t arg4 ; 4091 DBT_LOCKED ldbt3 ; 4092 int result; 4093 4094 (void)jenv; 4095 (void)jcls; 4096 (void)jarg1_; 4097 (void)jarg2_; 4098 arg1 = *(struct Db **)&jarg1; 4099 arg2 = *(DB_TXN **)&jarg2; 4100 4101 if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { 4102 return 0; /* An exception will be pending. */ 4103 } 4104 arg4 = (u_int32_t)jarg4; 4105 4106 if (jarg1 == 0) { 4107 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4108 return 0; 4109 } 4110 4111 result = (int)Db_del(arg1,arg2,arg3,arg4); 4112 if (!DB_RETOK_DBDEL(result)) { 4113 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 4114 } 4115 4116 jresult = (jint)result; 4117 __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); 4118 return jresult; 4119} 4120 4121 4122SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1err(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) { 4123 struct Db *arg1 = (struct Db *) 0 ; 4124 int arg2 ; 4125 char *arg3 = (char *) 0 ; 4126 4127 (void)jenv; 4128 (void)jcls; 4129 (void)jarg1_; 4130 arg1 = *(struct Db **)&jarg1; 4131 arg2 = (int)jarg2; 4132 arg3 = 0; 4133 if (jarg3) { 4134 arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); 4135 if (!arg3) return ; 4136 } 4137 4138 if (jarg1 == 0) { 4139 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4140 return ; 4141 } 4142 Db_err(arg1,arg2,(char const *)arg3); 4143 if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); 4144} 4145 4146 4147SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1errx(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { 4148 struct Db *arg1 = (struct Db *) 0 ; 4149 char *arg2 = (char *) 0 ; 4150 4151 (void)jenv; 4152 (void)jcls; 4153 (void)jarg1_; 4154 arg1 = *(struct Db **)&jarg1; 4155 arg2 = 0; 4156 if (jarg2) { 4157 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 4158 if (!arg2) return ; 4159 } 4160 4161 if (jarg1 == 0) { 4162 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4163 return ; 4164 } 4165 Db_errx(arg1,(char const *)arg2); 4166 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 4167} 4168 4169 4170SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1exists(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jint jarg4) { 4171 jint jresult = 0 ; 4172 struct Db *arg1 = (struct Db *) 0 ; 4173 DB_TXN *arg2 = (DB_TXN *) 0 ; 4174 DBT *arg3 = (DBT *) 0 ; 4175 u_int32_t arg4 ; 4176 DBT_LOCKED ldbt3 ; 4177 int result; 4178 4179 (void)jenv; 4180 (void)jcls; 4181 (void)jarg1_; 4182 (void)jarg2_; 4183 arg1 = *(struct Db **)&jarg1; 4184 arg2 = *(DB_TXN **)&jarg2; 4185 4186 if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { 4187 return 0; /* An exception will be pending. */ 4188 } 4189 arg4 = (u_int32_t)jarg4; 4190 4191 if (jarg1 == 0) { 4192 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4193 return 0; 4194 } 4195 4196 result = (int)Db_exists(arg1,arg2,arg3,arg4); 4197 if (!DB_RETOK_EXISTS(result)) { 4198 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 4199 } 4200 4201 jresult = (jint)result; 4202 __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); 4203 return jresult; 4204} 4205 4206 4207SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jobject jarg4, jint jarg5) { 4208 jint jresult = 0 ; 4209 struct Db *arg1 = (struct Db *) 0 ; 4210 DB_TXN *arg2 = (DB_TXN *) 0 ; 4211 DBT *arg3 = (DBT *) 0 ; 4212 DBT *arg4 = (DBT *) 0 ; 4213 u_int32_t arg5 ; 4214 DBT_LOCKED ldbt3 ; 4215 DBT_LOCKED ldbt4 ; 4216 int result; 4217 4218 (void)jenv; 4219 (void)jcls; 4220 (void)jarg1_; 4221 (void)jarg2_; 4222 arg1 = *(struct Db **)&jarg1; 4223 arg2 = *(DB_TXN **)&jarg2; 4224 4225 if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { 4226 return 0; /* An exception will be pending. */ 4227 } 4228 4229 if (__dbj_dbt_copyin(jenv, &ldbt4, &arg4, jarg4, 0) != 0) { 4230 return 0; /* An exception will be pending. */ 4231 } 4232 arg5 = (u_int32_t)jarg5; 4233 4234 if (jarg1 == 0) { 4235 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4236 return 0; 4237 } 4238 4239 result = (int)Db_get(arg1,arg2,arg3,arg4,arg5); 4240 if (!DB_RETOK_DBGET(result)) { 4241 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 4242 } 4243 4244 jresult = (jint)result; 4245 __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); 4246 __dbj_dbt_release(jenv, jarg4, arg4, &ldbt4); 4247 return jresult; 4248} 4249 4250 4251SWIGEXPORT jboolean JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1byteswapped(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4252 jboolean jresult = 0 ; 4253 struct Db *arg1 = (struct Db *) 0 ; 4254 int_bool result; 4255 4256 (void)jenv; 4257 (void)jcls; 4258 (void)jarg1_; 4259 arg1 = *(struct Db **)&jarg1; 4260 4261 if (jarg1 == 0) { 4262 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4263 return 0; 4264 } 4265 4266 errno = 0; 4267 result = (int_bool)Db_get_byteswapped(arg1); 4268 if (!DB_RETOK_STD(errno)) { 4269 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4270 } 4271 4272 jresult = (result) ? JNI_TRUE : JNI_FALSE; 4273 return jresult; 4274} 4275 4276 4277SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1cachesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4278 jlong jresult = 0 ; 4279 struct Db *arg1 = (struct Db *) 0 ; 4280 jlong result; 4281 4282 (void)jenv; 4283 (void)jcls; 4284 (void)jarg1_; 4285 arg1 = *(struct Db **)&jarg1; 4286 4287 if (jarg1 == 0) { 4288 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4289 return 0; 4290 } 4291 4292 errno = 0; 4293 result = Db_get_cachesize(arg1); 4294 if (!DB_RETOK_STD(errno)) { 4295 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4296 } 4297 4298 jresult = result; 4299 return jresult; 4300} 4301 4302 4303SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1cachesize_1ncache(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4304 jint jresult = 0 ; 4305 struct Db *arg1 = (struct Db *) 0 ; 4306 u_int32_t result; 4307 4308 (void)jenv; 4309 (void)jcls; 4310 (void)jarg1_; 4311 arg1 = *(struct Db **)&jarg1; 4312 4313 if (jarg1 == 0) { 4314 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4315 return 0; 4316 } 4317 4318 errno = 0; 4319 result = (u_int32_t)Db_get_cachesize_ncache(arg1); 4320 if (!DB_RETOK_STD(errno)) { 4321 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4322 } 4323 4324 jresult = (jint)result; 4325 return jresult; 4326} 4327 4328 4329SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1create_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4330 jstring jresult = 0 ; 4331 struct Db *arg1 = (struct Db *) 0 ; 4332 char *result = 0 ; 4333 4334 (void)jenv; 4335 (void)jcls; 4336 (void)jarg1_; 4337 arg1 = *(struct Db **)&jarg1; 4338 4339 if (jarg1 == 0) { 4340 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4341 return 0; 4342 } 4343 4344 errno = 0; 4345 result = (char *)Db_get_create_dir(arg1); 4346 if (!DB_RETOK_STD(errno)) { 4347 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4348 } 4349 4350 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); 4351 return jresult; 4352} 4353 4354 4355SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1filename(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4356 jstring jresult = 0 ; 4357 struct Db *arg1 = (struct Db *) 0 ; 4358 char *result = 0 ; 4359 4360 (void)jenv; 4361 (void)jcls; 4362 (void)jarg1_; 4363 arg1 = *(struct Db **)&jarg1; 4364 4365 if (jarg1 == 0) { 4366 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4367 return 0; 4368 } 4369 4370 errno = 0; 4371 result = (char *)Db_get_filename(arg1); 4372 if (!DB_RETOK_STD(errno)) { 4373 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4374 } 4375 4376 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); 4377 return jresult; 4378} 4379 4380 4381SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1dbname(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4382 jstring jresult = 0 ; 4383 struct Db *arg1 = (struct Db *) 0 ; 4384 char *result = 0 ; 4385 4386 (void)jenv; 4387 (void)jcls; 4388 (void)jarg1_; 4389 arg1 = *(struct Db **)&jarg1; 4390 4391 if (jarg1 == 0) { 4392 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4393 return 0; 4394 } 4395 4396 errno = 0; 4397 result = (char *)Db_get_dbname(arg1); 4398 if (!DB_RETOK_STD(errno)) { 4399 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4400 } 4401 4402 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); 4403 return jresult; 4404} 4405 4406 4407SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1encrypt_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4408 jint jresult = 0 ; 4409 struct Db *arg1 = (struct Db *) 0 ; 4410 u_int32_t result; 4411 4412 (void)jenv; 4413 (void)jcls; 4414 (void)jarg1_; 4415 arg1 = *(struct Db **)&jarg1; 4416 4417 if (jarg1 == 0) { 4418 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4419 return 0; 4420 } 4421 4422 errno = 0; 4423 result = (u_int32_t)Db_get_encrypt_flags(arg1); 4424 if (!DB_RETOK_STD(errno)) { 4425 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4426 } 4427 4428 jresult = (jint)result; 4429 return jresult; 4430} 4431 4432 4433SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4434 jint jresult = 0 ; 4435 struct Db *arg1 = (struct Db *) 0 ; 4436 u_int32_t result; 4437 4438 (void)jenv; 4439 (void)jcls; 4440 (void)jarg1_; 4441 arg1 = *(struct Db **)&jarg1; 4442 4443 if (jarg1 == 0) { 4444 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4445 return 0; 4446 } 4447 4448 errno = 0; 4449 result = (u_int32_t)Db_get_flags(arg1); 4450 if (!DB_RETOK_STD(errno)) { 4451 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4452 } 4453 4454 jresult = (jint)result; 4455 return jresult; 4456} 4457 4458 4459SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1lorder(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4460 jint jresult = 0 ; 4461 struct Db *arg1 = (struct Db *) 0 ; 4462 int result; 4463 4464 (void)jenv; 4465 (void)jcls; 4466 (void)jarg1_; 4467 arg1 = *(struct Db **)&jarg1; 4468 4469 if (jarg1 == 0) { 4470 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4471 return 0; 4472 } 4473 4474 errno = 0; 4475 result = (int)Db_get_lorder(arg1); 4476 if (!DB_RETOK_STD(errno)) { 4477 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4478 } 4479 4480 jresult = (jint)result; 4481 return jresult; 4482} 4483 4484 4485SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1mpf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4486 jlong jresult = 0 ; 4487 struct Db *arg1 = (struct Db *) 0 ; 4488 DB_MPOOLFILE *result = 0 ; 4489 4490 (void)jenv; 4491 (void)jcls; 4492 (void)jarg1_; 4493 arg1 = *(struct Db **)&jarg1; 4494 4495 if (jarg1 == 0) { 4496 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4497 return 0; 4498 } 4499 4500 errno = 0; 4501 result = (DB_MPOOLFILE *)Db_get_mpf(arg1); 4502 if (!DB_RETOK_STD(errno)) { 4503 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4504 } 4505 4506 *(DB_MPOOLFILE **)&jresult = result; 4507 return jresult; 4508} 4509 4510 4511SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1open_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4512 jint jresult = 0 ; 4513 struct Db *arg1 = (struct Db *) 0 ; 4514 u_int32_t result; 4515 4516 (void)jenv; 4517 (void)jcls; 4518 (void)jarg1_; 4519 arg1 = *(struct Db **)&jarg1; 4520 4521 if (jarg1 == 0) { 4522 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4523 return 0; 4524 } 4525 4526 errno = 0; 4527 result = (u_int32_t)Db_get_open_flags(arg1); 4528 if (!DB_RETOK_STD(errno)) { 4529 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4530 } 4531 4532 jresult = (jint)result; 4533 return jresult; 4534} 4535 4536 4537SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1pagesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4538 jint jresult = 0 ; 4539 struct Db *arg1 = (struct Db *) 0 ; 4540 u_int32_t result; 4541 4542 (void)jenv; 4543 (void)jcls; 4544 (void)jarg1_; 4545 arg1 = *(struct Db **)&jarg1; 4546 4547 if (jarg1 == 0) { 4548 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4549 return 0; 4550 } 4551 4552 errno = 0; 4553 result = (u_int32_t)Db_get_pagesize(arg1); 4554 if (!DB_RETOK_STD(errno)) { 4555 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4556 } 4557 4558 jresult = (jint)result; 4559 return jresult; 4560} 4561 4562 4563SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1bt_1minkey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4564 jint jresult = 0 ; 4565 struct Db *arg1 = (struct Db *) 0 ; 4566 u_int32_t result; 4567 4568 (void)jenv; 4569 (void)jcls; 4570 (void)jarg1_; 4571 arg1 = *(struct Db **)&jarg1; 4572 4573 if (jarg1 == 0) { 4574 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4575 return 0; 4576 } 4577 4578 errno = 0; 4579 result = (u_int32_t)Db_get_bt_minkey(arg1); 4580 if (!DB_RETOK_STD(errno)) { 4581 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4582 } 4583 4584 jresult = (jint)result; 4585 return jresult; 4586} 4587 4588 4589SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1h_1ffactor(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4590 jint jresult = 0 ; 4591 struct Db *arg1 = (struct Db *) 0 ; 4592 u_int32_t result; 4593 4594 (void)jenv; 4595 (void)jcls; 4596 (void)jarg1_; 4597 arg1 = *(struct Db **)&jarg1; 4598 4599 if (jarg1 == 0) { 4600 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4601 return 0; 4602 } 4603 4604 errno = 0; 4605 result = (u_int32_t)Db_get_h_ffactor(arg1); 4606 if (!DB_RETOK_STD(errno)) { 4607 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4608 } 4609 4610 jresult = (jint)result; 4611 return jresult; 4612} 4613 4614 4615SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1h_1nelem(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4616 jint jresult = 0 ; 4617 struct Db *arg1 = (struct Db *) 0 ; 4618 u_int32_t result; 4619 4620 (void)jenv; 4621 (void)jcls; 4622 (void)jarg1_; 4623 arg1 = *(struct Db **)&jarg1; 4624 4625 if (jarg1 == 0) { 4626 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4627 return 0; 4628 } 4629 4630 errno = 0; 4631 result = (u_int32_t)Db_get_h_nelem(arg1); 4632 if (!DB_RETOK_STD(errno)) { 4633 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4634 } 4635 4636 jresult = (jint)result; 4637 return jresult; 4638} 4639 4640 4641SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1re_1delim(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4642 jint jresult = 0 ; 4643 struct Db *arg1 = (struct Db *) 0 ; 4644 int result; 4645 4646 (void)jenv; 4647 (void)jcls; 4648 (void)jarg1_; 4649 arg1 = *(struct Db **)&jarg1; 4650 4651 if (jarg1 == 0) { 4652 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4653 return 0; 4654 } 4655 4656 errno = 0; 4657 result = (int)Db_get_re_delim(arg1); 4658 if (!DB_RETOK_STD(errno)) { 4659 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4660 } 4661 4662 jresult = (jint)result; 4663 return jresult; 4664} 4665 4666 4667SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1priority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4668 jint jresult = 0 ; 4669 struct Db *arg1 = (struct Db *) 0 ; 4670 DB_CACHE_PRIORITY result; 4671 4672 (void)jenv; 4673 (void)jcls; 4674 (void)jarg1_; 4675 arg1 = *(struct Db **)&jarg1; 4676 4677 if (jarg1 == 0) { 4678 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4679 return 0; 4680 } 4681 4682 errno = 0; 4683 result = (DB_CACHE_PRIORITY)Db_get_priority(arg1); 4684 if (!DB_RETOK_STD(errno)) { 4685 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4686 } 4687 4688 jresult = (jint)result; 4689 return jresult; 4690} 4691 4692 4693SWIGEXPORT jobjectArray JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1partition_1dirs(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4694 jobjectArray jresult = 0 ; 4695 struct Db *arg1 = (struct Db *) 0 ; 4696 char **result = 0 ; 4697 4698 (void)jenv; 4699 (void)jcls; 4700 (void)jarg1_; 4701 arg1 = *(struct Db **)&jarg1; 4702 4703 if (jarg1 == 0) { 4704 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4705 return 0; 4706 } 4707 4708 errno = 0; 4709 result = (char **)Db_get_partition_dirs(arg1); 4710 if (!DB_RETOK_STD(errno)) { 4711 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4712 } 4713 4714 { 4715 if (result != NULL) { 4716 /*@SWIG:../libdb_java/java_typemaps.i,367,STRING_ARRAY_OUT@*/ int i, len; 4717 4718 len = 0; 4719 while (result[len] != NULL) 4720 len++; 4721 if ((jresult = (*jenv)->NewObjectArray(jenv, (jsize)len, string_class, 4722 NULL)) == NULL) 4723 return 0; /* an exception is pending */ 4724 for (i = 0; i < len; i++) { 4725 jstring str = (*jenv)->NewStringUTF(jenv, result[i]); 4726 (*jenv)->SetObjectArrayElement(jenv, jresult, (jsize)i, str); 4727 } 4728 /*@SWIG@*/ 4729 } 4730 } 4731 return jresult; 4732} 4733 4734 4735SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1partition_1keys(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4736 jobject jresult = 0 ; 4737 struct Db *arg1 = (struct Db *) 0 ; 4738 DBT *result = 0 ; 4739 4740 (void)jenv; 4741 (void)jcls; 4742 (void)jarg1_; 4743 arg1 = *(struct Db **)&jarg1; 4744 4745 if (jarg1 == 0) { 4746 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4747 return 0; 4748 } 4749 4750 errno = 0; 4751 result = (DBT *)Db_get_partition_keys(arg1); 4752 if (!DB_RETOK_STD(errno)) { 4753 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4754 } 4755 4756 jresult = (jobject)result; 4757 return jresult; 4758} 4759 4760 4761SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1partition_1parts(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4762 jint jresult = 0 ; 4763 struct Db *arg1 = (struct Db *) 0 ; 4764 int result; 4765 4766 (void)jenv; 4767 (void)jcls; 4768 (void)jarg1_; 4769 arg1 = *(struct Db **)&jarg1; 4770 4771 if (jarg1 == 0) { 4772 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4773 return 0; 4774 } 4775 4776 errno = 0; 4777 result = (int)Db_get_partition_parts(arg1); 4778 if (!DB_RETOK_STD(errno)) { 4779 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4780 } 4781 4782 jresult = (jint)result; 4783 return jresult; 4784} 4785 4786 4787SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1re_1len(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4788 jint jresult = 0 ; 4789 struct Db *arg1 = (struct Db *) 0 ; 4790 u_int32_t result; 4791 4792 (void)jenv; 4793 (void)jcls; 4794 (void)jarg1_; 4795 arg1 = *(struct Db **)&jarg1; 4796 4797 if (jarg1 == 0) { 4798 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4799 return 0; 4800 } 4801 4802 errno = 0; 4803 result = (u_int32_t)Db_get_re_len(arg1); 4804 if (!DB_RETOK_STD(errno)) { 4805 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4806 } 4807 4808 jresult = (jint)result; 4809 return jresult; 4810} 4811 4812 4813SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1re_1pad(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4814 jint jresult = 0 ; 4815 struct Db *arg1 = (struct Db *) 0 ; 4816 int result; 4817 4818 (void)jenv; 4819 (void)jcls; 4820 (void)jarg1_; 4821 arg1 = *(struct Db **)&jarg1; 4822 4823 if (jarg1 == 0) { 4824 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4825 return 0; 4826 } 4827 4828 errno = 0; 4829 result = (int)Db_get_re_pad(arg1); 4830 if (!DB_RETOK_STD(errno)) { 4831 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4832 } 4833 4834 jresult = (jint)result; 4835 return jresult; 4836} 4837 4838 4839SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1re_1source(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4840 jstring jresult = 0 ; 4841 struct Db *arg1 = (struct Db *) 0 ; 4842 char *result = 0 ; 4843 4844 (void)jenv; 4845 (void)jcls; 4846 (void)jarg1_; 4847 arg1 = *(struct Db **)&jarg1; 4848 4849 if (jarg1 == 0) { 4850 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4851 return 0; 4852 } 4853 4854 errno = 0; 4855 result = (char *)Db_get_re_source(arg1); 4856 if (!DB_RETOK_STD(errno)) { 4857 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4858 } 4859 4860 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); 4861 return jresult; 4862} 4863 4864 4865SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1q_1extentsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4866 jint jresult = 0 ; 4867 struct Db *arg1 = (struct Db *) 0 ; 4868 u_int32_t result; 4869 4870 (void)jenv; 4871 (void)jcls; 4872 (void)jarg1_; 4873 arg1 = *(struct Db **)&jarg1; 4874 4875 if (jarg1 == 0) { 4876 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4877 return 0; 4878 } 4879 4880 errno = 0; 4881 result = (u_int32_t)Db_get_q_extentsize(arg1); 4882 if (!DB_RETOK_STD(errno)) { 4883 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4884 } 4885 4886 jresult = (jint)result; 4887 return jresult; 4888} 4889 4890 4891SWIGEXPORT jboolean JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1multiple(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4892 jboolean jresult = 0 ; 4893 struct Db *arg1 = (struct Db *) 0 ; 4894 int_bool result; 4895 4896 (void)jenv; 4897 (void)jcls; 4898 (void)jarg1_; 4899 arg1 = *(struct Db **)&jarg1; 4900 4901 if (jarg1 == 0) { 4902 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4903 return 0; 4904 } 4905 result = (int_bool)Db_get_multiple(arg1); 4906 jresult = (result) ? JNI_TRUE : JNI_FALSE; 4907 return jresult; 4908} 4909 4910 4911SWIGEXPORT jboolean JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1transactional(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4912 jboolean jresult = 0 ; 4913 struct Db *arg1 = (struct Db *) 0 ; 4914 int_bool result; 4915 4916 (void)jenv; 4917 (void)jcls; 4918 (void)jarg1_; 4919 arg1 = *(struct Db **)&jarg1; 4920 4921 if (jarg1 == 0) { 4922 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4923 return 0; 4924 } 4925 result = (int_bool)Db_get_transactional(arg1); 4926 jresult = (result) ? JNI_TRUE : JNI_FALSE; 4927 return jresult; 4928} 4929 4930 4931SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 4932 jint jresult = 0 ; 4933 struct Db *arg1 = (struct Db *) 0 ; 4934 DBTYPE result; 4935 4936 (void)jenv; 4937 (void)jcls; 4938 (void)jarg1_; 4939 arg1 = *(struct Db **)&jarg1; 4940 4941 if (jarg1 == 0) { 4942 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4943 return 0; 4944 } 4945 4946 errno = 0; 4947 result = (DBTYPE)Db_get_type(arg1); 4948 if (!DB_RETOK_STD(errno)) { 4949 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 4950 } 4951 4952 jresult = (jint)result; 4953 return jresult; 4954} 4955 4956 4957SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1join(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2, jint jarg3) { 4958 jlong jresult = 0 ; 4959 struct Db *arg1 = (struct Db *) 0 ; 4960 DBC **arg2 = (DBC **) 0 ; 4961 u_int32_t arg3 ; 4962 DBC *result = 0 ; 4963 4964 (void)jenv; 4965 (void)jcls; 4966 (void)jarg1_; 4967 arg1 = *(struct Db **)&jarg1; 4968 { 4969 int i, count, err; 4970 4971 count = (*jenv)->GetArrayLength(jenv, jarg2); 4972 if ((err = __os_malloc(NULL, (count + 1) * sizeof(DBC *), &arg2)) != 0) { 4973 __dbj_throw(jenv, err, NULL, NULL, DB2JDBENV); 4974 return 0; 4975 } 4976 for (i = 0; i < count; i++) { 4977 jobject jobj = (*jenv)->GetObjectArrayElement(jenv, jarg2, i); 4978 /* 4979 * A null in the array is treated as an endpoint. 4980 */ 4981 if (jobj == NULL) { 4982 arg2[i] = NULL; 4983 break; 4984 } else { 4985 jlong jptr = (*jenv)->GetLongField(jenv, jobj, 4986 dbc_cptr_fid); 4987 arg2[i] = *(DBC **)(void *)&jptr; 4988 } 4989 } 4990 arg2[count] = NULL; 4991 } 4992 arg3 = (u_int32_t)jarg3; 4993 4994 if (jarg1 == 0) { 4995 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 4996 return 0; 4997 } 4998 4999 errno = 0; 5000 result = (DBC *)Db_join(arg1,arg2,arg3); 5001 if (!DB_RETOK_STD(errno)) { 5002 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 5003 } 5004 5005 *(DBC **)&jresult = result; 5006 5007 __os_free(NULL, arg2); 5008 5009 return jresult; 5010} 5011 5012 5013SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1key_1range(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jobject jarg4, jint jarg5) { 5014 struct Db *arg1 = (struct Db *) 0 ; 5015 DB_TXN *arg2 = (DB_TXN *) 0 ; 5016 DBT *arg3 = (DBT *) 0 ; 5017 DB_KEY_RANGE *arg4 = (DB_KEY_RANGE *) 0 ; 5018 u_int32_t arg5 ; 5019 DBT_LOCKED ldbt3 ; 5020 DB_KEY_RANGE range4 ; 5021 db_ret_t result; 5022 5023 (void)jenv; 5024 (void)jcls; 5025 (void)jarg1_; 5026 (void)jarg2_; 5027 arg1 = *(struct Db **)&jarg1; 5028 arg2 = *(DB_TXN **)&jarg2; 5029 5030 if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { 5031 return ; /* An exception will be pending. */ 5032 } 5033 { 5034 arg4 = &range4; 5035 } 5036 arg5 = (u_int32_t)jarg5; 5037 5038 if (jarg1 == 0) { 5039 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5040 return ; 5041 } 5042 5043 result = (db_ret_t)Db_key_range(arg1,arg2,arg3,arg4,arg5); 5044 if (!DB_RETOK_STD(result)) { 5045 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5046 } 5047 5048 { 5049 (*jenv)->SetDoubleField(jenv, jarg4, kr_less_fid, arg4->less); 5050 (*jenv)->SetDoubleField(jenv, jarg4, kr_equal_fid, arg4->equal); 5051 (*jenv)->SetDoubleField(jenv, jarg4, kr_greater_fid, arg4->greater); 5052 } 5053 __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); 5054} 5055 5056 5057SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1open(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jstring jarg4, jint jarg5, jint jarg6, jint jarg7) { 5058 struct Db *arg1 = (struct Db *) 0 ; 5059 DB_TXN *arg2 = (DB_TXN *) 0 ; 5060 char *arg3 = (char *) 0 ; 5061 char *arg4 = (char *) 0 ; 5062 DBTYPE arg5 ; 5063 u_int32_t arg6 ; 5064 int arg7 ; 5065 db_ret_t result; 5066 5067 (void)jenv; 5068 (void)jcls; 5069 (void)jarg1_; 5070 (void)jarg2_; 5071 arg1 = *(struct Db **)&jarg1; 5072 arg2 = *(DB_TXN **)&jarg2; 5073 arg3 = 0; 5074 if (jarg3) { 5075 arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); 5076 if (!arg3) return ; 5077 } 5078 arg4 = 0; 5079 if (jarg4) { 5080 arg4 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg4, 0); 5081 if (!arg4) return ; 5082 } 5083 arg5 = (DBTYPE)jarg5; 5084 arg6 = (u_int32_t)jarg6; 5085 arg7 = (int)jarg7; 5086 5087 if (jarg1 == 0) { 5088 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5089 return ; 5090 } 5091 5092 result = (db_ret_t)Db_open(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7); 5093 if (!DB_RETOK_STD(result)) { 5094 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5095 } 5096 5097 if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); 5098 if (arg4) (*jenv)->ReleaseStringUTFChars(jenv, jarg4, (const char *)arg4); 5099} 5100 5101 5102SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1pget(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jobject jarg4, jobject jarg5, jint jarg6) { 5103 jint jresult = 0 ; 5104 struct Db *arg1 = (struct Db *) 0 ; 5105 DB_TXN *arg2 = (DB_TXN *) 0 ; 5106 DBT *arg3 = (DBT *) 0 ; 5107 DBT *arg4 = (DBT *) 0 ; 5108 DBT *arg5 = (DBT *) 0 ; 5109 u_int32_t arg6 ; 5110 DBT_LOCKED ldbt3 ; 5111 DBT_LOCKED ldbt4 ; 5112 DBT_LOCKED ldbt5 ; 5113 int result; 5114 5115 (void)jenv; 5116 (void)jcls; 5117 (void)jarg1_; 5118 (void)jarg2_; 5119 arg1 = *(struct Db **)&jarg1; 5120 arg2 = *(DB_TXN **)&jarg2; 5121 5122 if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { 5123 return 0; /* An exception will be pending. */ 5124 } 5125 5126 if (__dbj_dbt_copyin(jenv, &ldbt4, &arg4, jarg4, 0) != 0) { 5127 return 0; /* An exception will be pending. */ 5128 } 5129 5130 if (__dbj_dbt_copyin(jenv, &ldbt5, &arg5, jarg5, 0) != 0) { 5131 return 0; /* An exception will be pending. */ 5132 } 5133 arg6 = (u_int32_t)jarg6; 5134 5135 if (jarg1 == 0) { 5136 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5137 return 0; 5138 } 5139 5140 result = (int)Db_pget(arg1,arg2,arg3,arg4,arg5,arg6); 5141 if (!DB_RETOK_DBGET(result)) { 5142 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5143 } 5144 5145 jresult = (jint)result; 5146 __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); 5147 __dbj_dbt_release(jenv, jarg4, arg4, &ldbt4); 5148 __dbj_dbt_release(jenv, jarg5, arg5, &ldbt5); 5149 return jresult; 5150} 5151 5152 5153SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1put(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jobject jarg4, jint jarg5) { 5154 jint jresult = 0 ; 5155 struct Db *arg1 = (struct Db *) 0 ; 5156 DB_TXN *arg2 = (DB_TXN *) 0 ; 5157 DBT *arg3 = (DBT *) 0 ; 5158 DBT *arg4 = (DBT *) 0 ; 5159 u_int32_t arg5 ; 5160 DBT_LOCKED ldbt3 ; 5161 DBT_LOCKED ldbt4 ; 5162 int result; 5163 5164 (void)jenv; 5165 (void)jcls; 5166 (void)jarg1_; 5167 (void)jarg2_; 5168 arg1 = *(struct Db **)&jarg1; 5169 arg2 = *(DB_TXN **)&jarg2; 5170 5171 if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { 5172 return 0; /* An exception will be pending. */ 5173 } 5174 5175 if (__dbj_dbt_copyin(jenv, &ldbt4, &arg4, jarg4, 1) != 0) { 5176 return 0; /* An exception will be pending. */ 5177 } 5178 arg5 = (u_int32_t)jarg5; 5179 5180 if (jarg1 == 0) { 5181 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5182 return 0; 5183 } 5184 5185 result = (int)Db_put(arg1,arg2,arg3,arg4,arg5); 5186 if (!DB_RETOK_DBPUT(result)) { 5187 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5188 } 5189 5190 jresult = (jint)result; 5191 __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); 5192 __dbj_dbt_release(jenv, jarg4, arg4, &ldbt4); 5193 return jresult; 5194} 5195 5196 5197SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1remove0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jint jarg4) { 5198 struct Db *arg1 = (struct Db *) 0 ; 5199 char *arg2 = (char *) 0 ; 5200 char *arg3 = (char *) 0 ; 5201 u_int32_t arg4 ; 5202 db_ret_t result; 5203 5204 (void)jenv; 5205 (void)jcls; 5206 (void)jarg1_; 5207 arg1 = *(struct Db **)&jarg1; 5208 arg2 = 0; 5209 if (jarg2) { 5210 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 5211 if (!arg2) return ; 5212 } 5213 arg3 = 0; 5214 if (jarg3) { 5215 arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); 5216 if (!arg3) return ; 5217 } 5218 arg4 = (u_int32_t)jarg4; 5219 5220 if (jarg1 == 0) { 5221 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5222 return ; 5223 } 5224 5225 result = (db_ret_t)Db_remove(arg1,(char const *)arg2,(char const *)arg3,arg4); 5226 if (!DB_RETOK_STD(result)) { 5227 __dbj_throw(jenv, result, NULL, NULL, NULL); 5228 } 5229 5230 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 5231 if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); 5232} 5233 5234 5235SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1rename0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jstring jarg4, jint jarg5) { 5236 struct Db *arg1 = (struct Db *) 0 ; 5237 char *arg2 = (char *) 0 ; 5238 char *arg3 = (char *) 0 ; 5239 char *arg4 = (char *) 0 ; 5240 u_int32_t arg5 ; 5241 db_ret_t result; 5242 5243 (void)jenv; 5244 (void)jcls; 5245 (void)jarg1_; 5246 arg1 = *(struct Db **)&jarg1; 5247 arg2 = 0; 5248 if (jarg2) { 5249 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 5250 if (!arg2) return ; 5251 } 5252 arg3 = 0; 5253 if (jarg3) { 5254 arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); 5255 if (!arg3) return ; 5256 } 5257 arg4 = 0; 5258 if (jarg4) { 5259 arg4 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg4, 0); 5260 if (!arg4) return ; 5261 } 5262 arg5 = (u_int32_t)jarg5; 5263 5264 if (jarg1 == 0) { 5265 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5266 return ; 5267 } 5268 5269 result = (db_ret_t)Db_rename(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5); 5270 if (!DB_RETOK_STD(result)) { 5271 __dbj_throw(jenv, result, NULL, NULL, NULL); 5272 } 5273 5274 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 5275 if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); 5276 if (arg4) (*jenv)->ReleaseStringUTFChars(jenv, jarg4, (const char *)arg4); 5277} 5278 5279 5280SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1append_1recno(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { 5281 struct Db *arg1 = (struct Db *) 0 ; 5282 int (*arg2)(DB *,DBT *,db_recno_t) = (int (*)(DB *,DBT *,db_recno_t)) 0 ; 5283 db_ret_t result; 5284 5285 (void)jenv; 5286 (void)jcls; 5287 (void)jarg1_; 5288 arg1 = *(struct Db **)&jarg1; 5289 5290 arg2 = (jarg2 == JNI_TRUE) ? __dbj_append_recno : NULL; 5291 5292 5293 if (jarg1 == 0) { 5294 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5295 return ; 5296 } 5297 5298 result = (db_ret_t)Db_set_append_recno(arg1,arg2); 5299 if (!DB_RETOK_STD(result)) { 5300 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5301 } 5302 5303} 5304 5305 5306SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1bt_1compare(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { 5307 struct Db *arg1 = (struct Db *) 0 ; 5308 int (*arg2)(DB *,DBT const *,DBT const *) = (int (*)(DB *,DBT const *,DBT const *)) 0 ; 5309 db_ret_t result; 5310 5311 (void)jenv; 5312 (void)jcls; 5313 (void)jarg1_; 5314 arg1 = *(struct Db **)&jarg1; 5315 5316 arg2 = (jarg2 == JNI_TRUE) ? __dbj_bt_compare : NULL; 5317 5318 5319 if (jarg1 == 0) { 5320 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5321 return ; 5322 } 5323 5324 result = (db_ret_t)Db_set_bt_compare(arg1,arg2); 5325 if (!DB_RETOK_STD(result)) { 5326 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5327 } 5328 5329} 5330 5331 5332SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1bt_1minkey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 5333 struct Db *arg1 = (struct Db *) 0 ; 5334 u_int32_t arg2 ; 5335 db_ret_t result; 5336 5337 (void)jenv; 5338 (void)jcls; 5339 (void)jarg1_; 5340 arg1 = *(struct Db **)&jarg1; 5341 arg2 = (u_int32_t)jarg2; 5342 5343 if (jarg1 == 0) { 5344 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5345 return ; 5346 } 5347 5348 result = (db_ret_t)Db_set_bt_minkey(arg1,arg2); 5349 if (!DB_RETOK_STD(result)) { 5350 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5351 } 5352 5353} 5354 5355 5356SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1bt_1compress(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2, jboolean jarg3) { 5357 struct Db *arg1 = (struct Db *) 0 ; 5358 int (*arg2)(DB *,DBT const *,DBT const *,DBT const *,DBT const *,DBT *) = (int (*)(DB *,DBT const *,DBT const *,DBT const *,DBT const *,DBT *)) 0 ; 5359 int (*arg3)(DB *,DBT const *,DBT const *,DBT *,DBT *,DBT *) = (int (*)(DB *,DBT const *,DBT const *,DBT *,DBT *,DBT *)) 0 ; 5360 db_ret_t result; 5361 5362 (void)jenv; 5363 (void)jcls; 5364 (void)jarg1_; 5365 arg1 = *(struct Db **)&jarg1; 5366 5367 arg2 = (jarg2 == JNI_TRUE) ? __dbj_bt_compress : NULL; 5368 5369 5370 arg3 = (jarg3 == JNI_TRUE) ? __dbj_bt_decompress : NULL; 5371 5372 5373 if (jarg1 == 0) { 5374 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5375 return ; 5376 } 5377 5378 result = (db_ret_t)Db_set_bt_compress(arg1,arg2,arg3); 5379 if (!DB_RETOK_STD(result)) { 5380 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5381 } 5382 5383} 5384 5385 5386SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1bt_1prefix(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { 5387 struct Db *arg1 = (struct Db *) 0 ; 5388 size_t (*arg2)(DB *,DBT const *,DBT const *) = (size_t (*)(DB *,DBT const *,DBT const *)) 0 ; 5389 db_ret_t result; 5390 5391 (void)jenv; 5392 (void)jcls; 5393 (void)jarg1_; 5394 arg1 = *(struct Db **)&jarg1; 5395 5396 arg2 = (jarg2 == JNI_TRUE) ? __dbj_bt_prefix : NULL; 5397 5398 5399 if (jarg1 == 0) { 5400 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5401 return ; 5402 } 5403 5404 result = (db_ret_t)Db_set_bt_prefix(arg1,arg2); 5405 if (!DB_RETOK_STD(result)) { 5406 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5407 } 5408 5409} 5410 5411 5412SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1cachesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) { 5413 struct Db *arg1 = (struct Db *) 0 ; 5414 jlong arg2 ; 5415 int arg3 ; 5416 db_ret_t result; 5417 5418 (void)jenv; 5419 (void)jcls; 5420 (void)jarg1_; 5421 arg1 = *(struct Db **)&jarg1; 5422 arg2 = jarg2; 5423 arg3 = (int)jarg3; 5424 5425 if (jarg1 == 0) { 5426 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5427 return ; 5428 } 5429 5430 result = (db_ret_t)Db_set_cachesize(arg1,arg2,arg3); 5431 if (!DB_RETOK_STD(result)) { 5432 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5433 } 5434 5435} 5436 5437 5438SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1create_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { 5439 struct Db *arg1 = (struct Db *) 0 ; 5440 char *arg2 = (char *) 0 ; 5441 db_ret_t result; 5442 5443 (void)jenv; 5444 (void)jcls; 5445 (void)jarg1_; 5446 arg1 = *(struct Db **)&jarg1; 5447 arg2 = 0; 5448 if (jarg2) { 5449 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 5450 if (!arg2) return ; 5451 } 5452 5453 if (jarg1 == 0) { 5454 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5455 return ; 5456 } 5457 5458 result = (db_ret_t)Db_set_create_dir(arg1,(char const *)arg2); 5459 if (!DB_RETOK_STD(result)) { 5460 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5461 } 5462 5463 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 5464} 5465 5466 5467SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1dup_1compare(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { 5468 struct Db *arg1 = (struct Db *) 0 ; 5469 int (*arg2)(DB *,DBT const *,DBT const *) = (int (*)(DB *,DBT const *,DBT const *)) 0 ; 5470 db_ret_t result; 5471 5472 (void)jenv; 5473 (void)jcls; 5474 (void)jarg1_; 5475 arg1 = *(struct Db **)&jarg1; 5476 5477 arg2 = (jarg2 == JNI_TRUE) ? __dbj_dup_compare : NULL; 5478 5479 5480 if (jarg1 == 0) { 5481 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5482 return ; 5483 } 5484 5485 result = (db_ret_t)Db_set_dup_compare(arg1,arg2); 5486 if (!DB_RETOK_STD(result)) { 5487 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5488 } 5489 5490} 5491 5492 5493SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1encrypt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) { 5494 struct Db *arg1 = (struct Db *) 0 ; 5495 char *arg2 = (char *) 0 ; 5496 u_int32_t arg3 ; 5497 db_ret_t result; 5498 5499 (void)jenv; 5500 (void)jcls; 5501 (void)jarg1_; 5502 arg1 = *(struct Db **)&jarg1; 5503 arg2 = 0; 5504 if (jarg2) { 5505 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 5506 if (!arg2) return ; 5507 } 5508 arg3 = (u_int32_t)jarg3; 5509 5510 if (jarg1 == 0) { 5511 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5512 return ; 5513 } 5514 5515 result = (db_ret_t)Db_set_encrypt(arg1,(char const *)arg2,arg3); 5516 if (!DB_RETOK_STD(result)) { 5517 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5518 } 5519 5520 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 5521} 5522 5523 5524SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1feedback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { 5525 struct Db *arg1 = (struct Db *) 0 ; 5526 void (*arg2)(DB *,int,int) = (void (*)(DB *,int,int)) 0 ; 5527 db_ret_t result; 5528 5529 (void)jenv; 5530 (void)jcls; 5531 (void)jarg1_; 5532 arg1 = *(struct Db **)&jarg1; 5533 5534 arg2 = (jarg2 == JNI_TRUE) ? __dbj_db_feedback : NULL; 5535 5536 5537 if (jarg1 == 0) { 5538 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5539 return ; 5540 } 5541 5542 result = (db_ret_t)Db_set_feedback(arg1,arg2); 5543 if (!DB_RETOK_STD(result)) { 5544 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5545 } 5546 5547} 5548 5549 5550SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 5551 struct Db *arg1 = (struct Db *) 0 ; 5552 u_int32_t arg2 ; 5553 db_ret_t result; 5554 5555 (void)jenv; 5556 (void)jcls; 5557 (void)jarg1_; 5558 arg1 = *(struct Db **)&jarg1; 5559 arg2 = (u_int32_t)jarg2; 5560 5561 if (jarg1 == 0) { 5562 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5563 return ; 5564 } 5565 5566 result = (db_ret_t)Db_set_flags(arg1,arg2); 5567 if (!DB_RETOK_STD(result)) { 5568 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5569 } 5570 5571} 5572 5573 5574SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1h_1compare(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { 5575 struct Db *arg1 = (struct Db *) 0 ; 5576 int (*arg2)(DB *,DBT const *,DBT const *) = (int (*)(DB *,DBT const *,DBT const *)) 0 ; 5577 db_ret_t result; 5578 5579 (void)jenv; 5580 (void)jcls; 5581 (void)jarg1_; 5582 arg1 = *(struct Db **)&jarg1; 5583 5584 arg2 = (jarg2 == JNI_TRUE) ? __dbj_h_compare : NULL; 5585 5586 5587 if (jarg1 == 0) { 5588 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5589 return ; 5590 } 5591 5592 result = (db_ret_t)Db_set_h_compare(arg1,arg2); 5593 if (!DB_RETOK_STD(result)) { 5594 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5595 } 5596 5597} 5598 5599 5600SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1h_1ffactor(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 5601 struct Db *arg1 = (struct Db *) 0 ; 5602 u_int32_t arg2 ; 5603 db_ret_t result; 5604 5605 (void)jenv; 5606 (void)jcls; 5607 (void)jarg1_; 5608 arg1 = *(struct Db **)&jarg1; 5609 arg2 = (u_int32_t)jarg2; 5610 5611 if (jarg1 == 0) { 5612 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5613 return ; 5614 } 5615 5616 result = (db_ret_t)Db_set_h_ffactor(arg1,arg2); 5617 if (!DB_RETOK_STD(result)) { 5618 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5619 } 5620 5621} 5622 5623 5624SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1h_1hash(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { 5625 struct Db *arg1 = (struct Db *) 0 ; 5626 u_int32_t (*arg2)(DB *,void const *,u_int32_t) = (u_int32_t (*)(DB *,void const *,u_int32_t)) 0 ; 5627 db_ret_t result; 5628 5629 (void)jenv; 5630 (void)jcls; 5631 (void)jarg1_; 5632 arg1 = *(struct Db **)&jarg1; 5633 5634 arg2 = (jarg2 == JNI_TRUE) ? __dbj_h_hash : NULL; 5635 5636 5637 if (jarg1 == 0) { 5638 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5639 return ; 5640 } 5641 5642 result = (db_ret_t)Db_set_h_hash(arg1,arg2); 5643 if (!DB_RETOK_STD(result)) { 5644 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5645 } 5646 5647} 5648 5649 5650SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1h_1nelem(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 5651 struct Db *arg1 = (struct Db *) 0 ; 5652 u_int32_t arg2 ; 5653 db_ret_t result; 5654 5655 (void)jenv; 5656 (void)jcls; 5657 (void)jarg1_; 5658 arg1 = *(struct Db **)&jarg1; 5659 arg2 = (u_int32_t)jarg2; 5660 5661 if (jarg1 == 0) { 5662 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5663 return ; 5664 } 5665 5666 result = (db_ret_t)Db_set_h_nelem(arg1,arg2); 5667 if (!DB_RETOK_STD(result)) { 5668 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5669 } 5670 5671} 5672 5673 5674SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1lorder(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 5675 struct Db *arg1 = (struct Db *) 0 ; 5676 int arg2 ; 5677 db_ret_t result; 5678 5679 (void)jenv; 5680 (void)jcls; 5681 (void)jarg1_; 5682 arg1 = *(struct Db **)&jarg1; 5683 arg2 = (int)jarg2; 5684 5685 if (jarg1 == 0) { 5686 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5687 return ; 5688 } 5689 5690 result = (db_ret_t)Db_set_lorder(arg1,arg2); 5691 if (!DB_RETOK_STD(result)) { 5692 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5693 } 5694 5695} 5696 5697 5698SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1pagesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 5699 struct Db *arg1 = (struct Db *) 0 ; 5700 u_int32_t arg2 ; 5701 db_ret_t result; 5702 5703 (void)jenv; 5704 (void)jcls; 5705 (void)jarg1_; 5706 arg1 = *(struct Db **)&jarg1; 5707 arg2 = (u_int32_t)jarg2; 5708 5709 if (jarg1 == 0) { 5710 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5711 return ; 5712 } 5713 5714 result = (db_ret_t)Db_set_pagesize(arg1,arg2); 5715 if (!DB_RETOK_STD(result)) { 5716 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5717 } 5718 5719} 5720 5721 5722SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1partition(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jobject jarg3, jboolean jarg4) { 5723 struct Db *arg1 = (struct Db *) 0 ; 5724 u_int32_t arg2 ; 5725 DBT *arg3 = (DBT *) 0 ; 5726 u_int32_t (*arg4)(DB *,DBT *) = (u_int32_t (*)(DB *,DBT *)) 0 ; 5727 DBT_LOCKED ldbt3 ; 5728 db_ret_t result; 5729 5730 (void)jenv; 5731 (void)jcls; 5732 (void)jarg1_; 5733 arg1 = *(struct Db **)&jarg1; 5734 arg2 = (u_int32_t)jarg2; 5735 5736 if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 1) != 0) { 5737 return ; /* An exception will be pending. */ 5738 } 5739 5740 arg4 = (jarg4 == JNI_TRUE) ? __dbj_partition : NULL; 5741 5742 5743 if (jarg1 == 0) { 5744 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5745 return ; 5746 } 5747 5748 result = (db_ret_t)Db_set_partition(arg1,arg2,arg3,arg4); 5749 if (!DB_RETOK_STD(result)) { 5750 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5751 } 5752 5753 __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); 5754} 5755 5756 5757SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1partition_1dirs(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2) { 5758 struct Db *arg1 = (struct Db *) 0 ; 5759 char **arg2 = (char **) 0 ; 5760 db_ret_t result; 5761 5762 (void)jenv; 5763 (void)jcls; 5764 (void)jarg1_; 5765 arg1 = *(struct Db **)&jarg1; 5766 arg2 = *(char ***)&jarg2; 5767 5768 if (jarg1 == 0) { 5769 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5770 return ; 5771 } 5772 5773 result = (db_ret_t)Db_set_partition_dirs(arg1,(char const **)arg2); 5774 if (!DB_RETOK_STD(result)) { 5775 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5776 } 5777 5778} 5779 5780 5781SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1priority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 5782 struct Db *arg1 = (struct Db *) 0 ; 5783 DB_CACHE_PRIORITY arg2 ; 5784 db_ret_t result; 5785 5786 (void)jenv; 5787 (void)jcls; 5788 (void)jarg1_; 5789 arg1 = *(struct Db **)&jarg1; 5790 arg2 = (DB_CACHE_PRIORITY)jarg2; 5791 5792 if (jarg1 == 0) { 5793 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5794 return ; 5795 } 5796 5797 result = (db_ret_t)Db_set_priority(arg1,arg2); 5798 if (!DB_RETOK_STD(result)) { 5799 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5800 } 5801 5802} 5803 5804 5805SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1re_1delim(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 5806 struct Db *arg1 = (struct Db *) 0 ; 5807 int arg2 ; 5808 db_ret_t result; 5809 5810 (void)jenv; 5811 (void)jcls; 5812 (void)jarg1_; 5813 arg1 = *(struct Db **)&jarg1; 5814 arg2 = (int)jarg2; 5815 5816 if (jarg1 == 0) { 5817 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5818 return ; 5819 } 5820 5821 result = (db_ret_t)Db_set_re_delim(arg1,arg2); 5822 if (!DB_RETOK_STD(result)) { 5823 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5824 } 5825 5826} 5827 5828 5829SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1re_1len(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 5830 struct Db *arg1 = (struct Db *) 0 ; 5831 u_int32_t arg2 ; 5832 db_ret_t result; 5833 5834 (void)jenv; 5835 (void)jcls; 5836 (void)jarg1_; 5837 arg1 = *(struct Db **)&jarg1; 5838 arg2 = (u_int32_t)jarg2; 5839 5840 if (jarg1 == 0) { 5841 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5842 return ; 5843 } 5844 5845 result = (db_ret_t)Db_set_re_len(arg1,arg2); 5846 if (!DB_RETOK_STD(result)) { 5847 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5848 } 5849 5850} 5851 5852 5853SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1re_1pad(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 5854 struct Db *arg1 = (struct Db *) 0 ; 5855 int arg2 ; 5856 db_ret_t result; 5857 5858 (void)jenv; 5859 (void)jcls; 5860 (void)jarg1_; 5861 arg1 = *(struct Db **)&jarg1; 5862 arg2 = (int)jarg2; 5863 5864 if (jarg1 == 0) { 5865 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5866 return ; 5867 } 5868 5869 result = (db_ret_t)Db_set_re_pad(arg1,arg2); 5870 if (!DB_RETOK_STD(result)) { 5871 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5872 } 5873 5874} 5875 5876 5877SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1re_1source(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { 5878 struct Db *arg1 = (struct Db *) 0 ; 5879 char *arg2 = (char *) 0 ; 5880 db_ret_t result; 5881 5882 (void)jenv; 5883 (void)jcls; 5884 (void)jarg1_; 5885 arg1 = *(struct Db **)&jarg1; 5886 arg2 = 0; 5887 if (jarg2) { 5888 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 5889 if (!arg2) return ; 5890 } 5891 5892 if (jarg1 == 0) { 5893 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5894 return ; 5895 } 5896 5897 result = (db_ret_t)Db_set_re_source(arg1,arg2); 5898 if (!DB_RETOK_STD(result)) { 5899 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5900 } 5901 5902 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 5903} 5904 5905 5906SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1q_1extentsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 5907 struct Db *arg1 = (struct Db *) 0 ; 5908 u_int32_t arg2 ; 5909 db_ret_t result; 5910 5911 (void)jenv; 5912 (void)jcls; 5913 (void)jarg1_; 5914 arg1 = *(struct Db **)&jarg1; 5915 arg2 = (u_int32_t)jarg2; 5916 5917 if (jarg1 == 0) { 5918 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5919 return ; 5920 } 5921 5922 result = (db_ret_t)Db_set_q_extentsize(arg1,arg2); 5923 if (!DB_RETOK_STD(result)) { 5924 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5925 } 5926 5927} 5928 5929 5930SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1sort_1multiple(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3) { 5931 struct Db *arg1 = (struct Db *) 0 ; 5932 DBT *arg2 = (DBT *) 0 ; 5933 DBT *arg3 = (DBT *) 0 ; 5934 DBT_LOCKED ldbt2 ; 5935 DBT_LOCKED ldbt3 ; 5936 db_ret_t result; 5937 5938 (void)jenv; 5939 (void)jcls; 5940 (void)jarg1_; 5941 arg1 = *(struct Db **)&jarg1; 5942 5943 if (__dbj_dbt_copyin(jenv, &ldbt2, &arg2, jarg2, 0) != 0) { 5944 return ; /* An exception will be pending. */ 5945 } 5946 5947 if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { 5948 return ; /* An exception will be pending. */ 5949 } 5950 5951 if (jarg1 == 0) { 5952 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5953 return ; 5954 } 5955 5956 result = (db_ret_t)Db_sort_multiple(arg1,arg2,arg3); 5957 if (!DB_RETOK_STD(result)) { 5958 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 5959 } 5960 5961 __dbj_dbt_release(jenv, jarg2, arg2, &ldbt2); 5962 __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); 5963} 5964 5965 5966SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3) { 5967 jobject jresult = 0 ; 5968 struct Db *arg1 = (struct Db *) 0 ; 5969 DB_TXN *arg2 = (DB_TXN *) 0 ; 5970 u_int32_t arg3 ; 5971 void *result = 0 ; 5972 5973 (void)jenv; 5974 (void)jcls; 5975 (void)jarg1_; 5976 (void)jarg2_; 5977 arg1 = *(struct Db **)&jarg1; 5978 arg2 = *(DB_TXN **)&jarg2; 5979 arg3 = (u_int32_t)jarg3; 5980 5981 if (jarg1 == 0) { 5982 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 5983 return 0; 5984 } 5985 5986 errno = 0; 5987 result = (void *)Db_stat(arg1,arg2,arg3); 5988 if (!DB_RETOK_STD(errno)) { 5989 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 5990 } 5991 5992 5993 if (result == NULL) 5994 jresult = NULL; 5995 else { 5996 DB *db = (DB *)arg1; 5997 DBTYPE dbtype; 5998 int err; 5999 6000 if ((err = db->get_type(db, &dbtype)) != 0) { 6001 __dbj_throw(jenv, err, NULL, NULL, DB2JDBENV); 6002 return 0; 6003 } 6004 6005 switch (dbtype) { 6006 /* Btree and recno share the same stat structure */ 6007 case DB_BTREE: 6008 case DB_RECNO: 6009 jresult = (*jenv)->NewObject(jenv, bt_stat_class, 6010 bt_stat_construct); 6011 if (jresult != NULL) 6012 __dbj_fill_bt_stat(jenv, jresult, 6013 (DB_BTREE_STAT *)result); 6014 break; 6015 6016 /* Hash stat structure */ 6017 case DB_HASH: 6018 jresult = (*jenv)->NewObject(jenv, h_stat_class, 6019 h_stat_construct); 6020 if (jresult != NULL) 6021 __dbj_fill_h_stat(jenv, jresult, 6022 (DB_HASH_STAT *)result); 6023 break; 6024 6025 case DB_QUEUE: 6026 jresult = (*jenv)->NewObject(jenv, qam_stat_class, 6027 qam_stat_construct); 6028 if (jresult != NULL) 6029 __dbj_fill_qam_stat(jenv, jresult, 6030 (DB_QUEUE_STAT *)result); 6031 break; 6032 6033 /* That's all the database types we're aware of! */ 6034 default: 6035 __dbj_throw(jenv, EINVAL, "Db.stat only implemented for" 6036 " BTREE, HASH, QUEUE and RECNO", NULL, DB2JDBENV); 6037 break; 6038 } 6039 6040 __os_ufree(db->env, result); 6041 } 6042 6043 return jresult; 6044} 6045 6046 6047SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1sync(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 6048 struct Db *arg1 = (struct Db *) 0 ; 6049 u_int32_t arg2 ; 6050 db_ret_t result; 6051 6052 (void)jenv; 6053 (void)jcls; 6054 (void)jarg1_; 6055 arg1 = *(struct Db **)&jarg1; 6056 arg2 = (u_int32_t)jarg2; 6057 6058 if (jarg1 == 0) { 6059 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6060 return ; 6061 } 6062 6063 result = (db_ret_t)Db_sync(arg1,arg2); 6064 if (!DB_RETOK_STD(result)) { 6065 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 6066 } 6067 6068} 6069 6070 6071SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1truncate(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3) { 6072 jint jresult = 0 ; 6073 struct Db *arg1 = (struct Db *) 0 ; 6074 DB_TXN *arg2 = (DB_TXN *) 0 ; 6075 u_int32_t arg3 ; 6076 int result; 6077 6078 (void)jenv; 6079 (void)jcls; 6080 (void)jarg1_; 6081 (void)jarg2_; 6082 arg1 = *(struct Db **)&jarg1; 6083 arg2 = *(DB_TXN **)&jarg2; 6084 arg3 = (u_int32_t)jarg3; 6085 6086 if (jarg1 == 0) { 6087 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6088 return 0; 6089 } 6090 6091 errno = 0; 6092 result = (int)Db_truncate(arg1,arg2,arg3); 6093 if (!DB_RETOK_STD(errno)) { 6094 __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); 6095 } 6096 6097 jresult = (jint)result; 6098 return jresult; 6099} 6100 6101 6102SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1upgrade(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) { 6103 struct Db *arg1 = (struct Db *) 0 ; 6104 char *arg2 = (char *) 0 ; 6105 u_int32_t arg3 ; 6106 db_ret_t result; 6107 6108 (void)jenv; 6109 (void)jcls; 6110 (void)jarg1_; 6111 arg1 = *(struct Db **)&jarg1; 6112 arg2 = 0; 6113 if (jarg2) { 6114 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 6115 if (!arg2) return ; 6116 } 6117 arg3 = (u_int32_t)jarg3; 6118 6119 if (jarg1 == 0) { 6120 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6121 return ; 6122 } 6123 6124 result = (db_ret_t)Db_upgrade(arg1,(char const *)arg2,arg3); 6125 if (!DB_RETOK_STD(result)) { 6126 __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); 6127 } 6128 6129 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 6130} 6131 6132 6133SWIGEXPORT jboolean JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1verify0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jobject jarg4, jint jarg5) { 6134 jboolean jresult = 0 ; 6135 struct Db *arg1 = (struct Db *) 0 ; 6136 char *arg2 = (char *) 0 ; 6137 char *arg3 = (char *) 0 ; 6138 struct __db_out_stream arg4 ; 6139 u_int32_t arg5 ; 6140 struct __dbj_verify_data data4 ; 6141 int_bool result; 6142 6143 (void)jenv; 6144 (void)jcls; 6145 (void)jarg1_; 6146 arg1 = *(struct Db **)&jarg1; 6147 arg2 = 0; 6148 if (jarg2) { 6149 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 6150 if (!arg2) return 0; 6151 } 6152 arg3 = 0; 6153 if (jarg3) { 6154 arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); 6155 if (!arg3) return 0; 6156 } 6157 { 6158 data4.jenv = jenv; 6159 data4.streamobj = jarg4; 6160 data4.bytes = NULL; 6161 data4.nbytes = 0; 6162 (&arg4)->handle = &data4; 6163 (&arg4)->callback = __dbj_verify_callback; 6164 } 6165 arg5 = (u_int32_t)jarg5; 6166 6167 if (jarg1 == 0) { 6168 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6169 return 0; 6170 } 6171 6172 errno = 0; 6173 result = (int_bool)Db_verify(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5); 6174 if (!DB_RETOK_STD(errno)) { 6175 __dbj_throw(jenv, errno, NULL, NULL, NULL); 6176 } 6177 6178 jresult = (result) ? JNI_TRUE : JNI_FALSE; 6179 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 6180 if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); 6181 return jresult; 6182} 6183 6184 6185SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1close0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6186 struct Dbc *arg1 = (struct Dbc *) 0 ; 6187 db_ret_t result; 6188 6189 (void)jenv; 6190 (void)jcls; 6191 (void)jarg1_; 6192 arg1 = *(struct Dbc **)&jarg1; 6193 6194 if (jarg1 == 0) { 6195 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6196 return ; 6197 } 6198 6199 result = (db_ret_t)Dbc_close(arg1); 6200 if (!DB_RETOK_STD(result)) { 6201 __dbj_throw(jenv, result, NULL, NULL, NULL); 6202 } 6203 6204} 6205 6206 6207SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1cmp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3) { 6208 jint jresult = 0 ; 6209 struct Dbc *arg1 = (struct Dbc *) 0 ; 6210 DBC *arg2 = (DBC *) 0 ; 6211 u_int32_t arg3 ; 6212 int result; 6213 6214 (void)jenv; 6215 (void)jcls; 6216 (void)jarg1_; 6217 (void)jarg2_; 6218 arg1 = *(struct Dbc **)&jarg1; 6219 arg2 = *(DBC **)&jarg2; 6220 arg3 = (u_int32_t)jarg3; 6221 6222 if (jarg1 == 0) { 6223 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6224 return 0; 6225 } 6226 6227 errno = 0; 6228 result = (int)Dbc_cmp(arg1,arg2,arg3); 6229 if (!DB_RETOK_STD(errno)) { 6230 __dbj_throw(jenv, errno, NULL, NULL, DBC2JDBENV); 6231 } 6232 6233 jresult = (jint)result; 6234 return jresult; 6235} 6236 6237 6238SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1count(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 6239 jint jresult = 0 ; 6240 struct Dbc *arg1 = (struct Dbc *) 0 ; 6241 u_int32_t arg2 ; 6242 db_recno_t result; 6243 6244 (void)jenv; 6245 (void)jcls; 6246 (void)jarg1_; 6247 arg1 = *(struct Dbc **)&jarg1; 6248 arg2 = (u_int32_t)jarg2; 6249 6250 if (jarg1 == 0) { 6251 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6252 return 0; 6253 } 6254 6255 errno = 0; 6256 result = (db_recno_t)Dbc_count(arg1,arg2); 6257 if (!DB_RETOK_STD(errno)) { 6258 __dbj_throw(jenv, errno, NULL, NULL, DBC2JDBENV); 6259 } 6260 6261 jresult = (jint)result; 6262 return jresult; 6263} 6264 6265 6266SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1del(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 6267 jint jresult = 0 ; 6268 struct Dbc *arg1 = (struct Dbc *) 0 ; 6269 u_int32_t arg2 ; 6270 int result; 6271 6272 (void)jenv; 6273 (void)jcls; 6274 (void)jarg1_; 6275 arg1 = *(struct Dbc **)&jarg1; 6276 arg2 = (u_int32_t)jarg2; 6277 6278 if (jarg1 == 0) { 6279 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6280 return 0; 6281 } 6282 6283 result = (int)Dbc_del(arg1,arg2); 6284 if (!DB_RETOK_DBCDEL(result)) { 6285 __dbj_throw(jenv, result, NULL, NULL, DBC2JDBENV); 6286 } 6287 6288 jresult = (jint)result; 6289 return jresult; 6290} 6291 6292 6293SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1dup(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 6294 jlong jresult = 0 ; 6295 struct Dbc *arg1 = (struct Dbc *) 0 ; 6296 u_int32_t arg2 ; 6297 DBC *result = 0 ; 6298 6299 (void)jenv; 6300 (void)jcls; 6301 (void)jarg1_; 6302 arg1 = *(struct Dbc **)&jarg1; 6303 arg2 = (u_int32_t)jarg2; 6304 6305 if (jarg1 == 0) { 6306 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6307 return 0; 6308 } 6309 6310 errno = 0; 6311 result = (DBC *)Dbc_dup(arg1,arg2); 6312 if (!DB_RETOK_STD(errno)) { 6313 __dbj_throw(jenv, errno, NULL, NULL, DBC2JDBENV); 6314 } 6315 6316 *(DBC **)&jresult = result; 6317 return jresult; 6318} 6319 6320 6321SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jint jarg4) { 6322 jint jresult = 0 ; 6323 struct Dbc *arg1 = (struct Dbc *) 0 ; 6324 DBT *arg2 = (DBT *) 0 ; 6325 DBT *arg3 = (DBT *) 0 ; 6326 u_int32_t arg4 ; 6327 DBT_LOCKED ldbt2 ; 6328 DBT_LOCKED ldbt3 ; 6329 int result; 6330 6331 (void)jenv; 6332 (void)jcls; 6333 (void)jarg1_; 6334 arg1 = *(struct Dbc **)&jarg1; 6335 6336 if (__dbj_dbt_copyin(jenv, &ldbt2, &arg2, jarg2, 0) != 0) { 6337 return 0; /* An exception will be pending. */ 6338 } 6339 6340 if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { 6341 return 0; /* An exception will be pending. */ 6342 } 6343 arg4 = (u_int32_t)jarg4; 6344 6345 if (jarg1 == 0) { 6346 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6347 return 0; 6348 } 6349 6350 result = (int)Dbc_get(arg1,arg2,arg3,arg4); 6351 if (!DB_RETOK_DBCGET(result)) { 6352 __dbj_throw(jenv, result, NULL, NULL, DBC2JDBENV); 6353 } 6354 6355 jresult = (jint)result; 6356 __dbj_dbt_release(jenv, jarg2, arg2, &ldbt2); 6357 __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); 6358 return jresult; 6359} 6360 6361 6362SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1get_1priority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6363 jint jresult = 0 ; 6364 struct Dbc *arg1 = (struct Dbc *) 0 ; 6365 DB_CACHE_PRIORITY result; 6366 6367 (void)jenv; 6368 (void)jcls; 6369 (void)jarg1_; 6370 arg1 = *(struct Dbc **)&jarg1; 6371 6372 if (jarg1 == 0) { 6373 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6374 return 0; 6375 } 6376 6377 errno = 0; 6378 result = (DB_CACHE_PRIORITY)Dbc_get_priority(arg1); 6379 if (!DB_RETOK_STD(errno)) { 6380 __dbj_throw(jenv, errno, NULL, NULL, DBC2JDBENV); 6381 } 6382 6383 jresult = (jint)result; 6384 return jresult; 6385} 6386 6387 6388SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1pget(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jobject jarg4, jint jarg5) { 6389 jint jresult = 0 ; 6390 struct Dbc *arg1 = (struct Dbc *) 0 ; 6391 DBT *arg2 = (DBT *) 0 ; 6392 DBT *arg3 = (DBT *) 0 ; 6393 DBT *arg4 = (DBT *) 0 ; 6394 u_int32_t arg5 ; 6395 DBT_LOCKED ldbt2 ; 6396 DBT_LOCKED ldbt3 ; 6397 DBT_LOCKED ldbt4 ; 6398 int result; 6399 6400 (void)jenv; 6401 (void)jcls; 6402 (void)jarg1_; 6403 arg1 = *(struct Dbc **)&jarg1; 6404 6405 if (__dbj_dbt_copyin(jenv, &ldbt2, &arg2, jarg2, 0) != 0) { 6406 return 0; /* An exception will be pending. */ 6407 } 6408 6409 if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { 6410 return 0; /* An exception will be pending. */ 6411 } 6412 6413 if (__dbj_dbt_copyin(jenv, &ldbt4, &arg4, jarg4, 0) != 0) { 6414 return 0; /* An exception will be pending. */ 6415 } 6416 arg5 = (u_int32_t)jarg5; 6417 6418 if (jarg1 == 0) { 6419 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6420 return 0; 6421 } 6422 6423 result = (int)Dbc_pget(arg1,arg2,arg3,arg4,arg5); 6424 if (!DB_RETOK_DBCGET(result)) { 6425 __dbj_throw(jenv, result, NULL, NULL, DBC2JDBENV); 6426 } 6427 6428 jresult = (jint)result; 6429 __dbj_dbt_release(jenv, jarg2, arg2, &ldbt2); 6430 __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); 6431 __dbj_dbt_release(jenv, jarg4, arg4, &ldbt4); 6432 return jresult; 6433} 6434 6435 6436SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1put(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jint jarg4) { 6437 jint jresult = 0 ; 6438 struct Dbc *arg1 = (struct Dbc *) 0 ; 6439 DBT *arg2 = (DBT *) 0 ; 6440 DBT *arg3 = (DBT *) 0 ; 6441 u_int32_t arg4 ; 6442 DBT_LOCKED ldbt2 ; 6443 DBT_LOCKED ldbt3 ; 6444 int result; 6445 6446 (void)jenv; 6447 (void)jcls; 6448 (void)jarg1_; 6449 arg1 = *(struct Dbc **)&jarg1; 6450 6451 if (__dbj_dbt_copyin(jenv, &ldbt2, &arg2, jarg2, 0) != 0) { 6452 return 0; /* An exception will be pending. */ 6453 } 6454 6455 if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 1) != 0) { 6456 return 0; /* An exception will be pending. */ 6457 } 6458 arg4 = (u_int32_t)jarg4; 6459 6460 if (jarg1 == 0) { 6461 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6462 return 0; 6463 } 6464 6465 result = (int)Dbc_put(arg1,arg2,arg3,arg4); 6466 if (!DB_RETOK_DBCPUT(result)) { 6467 __dbj_throw(jenv, result, NULL, NULL, DBC2JDBENV); 6468 } 6469 6470 jresult = (jint)result; 6471 __dbj_dbt_release(jenv, jarg2, arg2, &ldbt2); 6472 __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); 6473 return jresult; 6474} 6475 6476 6477SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1set_1priority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 6478 struct Dbc *arg1 = (struct Dbc *) 0 ; 6479 DB_CACHE_PRIORITY arg2 ; 6480 db_ret_t result; 6481 6482 (void)jenv; 6483 (void)jcls; 6484 (void)jarg1_; 6485 arg1 = *(struct Dbc **)&jarg1; 6486 arg2 = (DB_CACHE_PRIORITY)jarg2; 6487 6488 if (jarg1 == 0) { 6489 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6490 return ; 6491 } 6492 6493 errno = 0; 6494 result = (db_ret_t)Dbc_set_priority(arg1,arg2); 6495 if (!DB_RETOK_STD(errno)) { 6496 __dbj_throw(jenv, errno, NULL, NULL, DBC2JDBENV); 6497 } 6498 6499} 6500 6501 6502SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_new_1DbEnv(JNIEnv *jenv, jclass jcls, jint jarg1) { 6503 jlong jresult = 0 ; 6504 u_int32_t arg1 ; 6505 struct DbEnv *result = 0 ; 6506 6507 (void)jenv; 6508 (void)jcls; 6509 arg1 = (u_int32_t)jarg1; 6510 6511 errno = 0; 6512 result = (struct DbEnv *)new_DbEnv(arg1); 6513 if (!DB_RETOK_STD(errno)) { 6514 __dbj_throw(jenv, errno, NULL, NULL, NULL); 6515 } 6516 6517 *(struct DbEnv **)&jresult = result; 6518 return jresult; 6519} 6520 6521 6522SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1close0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 6523 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6524 u_int32_t arg2 ; 6525 db_ret_t result; 6526 6527 (void)jenv; 6528 (void)jcls; 6529 (void)jarg1_; 6530 arg1 = *(struct DbEnv **)&jarg1; 6531 arg2 = (u_int32_t)jarg2; 6532 6533 if (jarg1 == 0) { 6534 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6535 return ; 6536 } 6537 6538 result = (db_ret_t)DbEnv_close(arg1,arg2); 6539 if (!DB_RETOK_STD(result)) { 6540 __dbj_throw(jenv, result, NULL, NULL, NULL); 6541 } 6542 6543} 6544 6545 6546SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1dbremove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jstring jarg4, jint jarg5) { 6547 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6548 DB_TXN *arg2 = (DB_TXN *) 0 ; 6549 char *arg3 = (char *) 0 ; 6550 char *arg4 = (char *) 0 ; 6551 u_int32_t arg5 ; 6552 db_ret_t result; 6553 6554 (void)jenv; 6555 (void)jcls; 6556 (void)jarg1_; 6557 (void)jarg2_; 6558 arg1 = *(struct DbEnv **)&jarg1; 6559 arg2 = *(DB_TXN **)&jarg2; 6560 arg3 = 0; 6561 if (jarg3) { 6562 arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); 6563 if (!arg3) return ; 6564 } 6565 arg4 = 0; 6566 if (jarg4) { 6567 arg4 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg4, 0); 6568 if (!arg4) return ; 6569 } 6570 arg5 = (u_int32_t)jarg5; 6571 6572 if (jarg1 == 0) { 6573 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6574 return ; 6575 } 6576 6577 result = (db_ret_t)DbEnv_dbremove(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5); 6578 if (!DB_RETOK_STD(result)) { 6579 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 6580 } 6581 6582 if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); 6583 if (arg4) (*jenv)->ReleaseStringUTFChars(jenv, jarg4, (const char *)arg4); 6584} 6585 6586 6587SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1dbrename(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jstring jarg4, jstring jarg5, jint jarg6) { 6588 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6589 DB_TXN *arg2 = (DB_TXN *) 0 ; 6590 char *arg3 = (char *) 0 ; 6591 char *arg4 = (char *) 0 ; 6592 char *arg5 = (char *) 0 ; 6593 u_int32_t arg6 ; 6594 db_ret_t result; 6595 6596 (void)jenv; 6597 (void)jcls; 6598 (void)jarg1_; 6599 (void)jarg2_; 6600 arg1 = *(struct DbEnv **)&jarg1; 6601 arg2 = *(DB_TXN **)&jarg2; 6602 arg3 = 0; 6603 if (jarg3) { 6604 arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); 6605 if (!arg3) return ; 6606 } 6607 arg4 = 0; 6608 if (jarg4) { 6609 arg4 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg4, 0); 6610 if (!arg4) return ; 6611 } 6612 arg5 = 0; 6613 if (jarg5) { 6614 arg5 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg5, 0); 6615 if (!arg5) return ; 6616 } 6617 arg6 = (u_int32_t)jarg6; 6618 6619 if (jarg1 == 0) { 6620 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6621 return ; 6622 } 6623 6624 result = (db_ret_t)DbEnv_dbrename(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,arg6); 6625 if (!DB_RETOK_STD(result)) { 6626 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 6627 } 6628 6629 if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); 6630 if (arg4) (*jenv)->ReleaseStringUTFChars(jenv, jarg4, (const char *)arg4); 6631 if (arg5) (*jenv)->ReleaseStringUTFChars(jenv, jarg5, (const char *)arg5); 6632} 6633 6634 6635SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1err(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) { 6636 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6637 int arg2 ; 6638 char *arg3 = (char *) 0 ; 6639 6640 (void)jenv; 6641 (void)jcls; 6642 (void)jarg1_; 6643 arg1 = *(struct DbEnv **)&jarg1; 6644 arg2 = (int)jarg2; 6645 arg3 = 0; 6646 if (jarg3) { 6647 arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); 6648 if (!arg3) return ; 6649 } 6650 6651 if (jarg1 == 0) { 6652 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6653 return ; 6654 } 6655 DbEnv_err(arg1,arg2,(char const *)arg3); 6656 if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); 6657} 6658 6659 6660SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1errx(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { 6661 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6662 char *arg2 = (char *) 0 ; 6663 6664 (void)jenv; 6665 (void)jcls; 6666 (void)jarg1_; 6667 arg1 = *(struct DbEnv **)&jarg1; 6668 arg2 = 0; 6669 if (jarg2) { 6670 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 6671 if (!arg2) return ; 6672 } 6673 6674 if (jarg1 == 0) { 6675 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6676 return ; 6677 } 6678 DbEnv_errx(arg1,(char const *)arg2); 6679 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 6680} 6681 6682 6683SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1cdsgroup_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6684 jlong jresult = 0 ; 6685 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6686 DB_TXN *result = 0 ; 6687 6688 (void)jenv; 6689 (void)jcls; 6690 (void)jarg1_; 6691 arg1 = *(struct DbEnv **)&jarg1; 6692 6693 if (jarg1 == 0) { 6694 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6695 return 0; 6696 } 6697 result = (DB_TXN *)DbEnv_cdsgroup_begin(arg1); 6698 *(DB_TXN **)&jresult = result; 6699 return jresult; 6700} 6701 6702 6703SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1fileid_1reset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) { 6704 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6705 char *arg2 = (char *) 0 ; 6706 u_int32_t arg3 ; 6707 db_ret_t result; 6708 6709 (void)jenv; 6710 (void)jcls; 6711 (void)jarg1_; 6712 arg1 = *(struct DbEnv **)&jarg1; 6713 arg2 = 0; 6714 if (jarg2) { 6715 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 6716 if (!arg2) return ; 6717 } 6718 arg3 = (u_int32_t)jarg3; 6719 6720 if (jarg1 == 0) { 6721 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6722 return ; 6723 } 6724 result = (db_ret_t)DbEnv_fileid_reset(arg1,(char const *)arg2,arg3); 6725 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 6726} 6727 6728 6729SWIGEXPORT jobjectArray JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1data_1dirs(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6730 jobjectArray jresult = 0 ; 6731 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6732 char **result = 0 ; 6733 6734 (void)jenv; 6735 (void)jcls; 6736 (void)jarg1_; 6737 arg1 = *(struct DbEnv **)&jarg1; 6738 6739 if (jarg1 == 0) { 6740 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6741 return 0; 6742 } 6743 6744 errno = 0; 6745 result = (char **)DbEnv_get_data_dirs(arg1); 6746 if (!DB_RETOK_STD(errno)) { 6747 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 6748 } 6749 6750 { 6751 if (result != NULL) { 6752 /*@SWIG:../libdb_java/java_typemaps.i,367,STRING_ARRAY_OUT@*/ int i, len; 6753 6754 len = 0; 6755 while (result[len] != NULL) 6756 len++; 6757 if ((jresult = (*jenv)->NewObjectArray(jenv, (jsize)len, string_class, 6758 NULL)) == NULL) 6759 return 0; /* an exception is pending */ 6760 for (i = 0; i < len; i++) { 6761 jstring str = (*jenv)->NewStringUTF(jenv, result[i]); 6762 (*jenv)->SetObjectArrayElement(jenv, jresult, (jsize)i, str); 6763 } 6764 /*@SWIG@*/ 6765 } 6766 } 6767 return jresult; 6768} 6769 6770 6771SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1encrypt_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6772 jint jresult = 0 ; 6773 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6774 u_int32_t result; 6775 6776 (void)jenv; 6777 (void)jcls; 6778 (void)jarg1_; 6779 arg1 = *(struct DbEnv **)&jarg1; 6780 6781 if (jarg1 == 0) { 6782 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6783 return 0; 6784 } 6785 6786 errno = 0; 6787 result = (u_int32_t)DbEnv_get_encrypt_flags(arg1); 6788 if (!DB_RETOK_STD(errno)) { 6789 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 6790 } 6791 6792 jresult = (jint)result; 6793 return jresult; 6794} 6795 6796 6797SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6798 jint jresult = 0 ; 6799 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6800 u_int32_t result; 6801 6802 (void)jenv; 6803 (void)jcls; 6804 (void)jarg1_; 6805 arg1 = *(struct DbEnv **)&jarg1; 6806 6807 if (jarg1 == 0) { 6808 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6809 return 0; 6810 } 6811 6812 errno = 0; 6813 result = (u_int32_t)DbEnv_get_flags(arg1); 6814 if (!DB_RETOK_STD(errno)) { 6815 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 6816 } 6817 6818 jresult = (jint)result; 6819 return jresult; 6820} 6821 6822 6823SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1home(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6824 jstring jresult = 0 ; 6825 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6826 char *result = 0 ; 6827 6828 (void)jenv; 6829 (void)jcls; 6830 (void)jarg1_; 6831 arg1 = *(struct DbEnv **)&jarg1; 6832 6833 if (jarg1 == 0) { 6834 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6835 return 0; 6836 } 6837 6838 errno = 0; 6839 result = (char *)DbEnv_get_home(arg1); 6840 if (!DB_RETOK_STD(errno)) { 6841 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 6842 } 6843 6844 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); 6845 return jresult; 6846} 6847 6848 6849SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1intermediate_1dir_1mode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6850 jstring jresult = 0 ; 6851 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6852 char *result = 0 ; 6853 6854 (void)jenv; 6855 (void)jcls; 6856 (void)jarg1_; 6857 arg1 = *(struct DbEnv **)&jarg1; 6858 6859 if (jarg1 == 0) { 6860 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6861 return 0; 6862 } 6863 6864 errno = 0; 6865 result = (char *)DbEnv_get_intermediate_dir_mode(arg1); 6866 if (!DB_RETOK_STD(errno)) { 6867 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 6868 } 6869 6870 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); 6871 return jresult; 6872} 6873 6874 6875SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1open_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6876 jint jresult = 0 ; 6877 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6878 u_int32_t result; 6879 6880 (void)jenv; 6881 (void)jcls; 6882 (void)jarg1_; 6883 arg1 = *(struct DbEnv **)&jarg1; 6884 6885 if (jarg1 == 0) { 6886 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6887 return 0; 6888 } 6889 6890 errno = 0; 6891 result = (u_int32_t)DbEnv_get_open_flags(arg1); 6892 if (!DB_RETOK_STD(errno)) { 6893 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 6894 } 6895 6896 jresult = (jint)result; 6897 return jresult; 6898} 6899 6900 6901SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1shm_1key(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6902 jlong jresult = 0 ; 6903 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6904 long result; 6905 6906 (void)jenv; 6907 (void)jcls; 6908 (void)jarg1_; 6909 arg1 = *(struct DbEnv **)&jarg1; 6910 6911 if (jarg1 == 0) { 6912 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6913 return 0; 6914 } 6915 6916 errno = 0; 6917 result = (long)DbEnv_get_shm_key(arg1); 6918 if (!DB_RETOK_STD(errno)) { 6919 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 6920 } 6921 6922 jresult = (jlong)result; 6923 return jresult; 6924} 6925 6926 6927SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1tmp_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6928 jstring jresult = 0 ; 6929 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6930 char *result = 0 ; 6931 6932 (void)jenv; 6933 (void)jcls; 6934 (void)jarg1_; 6935 arg1 = *(struct DbEnv **)&jarg1; 6936 6937 if (jarg1 == 0) { 6938 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6939 return 0; 6940 } 6941 6942 errno = 0; 6943 result = (char *)DbEnv_get_tmp_dir(arg1); 6944 if (!DB_RETOK_STD(errno)) { 6945 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 6946 } 6947 6948 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); 6949 return jresult; 6950} 6951 6952 6953SWIGEXPORT jboolean JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1verbose(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 6954 jboolean jresult = 0 ; 6955 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6956 u_int32_t arg2 ; 6957 int_bool result; 6958 6959 (void)jenv; 6960 (void)jcls; 6961 (void)jarg1_; 6962 arg1 = *(struct DbEnv **)&jarg1; 6963 arg2 = (u_int32_t)jarg2; 6964 6965 if (jarg1 == 0) { 6966 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6967 return 0; 6968 } 6969 6970 errno = 0; 6971 result = (int_bool)DbEnv_get_verbose(arg1,arg2); 6972 if (!DB_RETOK_STD(errno)) { 6973 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 6974 } 6975 6976 jresult = (result) ? JNI_TRUE : JNI_FALSE; 6977 return jresult; 6978} 6979 6980 6981SWIGEXPORT jboolean JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1is_1bigendian(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 6982 jboolean jresult = 0 ; 6983 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 6984 int_bool result; 6985 6986 (void)jenv; 6987 (void)jcls; 6988 (void)jarg1_; 6989 arg1 = *(struct DbEnv **)&jarg1; 6990 6991 if (jarg1 == 0) { 6992 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 6993 return 0; 6994 } 6995 result = (int_bool)DbEnv_is_bigendian(arg1); 6996 jresult = (result) ? JNI_TRUE : JNI_FALSE; 6997 return jresult; 6998} 6999 7000 7001SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1lsn_1reset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) { 7002 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7003 char *arg2 = (char *) 0 ; 7004 u_int32_t arg3 ; 7005 db_ret_t result; 7006 7007 (void)jenv; 7008 (void)jcls; 7009 (void)jarg1_; 7010 arg1 = *(struct DbEnv **)&jarg1; 7011 arg2 = 0; 7012 if (jarg2) { 7013 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 7014 if (!arg2) return ; 7015 } 7016 arg3 = (u_int32_t)jarg3; 7017 7018 if (jarg1 == 0) { 7019 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7020 return ; 7021 } 7022 7023 result = (db_ret_t)DbEnv_lsn_reset(arg1,(char const *)arg2,arg3); 7024 if (!DB_RETOK_STD(result)) { 7025 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7026 } 7027 7028 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 7029} 7030 7031 7032SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1open(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3, jint jarg4) { 7033 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7034 char *arg2 = (char *) 0 ; 7035 u_int32_t arg3 ; 7036 int arg4 ; 7037 db_ret_t result; 7038 7039 (void)jenv; 7040 (void)jcls; 7041 (void)jarg1_; 7042 arg1 = *(struct DbEnv **)&jarg1; 7043 arg2 = 0; 7044 if (jarg2) { 7045 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 7046 if (!arg2) return ; 7047 } 7048 arg3 = (u_int32_t)jarg3; 7049 arg4 = (int)jarg4; 7050 7051 if (jarg1 == 0) { 7052 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7053 return ; 7054 } 7055 7056 result = (db_ret_t)DbEnv_open(arg1,(char const *)arg2,arg3,arg4); 7057 if (!DB_RETOK_STD(result)) { 7058 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7059 } 7060 7061 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 7062} 7063 7064 7065SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1remove0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) { 7066 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7067 char *arg2 = (char *) 0 ; 7068 u_int32_t arg3 ; 7069 db_ret_t result; 7070 7071 (void)jenv; 7072 (void)jcls; 7073 (void)jarg1_; 7074 arg1 = *(struct DbEnv **)&jarg1; 7075 arg2 = 0; 7076 if (jarg2) { 7077 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 7078 if (!arg2) return ; 7079 } 7080 arg3 = (u_int32_t)jarg3; 7081 7082 if (jarg1 == 0) { 7083 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7084 return ; 7085 } 7086 7087 result = (db_ret_t)DbEnv_remove(arg1,(char const *)arg2,arg3); 7088 if (!DB_RETOK_STD(result)) { 7089 __dbj_throw(jenv, result, NULL, NULL, NULL); 7090 } 7091 7092 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 7093} 7094 7095 7096SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1cachesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) { 7097 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7098 jlong arg2 ; 7099 int arg3 ; 7100 db_ret_t result; 7101 7102 (void)jenv; 7103 (void)jcls; 7104 (void)jarg1_; 7105 arg1 = *(struct DbEnv **)&jarg1; 7106 arg2 = jarg2; 7107 arg3 = (int)jarg3; 7108 7109 if (jarg1 == 0) { 7110 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7111 return ; 7112 } 7113 7114 result = (db_ret_t)DbEnv_set_cachesize(arg1,arg2,arg3); 7115 if (!DB_RETOK_STD(result)) { 7116 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7117 } 7118 7119} 7120 7121 7122SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1cache_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 7123 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7124 jlong arg2 ; 7125 db_ret_t result; 7126 7127 (void)jenv; 7128 (void)jcls; 7129 (void)jarg1_; 7130 arg1 = *(struct DbEnv **)&jarg1; 7131 arg2 = jarg2; 7132 7133 if (jarg1 == 0) { 7134 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7135 return ; 7136 } 7137 7138 result = (db_ret_t)DbEnv_set_cache_max(arg1,arg2); 7139 if (!DB_RETOK_STD(result)) { 7140 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7141 } 7142 7143} 7144 7145 7146SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1create_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { 7147 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7148 char *arg2 = (char *) 0 ; 7149 db_ret_t result; 7150 7151 (void)jenv; 7152 (void)jcls; 7153 (void)jarg1_; 7154 arg1 = *(struct DbEnv **)&jarg1; 7155 arg2 = 0; 7156 if (jarg2) { 7157 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 7158 if (!arg2) return ; 7159 } 7160 7161 if (jarg1 == 0) { 7162 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7163 return ; 7164 } 7165 7166 result = (db_ret_t)DbEnv_set_create_dir(arg1,(char const *)arg2); 7167 if (!DB_RETOK_STD(result)) { 7168 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7169 } 7170 7171 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 7172} 7173 7174 7175SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1data_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { 7176 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7177 char *arg2 = (char *) 0 ; 7178 db_ret_t result; 7179 7180 (void)jenv; 7181 (void)jcls; 7182 (void)jarg1_; 7183 arg1 = *(struct DbEnv **)&jarg1; 7184 arg2 = 0; 7185 if (jarg2) { 7186 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 7187 if (!arg2) return ; 7188 } 7189 7190 if (jarg1 == 0) { 7191 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7192 return ; 7193 } 7194 7195 result = (db_ret_t)DbEnv_set_data_dir(arg1,(char const *)arg2); 7196 if (!DB_RETOK_STD(result)) { 7197 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7198 } 7199 7200 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 7201} 7202 7203 7204SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1intermediate_1dir_1mode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { 7205 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7206 char *arg2 = (char *) 0 ; 7207 db_ret_t result; 7208 7209 (void)jenv; 7210 (void)jcls; 7211 (void)jarg1_; 7212 arg1 = *(struct DbEnv **)&jarg1; 7213 arg2 = 0; 7214 if (jarg2) { 7215 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 7216 if (!arg2) return ; 7217 } 7218 7219 if (jarg1 == 0) { 7220 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7221 return ; 7222 } 7223 7224 result = (db_ret_t)DbEnv_set_intermediate_dir_mode(arg1,(char const *)arg2); 7225 if (!DB_RETOK_STD(result)) { 7226 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7227 } 7228 7229 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 7230} 7231 7232 7233SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1encrypt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) { 7234 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7235 char *arg2 = (char *) 0 ; 7236 u_int32_t arg3 ; 7237 db_ret_t result; 7238 7239 (void)jenv; 7240 (void)jcls; 7241 (void)jarg1_; 7242 arg1 = *(struct DbEnv **)&jarg1; 7243 arg2 = 0; 7244 if (jarg2) { 7245 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 7246 if (!arg2) return ; 7247 } 7248 arg3 = (u_int32_t)jarg3; 7249 7250 if (jarg1 == 0) { 7251 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7252 return ; 7253 } 7254 7255 result = (db_ret_t)DbEnv_set_encrypt(arg1,(char const *)arg2,arg3); 7256 if (!DB_RETOK_STD(result)) { 7257 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7258 } 7259 7260 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 7261} 7262 7263 7264SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1errcall(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { 7265 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7266 void (*arg2)(DB_ENV const *,char const *,char const *) = (void (*)(DB_ENV const *,char const *,char const *)) 0 ; 7267 7268 (void)jenv; 7269 (void)jcls; 7270 (void)jarg1_; 7271 arg1 = *(struct DbEnv **)&jarg1; 7272 7273 arg2 = (jarg2 == JNI_TRUE) ? __dbj_error : NULL; 7274 7275 7276 if (jarg1 == 0) { 7277 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7278 return ; 7279 } 7280 DbEnv_set_errcall(arg1,arg2); 7281} 7282 7283 7284SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) { 7285 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7286 u_int32_t arg2 ; 7287 int_bool arg3 ; 7288 db_ret_t result; 7289 7290 (void)jenv; 7291 (void)jcls; 7292 (void)jarg1_; 7293 arg1 = *(struct DbEnv **)&jarg1; 7294 arg2 = (u_int32_t)jarg2; 7295 arg3 = (jarg3 == JNI_TRUE); 7296 7297 if (jarg1 == 0) { 7298 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7299 return ; 7300 } 7301 7302 result = (db_ret_t)DbEnv_set_flags(arg1,arg2,arg3); 7303 if (!DB_RETOK_STD(result)) { 7304 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7305 } 7306 7307} 7308 7309 7310SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1feedback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { 7311 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7312 void (*arg2)(DB_ENV *,int,int) = (void (*)(DB_ENV *,int,int)) 0 ; 7313 db_ret_t result; 7314 7315 (void)jenv; 7316 (void)jcls; 7317 (void)jarg1_; 7318 arg1 = *(struct DbEnv **)&jarg1; 7319 7320 arg2 = (jarg2 == JNI_TRUE) ? __dbj_env_feedback : NULL; 7321 7322 7323 if (jarg1 == 0) { 7324 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7325 return ; 7326 } 7327 7328 result = (db_ret_t)DbEnv_set_feedback(arg1,arg2); 7329 if (!DB_RETOK_STD(result)) { 7330 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7331 } 7332 7333} 7334 7335 7336SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1mp_1max_1openfd(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 7337 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7338 int arg2 ; 7339 db_ret_t result; 7340 7341 (void)jenv; 7342 (void)jcls; 7343 (void)jarg1_; 7344 arg1 = *(struct DbEnv **)&jarg1; 7345 arg2 = (int)jarg2; 7346 7347 if (jarg1 == 0) { 7348 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7349 return ; 7350 } 7351 7352 result = (db_ret_t)DbEnv_set_mp_max_openfd(arg1,arg2); 7353 if (!DB_RETOK_STD(result)) { 7354 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7355 } 7356 7357} 7358 7359 7360SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1mp_1max_1write(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) { 7361 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7362 int arg2 ; 7363 db_timeout_t arg3 ; 7364 db_ret_t result; 7365 7366 (void)jenv; 7367 (void)jcls; 7368 (void)jarg1_; 7369 arg1 = *(struct DbEnv **)&jarg1; 7370 arg2 = (int)jarg2; 7371 arg3 = (db_timeout_t)jarg3; 7372 7373 if (jarg1 == 0) { 7374 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7375 return ; 7376 } 7377 7378 result = (db_ret_t)DbEnv_set_mp_max_write(arg1,arg2,arg3); 7379 if (!DB_RETOK_STD(result)) { 7380 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7381 } 7382 7383} 7384 7385 7386SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1mp_1mmapsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 7387 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7388 size_t arg2 ; 7389 db_ret_t result; 7390 7391 (void)jenv; 7392 (void)jcls; 7393 (void)jarg1_; 7394 arg1 = *(struct DbEnv **)&jarg1; 7395 arg2 = (size_t)jarg2; 7396 7397 if (jarg1 == 0) { 7398 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7399 return ; 7400 } 7401 7402 result = (db_ret_t)DbEnv_set_mp_mmapsize(arg1,arg2); 7403 if (!DB_RETOK_STD(result)) { 7404 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7405 } 7406 7407} 7408 7409 7410SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1mp_1pagesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 7411 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7412 size_t arg2 ; 7413 db_ret_t result; 7414 7415 (void)jenv; 7416 (void)jcls; 7417 (void)jarg1_; 7418 arg1 = *(struct DbEnv **)&jarg1; 7419 arg2 = (size_t)jarg2; 7420 7421 if (jarg1 == 0) { 7422 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7423 return ; 7424 } 7425 7426 result = (db_ret_t)DbEnv_set_mp_pagesize(arg1,arg2); 7427 if (!DB_RETOK_STD(result)) { 7428 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7429 } 7430 7431} 7432 7433 7434SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1mp_1tablesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 7435 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7436 size_t arg2 ; 7437 db_ret_t result; 7438 7439 (void)jenv; 7440 (void)jcls; 7441 (void)jarg1_; 7442 arg1 = *(struct DbEnv **)&jarg1; 7443 arg2 = (size_t)jarg2; 7444 7445 if (jarg1 == 0) { 7446 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7447 return ; 7448 } 7449 7450 result = (db_ret_t)DbEnv_set_mp_tablesize(arg1,arg2); 7451 if (!DB_RETOK_STD(result)) { 7452 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7453 } 7454 7455} 7456 7457 7458SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1msgcall(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { 7459 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7460 void (*arg2)(DB_ENV const *,char const *) = (void (*)(DB_ENV const *,char const *)) 0 ; 7461 7462 (void)jenv; 7463 (void)jcls; 7464 (void)jarg1_; 7465 arg1 = *(struct DbEnv **)&jarg1; 7466 7467 arg2 = (jarg2 == JNI_TRUE) ? __dbj_message : NULL; 7468 7469 7470 if (jarg1 == 0) { 7471 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7472 return ; 7473 } 7474 DbEnv_set_msgcall(arg1,arg2); 7475} 7476 7477 7478SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1paniccall(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { 7479 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7480 void (*arg2)(DB_ENV *,int) = (void (*)(DB_ENV *,int)) 0 ; 7481 db_ret_t result; 7482 7483 (void)jenv; 7484 (void)jcls; 7485 (void)jarg1_; 7486 arg1 = *(struct DbEnv **)&jarg1; 7487 7488 arg2 = (jarg2 == JNI_TRUE) ? __dbj_panic : NULL; 7489 7490 7491 if (jarg1 == 0) { 7492 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7493 return ; 7494 } 7495 7496 result = (db_ret_t)DbEnv_set_paniccall(arg1,arg2); 7497 if (!DB_RETOK_STD(result)) { 7498 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7499 } 7500 7501} 7502 7503 7504SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1rpc_1server(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jlong jarg4, jint jarg5) { 7505 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7506 char *arg2 = (char *) 0 ; 7507 long arg3 ; 7508 long arg4 ; 7509 u_int32_t arg5 ; 7510 db_ret_t result; 7511 7512 (void)jenv; 7513 (void)jcls; 7514 (void)jarg1_; 7515 arg1 = *(struct DbEnv **)&jarg1; 7516 arg2 = 0; 7517 if (jarg2) { 7518 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 7519 if (!arg2) return ; 7520 } 7521 arg3 = (long)jarg3; 7522 arg4 = (long)jarg4; 7523 arg5 = (u_int32_t)jarg5; 7524 7525 if (jarg1 == 0) { 7526 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7527 return ; 7528 } 7529 7530 result = (db_ret_t)DbEnv_set_rpc_server(arg1,arg2,arg3,arg4,arg5); 7531 if (!DB_RETOK_STD(result)) { 7532 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7533 } 7534 7535 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 7536} 7537 7538 7539SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1shm_1key(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 7540 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7541 long arg2 ; 7542 db_ret_t result; 7543 7544 (void)jenv; 7545 (void)jcls; 7546 (void)jarg1_; 7547 arg1 = *(struct DbEnv **)&jarg1; 7548 arg2 = (long)jarg2; 7549 7550 if (jarg1 == 0) { 7551 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7552 return ; 7553 } 7554 7555 result = (db_ret_t)DbEnv_set_shm_key(arg1,arg2); 7556 if (!DB_RETOK_STD(result)) { 7557 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7558 } 7559 7560} 7561 7562 7563SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1timeout(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) { 7564 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7565 db_timeout_t arg2 ; 7566 u_int32_t arg3 ; 7567 db_ret_t result; 7568 7569 (void)jenv; 7570 (void)jcls; 7571 (void)jarg1_; 7572 arg1 = *(struct DbEnv **)&jarg1; 7573 arg2 = (db_timeout_t)jarg2; 7574 arg3 = (u_int32_t)jarg3; 7575 7576 if (jarg1 == 0) { 7577 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7578 return ; 7579 } 7580 7581 result = (db_ret_t)DbEnv_set_timeout(arg1,arg2,arg3); 7582 if (!DB_RETOK_STD(result)) { 7583 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7584 } 7585 7586} 7587 7588 7589SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1tmp_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { 7590 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7591 char *arg2 = (char *) 0 ; 7592 db_ret_t result; 7593 7594 (void)jenv; 7595 (void)jcls; 7596 (void)jarg1_; 7597 arg1 = *(struct DbEnv **)&jarg1; 7598 arg2 = 0; 7599 if (jarg2) { 7600 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 7601 if (!arg2) return ; 7602 } 7603 7604 if (jarg1 == 0) { 7605 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7606 return ; 7607 } 7608 7609 result = (db_ret_t)DbEnv_set_tmp_dir(arg1,(char const *)arg2); 7610 if (!DB_RETOK_STD(result)) { 7611 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7612 } 7613 7614 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 7615} 7616 7617 7618SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1tx_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 7619 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7620 u_int32_t arg2 ; 7621 db_ret_t result; 7622 7623 (void)jenv; 7624 (void)jcls; 7625 (void)jarg1_; 7626 arg1 = *(struct DbEnv **)&jarg1; 7627 arg2 = (u_int32_t)jarg2; 7628 7629 if (jarg1 == 0) { 7630 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7631 return ; 7632 } 7633 7634 result = (db_ret_t)DbEnv_set_tx_max(arg1,arg2); 7635 if (!DB_RETOK_STD(result)) { 7636 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7637 } 7638 7639} 7640 7641 7642SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1app_1dispatch(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { 7643 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7644 int (*arg2)(DB_ENV *,DBT *,DB_LSN *,db_recops) = (int (*)(DB_ENV *,DBT *,DB_LSN *,db_recops)) 0 ; 7645 db_ret_t result; 7646 7647 (void)jenv; 7648 (void)jcls; 7649 (void)jarg1_; 7650 arg1 = *(struct DbEnv **)&jarg1; 7651 7652 arg2 = (jarg2 == JNI_TRUE) ? __dbj_app_dispatch : NULL; 7653 7654 7655 if (jarg1 == 0) { 7656 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7657 return ; 7658 } 7659 7660 result = (db_ret_t)DbEnv_set_app_dispatch(arg1,arg2); 7661 if (!DB_RETOK_STD(result)) { 7662 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7663 } 7664 7665} 7666 7667 7668SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1event_1notify(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { 7669 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7670 void (*arg2)(DB_ENV *,u_int32_t,void *) = (void (*)(DB_ENV *,u_int32_t,void *)) 0 ; 7671 db_ret_t result; 7672 7673 (void)jenv; 7674 (void)jcls; 7675 (void)jarg1_; 7676 arg1 = *(struct DbEnv **)&jarg1; 7677 7678 arg2 = (jarg2 == JNI_TRUE) ? __dbj_event_notify : NULL; 7679 7680 7681 if (jarg1 == 0) { 7682 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7683 return ; 7684 } 7685 7686 result = (db_ret_t)DbEnv_set_event_notify(arg1,arg2); 7687 if (!DB_RETOK_STD(result)) { 7688 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7689 } 7690 7691} 7692 7693 7694SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1tx_1timestamp0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 7695 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7696 time_t *arg2 = (time_t *) 0 ; 7697 time_t time2 ; 7698 db_ret_t result; 7699 7700 (void)jenv; 7701 (void)jcls; 7702 (void)jarg1_; 7703 arg1 = *(struct DbEnv **)&jarg1; 7704 7705 time2 = (time_t)jarg2; 7706 arg2 = &time2; 7707 7708 7709 if (jarg1 == 0) { 7710 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7711 return ; 7712 } 7713 7714 result = (db_ret_t)DbEnv_set_tx_timestamp(arg1,arg2); 7715 if (!DB_RETOK_STD(result)) { 7716 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7717 } 7718 7719} 7720 7721 7722SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1verbose(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) { 7723 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7724 u_int32_t arg2 ; 7725 int_bool arg3 ; 7726 db_ret_t result; 7727 7728 (void)jenv; 7729 (void)jcls; 7730 (void)jarg1_; 7731 arg1 = *(struct DbEnv **)&jarg1; 7732 arg2 = (u_int32_t)jarg2; 7733 arg3 = (jarg3 == JNI_TRUE); 7734 7735 if (jarg1 == 0) { 7736 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7737 return ; 7738 } 7739 7740 result = (db_ret_t)DbEnv_set_verbose(arg1,arg2,arg3); 7741 if (!DB_RETOK_STD(result)) { 7742 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 7743 } 7744 7745} 7746 7747 7748SWIGEXPORT jobjectArray JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lk_1conflicts(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7749 jobjectArray jresult = 0 ; 7750 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7751 struct __db_lk_conflicts result; 7752 7753 (void)jenv; 7754 (void)jcls; 7755 (void)jarg1_; 7756 arg1 = *(struct DbEnv **)&jarg1; 7757 7758 if (jarg1 == 0) { 7759 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7760 return 0; 7761 } 7762 7763 errno = 0; 7764 result = DbEnv_get_lk_conflicts(arg1); 7765 if (!DB_RETOK_STD(errno)) { 7766 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 7767 } 7768 7769 { 7770 int i; 7771 jbyteArray bytes; 7772 7773 jresult = (*jenv)->NewObjectArray(jenv, 7774 (jsize)(&result)->lk_modes, bytearray_class, NULL); 7775 if (jresult == NULL) 7776 return 0; /* an exception is pending */ 7777 for (i = 0; i < (&result)->lk_modes; i++) { 7778 bytes = (*jenv)->NewByteArray(jenv, (jsize)(&result)->lk_modes); 7779 if (bytes == NULL) 7780 return 0; /* an exception is pending */ 7781 (*jenv)->SetByteArrayRegion(jenv, bytes, 0, (jsize)(&result)->lk_modes, 7782 (jbyte *)((&result)->lk_conflicts + i * (&result)->lk_modes)); 7783 (*jenv)->SetObjectArrayElement(jenv, jresult, (jsize)i, bytes); 7784 } 7785 } 7786 return jresult; 7787} 7788 7789 7790SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lk_1detect(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7791 jint jresult = 0 ; 7792 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7793 u_int32_t result; 7794 7795 (void)jenv; 7796 (void)jcls; 7797 (void)jarg1_; 7798 arg1 = *(struct DbEnv **)&jarg1; 7799 7800 if (jarg1 == 0) { 7801 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7802 return 0; 7803 } 7804 7805 errno = 0; 7806 result = (u_int32_t)DbEnv_get_lk_detect(arg1); 7807 if (!DB_RETOK_STD(errno)) { 7808 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 7809 } 7810 7811 jresult = (jint)result; 7812 return jresult; 7813} 7814 7815 7816SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lk_1max_1locks(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7817 jint jresult = 0 ; 7818 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7819 u_int32_t result; 7820 7821 (void)jenv; 7822 (void)jcls; 7823 (void)jarg1_; 7824 arg1 = *(struct DbEnv **)&jarg1; 7825 7826 if (jarg1 == 0) { 7827 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7828 return 0; 7829 } 7830 7831 errno = 0; 7832 result = (u_int32_t)DbEnv_get_lk_max_locks(arg1); 7833 if (!DB_RETOK_STD(errno)) { 7834 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 7835 } 7836 7837 jresult = (jint)result; 7838 return jresult; 7839} 7840 7841 7842SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lk_1max_1lockers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7843 jint jresult = 0 ; 7844 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7845 u_int32_t result; 7846 7847 (void)jenv; 7848 (void)jcls; 7849 (void)jarg1_; 7850 arg1 = *(struct DbEnv **)&jarg1; 7851 7852 if (jarg1 == 0) { 7853 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7854 return 0; 7855 } 7856 7857 errno = 0; 7858 result = (u_int32_t)DbEnv_get_lk_max_lockers(arg1); 7859 if (!DB_RETOK_STD(errno)) { 7860 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 7861 } 7862 7863 jresult = (jint)result; 7864 return jresult; 7865} 7866 7867 7868SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lk_1max_1objects(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7869 jint jresult = 0 ; 7870 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7871 u_int32_t result; 7872 7873 (void)jenv; 7874 (void)jcls; 7875 (void)jarg1_; 7876 arg1 = *(struct DbEnv **)&jarg1; 7877 7878 if (jarg1 == 0) { 7879 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7880 return 0; 7881 } 7882 7883 errno = 0; 7884 result = (u_int32_t)DbEnv_get_lk_max_objects(arg1); 7885 if (!DB_RETOK_STD(errno)) { 7886 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 7887 } 7888 7889 jresult = (jint)result; 7890 return jresult; 7891} 7892 7893 7894SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lk_1partitions(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7895 jint jresult = 0 ; 7896 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7897 u_int32_t result; 7898 7899 (void)jenv; 7900 (void)jcls; 7901 (void)jarg1_; 7902 arg1 = *(struct DbEnv **)&jarg1; 7903 7904 if (jarg1 == 0) { 7905 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7906 return 0; 7907 } 7908 7909 errno = 0; 7910 result = (u_int32_t)DbEnv_get_lk_partitions(arg1); 7911 if (!DB_RETOK_STD(errno)) { 7912 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 7913 } 7914 7915 jresult = (jint)result; 7916 return jresult; 7917} 7918 7919 7920SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1lock_1detect(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { 7921 jint jresult = 0 ; 7922 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7923 u_int32_t arg2 ; 7924 u_int32_t arg3 ; 7925 int result; 7926 7927 (void)jenv; 7928 (void)jcls; 7929 (void)jarg1_; 7930 arg1 = *(struct DbEnv **)&jarg1; 7931 arg2 = (u_int32_t)jarg2; 7932 arg3 = (u_int32_t)jarg3; 7933 7934 if (jarg1 == 0) { 7935 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7936 return 0; 7937 } 7938 7939 errno = 0; 7940 result = (int)DbEnv_lock_detect(arg1,arg2,arg3); 7941 if (!DB_RETOK_STD(errno)) { 7942 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 7943 } 7944 7945 jresult = (jint)result; 7946 return jresult; 7947} 7948 7949 7950SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1lock_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jobject jarg4, jint jarg5) { 7951 jlong jresult = 0 ; 7952 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7953 u_int32_t arg2 ; 7954 u_int32_t arg3 ; 7955 DBT *arg4 = (DBT *) 0 ; 7956 db_lockmode_t arg5 ; 7957 DBT_LOCKED ldbt4 ; 7958 DB_LOCK *result = 0 ; 7959 7960 (void)jenv; 7961 (void)jcls; 7962 (void)jarg1_; 7963 arg1 = *(struct DbEnv **)&jarg1; 7964 arg2 = (u_int32_t)jarg2; 7965 arg3 = (u_int32_t)jarg3; 7966 7967 if (__dbj_dbt_copyin(jenv, &ldbt4, &arg4, jarg4, 0) != 0) { 7968 return 0; /* An exception will be pending. */ 7969 } 7970 arg5 = (db_lockmode_t)jarg5; 7971 7972 if (jarg1 == 0) { 7973 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 7974 return 0; 7975 } 7976 7977 errno = 0; 7978 result = (DB_LOCK *)DbEnv_lock_get(arg1,arg2,arg3,arg4,arg5); 7979 if (!DB_RETOK_STD(errno)) { 7980 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 7981 } 7982 7983 *(DB_LOCK **)&jresult = result; 7984 __dbj_dbt_release(jenv, jarg4, arg4, &ldbt4); 7985 return jresult; 7986} 7987 7988 7989SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1lock_1id(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 7990 jint jresult = 0 ; 7991 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 7992 u_int32_t result; 7993 7994 (void)jenv; 7995 (void)jcls; 7996 (void)jarg1_; 7997 arg1 = *(struct DbEnv **)&jarg1; 7998 7999 if (jarg1 == 0) { 8000 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8001 return 0; 8002 } 8003 8004 errno = 0; 8005 result = (u_int32_t)DbEnv_lock_id(arg1); 8006 if (!DB_RETOK_STD(errno)) { 8007 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 8008 } 8009 8010 jresult = (jint)result; 8011 return jresult; 8012} 8013 8014 8015SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1lock_1id_1free(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8016 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8017 u_int32_t arg2 ; 8018 db_ret_t result; 8019 8020 (void)jenv; 8021 (void)jcls; 8022 (void)jarg1_; 8023 arg1 = *(struct DbEnv **)&jarg1; 8024 arg2 = (u_int32_t)jarg2; 8025 8026 if (jarg1 == 0) { 8027 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8028 return ; 8029 } 8030 8031 result = (db_ret_t)DbEnv_lock_id_free(arg1,arg2); 8032 if (!DB_RETOK_STD(result)) { 8033 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8034 } 8035 8036} 8037 8038 8039SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1lock_1put(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { 8040 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8041 DB_LOCK *arg2 = (DB_LOCK *) 0 ; 8042 db_ret_t result; 8043 8044 (void)jenv; 8045 (void)jcls; 8046 (void)jarg1_; 8047 (void)jarg2_; 8048 arg1 = *(struct DbEnv **)&jarg1; 8049 arg2 = *(DB_LOCK **)&jarg2; 8050 8051 if (jarg1 == 0) { 8052 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8053 return ; 8054 } 8055 8056 result = (db_ret_t)DbEnv_lock_put(arg1,arg2); 8057 if (!DB_RETOK_STD(result)) { 8058 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8059 } 8060 8061} 8062 8063 8064SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1lock_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8065 jobject jresult = 0 ; 8066 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8067 u_int32_t arg2 ; 8068 DB_LOCK_STAT *result = 0 ; 8069 8070 (void)jenv; 8071 (void)jcls; 8072 (void)jarg1_; 8073 arg1 = *(struct DbEnv **)&jarg1; 8074 arg2 = (u_int32_t)jarg2; 8075 8076 if (jarg1 == 0) { 8077 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8078 return 0; 8079 } 8080 8081 errno = 0; 8082 result = (DB_LOCK_STAT *)DbEnv_lock_stat(arg1,arg2); 8083 if (!DB_RETOK_STD(errno)) { 8084 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 8085 } 8086 8087 8088 jresult = (*jenv)->NewObject(jenv, lock_stat_class, lock_stat_construct); 8089 if (jresult != NULL) 8090 __dbj_fill_lock_stat(jenv, jresult, result); 8091 __os_ufree(NULL, result); 8092 8093 return jresult; 8094} 8095 8096 8097SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lk_1conflicts(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2) { 8098 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8099 struct __db_lk_conflicts arg2 ; 8100 db_ret_t result; 8101 8102 (void)jenv; 8103 (void)jcls; 8104 (void)jarg1_; 8105 arg1 = *(struct DbEnv **)&jarg1; 8106 { 8107 int i, len, err; 8108 size_t bytesize; 8109 8110 len = (&arg2)->lk_modes = (*jenv)->GetArrayLength(jenv, jarg2); 8111 bytesize = sizeof(u_char) * len * len; 8112 8113 if ((err = __os_malloc(NULL, bytesize, &(&arg2)->lk_conflicts)) != 0) { 8114 __dbj_throw(jenv, err, NULL, NULL, JDBENV); 8115 return ; 8116 } 8117 8118 for (i = 0; i < len; i++) { 8119 jobject sub_array = (*jenv)->GetObjectArrayElement(jenv, 8120 jarg2, i); 8121 (*jenv)->GetByteArrayRegion(jenv,(jbyteArray)sub_array, 0, len, 8122 (jbyte *)&(&arg2)->lk_conflicts[i * len]); 8123 } 8124 } 8125 8126 if (jarg1 == 0) { 8127 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8128 return ; 8129 } 8130 8131 result = (db_ret_t)DbEnv_set_lk_conflicts(arg1,arg2); 8132 if (!DB_RETOK_STD(result)) { 8133 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8134 } 8135 8136 8137 __os_free(NULL, (&arg2)->lk_conflicts); 8138 8139} 8140 8141 8142SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lk_1detect(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8143 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8144 u_int32_t arg2 ; 8145 db_ret_t result; 8146 8147 (void)jenv; 8148 (void)jcls; 8149 (void)jarg1_; 8150 arg1 = *(struct DbEnv **)&jarg1; 8151 arg2 = (u_int32_t)jarg2; 8152 8153 if (jarg1 == 0) { 8154 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8155 return ; 8156 } 8157 8158 result = (db_ret_t)DbEnv_set_lk_detect(arg1,arg2); 8159 if (!DB_RETOK_STD(result)) { 8160 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8161 } 8162 8163} 8164 8165 8166SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lk_1max_1lockers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8167 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8168 u_int32_t arg2 ; 8169 db_ret_t result; 8170 8171 (void)jenv; 8172 (void)jcls; 8173 (void)jarg1_; 8174 arg1 = *(struct DbEnv **)&jarg1; 8175 arg2 = (u_int32_t)jarg2; 8176 8177 if (jarg1 == 0) { 8178 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8179 return ; 8180 } 8181 8182 result = (db_ret_t)DbEnv_set_lk_max_lockers(arg1,arg2); 8183 if (!DB_RETOK_STD(result)) { 8184 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8185 } 8186 8187} 8188 8189 8190SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lk_1max_1locks(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8191 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8192 u_int32_t arg2 ; 8193 db_ret_t result; 8194 8195 (void)jenv; 8196 (void)jcls; 8197 (void)jarg1_; 8198 arg1 = *(struct DbEnv **)&jarg1; 8199 arg2 = (u_int32_t)jarg2; 8200 8201 if (jarg1 == 0) { 8202 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8203 return ; 8204 } 8205 8206 result = (db_ret_t)DbEnv_set_lk_max_locks(arg1,arg2); 8207 if (!DB_RETOK_STD(result)) { 8208 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8209 } 8210 8211} 8212 8213 8214SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lk_1max_1objects(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8215 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8216 u_int32_t arg2 ; 8217 db_ret_t result; 8218 8219 (void)jenv; 8220 (void)jcls; 8221 (void)jarg1_; 8222 arg1 = *(struct DbEnv **)&jarg1; 8223 arg2 = (u_int32_t)jarg2; 8224 8225 if (jarg1 == 0) { 8226 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8227 return ; 8228 } 8229 8230 result = (db_ret_t)DbEnv_set_lk_max_objects(arg1,arg2); 8231 if (!DB_RETOK_STD(result)) { 8232 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8233 } 8234 8235} 8236 8237 8238SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lk_1partitions(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8239 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8240 u_int32_t arg2 ; 8241 db_ret_t result; 8242 8243 (void)jenv; 8244 (void)jcls; 8245 (void)jarg1_; 8246 arg1 = *(struct DbEnv **)&jarg1; 8247 arg2 = (u_int32_t)jarg2; 8248 8249 if (jarg1 == 0) { 8250 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8251 return ; 8252 } 8253 8254 result = (db_ret_t)DbEnv_set_lk_partitions(arg1,arg2); 8255 if (!DB_RETOK_STD(result)) { 8256 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8257 } 8258 8259} 8260 8261 8262SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lg_1bsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8263 jint jresult = 0 ; 8264 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8265 u_int32_t result; 8266 8267 (void)jenv; 8268 (void)jcls; 8269 (void)jarg1_; 8270 arg1 = *(struct DbEnv **)&jarg1; 8271 8272 if (jarg1 == 0) { 8273 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8274 return 0; 8275 } 8276 8277 errno = 0; 8278 result = (u_int32_t)DbEnv_get_lg_bsize(arg1); 8279 if (!DB_RETOK_STD(errno)) { 8280 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 8281 } 8282 8283 jresult = (jint)result; 8284 return jresult; 8285} 8286 8287 8288SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lg_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8289 jstring jresult = 0 ; 8290 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8291 char *result = 0 ; 8292 8293 (void)jenv; 8294 (void)jcls; 8295 (void)jarg1_; 8296 arg1 = *(struct DbEnv **)&jarg1; 8297 8298 if (jarg1 == 0) { 8299 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8300 return 0; 8301 } 8302 8303 errno = 0; 8304 result = (char *)DbEnv_get_lg_dir(arg1); 8305 if (!DB_RETOK_STD(errno)) { 8306 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 8307 } 8308 8309 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); 8310 return jresult; 8311} 8312 8313 8314SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lg_1filemode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8315 jint jresult = 0 ; 8316 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8317 int result; 8318 8319 (void)jenv; 8320 (void)jcls; 8321 (void)jarg1_; 8322 arg1 = *(struct DbEnv **)&jarg1; 8323 8324 if (jarg1 == 0) { 8325 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8326 return 0; 8327 } 8328 8329 errno = 0; 8330 result = (int)DbEnv_get_lg_filemode(arg1); 8331 if (!DB_RETOK_STD(errno)) { 8332 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 8333 } 8334 8335 jresult = (jint)result; 8336 return jresult; 8337} 8338 8339 8340SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lg_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8341 jint jresult = 0 ; 8342 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8343 u_int32_t result; 8344 8345 (void)jenv; 8346 (void)jcls; 8347 (void)jarg1_; 8348 arg1 = *(struct DbEnv **)&jarg1; 8349 8350 if (jarg1 == 0) { 8351 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8352 return 0; 8353 } 8354 8355 errno = 0; 8356 result = (u_int32_t)DbEnv_get_lg_max(arg1); 8357 if (!DB_RETOK_STD(errno)) { 8358 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 8359 } 8360 8361 jresult = (jint)result; 8362 return jresult; 8363} 8364 8365 8366SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lg_1regionmax(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8367 jint jresult = 0 ; 8368 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8369 u_int32_t result; 8370 8371 (void)jenv; 8372 (void)jcls; 8373 (void)jarg1_; 8374 arg1 = *(struct DbEnv **)&jarg1; 8375 8376 if (jarg1 == 0) { 8377 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8378 return 0; 8379 } 8380 8381 errno = 0; 8382 result = (u_int32_t)DbEnv_get_lg_regionmax(arg1); 8383 if (!DB_RETOK_STD(errno)) { 8384 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 8385 } 8386 8387 jresult = (jint)result; 8388 return jresult; 8389} 8390 8391 8392SWIGEXPORT jobjectArray JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1archive(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8393 jobjectArray jresult = 0 ; 8394 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8395 u_int32_t arg2 ; 8396 char **result = 0 ; 8397 8398 (void)jenv; 8399 (void)jcls; 8400 (void)jarg1_; 8401 arg1 = *(struct DbEnv **)&jarg1; 8402 arg2 = (u_int32_t)jarg2; 8403 8404 if (jarg1 == 0) { 8405 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8406 return 0; 8407 } 8408 8409 errno = 0; 8410 result = (char **)DbEnv_log_archive(arg1,arg2); 8411 if (!DB_RETOK_STD(errno)) { 8412 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 8413 } 8414 8415 { 8416 if (result != NULL) { 8417 /*@SWIG:../libdb_java/java_typemaps.i,367,STRING_ARRAY_OUT@*/ int i, len; 8418 8419 len = 0; 8420 while (result[len] != NULL) 8421 len++; 8422 if ((jresult = (*jenv)->NewObjectArray(jenv, (jsize)len, string_class, 8423 NULL)) == NULL) 8424 return 0; /* an exception is pending */ 8425 for (i = 0; i < len; i++) { 8426 jstring str = (*jenv)->NewStringUTF(jenv, result[i]); 8427 (*jenv)->SetObjectArrayElement(jenv, jresult, (jsize)i, str); 8428 } 8429 /*@SWIG@*/ 8430 __os_ufree(NULL, result); 8431 } 8432 } 8433 return jresult; 8434} 8435 8436 8437SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1compare(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { 8438 jint jresult = 0 ; 8439 DB_LSN *arg1 = (DB_LSN *) 0 ; 8440 DB_LSN *arg2 = (DB_LSN *) 0 ; 8441 DB_LSN lsn1 ; 8442 DB_LSN lsn2 ; 8443 int result; 8444 8445 (void)jenv; 8446 (void)jcls; 8447 8448 if (jarg1 == NULL) { 8449 arg1 = NULL; 8450 } else { 8451 arg1 = &lsn1; 8452 arg1->file = (*jenv)->GetIntField(jenv, jarg1, dblsn_file_fid); 8453 arg1->offset = (*jenv)->GetIntField(jenv, jarg1, 8454 dblsn_offset_fid); 8455 } 8456 8457 8458 if (jarg2 == NULL) { 8459 arg2 = NULL; 8460 } else { 8461 arg2 = &lsn2; 8462 arg2->file = (*jenv)->GetIntField(jenv, jarg2, dblsn_file_fid); 8463 arg2->offset = (*jenv)->GetIntField(jenv, jarg2, 8464 dblsn_offset_fid); 8465 } 8466 8467 8468 if (arg1 == NULL) { 8469 __dbj_throw(jenv, EINVAL, "null LogSequenceNumber", NULL, NULL); 8470 return 0; 8471 } 8472 8473 8474 if (arg2 == NULL) { 8475 __dbj_throw(jenv, EINVAL, "null LogSequenceNumber", NULL, NULL); 8476 return 0; 8477 } 8478 8479 result = (int)DbEnv_log_compare((struct DbLsn const *)arg1,(struct DbLsn const *)arg2); 8480 jresult = (jint)result; 8481 8482 if (jarg1 != NULL) { 8483 (*jenv)->SetIntField(jenv, jarg1, dblsn_file_fid, arg1->file); 8484 (*jenv)->SetIntField(jenv, jarg1, 8485 dblsn_offset_fid, arg1->offset); 8486 } 8487 8488 8489 if (jarg2 != NULL) { 8490 (*jenv)->SetIntField(jenv, jarg2, dblsn_file_fid, arg2->file); 8491 (*jenv)->SetIntField(jenv, jarg2, 8492 dblsn_offset_fid, arg2->offset); 8493 } 8494 8495 return jresult; 8496} 8497 8498 8499SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1cursor(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8500 jlong jresult = 0 ; 8501 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8502 u_int32_t arg2 ; 8503 DB_LOGC *result = 0 ; 8504 8505 (void)jenv; 8506 (void)jcls; 8507 (void)jarg1_; 8508 arg1 = *(struct DbEnv **)&jarg1; 8509 arg2 = (u_int32_t)jarg2; 8510 8511 if (jarg1 == 0) { 8512 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8513 return 0; 8514 } 8515 8516 errno = 0; 8517 result = (DB_LOGC *)DbEnv_log_cursor(arg1,arg2); 8518 if (!DB_RETOK_STD(errno)) { 8519 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 8520 } 8521 8522 *(DB_LOGC **)&jresult = result; 8523 return jresult; 8524} 8525 8526 8527SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 8528 jstring jresult = 0 ; 8529 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8530 DB_LSN *arg2 = (DB_LSN *) 0 ; 8531 DB_LSN lsn2 ; 8532 char *result = 0 ; 8533 8534 (void)jenv; 8535 (void)jcls; 8536 (void)jarg1_; 8537 arg1 = *(struct DbEnv **)&jarg1; 8538 8539 if (jarg2 == NULL) { 8540 arg2 = NULL; 8541 } else { 8542 arg2 = &lsn2; 8543 arg2->file = (*jenv)->GetIntField(jenv, jarg2, dblsn_file_fid); 8544 arg2->offset = (*jenv)->GetIntField(jenv, jarg2, 8545 dblsn_offset_fid); 8546 } 8547 8548 8549 if (jarg1 == 0) { 8550 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8551 return 0; 8552 } 8553 8554 if (arg2 == NULL) { 8555 __dbj_throw(jenv, EINVAL, "null LogSequenceNumber", NULL, NULL); 8556 return 0; 8557 } 8558 8559 8560 errno = 0; 8561 result = (char *)DbEnv_log_file(arg1,arg2); 8562 if (!DB_RETOK_STD(errno)) { 8563 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 8564 } 8565 8566 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); 8567 8568 if (jarg2 != NULL) { 8569 (*jenv)->SetIntField(jenv, jarg2, dblsn_file_fid, arg2->file); 8570 (*jenv)->SetIntField(jenv, jarg2, 8571 dblsn_offset_fid, arg2->offset); 8572 } 8573 8574 return jresult; 8575} 8576 8577 8578SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1flush(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 8579 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8580 DB_LSN *arg2 = (DB_LSN *) 0 ; 8581 DB_LSN lsn2 ; 8582 db_ret_t result; 8583 8584 (void)jenv; 8585 (void)jcls; 8586 (void)jarg1_; 8587 arg1 = *(struct DbEnv **)&jarg1; 8588 8589 if (jarg2 == NULL) { 8590 arg2 = NULL; 8591 } else { 8592 arg2 = &lsn2; 8593 arg2->file = (*jenv)->GetIntField(jenv, jarg2, dblsn_file_fid); 8594 arg2->offset = (*jenv)->GetIntField(jenv, jarg2, 8595 dblsn_offset_fid); 8596 } 8597 8598 8599 if (jarg1 == 0) { 8600 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8601 return ; 8602 } 8603 8604 8605 result = (db_ret_t)DbEnv_log_flush(arg1,(struct DbLsn const *)arg2); 8606 if (!DB_RETOK_STD(result)) { 8607 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8608 } 8609 8610 8611 if (jarg2 != NULL) { 8612 (*jenv)->SetIntField(jenv, jarg2, dblsn_file_fid, arg2->file); 8613 (*jenv)->SetIntField(jenv, jarg2, 8614 dblsn_offset_fid, arg2->offset); 8615 } 8616 8617} 8618 8619 8620SWIGEXPORT jboolean JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1get_1config(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8621 jboolean jresult = 0 ; 8622 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8623 u_int32_t arg2 ; 8624 int_bool result; 8625 8626 (void)jenv; 8627 (void)jcls; 8628 (void)jarg1_; 8629 arg1 = *(struct DbEnv **)&jarg1; 8630 arg2 = (u_int32_t)jarg2; 8631 8632 if (jarg1 == 0) { 8633 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8634 return 0; 8635 } 8636 8637 errno = 0; 8638 result = (int_bool)DbEnv_log_get_config(arg1,arg2); 8639 if (!DB_RETOK_STD(errno)) { 8640 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 8641 } 8642 8643 jresult = (result) ? JNI_TRUE : JNI_FALSE; 8644 return jresult; 8645} 8646 8647 8648SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1put(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jint jarg4) { 8649 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8650 DB_LSN *arg2 = (DB_LSN *) 0 ; 8651 DBT *arg3 = (DBT *) 0 ; 8652 u_int32_t arg4 ; 8653 DB_LSN lsn2 ; 8654 DBT_LOCKED ldbt3 ; 8655 db_ret_t result; 8656 8657 (void)jenv; 8658 (void)jcls; 8659 (void)jarg1_; 8660 arg1 = *(struct DbEnv **)&jarg1; 8661 8662 if (jarg2 == NULL) { 8663 arg2 = NULL; 8664 } else { 8665 arg2 = &lsn2; 8666 arg2->file = (*jenv)->GetIntField(jenv, jarg2, dblsn_file_fid); 8667 arg2->offset = (*jenv)->GetIntField(jenv, jarg2, 8668 dblsn_offset_fid); 8669 } 8670 8671 8672 if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { 8673 return ; /* An exception will be pending. */ 8674 } 8675 arg4 = (u_int32_t)jarg4; 8676 8677 if (jarg1 == 0) { 8678 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8679 return ; 8680 } 8681 8682 if (arg2 == NULL) { 8683 __dbj_throw(jenv, EINVAL, "null LogSequenceNumber", NULL, NULL); 8684 return ; 8685 } 8686 8687 8688 result = (db_ret_t)DbEnv_log_put(arg1,arg2,(struct Dbt const *)arg3,arg4); 8689 if (!DB_RETOK_STD(result)) { 8690 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8691 } 8692 8693 8694 if (jarg2 != NULL) { 8695 (*jenv)->SetIntField(jenv, jarg2, dblsn_file_fid, arg2->file); 8696 (*jenv)->SetIntField(jenv, jarg2, 8697 dblsn_offset_fid, arg2->offset); 8698 } 8699 8700 __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); 8701} 8702 8703 8704SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1print(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3) { 8705 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8706 DB_TXN *arg2 = (DB_TXN *) 0 ; 8707 char *arg3 = (char *) 0 ; 8708 db_ret_t result; 8709 8710 (void)jenv; 8711 (void)jcls; 8712 (void)jarg1_; 8713 (void)jarg2_; 8714 arg1 = *(struct DbEnv **)&jarg1; 8715 arg2 = *(DB_TXN **)&jarg2; 8716 arg3 = 0; 8717 if (jarg3) { 8718 arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); 8719 if (!arg3) return ; 8720 } 8721 8722 if (jarg1 == 0) { 8723 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8724 return ; 8725 } 8726 8727 result = (db_ret_t)DbEnv_log_print(arg1,arg2,(char const *)arg3); 8728 if (!DB_RETOK_STD(result)) { 8729 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8730 } 8731 8732 if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); 8733} 8734 8735 8736SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1set_1config(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) { 8737 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8738 u_int32_t arg2 ; 8739 int_bool arg3 ; 8740 db_ret_t result; 8741 8742 (void)jenv; 8743 (void)jcls; 8744 (void)jarg1_; 8745 arg1 = *(struct DbEnv **)&jarg1; 8746 arg2 = (u_int32_t)jarg2; 8747 arg3 = (jarg3 == JNI_TRUE); 8748 8749 if (jarg1 == 0) { 8750 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8751 return ; 8752 } 8753 8754 result = (db_ret_t)DbEnv_log_set_config(arg1,arg2,arg3); 8755 if (!DB_RETOK_STD(result)) { 8756 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8757 } 8758 8759} 8760 8761 8762SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8763 jobject jresult = 0 ; 8764 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8765 u_int32_t arg2 ; 8766 DB_LOG_STAT *result = 0 ; 8767 8768 (void)jenv; 8769 (void)jcls; 8770 (void)jarg1_; 8771 arg1 = *(struct DbEnv **)&jarg1; 8772 arg2 = (u_int32_t)jarg2; 8773 8774 if (jarg1 == 0) { 8775 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8776 return 0; 8777 } 8778 8779 errno = 0; 8780 result = (DB_LOG_STAT *)DbEnv_log_stat(arg1,arg2); 8781 if (!DB_RETOK_STD(errno)) { 8782 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 8783 } 8784 8785 8786 jresult = (*jenv)->NewObject(jenv, log_stat_class, log_stat_construct); 8787 if (jresult != NULL) 8788 __dbj_fill_log_stat(jenv, jresult, result); 8789 __os_ufree(NULL, result); 8790 8791 return jresult; 8792} 8793 8794 8795SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lg_1bsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8796 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8797 u_int32_t arg2 ; 8798 db_ret_t result; 8799 8800 (void)jenv; 8801 (void)jcls; 8802 (void)jarg1_; 8803 arg1 = *(struct DbEnv **)&jarg1; 8804 arg2 = (u_int32_t)jarg2; 8805 8806 if (jarg1 == 0) { 8807 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8808 return ; 8809 } 8810 8811 result = (db_ret_t)DbEnv_set_lg_bsize(arg1,arg2); 8812 if (!DB_RETOK_STD(result)) { 8813 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8814 } 8815 8816} 8817 8818 8819SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lg_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { 8820 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8821 char *arg2 = (char *) 0 ; 8822 db_ret_t result; 8823 8824 (void)jenv; 8825 (void)jcls; 8826 (void)jarg1_; 8827 arg1 = *(struct DbEnv **)&jarg1; 8828 arg2 = 0; 8829 if (jarg2) { 8830 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 8831 if (!arg2) return ; 8832 } 8833 8834 if (jarg1 == 0) { 8835 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8836 return ; 8837 } 8838 8839 result = (db_ret_t)DbEnv_set_lg_dir(arg1,(char const *)arg2); 8840 if (!DB_RETOK_STD(result)) { 8841 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8842 } 8843 8844 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 8845} 8846 8847 8848SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lg_1filemode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8849 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8850 int arg2 ; 8851 db_ret_t result; 8852 8853 (void)jenv; 8854 (void)jcls; 8855 (void)jarg1_; 8856 arg1 = *(struct DbEnv **)&jarg1; 8857 arg2 = (int)jarg2; 8858 8859 if (jarg1 == 0) { 8860 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8861 return ; 8862 } 8863 8864 result = (db_ret_t)DbEnv_set_lg_filemode(arg1,arg2); 8865 if (!DB_RETOK_STD(result)) { 8866 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8867 } 8868 8869} 8870 8871 8872SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lg_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8873 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8874 u_int32_t arg2 ; 8875 db_ret_t result; 8876 8877 (void)jenv; 8878 (void)jcls; 8879 (void)jarg1_; 8880 arg1 = *(struct DbEnv **)&jarg1; 8881 arg2 = (u_int32_t)jarg2; 8882 8883 if (jarg1 == 0) { 8884 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8885 return ; 8886 } 8887 8888 result = (db_ret_t)DbEnv_set_lg_max(arg1,arg2); 8889 if (!DB_RETOK_STD(result)) { 8890 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8891 } 8892 8893} 8894 8895 8896SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lg_1regionmax(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 8897 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8898 u_int32_t arg2 ; 8899 db_ret_t result; 8900 8901 (void)jenv; 8902 (void)jcls; 8903 (void)jarg1_; 8904 arg1 = *(struct DbEnv **)&jarg1; 8905 arg2 = (u_int32_t)jarg2; 8906 8907 if (jarg1 == 0) { 8908 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8909 return ; 8910 } 8911 8912 result = (db_ret_t)DbEnv_set_lg_regionmax(arg1,arg2); 8913 if (!DB_RETOK_STD(result)) { 8914 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 8915 } 8916 8917} 8918 8919 8920SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1cachesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8921 jlong jresult = 0 ; 8922 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8923 jlong result; 8924 8925 (void)jenv; 8926 (void)jcls; 8927 (void)jarg1_; 8928 arg1 = *(struct DbEnv **)&jarg1; 8929 8930 if (jarg1 == 0) { 8931 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8932 return 0; 8933 } 8934 8935 errno = 0; 8936 result = DbEnv_get_cachesize(arg1); 8937 if (!DB_RETOK_STD(errno)) { 8938 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 8939 } 8940 8941 jresult = result; 8942 return jresult; 8943} 8944 8945 8946SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1cachesize_1ncache(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8947 jint jresult = 0 ; 8948 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8949 int result; 8950 8951 (void)jenv; 8952 (void)jcls; 8953 (void)jarg1_; 8954 arg1 = *(struct DbEnv **)&jarg1; 8955 8956 if (jarg1 == 0) { 8957 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8958 return 0; 8959 } 8960 8961 errno = 0; 8962 result = (int)DbEnv_get_cachesize_ncache(arg1); 8963 if (!DB_RETOK_STD(errno)) { 8964 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 8965 } 8966 8967 jresult = (jint)result; 8968 return jresult; 8969} 8970 8971 8972SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1cache_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8973 jlong jresult = 0 ; 8974 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 8975 jlong result; 8976 8977 (void)jenv; 8978 (void)jcls; 8979 (void)jarg1_; 8980 arg1 = *(struct DbEnv **)&jarg1; 8981 8982 if (jarg1 == 0) { 8983 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 8984 return 0; 8985 } 8986 8987 errno = 0; 8988 result = DbEnv_get_cache_max(arg1); 8989 if (!DB_RETOK_STD(errno)) { 8990 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 8991 } 8992 8993 jresult = result; 8994 return jresult; 8995} 8996 8997 8998SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1create_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 8999 jstring jresult = 0 ; 9000 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9001 char *result = 0 ; 9002 9003 (void)jenv; 9004 (void)jcls; 9005 (void)jarg1_; 9006 arg1 = *(struct DbEnv **)&jarg1; 9007 9008 if (jarg1 == 0) { 9009 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9010 return 0; 9011 } 9012 9013 errno = 0; 9014 result = (char *)DbEnv_get_create_dir(arg1); 9015 if (!DB_RETOK_STD(errno)) { 9016 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9017 } 9018 9019 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); 9020 return jresult; 9021} 9022 9023 9024SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1mp_1max_1openfd(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9025 jint jresult = 0 ; 9026 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9027 int result; 9028 9029 (void)jenv; 9030 (void)jcls; 9031 (void)jarg1_; 9032 arg1 = *(struct DbEnv **)&jarg1; 9033 9034 if (jarg1 == 0) { 9035 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9036 return 0; 9037 } 9038 9039 errno = 0; 9040 result = (int)DbEnv_get_mp_max_openfd(arg1); 9041 if (!DB_RETOK_STD(errno)) { 9042 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9043 } 9044 9045 jresult = (jint)result; 9046 return jresult; 9047} 9048 9049 9050SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1mp_1max_1write(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9051 jint jresult = 0 ; 9052 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9053 int result; 9054 9055 (void)jenv; 9056 (void)jcls; 9057 (void)jarg1_; 9058 arg1 = *(struct DbEnv **)&jarg1; 9059 9060 if (jarg1 == 0) { 9061 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9062 return 0; 9063 } 9064 9065 errno = 0; 9066 result = (int)DbEnv_get_mp_max_write(arg1); 9067 if (!DB_RETOK_STD(errno)) { 9068 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9069 } 9070 9071 jresult = (jint)result; 9072 return jresult; 9073} 9074 9075 9076SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1mp_1max_1write_1sleep(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9077 jlong jresult = 0 ; 9078 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9079 db_timeout_t result; 9080 9081 (void)jenv; 9082 (void)jcls; 9083 (void)jarg1_; 9084 arg1 = *(struct DbEnv **)&jarg1; 9085 9086 if (jarg1 == 0) { 9087 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9088 return 0; 9089 } 9090 9091 errno = 0; 9092 result = (db_timeout_t)DbEnv_get_mp_max_write_sleep(arg1); 9093 if (!DB_RETOK_STD(errno)) { 9094 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9095 } 9096 9097 jresult = (jlong)result; 9098 return jresult; 9099} 9100 9101 9102SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1mp_1mmapsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9103 jlong jresult = 0 ; 9104 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9105 size_t result; 9106 9107 (void)jenv; 9108 (void)jcls; 9109 (void)jarg1_; 9110 arg1 = *(struct DbEnv **)&jarg1; 9111 9112 if (jarg1 == 0) { 9113 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9114 return 0; 9115 } 9116 9117 errno = 0; 9118 result = DbEnv_get_mp_mmapsize(arg1); 9119 if (!DB_RETOK_STD(errno)) { 9120 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9121 } 9122 9123 jresult = (jlong)result; 9124 return jresult; 9125} 9126 9127 9128SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1mp_1pagesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9129 jint jresult = 0 ; 9130 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9131 int result; 9132 9133 (void)jenv; 9134 (void)jcls; 9135 (void)jarg1_; 9136 arg1 = *(struct DbEnv **)&jarg1; 9137 9138 if (jarg1 == 0) { 9139 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9140 return 0; 9141 } 9142 9143 errno = 0; 9144 result = (int)DbEnv_get_mp_pagesize(arg1); 9145 if (!DB_RETOK_STD(errno)) { 9146 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9147 } 9148 9149 jresult = (jint)result; 9150 return jresult; 9151} 9152 9153 9154SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1mp_1tablesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9155 jint jresult = 0 ; 9156 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9157 int result; 9158 9159 (void)jenv; 9160 (void)jcls; 9161 (void)jarg1_; 9162 arg1 = *(struct DbEnv **)&jarg1; 9163 9164 if (jarg1 == 0) { 9165 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9166 return 0; 9167 } 9168 9169 errno = 0; 9170 result = (int)DbEnv_get_mp_tablesize(arg1); 9171 if (!DB_RETOK_STD(errno)) { 9172 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9173 } 9174 9175 jresult = (jint)result; 9176 return jresult; 9177} 9178 9179 9180SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1memp_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9181 jobject jresult = 0 ; 9182 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9183 u_int32_t arg2 ; 9184 DB_MPOOL_STAT *result = 0 ; 9185 9186 (void)jenv; 9187 (void)jcls; 9188 (void)jarg1_; 9189 arg1 = *(struct DbEnv **)&jarg1; 9190 arg2 = (u_int32_t)jarg2; 9191 9192 if (jarg1 == 0) { 9193 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9194 return 0; 9195 } 9196 9197 errno = 0; 9198 result = (DB_MPOOL_STAT *)DbEnv_memp_stat(arg1,arg2); 9199 if (!DB_RETOK_STD(errno)) { 9200 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9201 } 9202 9203 9204 jresult = (*jenv)->NewObject(jenv, mpool_stat_class, mpool_stat_construct); 9205 if (jresult != NULL) 9206 __dbj_fill_mpool_stat(jenv, jresult, result); 9207 __os_ufree(NULL, result); 9208 9209 return jresult; 9210} 9211 9212 9213SWIGEXPORT jobjectArray JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1memp_1fstat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9214 jobjectArray jresult = 0 ; 9215 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9216 u_int32_t arg2 ; 9217 DB_MPOOL_FSTAT **result = 0 ; 9218 9219 (void)jenv; 9220 (void)jcls; 9221 (void)jarg1_; 9222 arg1 = *(struct DbEnv **)&jarg1; 9223 arg2 = (u_int32_t)jarg2; 9224 9225 if (jarg1 == 0) { 9226 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9227 return 0; 9228 } 9229 9230 errno = 0; 9231 result = (DB_MPOOL_FSTAT **)DbEnv_memp_fstat(arg1,arg2); 9232 if (!DB_RETOK_STD(errno)) { 9233 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9234 } 9235 9236 { 9237 int i, len; 9238 9239 len = 0; 9240 while (result[len] != NULL) 9241 len++; 9242 jresult = (*jenv)->NewObjectArray(jenv, (jsize)len, 9243 mpool_fstat_class, 0); 9244 if (jresult == NULL) { 9245 __os_ufree(NULL, result); 9246 return 0; 9247 } 9248 for (i = 0; i < len; i++) { 9249 jobject obj = (*jenv)->NewObject(jenv, mpool_fstat_class, 9250 mpool_fstat_construct); 9251 if (obj == NULL) { 9252 __os_ufree(NULL, result); 9253 return 0; /* an exception is pending */ 9254 } 9255 (*jenv)->SetObjectArrayElement(jenv, jresult, i, obj); 9256 __dbj_fill_mpool_fstat(jenv, obj, result[i]); 9257 } 9258 __os_ufree(NULL, result); 9259 } 9260 return jresult; 9261} 9262 9263 9264SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1memp_1sync(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 9265 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9266 DB_LSN *arg2 = (DB_LSN *) 0 ; 9267 DB_LSN lsn2 ; 9268 db_ret_t result; 9269 9270 (void)jenv; 9271 (void)jcls; 9272 (void)jarg1_; 9273 arg1 = *(struct DbEnv **)&jarg1; 9274 9275 if (jarg2 == NULL) { 9276 arg2 = NULL; 9277 } else { 9278 arg2 = &lsn2; 9279 arg2->file = (*jenv)->GetIntField(jenv, jarg2, dblsn_file_fid); 9280 arg2->offset = (*jenv)->GetIntField(jenv, jarg2, 9281 dblsn_offset_fid); 9282 } 9283 9284 9285 if (jarg1 == 0) { 9286 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9287 return ; 9288 } 9289 9290 if (arg2 == NULL) { 9291 __dbj_throw(jenv, EINVAL, "null LogSequenceNumber", NULL, NULL); 9292 return ; 9293 } 9294 9295 9296 errno = 0; 9297 result = (db_ret_t)DbEnv_memp_sync(arg1,arg2); 9298 if (!DB_RETOK_STD(errno)) { 9299 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9300 } 9301 9302 9303 if (jarg2 != NULL) { 9304 (*jenv)->SetIntField(jenv, jarg2, dblsn_file_fid, arg2->file); 9305 (*jenv)->SetIntField(jenv, jarg2, 9306 dblsn_offset_fid, arg2->offset); 9307 } 9308 9309} 9310 9311 9312SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1memp_1trickle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9313 jint jresult = 0 ; 9314 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9315 int arg2 ; 9316 int result; 9317 9318 (void)jenv; 9319 (void)jcls; 9320 (void)jarg1_; 9321 arg1 = *(struct DbEnv **)&jarg1; 9322 arg2 = (int)jarg2; 9323 9324 if (jarg1 == 0) { 9325 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9326 return 0; 9327 } 9328 9329 errno = 0; 9330 result = (int)DbEnv_memp_trickle(arg1,arg2); 9331 if (!DB_RETOK_STD(errno)) { 9332 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9333 } 9334 9335 jresult = (jint)result; 9336 return jresult; 9337} 9338 9339 9340SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1get_1align(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9341 jint jresult = 0 ; 9342 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9343 u_int32_t result; 9344 9345 (void)jenv; 9346 (void)jcls; 9347 (void)jarg1_; 9348 arg1 = *(struct DbEnv **)&jarg1; 9349 9350 if (jarg1 == 0) { 9351 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9352 return 0; 9353 } 9354 9355 errno = 0; 9356 result = (u_int32_t)DbEnv_mutex_get_align(arg1); 9357 if (!DB_RETOK_STD(errno)) { 9358 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9359 } 9360 9361 jresult = (jint)result; 9362 return jresult; 9363} 9364 9365 9366SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1get_1increment(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9367 jint jresult = 0 ; 9368 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9369 u_int32_t result; 9370 9371 (void)jenv; 9372 (void)jcls; 9373 (void)jarg1_; 9374 arg1 = *(struct DbEnv **)&jarg1; 9375 9376 if (jarg1 == 0) { 9377 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9378 return 0; 9379 } 9380 9381 errno = 0; 9382 result = (u_int32_t)DbEnv_mutex_get_increment(arg1); 9383 if (!DB_RETOK_STD(errno)) { 9384 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9385 } 9386 9387 jresult = (jint)result; 9388 return jresult; 9389} 9390 9391 9392SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1get_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9393 jint jresult = 0 ; 9394 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9395 u_int32_t result; 9396 9397 (void)jenv; 9398 (void)jcls; 9399 (void)jarg1_; 9400 arg1 = *(struct DbEnv **)&jarg1; 9401 9402 if (jarg1 == 0) { 9403 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9404 return 0; 9405 } 9406 9407 errno = 0; 9408 result = (u_int32_t)DbEnv_mutex_get_max(arg1); 9409 if (!DB_RETOK_STD(errno)) { 9410 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9411 } 9412 9413 jresult = (jint)result; 9414 return jresult; 9415} 9416 9417 9418SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1get_1tas_1spins(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9419 jint jresult = 0 ; 9420 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9421 u_int32_t result; 9422 9423 (void)jenv; 9424 (void)jcls; 9425 (void)jarg1_; 9426 arg1 = *(struct DbEnv **)&jarg1; 9427 9428 if (jarg1 == 0) { 9429 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9430 return 0; 9431 } 9432 9433 errno = 0; 9434 result = (u_int32_t)DbEnv_mutex_get_tas_spins(arg1); 9435 if (!DB_RETOK_STD(errno)) { 9436 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9437 } 9438 9439 jresult = (jint)result; 9440 return jresult; 9441} 9442 9443 9444SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1set_1align(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9445 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9446 u_int32_t arg2 ; 9447 db_ret_t result; 9448 9449 (void)jenv; 9450 (void)jcls; 9451 (void)jarg1_; 9452 arg1 = *(struct DbEnv **)&jarg1; 9453 arg2 = (u_int32_t)jarg2; 9454 9455 if (jarg1 == 0) { 9456 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9457 return ; 9458 } 9459 9460 result = (db_ret_t)DbEnv_mutex_set_align(arg1,arg2); 9461 if (!DB_RETOK_STD(result)) { 9462 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 9463 } 9464 9465} 9466 9467 9468SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1set_1increment(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9469 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9470 u_int32_t arg2 ; 9471 db_ret_t result; 9472 9473 (void)jenv; 9474 (void)jcls; 9475 (void)jarg1_; 9476 arg1 = *(struct DbEnv **)&jarg1; 9477 arg2 = (u_int32_t)jarg2; 9478 9479 if (jarg1 == 0) { 9480 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9481 return ; 9482 } 9483 9484 result = (db_ret_t)DbEnv_mutex_set_increment(arg1,arg2); 9485 if (!DB_RETOK_STD(result)) { 9486 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 9487 } 9488 9489} 9490 9491 9492SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1set_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9493 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9494 u_int32_t arg2 ; 9495 db_ret_t result; 9496 9497 (void)jenv; 9498 (void)jcls; 9499 (void)jarg1_; 9500 arg1 = *(struct DbEnv **)&jarg1; 9501 arg2 = (u_int32_t)jarg2; 9502 9503 if (jarg1 == 0) { 9504 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9505 return ; 9506 } 9507 9508 result = (db_ret_t)DbEnv_mutex_set_max(arg1,arg2); 9509 if (!DB_RETOK_STD(result)) { 9510 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 9511 } 9512 9513} 9514 9515 9516SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1set_1tas_1spins(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9517 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9518 u_int32_t arg2 ; 9519 db_ret_t result; 9520 9521 (void)jenv; 9522 (void)jcls; 9523 (void)jarg1_; 9524 arg1 = *(struct DbEnv **)&jarg1; 9525 arg2 = (u_int32_t)jarg2; 9526 9527 if (jarg1 == 0) { 9528 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9529 return ; 9530 } 9531 9532 result = (db_ret_t)DbEnv_mutex_set_tas_spins(arg1,arg2); 9533 if (!DB_RETOK_STD(result)) { 9534 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 9535 } 9536 9537} 9538 9539 9540SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9541 jobject jresult = 0 ; 9542 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9543 u_int32_t arg2 ; 9544 DB_MUTEX_STAT *result = 0 ; 9545 9546 (void)jenv; 9547 (void)jcls; 9548 (void)jarg1_; 9549 arg1 = *(struct DbEnv **)&jarg1; 9550 arg2 = (u_int32_t)jarg2; 9551 9552 if (jarg1 == 0) { 9553 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9554 return 0; 9555 } 9556 9557 errno = 0; 9558 result = (DB_MUTEX_STAT *)DbEnv_mutex_stat(arg1,arg2); 9559 if (!DB_RETOK_STD(errno)) { 9560 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9561 } 9562 9563 9564 jresult = (*jenv)->NewObject(jenv, mutex_stat_class, mutex_stat_construct); 9565 if (jresult != NULL) 9566 __dbj_fill_mutex_stat(jenv, jresult, result); 9567 __os_ufree(NULL, result); 9568 9569 return jresult; 9570} 9571 9572 9573SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1tx_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9574 jint jresult = 0 ; 9575 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9576 u_int32_t result; 9577 9578 (void)jenv; 9579 (void)jcls; 9580 (void)jarg1_; 9581 arg1 = *(struct DbEnv **)&jarg1; 9582 9583 if (jarg1 == 0) { 9584 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9585 return 0; 9586 } 9587 9588 errno = 0; 9589 result = (u_int32_t)DbEnv_get_tx_max(arg1); 9590 if (!DB_RETOK_STD(errno)) { 9591 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9592 } 9593 9594 jresult = (jint)result; 9595 return jresult; 9596} 9597 9598 9599SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1tx_1timestamp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9600 jlong jresult = 0 ; 9601 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9602 time_t result; 9603 9604 (void)jenv; 9605 (void)jcls; 9606 (void)jarg1_; 9607 arg1 = *(struct DbEnv **)&jarg1; 9608 9609 if (jarg1 == 0) { 9610 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9611 return 0; 9612 } 9613 9614 errno = 0; 9615 result = DbEnv_get_tx_timestamp(arg1); 9616 if (!DB_RETOK_STD(errno)) { 9617 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9618 } 9619 9620 jresult = (jlong)result; 9621 return jresult; 9622} 9623 9624 9625SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1timeout(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9626 jlong jresult = 0 ; 9627 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9628 u_int32_t arg2 ; 9629 db_timeout_t result; 9630 9631 (void)jenv; 9632 (void)jcls; 9633 (void)jarg1_; 9634 arg1 = *(struct DbEnv **)&jarg1; 9635 arg2 = (u_int32_t)jarg2; 9636 9637 if (jarg1 == 0) { 9638 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9639 return 0; 9640 } 9641 9642 errno = 0; 9643 result = (db_timeout_t)DbEnv_get_timeout(arg1,arg2); 9644 if (!DB_RETOK_STD(errno)) { 9645 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9646 } 9647 9648 jresult = (jlong)result; 9649 return jresult; 9650} 9651 9652 9653SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1txn_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3) { 9654 jlong jresult = 0 ; 9655 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9656 DB_TXN *arg2 = (DB_TXN *) 0 ; 9657 u_int32_t arg3 ; 9658 DB_TXN *result = 0 ; 9659 9660 (void)jenv; 9661 (void)jcls; 9662 (void)jarg1_; 9663 (void)jarg2_; 9664 arg1 = *(struct DbEnv **)&jarg1; 9665 arg2 = *(DB_TXN **)&jarg2; 9666 arg3 = (u_int32_t)jarg3; 9667 9668 if (jarg1 == 0) { 9669 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9670 return 0; 9671 } 9672 9673 errno = 0; 9674 result = (DB_TXN *)DbEnv_txn_begin(arg1,arg2,arg3); 9675 if (!DB_RETOK_STD(errno)) { 9676 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9677 } 9678 9679 *(DB_TXN **)&jresult = result; 9680 return jresult; 9681} 9682 9683 9684SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1txn_1checkpoint(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4) { 9685 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9686 u_int32_t arg2 ; 9687 u_int32_t arg3 ; 9688 u_int32_t arg4 ; 9689 db_ret_t result; 9690 9691 (void)jenv; 9692 (void)jcls; 9693 (void)jarg1_; 9694 arg1 = *(struct DbEnv **)&jarg1; 9695 arg2 = (u_int32_t)jarg2; 9696 arg3 = (u_int32_t)jarg3; 9697 arg4 = (u_int32_t)jarg4; 9698 9699 if (jarg1 == 0) { 9700 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9701 return ; 9702 } 9703 9704 result = (db_ret_t)DbEnv_txn_checkpoint(arg1,arg2,arg3,arg4); 9705 if (!DB_RETOK_STD(result)) { 9706 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 9707 } 9708 9709} 9710 9711 9712SWIGEXPORT jobjectArray JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1txn_1recover(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { 9713 jobjectArray jresult = 0 ; 9714 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9715 int arg2 ; 9716 u_int32_t arg3 ; 9717 DB_PREPLIST *result = 0 ; 9718 9719 (void)jenv; 9720 (void)jcls; 9721 (void)jarg1_; 9722 arg1 = *(struct DbEnv **)&jarg1; 9723 arg2 = (int)jarg2; 9724 arg3 = (u_int32_t)jarg3; 9725 9726 if (jarg1 == 0) { 9727 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9728 return 0; 9729 } 9730 9731 errno = 0; 9732 result = (DB_PREPLIST *)DbEnv_txn_recover(arg1,arg2,arg3); 9733 if (!DB_RETOK_STD(errno)) { 9734 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9735 } 9736 9737 { 9738 int i, len; 9739 9740 len = 0; 9741 while (result[len].txn != NULL) 9742 len++; 9743 jresult = (*jenv)->NewObjectArray(jenv, (jsize)len, dbpreplist_class, 9744 NULL); 9745 if (jresult == NULL) 9746 return 0; /* an exception is pending */ 9747 for (i = 0; i < len; i++) { 9748 jobject jtxn = (*jenv)->NewObject(jenv, dbtxn_class, 9749 dbtxn_construct, result[i].txn, JNI_FALSE); 9750 jobject bytearr = (*jenv)->NewByteArray(jenv, 9751 (jsize)sizeof(result[i].gid)); 9752 jobject obj = (*jenv)->NewObject(jenv, dbpreplist_class, 9753 dbpreplist_construct, jtxn, bytearr); 9754 9755 if (jtxn == NULL || bytearr == NULL || obj == NULL) 9756 return 0; /* An exception is pending */ 9757 9758 (*jenv)->SetByteArrayRegion(jenv, bytearr, 0, 9759 (jsize)sizeof(result[i].gid), (jbyte *)result[i].gid); 9760 (*jenv)->SetObjectArrayElement(jenv, jresult, i, obj); 9761 } 9762 __os_ufree(NULL, result); 9763 } 9764 return jresult; 9765} 9766 9767 9768SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1txn_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 9769 jobject jresult = 0 ; 9770 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9771 u_int32_t arg2 ; 9772 DB_TXN_STAT *result = 0 ; 9773 9774 (void)jenv; 9775 (void)jcls; 9776 (void)jarg1_; 9777 arg1 = *(struct DbEnv **)&jarg1; 9778 arg2 = (u_int32_t)jarg2; 9779 9780 if (jarg1 == 0) { 9781 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9782 return 0; 9783 } 9784 9785 errno = 0; 9786 result = (DB_TXN_STAT *)DbEnv_txn_stat(arg1,arg2); 9787 if (!DB_RETOK_STD(errno)) { 9788 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9789 } 9790 9791 { 9792 unsigned int i; 9793 jobjectArray actives; 9794 jresult = (*jenv)->NewObject(jenv, txn_stat_class, txn_stat_construct); 9795 if (jresult != NULL) 9796 __dbj_fill_txn_stat(jenv, jresult, result); 9797 9798 actives = (*jenv)->NewObjectArray(jenv, (jsize)result->st_nactive, 9799 txn_active_class, 0); 9800 if (actives == NULL) { 9801 __os_ufree(NULL, result); 9802 return 0; 9803 } 9804 (*jenv)->SetObjectField(jenv, jresult, 9805 txn_stat_st_txnarray_fid, actives); 9806 for (i = 0; i < result->st_nactive; i++) { 9807 jobject obj = (*jenv)->NewObject(jenv, txn_active_class, 9808 txn_active_construct); 9809 if (obj == NULL) { 9810 __os_ufree(NULL, result); 9811 return 0; /* an exception is pending */ 9812 } 9813 (*jenv)->SetObjectArrayElement(jenv, actives, (jsize)i, obj); 9814 __dbj_fill_txn_active(jenv, obj, &result->st_txnarray[i]); 9815 } 9816 __os_ufree(NULL, result); 9817 } 9818 return jresult; 9819} 9820 9821 9822SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1limit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9823 jlong jresult = 0 ; 9824 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9825 jlong result; 9826 9827 (void)jenv; 9828 (void)jcls; 9829 (void)jarg1_; 9830 arg1 = *(struct DbEnv **)&jarg1; 9831 9832 if (jarg1 == 0) { 9833 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9834 return 0; 9835 } 9836 9837 errno = 0; 9838 result = DbEnv_rep_get_limit(arg1); 9839 if (!DB_RETOK_STD(errno)) { 9840 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 9841 } 9842 9843 jresult = result; 9844 return jresult; 9845} 9846 9847 9848SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1elect(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4) { 9849 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9850 u_int32_t arg2 ; 9851 int arg3 ; 9852 u_int32_t arg4 ; 9853 db_ret_t result; 9854 9855 (void)jenv; 9856 (void)jcls; 9857 (void)jarg1_; 9858 arg1 = *(struct DbEnv **)&jarg1; 9859 arg2 = (u_int32_t)jarg2; 9860 arg3 = (int)jarg3; 9861 arg4 = (u_int32_t)jarg4; 9862 9863 if (jarg1 == 0) { 9864 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9865 return ; 9866 } 9867 9868 result = (db_ret_t)DbEnv_rep_elect(arg1,arg2,arg3,arg4); 9869 if (!DB_RETOK_STD(result)) { 9870 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 9871 } 9872 9873} 9874 9875 9876SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1process_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jint jarg4, jobject jarg5) { 9877 jint jresult = 0 ; 9878 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9879 DBT *arg2 = (DBT *) 0 ; 9880 DBT *arg3 = (DBT *) 0 ; 9881 int arg4 ; 9882 DB_LSN *arg5 = (DB_LSN *) 0 ; 9883 DBT_LOCKED ldbt2 ; 9884 DBT_LOCKED ldbt3 ; 9885 DB_LSN lsn5 ; 9886 int result; 9887 9888 (void)jenv; 9889 (void)jcls; 9890 (void)jarg1_; 9891 arg1 = *(struct DbEnv **)&jarg1; 9892 9893 if (__dbj_dbt_copyin(jenv, &ldbt2, &arg2, jarg2, 0) != 0) { 9894 return 0; /* An exception will be pending. */ 9895 } 9896 9897 if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { 9898 return 0; /* An exception will be pending. */ 9899 } 9900 arg4 = (int)jarg4; 9901 9902 if (jarg5 == NULL) { 9903 arg5 = NULL; 9904 } else { 9905 arg5 = &lsn5; 9906 arg5->file = (*jenv)->GetIntField(jenv, jarg5, dblsn_file_fid); 9907 arg5->offset = (*jenv)->GetIntField(jenv, jarg5, 9908 dblsn_offset_fid); 9909 } 9910 9911 9912 if (jarg1 == 0) { 9913 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9914 return 0; 9915 } 9916 9917 if (arg5 == NULL) { 9918 __dbj_throw(jenv, EINVAL, "null LogSequenceNumber", NULL, NULL); 9919 return 0; 9920 } 9921 9922 9923 result = (int)DbEnv_rep_process_message(arg1,arg2,arg3,arg4,arg5); 9924 if (!DB_RETOK_REPPMSG(result)) { 9925 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 9926 } 9927 9928 jresult = (jint)result; 9929 __dbj_dbt_release(jenv, jarg2, arg2, &ldbt2); 9930 __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); 9931 9932 if (jarg5 != NULL) { 9933 (*jenv)->SetIntField(jenv, jarg5, dblsn_file_fid, arg5->file); 9934 (*jenv)->SetIntField(jenv, jarg5, 9935 dblsn_offset_fid, arg5->offset); 9936 } 9937 9938 return jresult; 9939} 9940 9941 9942SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1flush(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 9943 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9944 db_ret_t result; 9945 9946 (void)jenv; 9947 (void)jcls; 9948 (void)jarg1_; 9949 arg1 = *(struct DbEnv **)&jarg1; 9950 9951 if (jarg1 == 0) { 9952 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9953 return ; 9954 } 9955 9956 result = (db_ret_t)DbEnv_rep_flush(arg1); 9957 if (!DB_RETOK_STD(result)) { 9958 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 9959 } 9960 9961} 9962 9963 9964SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1set_1config(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) { 9965 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9966 u_int32_t arg2 ; 9967 int_bool arg3 ; 9968 db_ret_t result; 9969 9970 (void)jenv; 9971 (void)jcls; 9972 (void)jarg1_; 9973 arg1 = *(struct DbEnv **)&jarg1; 9974 arg2 = (u_int32_t)jarg2; 9975 arg3 = (jarg3 == JNI_TRUE); 9976 9977 if (jarg1 == 0) { 9978 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 9979 return ; 9980 } 9981 9982 result = (db_ret_t)DbEnv_rep_set_config(arg1,arg2,arg3); 9983 if (!DB_RETOK_STD(result)) { 9984 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 9985 } 9986 9987} 9988 9989 9990SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1set_1clockskew(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { 9991 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 9992 u_int32_t arg2 ; 9993 u_int32_t arg3 ; 9994 db_ret_t result; 9995 9996 (void)jenv; 9997 (void)jcls; 9998 (void)jarg1_; 9999 arg1 = *(struct DbEnv **)&jarg1; 10000 arg2 = (u_int32_t)jarg2; 10001 arg3 = (u_int32_t)jarg3; 10002 10003 if (jarg1 == 0) { 10004 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10005 return ; 10006 } 10007 10008 result = (db_ret_t)DbEnv_rep_set_clockskew(arg1,arg2,arg3); 10009 if (!DB_RETOK_STD(result)) { 10010 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 10011 } 10012 10013} 10014 10015 10016SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1clockskew_1fast(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10017 jint jresult = 0 ; 10018 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10019 u_int32_t result; 10020 10021 (void)jenv; 10022 (void)jcls; 10023 (void)jarg1_; 10024 arg1 = *(struct DbEnv **)&jarg1; 10025 10026 if (jarg1 == 0) { 10027 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10028 return 0; 10029 } 10030 10031 errno = 0; 10032 result = (u_int32_t)DbEnv_rep_get_clockskew_fast(arg1); 10033 if (!DB_RETOK_STD(errno)) { 10034 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 10035 } 10036 10037 jresult = (jint)result; 10038 return jresult; 10039} 10040 10041 10042SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1clockskew_1slow(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10043 jint jresult = 0 ; 10044 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10045 u_int32_t result; 10046 10047 (void)jenv; 10048 (void)jcls; 10049 (void)jarg1_; 10050 arg1 = *(struct DbEnv **)&jarg1; 10051 10052 if (jarg1 == 0) { 10053 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10054 return 0; 10055 } 10056 10057 errno = 0; 10058 result = (u_int32_t)DbEnv_rep_get_clockskew_slow(arg1); 10059 if (!DB_RETOK_STD(errno)) { 10060 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 10061 } 10062 10063 jresult = (jint)result; 10064 return jresult; 10065} 10066 10067 10068SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1start(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jint jarg3) { 10069 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10070 DBT *arg2 = (DBT *) 0 ; 10071 u_int32_t arg3 ; 10072 DBT_LOCKED ldbt2 ; 10073 db_ret_t result; 10074 10075 (void)jenv; 10076 (void)jcls; 10077 (void)jarg1_; 10078 arg1 = *(struct DbEnv **)&jarg1; 10079 10080 if (__dbj_dbt_copyin(jenv, &ldbt2, &arg2, jarg2, 1) != 0) { 10081 return ; /* An exception will be pending. */ 10082 } 10083 arg3 = (u_int32_t)jarg3; 10084 10085 if (jarg1 == 0) { 10086 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10087 return ; 10088 } 10089 10090 result = (db_ret_t)DbEnv_rep_start(arg1,arg2,arg3); 10091 if (!DB_RETOK_STD(result)) { 10092 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 10093 } 10094 10095 __dbj_dbt_release(jenv, jarg2, arg2, &ldbt2); 10096} 10097 10098 10099SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1sync(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10100 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10101 u_int32_t arg2 ; 10102 db_ret_t result; 10103 10104 (void)jenv; 10105 (void)jcls; 10106 (void)jarg1_; 10107 arg1 = *(struct DbEnv **)&jarg1; 10108 arg2 = (u_int32_t)jarg2; 10109 10110 if (jarg1 == 0) { 10111 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10112 return ; 10113 } 10114 10115 result = (db_ret_t)DbEnv_rep_sync(arg1,arg2); 10116 if (!DB_RETOK_STD(result)) { 10117 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 10118 } 10119 10120} 10121 10122 10123SWIGEXPORT jboolean JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1config(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10124 jboolean jresult = 0 ; 10125 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10126 u_int32_t arg2 ; 10127 int_bool result; 10128 10129 (void)jenv; 10130 (void)jcls; 10131 (void)jarg1_; 10132 arg1 = *(struct DbEnv **)&jarg1; 10133 arg2 = (u_int32_t)jarg2; 10134 10135 if (jarg1 == 0) { 10136 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10137 return 0; 10138 } 10139 10140 errno = 0; 10141 result = (int_bool)DbEnv_rep_get_config(arg1,arg2); 10142 if (!DB_RETOK_STD(errno)) { 10143 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 10144 } 10145 10146 jresult = (result) ? JNI_TRUE : JNI_FALSE; 10147 return jresult; 10148} 10149 10150 10151SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10152 jobject jresult = 0 ; 10153 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10154 u_int32_t arg2 ; 10155 DB_REP_STAT *result = 0 ; 10156 10157 (void)jenv; 10158 (void)jcls; 10159 (void)jarg1_; 10160 arg1 = *(struct DbEnv **)&jarg1; 10161 arg2 = (u_int32_t)jarg2; 10162 10163 if (jarg1 == 0) { 10164 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10165 return 0; 10166 } 10167 10168 errno = 0; 10169 result = (DB_REP_STAT *)DbEnv_rep_stat(arg1,arg2); 10170 if (!DB_RETOK_STD(errno)) { 10171 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 10172 } 10173 10174 10175 jresult = (*jenv)->NewObject(jenv, rep_stat_class, rep_stat_construct); 10176 if (jresult != NULL) 10177 __dbj_fill_rep_stat(jenv, jresult, result); 10178 __os_ufree(NULL, result); 10179 10180 return jresult; 10181} 10182 10183 10184SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1set_1limit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 10185 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10186 jlong arg2 ; 10187 db_ret_t result; 10188 10189 (void)jenv; 10190 (void)jcls; 10191 (void)jarg1_; 10192 arg1 = *(struct DbEnv **)&jarg1; 10193 arg2 = jarg2; 10194 10195 if (jarg1 == 0) { 10196 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10197 return ; 10198 } 10199 10200 result = (db_ret_t)DbEnv_rep_set_limit(arg1,arg2); 10201 if (!DB_RETOK_STD(result)) { 10202 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 10203 } 10204 10205} 10206 10207 10208SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1request_1min(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10209 jint jresult = 0 ; 10210 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10211 u_int32_t result; 10212 10213 (void)jenv; 10214 (void)jcls; 10215 (void)jarg1_; 10216 arg1 = *(struct DbEnv **)&jarg1; 10217 10218 if (jarg1 == 0) { 10219 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10220 return 0; 10221 } 10222 10223 errno = 0; 10224 result = (u_int32_t)DbEnv_rep_get_request_min(arg1); 10225 if (!DB_RETOK_STD(errno)) { 10226 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 10227 } 10228 10229 jresult = (jint)result; 10230 return jresult; 10231} 10232 10233 10234SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1request_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10235 jint jresult = 0 ; 10236 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10237 u_int32_t result; 10238 10239 (void)jenv; 10240 (void)jcls; 10241 (void)jarg1_; 10242 arg1 = *(struct DbEnv **)&jarg1; 10243 10244 if (jarg1 == 0) { 10245 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10246 return 0; 10247 } 10248 10249 errno = 0; 10250 result = (u_int32_t)DbEnv_rep_get_request_max(arg1); 10251 if (!DB_RETOK_STD(errno)) { 10252 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 10253 } 10254 10255 jresult = (jint)result; 10256 return jresult; 10257} 10258 10259 10260SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1set_1request(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { 10261 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10262 u_int32_t arg2 ; 10263 u_int32_t arg3 ; 10264 db_ret_t result; 10265 10266 (void)jenv; 10267 (void)jcls; 10268 (void)jarg1_; 10269 arg1 = *(struct DbEnv **)&jarg1; 10270 arg2 = (u_int32_t)jarg2; 10271 arg3 = (u_int32_t)jarg3; 10272 10273 if (jarg1 == 0) { 10274 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10275 return ; 10276 } 10277 10278 result = (db_ret_t)DbEnv_rep_set_request(arg1,arg2,arg3); 10279 if (!DB_RETOK_STD(result)) { 10280 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 10281 } 10282 10283} 10284 10285 10286SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1set_1transport(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) { 10287 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10288 int arg2 ; 10289 int (*arg3)(DB_ENV *,DBT const *,DBT const *,DB_LSN const *,int,u_int32_t) = (int (*)(DB_ENV *,DBT const *,DBT const *,DB_LSN const *,int,u_int32_t)) 0 ; 10290 db_ret_t result; 10291 10292 (void)jenv; 10293 (void)jcls; 10294 (void)jarg1_; 10295 arg1 = *(struct DbEnv **)&jarg1; 10296 arg2 = (int)jarg2; 10297 10298 arg3 = (jarg3 == JNI_TRUE) ? __dbj_rep_transport : NULL; 10299 10300 10301 if (jarg1 == 0) { 10302 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10303 return ; 10304 } 10305 10306 result = (db_ret_t)DbEnv_rep_set_transport(arg1,arg2,arg3); 10307 if (!DB_RETOK_STD(result)) { 10308 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 10309 } 10310 10311} 10312 10313 10314SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1nsites(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10315 jint jresult = 0 ; 10316 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10317 u_int32_t result; 10318 10319 (void)jenv; 10320 (void)jcls; 10321 (void)jarg1_; 10322 arg1 = *(struct DbEnv **)&jarg1; 10323 10324 if (jarg1 == 0) { 10325 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10326 return 0; 10327 } 10328 10329 errno = 0; 10330 result = (u_int32_t)DbEnv_rep_get_nsites(arg1); 10331 if (!DB_RETOK_STD(errno)) { 10332 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 10333 } 10334 10335 jresult = (jint)result; 10336 return jresult; 10337} 10338 10339 10340SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1priority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10341 jint jresult = 0 ; 10342 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10343 u_int32_t result; 10344 10345 (void)jenv; 10346 (void)jcls; 10347 (void)jarg1_; 10348 arg1 = *(struct DbEnv **)&jarg1; 10349 10350 if (jarg1 == 0) { 10351 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10352 return 0; 10353 } 10354 10355 errno = 0; 10356 result = (u_int32_t)DbEnv_rep_get_priority(arg1); 10357 if (!DB_RETOK_STD(errno)) { 10358 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 10359 } 10360 10361 jresult = (jint)result; 10362 return jresult; 10363} 10364 10365 10366SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1timeout(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10367 jint jresult = 0 ; 10368 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10369 int arg2 ; 10370 u_int32_t result; 10371 10372 (void)jenv; 10373 (void)jcls; 10374 (void)jarg1_; 10375 arg1 = *(struct DbEnv **)&jarg1; 10376 arg2 = (int)jarg2; 10377 10378 if (jarg1 == 0) { 10379 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10380 return 0; 10381 } 10382 10383 errno = 0; 10384 result = (u_int32_t)DbEnv_rep_get_timeout(arg1,arg2); 10385 if (!DB_RETOK_STD(errno)) { 10386 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 10387 } 10388 10389 jresult = (jint)result; 10390 return jresult; 10391} 10392 10393 10394SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1set_1nsites(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10395 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10396 u_int32_t arg2 ; 10397 db_ret_t result; 10398 10399 (void)jenv; 10400 (void)jcls; 10401 (void)jarg1_; 10402 arg1 = *(struct DbEnv **)&jarg1; 10403 arg2 = (u_int32_t)jarg2; 10404 10405 if (jarg1 == 0) { 10406 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10407 return ; 10408 } 10409 10410 result = (db_ret_t)DbEnv_rep_set_nsites(arg1,arg2); 10411 if (!DB_RETOK_STD(result)) { 10412 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 10413 } 10414 10415} 10416 10417 10418SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1set_1priority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10419 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10420 u_int32_t arg2 ; 10421 db_ret_t result; 10422 10423 (void)jenv; 10424 (void)jcls; 10425 (void)jarg1_; 10426 arg1 = *(struct DbEnv **)&jarg1; 10427 arg2 = (u_int32_t)jarg2; 10428 10429 if (jarg1 == 0) { 10430 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10431 return ; 10432 } 10433 10434 result = (db_ret_t)DbEnv_rep_set_priority(arg1,arg2); 10435 if (!DB_RETOK_STD(result)) { 10436 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 10437 } 10438 10439} 10440 10441 10442SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1set_1timeout(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) { 10443 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10444 int arg2 ; 10445 db_timeout_t arg3 ; 10446 db_ret_t result; 10447 10448 (void)jenv; 10449 (void)jcls; 10450 (void)jarg1_; 10451 arg1 = *(struct DbEnv **)&jarg1; 10452 arg2 = (int)jarg2; 10453 arg3 = (db_timeout_t)jarg3; 10454 10455 if (jarg1 == 0) { 10456 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10457 return ; 10458 } 10459 10460 result = (db_ret_t)DbEnv_rep_set_timeout(arg1,arg2,arg3); 10461 if (!DB_RETOK_STD(result)) { 10462 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 10463 } 10464 10465} 10466 10467 10468SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1repmgr_1add_1remote_1site(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3, jint jarg4) { 10469 jint jresult = 0 ; 10470 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10471 char *arg2 = (char *) 0 ; 10472 u_int32_t arg3 ; 10473 u_int32_t arg4 ; 10474 int result; 10475 10476 (void)jenv; 10477 (void)jcls; 10478 (void)jarg1_; 10479 arg1 = *(struct DbEnv **)&jarg1; 10480 arg2 = 0; 10481 if (jarg2) { 10482 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 10483 if (!arg2) return 0; 10484 } 10485 arg3 = (u_int32_t)jarg3; 10486 arg4 = (u_int32_t)jarg4; 10487 10488 if (jarg1 == 0) { 10489 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10490 return 0; 10491 } 10492 10493 errno = 0; 10494 result = (int)DbEnv_repmgr_add_remote_site(arg1,(char const *)arg2,arg3,arg4); 10495 if (!DB_RETOK_STD(errno)) { 10496 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 10497 } 10498 10499 jresult = (jint)result; 10500 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 10501 return jresult; 10502} 10503 10504 10505SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1repmgr_1get_1ack_1policy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10506 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10507 db_ret_t result; 10508 10509 (void)jenv; 10510 (void)jcls; 10511 (void)jarg1_; 10512 arg1 = *(struct DbEnv **)&jarg1; 10513 10514 if (jarg1 == 0) { 10515 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10516 return ; 10517 } 10518 10519 result = (db_ret_t)DbEnv_repmgr_get_ack_policy(arg1); 10520 if (!DB_RETOK_STD(result)) { 10521 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 10522 } 10523 10524} 10525 10526 10527SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1repmgr_1set_1ack_1policy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10528 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10529 int arg2 ; 10530 db_ret_t result; 10531 10532 (void)jenv; 10533 (void)jcls; 10534 (void)jarg1_; 10535 arg1 = *(struct DbEnv **)&jarg1; 10536 arg2 = (int)jarg2; 10537 10538 if (jarg1 == 0) { 10539 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10540 return ; 10541 } 10542 10543 result = (db_ret_t)DbEnv_repmgr_set_ack_policy(arg1,arg2); 10544 if (!DB_RETOK_STD(result)) { 10545 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 10546 } 10547 10548} 10549 10550 10551SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1repmgr_1set_1local_1site(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3, jint jarg4) { 10552 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10553 char *arg2 = (char *) 0 ; 10554 u_int32_t arg3 ; 10555 u_int32_t arg4 ; 10556 db_ret_t result; 10557 10558 (void)jenv; 10559 (void)jcls; 10560 (void)jarg1_; 10561 arg1 = *(struct DbEnv **)&jarg1; 10562 arg2 = 0; 10563 if (jarg2) { 10564 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 10565 if (!arg2) return ; 10566 } 10567 arg3 = (u_int32_t)jarg3; 10568 arg4 = (u_int32_t)jarg4; 10569 10570 if (jarg1 == 0) { 10571 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10572 return ; 10573 } 10574 10575 result = (db_ret_t)DbEnv_repmgr_set_local_site(arg1,(char const *)arg2,arg3,arg4); 10576 if (!DB_RETOK_STD(result)) { 10577 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 10578 } 10579 10580 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 10581} 10582 10583 10584SWIGEXPORT jobjectArray JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1repmgr_1site_1list(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10585 jobjectArray jresult = 0 ; 10586 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10587 struct __db_repmgr_sites result; 10588 10589 (void)jenv; 10590 (void)jcls; 10591 (void)jarg1_; 10592 arg1 = *(struct DbEnv **)&jarg1; 10593 10594 if (jarg1 == 0) { 10595 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10596 return 0; 10597 } 10598 10599 errno = 0; 10600 result = DbEnv_repmgr_site_list(arg1); 10601 if (!DB_RETOK_STD(errno)) { 10602 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 10603 } 10604 10605 { 10606 int i, len; 10607 jobject jrep_addr, jrep_info; 10608 10609 len = (&result)->nsites; 10610 jresult = (*jenv)->NewObjectArray(jenv, (jsize)len, repmgr_siteinfo_class, 10611 NULL); 10612 if (jresult == NULL) 10613 return 0; /* an exception is pending */ 10614 for (i = 0; i < len; i++) { 10615 jstring addr_host = (*jenv)->NewStringUTF(jenv, (&result)->sites[i].host); 10616 if (addr_host == NULL) 10617 return 0; /* An exception is pending */ 10618 jrep_addr = (*jenv)->NewObject(jenv, 10619 rephost_class, rephost_construct, addr_host, (&result)->sites[i].port); 10620 if (jrep_addr == NULL) 10621 return 0; /* An exception is pending */ 10622 10623 jrep_info = (*jenv)->NewObject(jenv, 10624 repmgr_siteinfo_class, repmgr_siteinfo_construct, jrep_addr, (&result)->sites[i].eid); 10625 (*jenv)->SetIntField(jenv, jrep_info, repmgr_siteinfo_status_fid, 10626 (&result)->sites[i].status); 10627 if (jrep_info == NULL) 10628 return 0; /* An exception is pending */ 10629 10630 (*jenv)->SetObjectArrayElement(jenv, jresult, i, jrep_info); 10631 } 10632 __os_ufree(NULL, (&result)->sites); 10633 } 10634 return jresult; 10635} 10636 10637 10638SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1repmgr_1start(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { 10639 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10640 int arg2 ; 10641 u_int32_t arg3 ; 10642 db_ret_t result; 10643 10644 (void)jenv; 10645 (void)jcls; 10646 (void)jarg1_; 10647 arg1 = *(struct DbEnv **)&jarg1; 10648 arg2 = (int)jarg2; 10649 arg3 = (u_int32_t)jarg3; 10650 10651 if (jarg1 == 0) { 10652 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10653 return ; 10654 } 10655 10656 result = (db_ret_t)DbEnv_repmgr_start(arg1,arg2,arg3); 10657 if (!DB_RETOK_REPMGR_START(result)) { 10658 __dbj_throw(jenv, result, NULL, NULL, JDBENV); 10659 } 10660 10661} 10662 10663 10664SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1repmgr_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10665 jobject jresult = 0 ; 10666 struct DbEnv *arg1 = (struct DbEnv *) 0 ; 10667 u_int32_t arg2 ; 10668 DB_REPMGR_STAT *result = 0 ; 10669 10670 (void)jenv; 10671 (void)jcls; 10672 (void)jarg1_; 10673 arg1 = *(struct DbEnv **)&jarg1; 10674 arg2 = (u_int32_t)jarg2; 10675 10676 if (jarg1 == 0) { 10677 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10678 return 0; 10679 } 10680 10681 errno = 0; 10682 result = (DB_REPMGR_STAT *)DbEnv_repmgr_stat(arg1,arg2); 10683 if (!DB_RETOK_STD(errno)) { 10684 __dbj_throw(jenv, errno, NULL, NULL, JDBENV); 10685 } 10686 10687 10688 jresult = (*jenv)->NewObject(jenv, repmgr_stat_class, repmgr_stat_construct); 10689 if (jresult != NULL) 10690 __dbj_fill_repmgr_stat(jenv, jresult, result); 10691 __os_ufree(NULL, result); 10692 10693 return jresult; 10694} 10695 10696 10697SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1strerror(JNIEnv *jenv, jclass jcls, jint jarg1) { 10698 jstring jresult = 0 ; 10699 int arg1 ; 10700 char *result = 0 ; 10701 10702 (void)jenv; 10703 (void)jcls; 10704 arg1 = (int)jarg1; 10705 result = (char *)DbEnv_strerror(arg1); 10706 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); 10707 return jresult; 10708} 10709 10710 10711SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1version_1major(JNIEnv *jenv, jclass jcls) { 10712 jint jresult = 0 ; 10713 int result; 10714 10715 (void)jenv; 10716 (void)jcls; 10717 result = (int)DbEnv_get_version_major(); 10718 jresult = (jint)result; 10719 return jresult; 10720} 10721 10722 10723SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1version_1minor(JNIEnv *jenv, jclass jcls) { 10724 jint jresult = 0 ; 10725 int result; 10726 10727 (void)jenv; 10728 (void)jcls; 10729 result = (int)DbEnv_get_version_minor(); 10730 jresult = (jint)result; 10731 return jresult; 10732} 10733 10734 10735SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1version_1patch(JNIEnv *jenv, jclass jcls) { 10736 jint jresult = 0 ; 10737 int result; 10738 10739 (void)jenv; 10740 (void)jcls; 10741 result = (int)DbEnv_get_version_patch(); 10742 jresult = (jint)result; 10743 return jresult; 10744} 10745 10746 10747SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1version_1string(JNIEnv *jenv, jclass jcls) { 10748 jstring jresult = 0 ; 10749 char *result = 0 ; 10750 10751 (void)jenv; 10752 (void)jcls; 10753 result = (char *)DbEnv_get_version_string(); 10754 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); 10755 return jresult; 10756} 10757 10758 10759SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_delete_1DbLock(JNIEnv *jenv, jclass jcls, jlong jarg1) { 10760 struct DbLock *arg1 = (struct DbLock *) 0 ; 10761 10762 (void)jenv; 10763 (void)jcls; 10764 arg1 = *(struct DbLock **)&jarg1; 10765 10766 if (jarg1 == 0) { 10767 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10768 return ; 10769 } 10770 delete_DbLock(arg1); 10771} 10772 10773 10774SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbLogc_1close0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10775 struct DbLogc *arg1 = (struct DbLogc *) 0 ; 10776 u_int32_t arg2 ; 10777 db_ret_t result; 10778 10779 (void)jenv; 10780 (void)jcls; 10781 (void)jarg1_; 10782 arg1 = *(struct DbLogc **)&jarg1; 10783 arg2 = (u_int32_t)jarg2; 10784 10785 if (jarg1 == 0) { 10786 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10787 return ; 10788 } 10789 10790 result = (db_ret_t)DbLogc_close(arg1,arg2); 10791 if (!DB_RETOK_STD(result)) { 10792 __dbj_throw(jenv, result, NULL, NULL, NULL); 10793 } 10794 10795} 10796 10797 10798SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbLogc_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3, jint jarg4) { 10799 jint jresult = 0 ; 10800 struct DbLogc *arg1 = (struct DbLogc *) 0 ; 10801 DB_LSN *arg2 = (DB_LSN *) 0 ; 10802 DBT *arg3 = (DBT *) 0 ; 10803 u_int32_t arg4 ; 10804 DB_LSN lsn2 ; 10805 DBT_LOCKED ldbt3 ; 10806 int result; 10807 10808 (void)jenv; 10809 (void)jcls; 10810 (void)jarg1_; 10811 arg1 = *(struct DbLogc **)&jarg1; 10812 10813 if (jarg2 == NULL) { 10814 arg2 = NULL; 10815 } else { 10816 arg2 = &lsn2; 10817 arg2->file = (*jenv)->GetIntField(jenv, jarg2, dblsn_file_fid); 10818 arg2->offset = (*jenv)->GetIntField(jenv, jarg2, 10819 dblsn_offset_fid); 10820 } 10821 10822 10823 if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { 10824 return 0; /* An exception will be pending. */ 10825 } 10826 arg4 = (u_int32_t)jarg4; 10827 10828 if (jarg1 == 0) { 10829 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10830 return 0; 10831 } 10832 10833 if (arg2 == NULL) { 10834 __dbj_throw(jenv, EINVAL, "null LogSequenceNumber", NULL, NULL); 10835 return 0; 10836 } 10837 10838 10839 result = (int)DbLogc_get(arg1,arg2,arg3,arg4); 10840 if (!DB_RETOK_LGGET(result)) { 10841 __dbj_throw(jenv, result, NULL, NULL, NULL); 10842 } 10843 10844 jresult = (jint)result; 10845 10846 if (jarg2 != NULL) { 10847 (*jenv)->SetIntField(jenv, jarg2, dblsn_file_fid, arg2->file); 10848 (*jenv)->SetIntField(jenv, jarg2, 10849 dblsn_offset_fid, arg2->offset); 10850 } 10851 10852 __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); 10853 return jresult; 10854} 10855 10856 10857SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbLogc_1version(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10858 jint jresult = 0 ; 10859 struct DbLogc *arg1 = (struct DbLogc *) 0 ; 10860 u_int32_t arg2 ; 10861 u_int32_t result; 10862 10863 (void)jenv; 10864 (void)jcls; 10865 (void)jarg1_; 10866 arg1 = *(struct DbLogc **)&jarg1; 10867 arg2 = (u_int32_t)jarg2; 10868 10869 if (jarg1 == 0) { 10870 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10871 return 0; 10872 } 10873 10874 errno = 0; 10875 result = (u_int32_t)DbLogc_version(arg1,arg2); 10876 if (!DB_RETOK_STD(errno)) { 10877 __dbj_throw(jenv, errno, NULL, NULL, NULL); 10878 } 10879 10880 jresult = (jint)result; 10881 return jresult; 10882} 10883 10884 10885SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbMpoolFile_1get_1priority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10886 jint jresult = 0 ; 10887 struct DbMpoolFile *arg1 = (struct DbMpoolFile *) 0 ; 10888 DB_CACHE_PRIORITY result; 10889 10890 (void)jenv; 10891 (void)jcls; 10892 (void)jarg1_; 10893 arg1 = *(struct DbMpoolFile **)&jarg1; 10894 10895 if (jarg1 == 0) { 10896 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10897 return 0; 10898 } 10899 10900 errno = 0; 10901 result = (DB_CACHE_PRIORITY)DbMpoolFile_get_priority(arg1); 10902 if (!DB_RETOK_STD(errno)) { 10903 __dbj_throw(jenv, errno, NULL, NULL, NULL); 10904 } 10905 10906 jresult = (jint)result; 10907 return jresult; 10908} 10909 10910 10911SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbMpoolFile_1set_1priority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 10912 struct DbMpoolFile *arg1 = (struct DbMpoolFile *) 0 ; 10913 DB_CACHE_PRIORITY arg2 ; 10914 db_ret_t result; 10915 10916 (void)jenv; 10917 (void)jcls; 10918 (void)jarg1_; 10919 arg1 = *(struct DbMpoolFile **)&jarg1; 10920 arg2 = (DB_CACHE_PRIORITY)jarg2; 10921 10922 if (jarg1 == 0) { 10923 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10924 return ; 10925 } 10926 10927 result = (db_ret_t)DbMpoolFile_set_priority(arg1,arg2); 10928 if (!DB_RETOK_STD(result)) { 10929 __dbj_throw(jenv, result, NULL, NULL, NULL); 10930 } 10931 10932} 10933 10934 10935SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbMpoolFile_1get_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10936 jint jresult = 0 ; 10937 struct DbMpoolFile *arg1 = (struct DbMpoolFile *) 0 ; 10938 u_int32_t result; 10939 10940 (void)jenv; 10941 (void)jcls; 10942 (void)jarg1_; 10943 arg1 = *(struct DbMpoolFile **)&jarg1; 10944 10945 if (jarg1 == 0) { 10946 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10947 return 0; 10948 } 10949 10950 errno = 0; 10951 result = (u_int32_t)DbMpoolFile_get_flags(arg1); 10952 if (!DB_RETOK_STD(errno)) { 10953 __dbj_throw(jenv, errno, NULL, NULL, NULL); 10954 } 10955 10956 jresult = (jint)result; 10957 return jresult; 10958} 10959 10960 10961SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbMpoolFile_1set_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) { 10962 struct DbMpoolFile *arg1 = (struct DbMpoolFile *) 0 ; 10963 u_int32_t arg2 ; 10964 int_bool arg3 ; 10965 db_ret_t result; 10966 10967 (void)jenv; 10968 (void)jcls; 10969 (void)jarg1_; 10970 arg1 = *(struct DbMpoolFile **)&jarg1; 10971 arg2 = (u_int32_t)jarg2; 10972 arg3 = (jarg3 == JNI_TRUE); 10973 10974 if (jarg1 == 0) { 10975 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10976 return ; 10977 } 10978 10979 result = (db_ret_t)DbMpoolFile_set_flags(arg1,arg2,arg3); 10980 if (!DB_RETOK_STD(result)) { 10981 __dbj_throw(jenv, result, NULL, NULL, NULL); 10982 } 10983 10984} 10985 10986 10987SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbMpoolFile_1get_1maxsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 10988 jlong jresult = 0 ; 10989 struct DbMpoolFile *arg1 = (struct DbMpoolFile *) 0 ; 10990 jlong result; 10991 10992 (void)jenv; 10993 (void)jcls; 10994 (void)jarg1_; 10995 arg1 = *(struct DbMpoolFile **)&jarg1; 10996 10997 if (jarg1 == 0) { 10998 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 10999 return 0; 11000 } 11001 11002 errno = 0; 11003 result = DbMpoolFile_get_maxsize(arg1); 11004 if (!DB_RETOK_STD(errno)) { 11005 __dbj_throw(jenv, errno, NULL, NULL, NULL); 11006 } 11007 11008 jresult = result; 11009 return jresult; 11010} 11011 11012 11013SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbMpoolFile_1set_1maxsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 11014 struct DbMpoolFile *arg1 = (struct DbMpoolFile *) 0 ; 11015 jlong arg2 ; 11016 db_ret_t result; 11017 11018 (void)jenv; 11019 (void)jcls; 11020 (void)jarg1_; 11021 arg1 = *(struct DbMpoolFile **)&jarg1; 11022 arg2 = jarg2; 11023 11024 if (jarg1 == 0) { 11025 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11026 return ; 11027 } 11028 11029 result = (db_ret_t)DbMpoolFile_set_maxsize(arg1,arg2); 11030 if (!DB_RETOK_STD(result)) { 11031 __dbj_throw(jenv, result, NULL, NULL, NULL); 11032 } 11033 11034} 11035 11036 11037SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_new_1DbSequence(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 11038 jlong jresult = 0 ; 11039 DB *arg1 = (DB *) 0 ; 11040 u_int32_t arg2 ; 11041 struct DbSequence *result = 0 ; 11042 11043 (void)jenv; 11044 (void)jcls; 11045 (void)jarg1_; 11046 arg1 = *(DB **)&jarg1; 11047 arg2 = (u_int32_t)jarg2; 11048 11049 errno = 0; 11050 result = (struct DbSequence *)new_DbSequence(arg1,arg2); 11051 if (!DB_RETOK_STD(errno)) { 11052 __dbj_throw(jenv, errno, NULL, NULL, NULL); 11053 } 11054 11055 *(struct DbSequence **)&jresult = result; 11056 return jresult; 11057} 11058 11059 11060SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1close0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 11061 struct DbSequence *arg1 = (struct DbSequence *) 0 ; 11062 u_int32_t arg2 ; 11063 db_ret_t result; 11064 11065 (void)jenv; 11066 (void)jcls; 11067 (void)jarg1_; 11068 arg1 = *(struct DbSequence **)&jarg1; 11069 arg2 = (u_int32_t)jarg2; 11070 11071 if (jarg1 == 0) { 11072 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11073 return ; 11074 } 11075 11076 result = (db_ret_t)DbSequence_close(arg1,arg2); 11077 if (!DB_RETOK_STD(result)) { 11078 __dbj_throw(jenv, result, NULL, NULL, NULL); 11079 } 11080 11081} 11082 11083 11084SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, jint jarg4) { 11085 jlong jresult = 0 ; 11086 struct DbSequence *arg1 = (struct DbSequence *) 0 ; 11087 DB_TXN *arg2 = (DB_TXN *) 0 ; 11088 int32_t arg3 ; 11089 u_int32_t arg4 ; 11090 db_seq_t result; 11091 11092 (void)jenv; 11093 (void)jcls; 11094 (void)jarg1_; 11095 (void)jarg2_; 11096 arg1 = *(struct DbSequence **)&jarg1; 11097 arg2 = *(DB_TXN **)&jarg2; 11098 arg3 = (int32_t)jarg3; 11099 arg4 = (u_int32_t)jarg4; 11100 11101 if (jarg1 == 0) { 11102 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11103 return 0; 11104 } 11105 11106 errno = 0; 11107 result = (db_seq_t)DbSequence_get(arg1,arg2,arg3,arg4); 11108 if (!DB_RETOK_STD(errno)) { 11109 __dbj_throw(jenv, errno, NULL, NULL, NULL); 11110 } 11111 11112 jresult = (jlong)result; 11113 return jresult; 11114} 11115 11116 11117SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1get_1cachesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11118 jint jresult = 0 ; 11119 struct DbSequence *arg1 = (struct DbSequence *) 0 ; 11120 int32_t result; 11121 11122 (void)jenv; 11123 (void)jcls; 11124 (void)jarg1_; 11125 arg1 = *(struct DbSequence **)&jarg1; 11126 11127 if (jarg1 == 0) { 11128 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11129 return 0; 11130 } 11131 11132 errno = 0; 11133 result = (int32_t)DbSequence_get_cachesize(arg1); 11134 if (!DB_RETOK_STD(errno)) { 11135 __dbj_throw(jenv, errno, NULL, NULL, NULL); 11136 } 11137 11138 jresult = (jint)result; 11139 return jresult; 11140} 11141 11142 11143SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1get_1db(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11144 jlong jresult = 0 ; 11145 struct DbSequence *arg1 = (struct DbSequence *) 0 ; 11146 DB *result = 0 ; 11147 11148 (void)jenv; 11149 (void)jcls; 11150 (void)jarg1_; 11151 arg1 = *(struct DbSequence **)&jarg1; 11152 11153 if (jarg1 == 0) { 11154 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11155 return 0; 11156 } 11157 11158 errno = 0; 11159 result = (DB *)DbSequence_get_db(arg1); 11160 if (!DB_RETOK_STD(errno)) { 11161 __dbj_throw(jenv, errno, NULL, NULL, NULL); 11162 } 11163 11164 *(DB **)&jresult = result; 11165 return jresult; 11166} 11167 11168 11169SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1get_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11170 jint jresult = 0 ; 11171 struct DbSequence *arg1 = (struct DbSequence *) 0 ; 11172 u_int32_t result; 11173 11174 (void)jenv; 11175 (void)jcls; 11176 (void)jarg1_; 11177 arg1 = *(struct DbSequence **)&jarg1; 11178 11179 if (jarg1 == 0) { 11180 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11181 return 0; 11182 } 11183 11184 errno = 0; 11185 result = (u_int32_t)DbSequence_get_flags(arg1); 11186 if (!DB_RETOK_STD(errno)) { 11187 __dbj_throw(jenv, errno, NULL, NULL, NULL); 11188 } 11189 11190 jresult = (jint)result; 11191 return jresult; 11192} 11193 11194 11195SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1get_1key(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { 11196 struct DbSequence *arg1 = (struct DbSequence *) 0 ; 11197 DBT *arg2 = (DBT *) 0 ; 11198 DBT_LOCKED ldbt2 ; 11199 db_ret_t result; 11200 11201 (void)jenv; 11202 (void)jcls; 11203 (void)jarg1_; 11204 arg1 = *(struct DbSequence **)&jarg1; 11205 11206 if (__dbj_dbt_copyin(jenv, &ldbt2, &arg2, jarg2, 0) != 0) { 11207 return ; /* An exception will be pending. */ 11208 } 11209 11210 if (jarg1 == 0) { 11211 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11212 return ; 11213 } 11214 11215 result = (db_ret_t)DbSequence_get_key(arg1,arg2); 11216 if (!DB_RETOK_STD(result)) { 11217 __dbj_throw(jenv, result, NULL, NULL, NULL); 11218 } 11219 11220 __dbj_dbt_release(jenv, jarg2, arg2, &ldbt2); 11221} 11222 11223 11224SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1get_1range_1min(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11225 jlong jresult = 0 ; 11226 struct DbSequence *arg1 = (struct DbSequence *) 0 ; 11227 db_seq_t result; 11228 11229 (void)jenv; 11230 (void)jcls; 11231 (void)jarg1_; 11232 arg1 = *(struct DbSequence **)&jarg1; 11233 11234 if (jarg1 == 0) { 11235 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11236 return 0; 11237 } 11238 11239 errno = 0; 11240 result = (db_seq_t)DbSequence_get_range_min(arg1); 11241 if (!DB_RETOK_STD(errno)) { 11242 __dbj_throw(jenv, errno, NULL, NULL, NULL); 11243 } 11244 11245 jresult = (jlong)result; 11246 return jresult; 11247} 11248 11249 11250SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1get_1range_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11251 jlong jresult = 0 ; 11252 struct DbSequence *arg1 = (struct DbSequence *) 0 ; 11253 db_seq_t result; 11254 11255 (void)jenv; 11256 (void)jcls; 11257 (void)jarg1_; 11258 arg1 = *(struct DbSequence **)&jarg1; 11259 11260 if (jarg1 == 0) { 11261 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11262 return 0; 11263 } 11264 11265 errno = 0; 11266 result = (db_seq_t)DbSequence_get_range_max(arg1); 11267 if (!DB_RETOK_STD(errno)) { 11268 __dbj_throw(jenv, errno, NULL, NULL, NULL); 11269 } 11270 11271 jresult = (jlong)result; 11272 return jresult; 11273} 11274 11275 11276SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1initial_1value(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { 11277 struct DbSequence *arg1 = (struct DbSequence *) 0 ; 11278 db_seq_t arg2 ; 11279 db_ret_t result; 11280 11281 (void)jenv; 11282 (void)jcls; 11283 (void)jarg1_; 11284 arg1 = *(struct DbSequence **)&jarg1; 11285 arg2 = (db_seq_t)jarg2; 11286 11287 if (jarg1 == 0) { 11288 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11289 return ; 11290 } 11291 11292 result = (db_ret_t)DbSequence_initial_value(arg1,arg2); 11293 if (!DB_RETOK_STD(result)) { 11294 __dbj_throw(jenv, result, NULL, NULL, NULL); 11295 } 11296 11297} 11298 11299 11300SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1open(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jint jarg4) { 11301 struct DbSequence *arg1 = (struct DbSequence *) 0 ; 11302 DB_TXN *arg2 = (DB_TXN *) 0 ; 11303 DBT *arg3 = (DBT *) 0 ; 11304 u_int32_t arg4 ; 11305 DBT_LOCKED ldbt3 ; 11306 db_ret_t result; 11307 11308 (void)jenv; 11309 (void)jcls; 11310 (void)jarg1_; 11311 (void)jarg2_; 11312 arg1 = *(struct DbSequence **)&jarg1; 11313 arg2 = *(DB_TXN **)&jarg2; 11314 11315 if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { 11316 return ; /* An exception will be pending. */ 11317 } 11318 arg4 = (u_int32_t)jarg4; 11319 11320 if (jarg1 == 0) { 11321 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11322 return ; 11323 } 11324 11325 result = (db_ret_t)DbSequence_open(arg1,arg2,arg3,arg4); 11326 if (!DB_RETOK_STD(result)) { 11327 __dbj_throw(jenv, result, NULL, NULL, NULL); 11328 } 11329 11330 __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); 11331} 11332 11333 11334SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1remove0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3) { 11335 struct DbSequence *arg1 = (struct DbSequence *) 0 ; 11336 DB_TXN *arg2 = (DB_TXN *) 0 ; 11337 u_int32_t arg3 ; 11338 db_ret_t result; 11339 11340 (void)jenv; 11341 (void)jcls; 11342 (void)jarg1_; 11343 (void)jarg2_; 11344 arg1 = *(struct DbSequence **)&jarg1; 11345 arg2 = *(DB_TXN **)&jarg2; 11346 arg3 = (u_int32_t)jarg3; 11347 11348 if (jarg1 == 0) { 11349 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11350 return ; 11351 } 11352 11353 result = (db_ret_t)DbSequence_remove(arg1,arg2,arg3); 11354 if (!DB_RETOK_STD(result)) { 11355 __dbj_throw(jenv, result, NULL, NULL, NULL); 11356 } 11357 11358} 11359 11360 11361SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1set_1cachesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 11362 struct DbSequence *arg1 = (struct DbSequence *) 0 ; 11363 int32_t arg2 ; 11364 db_ret_t result; 11365 11366 (void)jenv; 11367 (void)jcls; 11368 (void)jarg1_; 11369 arg1 = *(struct DbSequence **)&jarg1; 11370 arg2 = (int32_t)jarg2; 11371 11372 if (jarg1 == 0) { 11373 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11374 return ; 11375 } 11376 11377 result = (db_ret_t)DbSequence_set_cachesize(arg1,arg2); 11378 if (!DB_RETOK_STD(result)) { 11379 __dbj_throw(jenv, result, NULL, NULL, NULL); 11380 } 11381 11382} 11383 11384 11385SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1set_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 11386 struct DbSequence *arg1 = (struct DbSequence *) 0 ; 11387 u_int32_t arg2 ; 11388 db_ret_t result; 11389 11390 (void)jenv; 11391 (void)jcls; 11392 (void)jarg1_; 11393 arg1 = *(struct DbSequence **)&jarg1; 11394 arg2 = (u_int32_t)jarg2; 11395 11396 if (jarg1 == 0) { 11397 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11398 return ; 11399 } 11400 11401 result = (db_ret_t)DbSequence_set_flags(arg1,arg2); 11402 if (!DB_RETOK_STD(result)) { 11403 __dbj_throw(jenv, result, NULL, NULL, NULL); 11404 } 11405 11406} 11407 11408 11409SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1set_1range(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { 11410 struct DbSequence *arg1 = (struct DbSequence *) 0 ; 11411 db_seq_t arg2 ; 11412 db_seq_t arg3 ; 11413 db_ret_t result; 11414 11415 (void)jenv; 11416 (void)jcls; 11417 (void)jarg1_; 11418 arg1 = *(struct DbSequence **)&jarg1; 11419 arg2 = (db_seq_t)jarg2; 11420 arg3 = (db_seq_t)jarg3; 11421 11422 if (jarg1 == 0) { 11423 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11424 return ; 11425 } 11426 11427 result = (db_ret_t)DbSequence_set_range(arg1,arg2,arg3); 11428 if (!DB_RETOK_STD(result)) { 11429 __dbj_throw(jenv, result, NULL, NULL, NULL); 11430 } 11431 11432} 11433 11434 11435SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 11436 jobject jresult = 0 ; 11437 struct DbSequence *arg1 = (struct DbSequence *) 0 ; 11438 u_int32_t arg2 ; 11439 DB_SEQUENCE_STAT *result = 0 ; 11440 11441 (void)jenv; 11442 (void)jcls; 11443 (void)jarg1_; 11444 arg1 = *(struct DbSequence **)&jarg1; 11445 arg2 = (u_int32_t)jarg2; 11446 11447 if (jarg1 == 0) { 11448 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11449 return 0; 11450 } 11451 11452 errno = 0; 11453 result = (DB_SEQUENCE_STAT *)DbSequence_stat(arg1,arg2); 11454 if (!DB_RETOK_STD(errno)) { 11455 __dbj_throw(jenv, errno, NULL, NULL, NULL); 11456 } 11457 11458 11459 jresult = (*jenv)->NewObject(jenv, seq_stat_class, seq_stat_construct); 11460 if (jresult != NULL) 11461 __dbj_fill_seq_stat(jenv, jresult, result); 11462 __os_ufree(NULL, result); 11463 11464 return jresult; 11465} 11466 11467 11468SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbTxn_1abort0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11469 struct DbTxn *arg1 = (struct DbTxn *) 0 ; 11470 db_ret_t result; 11471 11472 (void)jenv; 11473 (void)jcls; 11474 (void)jarg1_; 11475 arg1 = *(struct DbTxn **)&jarg1; 11476 11477 if (jarg1 == 0) { 11478 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11479 return ; 11480 } 11481 11482 result = (db_ret_t)DbTxn_abort(arg1); 11483 if (!DB_RETOK_STD(result)) { 11484 __dbj_throw(jenv, result, NULL, NULL, NULL); 11485 } 11486 11487} 11488 11489 11490SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbTxn_1commit0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 11491 struct DbTxn *arg1 = (struct DbTxn *) 0 ; 11492 u_int32_t arg2 ; 11493 db_ret_t result; 11494 11495 (void)jenv; 11496 (void)jcls; 11497 (void)jarg1_; 11498 arg1 = *(struct DbTxn **)&jarg1; 11499 arg2 = (u_int32_t)jarg2; 11500 11501 if (jarg1 == 0) { 11502 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11503 return ; 11504 } 11505 11506 result = (db_ret_t)DbTxn_commit(arg1,arg2); 11507 if (!DB_RETOK_STD(result)) { 11508 __dbj_throw(jenv, result, NULL, NULL, NULL); 11509 } 11510 11511} 11512 11513 11514SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbTxn_1discard0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { 11515 struct DbTxn *arg1 = (struct DbTxn *) 0 ; 11516 u_int32_t arg2 ; 11517 db_ret_t result; 11518 11519 (void)jenv; 11520 (void)jcls; 11521 (void)jarg1_; 11522 arg1 = *(struct DbTxn **)&jarg1; 11523 arg2 = (u_int32_t)jarg2; 11524 11525 if (jarg1 == 0) { 11526 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11527 return ; 11528 } 11529 11530 result = (db_ret_t)DbTxn_discard(arg1,arg2); 11531 if (!DB_RETOK_STD(result)) { 11532 __dbj_throw(jenv, result, NULL, NULL, NULL); 11533 } 11534 11535} 11536 11537 11538SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbTxn_1get_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11539 jstring jresult = 0 ; 11540 struct DbTxn *arg1 = (struct DbTxn *) 0 ; 11541 char *result = 0 ; 11542 11543 (void)jenv; 11544 (void)jcls; 11545 (void)jarg1_; 11546 arg1 = *(struct DbTxn **)&jarg1; 11547 11548 if (jarg1 == 0) { 11549 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11550 return 0; 11551 } 11552 11553 errno = 0; 11554 result = (char *)DbTxn_get_name(arg1); 11555 if (!DB_RETOK_STD(errno)) { 11556 __dbj_throw(jenv, errno, NULL, NULL, TXN2JDBENV); 11557 } 11558 11559 if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); 11560 return jresult; 11561} 11562 11563 11564SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbTxn_1id(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { 11565 jint jresult = 0 ; 11566 struct DbTxn *arg1 = (struct DbTxn *) 0 ; 11567 u_int32_t result; 11568 11569 (void)jenv; 11570 (void)jcls; 11571 (void)jarg1_; 11572 arg1 = *(struct DbTxn **)&jarg1; 11573 11574 if (jarg1 == 0) { 11575 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11576 return 0; 11577 } 11578 result = (u_int32_t)DbTxn_id(arg1); 11579 jresult = (jint)result; 11580 return jresult; 11581} 11582 11583 11584SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbTxn_1prepare(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jbyteArray jarg2) { 11585 struct DbTxn *arg1 = (struct DbTxn *) 0 ; 11586 u_int8_t *arg2 = (u_int8_t *) 0 ; 11587 db_ret_t result; 11588 11589 (void)jenv; 11590 (void)jcls; 11591 (void)jarg1_; 11592 arg1 = *(struct DbTxn **)&jarg1; 11593 11594 arg2 = (u_int8_t *)(*jenv)->GetByteArrayElements(jenv, jarg2, NULL); 11595 11596 11597 if (jarg1 == 0) { 11598 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11599 return ; 11600 } 11601 11602 if ((*jenv)->GetArrayLength(jenv, jarg2) < DB_GID_SIZE) { 11603 __dbj_throw(jenv, EINVAL, 11604 "DbTxn.prepare gid array must be >= 128 bytes", NULL, 11605 TXN2JDBENV); 11606 return ; 11607 } 11608 11609 11610 result = (db_ret_t)DbTxn_prepare(arg1,arg2); 11611 if (!DB_RETOK_STD(result)) { 11612 __dbj_throw(jenv, result, NULL, NULL, TXN2JDBENV); 11613 } 11614 11615 11616 (*jenv)->ReleaseByteArrayElements(jenv, jarg2, (jbyte *)arg2, 0); 11617 11618} 11619 11620 11621SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbTxn_1set_1timeout(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) { 11622 struct DbTxn *arg1 = (struct DbTxn *) 0 ; 11623 db_timeout_t arg2 ; 11624 u_int32_t arg3 ; 11625 db_ret_t result; 11626 11627 (void)jenv; 11628 (void)jcls; 11629 (void)jarg1_; 11630 arg1 = *(struct DbTxn **)&jarg1; 11631 arg2 = (db_timeout_t)jarg2; 11632 arg3 = (u_int32_t)jarg3; 11633 11634 if (jarg1 == 0) { 11635 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11636 return ; 11637 } 11638 11639 result = (db_ret_t)DbTxn_set_timeout(arg1,arg2,arg3); 11640 if (!DB_RETOK_STD(result)) { 11641 __dbj_throw(jenv, result, NULL, NULL, TXN2JDBENV); 11642 } 11643 11644} 11645 11646 11647SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbTxn_1set_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { 11648 struct DbTxn *arg1 = (struct DbTxn *) 0 ; 11649 char *arg2 = (char *) 0 ; 11650 db_ret_t result; 11651 11652 (void)jenv; 11653 (void)jcls; 11654 (void)jarg1_; 11655 arg1 = *(struct DbTxn **)&jarg1; 11656 arg2 = 0; 11657 if (jarg2) { 11658 arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); 11659 if (!arg2) return ; 11660 } 11661 11662 if (jarg1 == 0) { 11663 __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); 11664 return ; 11665 } 11666 11667 result = (db_ret_t)DbTxn_set_name(arg1,(char const *)arg2); 11668 if (!DB_RETOK_STD(result)) { 11669 __dbj_throw(jenv, result, NULL, NULL, TXN2JDBENV); 11670 } 11671 11672 if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); 11673} 11674 11675 11676#ifdef __cplusplus 11677} 11678#endif 11679 11680