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