diff options
Diffstat (limited to 'libdb_java')
| -rw-r--r-- | libdb_java/README | 190 | ||||
| -rw-r--r-- | libdb_java/db.i | 1795 | ||||
| -rw-r--r-- | libdb_java/db_java.i | 736 | ||||
| -rw-r--r-- | libdb_java/db_java_wrap.c | 11679 | ||||
| -rw-r--r-- | libdb_java/java-post.pl | 23 | ||||
| -rw-r--r-- | libdb_java/java_callbacks.i | 930 | ||||
| -rw-r--r-- | libdb_java/java_except.i | 180 | ||||
| -rw-r--r-- | libdb_java/java_stat.i | 176 | ||||
| -rw-r--r-- | libdb_java/java_stat_auto.c | 343 | ||||
| -rw-r--r-- | libdb_java/java_typemaps.i | 769 | ||||
| -rw-r--r-- | libdb_java/java_util.i | 1046 |
11 files changed, 17867 insertions, 0 deletions
diff --git a/libdb_java/README b/libdb_java/README new file mode 100644 index 0000000..50db690 --- /dev/null +++ b/libdb_java/README @@ -0,0 +1,190 @@ +Berkeley DB's Java API +$Id$ + +Berkeley DB's Java API is now generated with SWIG +(http://www.swig.org). This document describes how SWIG is used - +what we trust it to do, what things we needed to work around. + + +Overview +======== + +SWIG is a tool that generates wrappers around native (C/C++) APIs for +various languages (mainly scripting languages) including Java. + +By default, SWIG creates an API in the target language that exactly +replicates the native API (for example, each pointer type in the API +is wrapped as a distinct type in the language). Although this +simplifies the wrapper layer (type translation is trivial), it usually +doesn't result in natural API in the target language. + +A further constraint for Berkeley DB's Java API was backwards +compatibility. The original hand-coded Java API is in widespread use, +and included many design decisions about how native types should be +represented in Java. As an example, callback functions are +represented by Java interfaces that applications using Berkeley DB +could implement. The SWIG implementation was required to maintain +backwards compatibility for those applications. + + +Running SWIG +============ + +The simplest use of SWIG is to simply run it with a C include file as +input. SWIG parses the file and generates wrapper code for the target +language. For Java, this includes a Java class for each C struct and +a C source file containing the Java Native Interface (JNI) function +calls for each native method. + +The s_swig shell script in db/dist runs SWIG, and then post-processes +each Java source file with the sed commands in +libdb_java/java-post.sed. The Java sources are placed in +java/src/com/sleepycat/db, and the native wrapper code is in a single +file in libdb_java/db_java_wrap.c. + +The post-processing step modifies code in ways that is difficult with +SWIG (given my current level of knowledge). This includes changing +some access modifiers to hide some of the implementation methods, +selectively adding "throws" clauses to methods, and adding calls to +"initialize" methods in Db and DbEnv after they are constructed (more +below on what these aclls do). + +In addition to the source code generated by SWIG, some of the Java +classes are written by hand, and constants and code to fill statistics +structures are generated by the script dist/s_java. The native +statistics code is in libdb_java/java_stat_auto.c, and is compiled +into the db_java_wrap object file with a #include directive. This +allows most functions in that object to be static, which encourages +compiler inlining and reduces the number of symbols we export. + + +The Implementation +================== + +For the reasons mentioned above, Berkeley DB requires a more +sophisticated mapping between the native API and Java, so additional +SWIG directives are added to the input. In particular: + +* The general intention is for db.i to contain the full DB API (just + like db.h). As much as possible, this file is kept Java independent + so that it can be updated easily when the API changes. SWIG doesn't + have any builtin rules for how to handle function pointers in a + struct, so each DB method must be added in a SWIG "%extend" block + which includes the method signature and a call to the method. + + * SWIG's automatically generated function names happen to collide + with Berkeley DB's naming convention. For example, in a SWIG class + called __db, a method called "open" would result in a wrapper + function called "__db_open", which already exists in DB. This is + another reason why making these static functions is important. + +* The main Java support starts in db_java.i - this file includes all + Java code that is explicitly inserted into the generated classes, + and is responsible for defining object lifecycles (handling + allocation and cleanup). + + * Methods that need to be wrapped for special handling in Java code + are renamed with a trailing zero (e.g., close becomes close0). + This is invisible to applications. + + * Most DB classes that are wrapped have method calls that imply the + cleanup of any native resources associated with the Java object + (for example, Db.close or DbTxn.abort). These methods are wrapped + so that if the object is accessed after the native part has been + destroyed, an exception is thrown rather than a trap that crashes + the JVM. + + * Db and DbEnv initialization is more complex: a global reference is + stored in the corresponding struct so that native code can + efficiently map back to Java code. In addition, if a Db is + created without an environment (i.e., in a private environment), + the initialization wraps the internal DbEnv to simplify handling + of various Db methods that just call the corresponding DbEnv + method (like err, errx, etc.). It is important that the global + references are cleaned up before the DB and DB_ENV handles are + closed, so the Java objects can be garbage collected. + + * In the case of DbLock and DbLsn, there are no such methods. In + these cases, there is a finalize method that does the appropriate + cleanup. No other classes have finalize methods (in particular, + the Dbt class is now implemented entirely in Java, so no + finalization is necessary). + +* Overall initialization code, including the System.loadLibrary call, + is in java_util.i. This includes looking up all class, field and + method handles once so that execution is not slowed down by repeated + runtime type queries. + +* Exception handling is in java_except.i. The main non-obvious design + choice was to create a db_ret_t type for methods that return an + error code as an int in the C API, but return void in the Java API + (and throw exceptions on error). + + * The only other odd case with exceptions is DbMemoryException - + this is thrown as normal when a call returns ENOMEM, but there is + special handling for the case where a Dbt with DB_DBT_USERMEM is + not big enough to handle a result: in this case, the Dbt handling + code calls the method update_dbt on the exception that is about to + be thrown to register the failed Dbt in the exception. + +* Statistics handling is in java_stat.i - this mainly just hooks into + the automatically-generated code in java_stat_auto.c. + +* Callbacks: the general approach is that Db and DbEnv maintain + references to the objects that handle each callback, and have a + helper method for each call. This is primarily to simplify the + native code, and performs better than more complex native code. + + * One difference with the new approach is that the implementation is + more careful about calling DeleteLocalRef on objects created for + callbacks. This is particularly important for callbacks like + bt_compare, which may be called repeatedly from native code. + Without the DeleteLocalRef calls, the Java objects that are + created can not be collected until the original call returns. + +* Most of the rest of the code is in java_typemaps.i. A typemap is a + rule describing how a native type is mapped onto a Java type for + parameters and return values. These handle most of the complexity + of creating exactly the Java API we want. + + * One of the main areas of complexity is Dbt handling. The approach + taken is to accept whatever data is passed in by the application, + pass that to native code, and reflect any changes to the native + DBT back into the Java object. In other words, the Dbt typemaps + don't replicate DB's rules about whether Dbts will be modified or + not - they just pass the data through. + + * As noted above, when a Dbt is "released" (i.e., no longer needed + in native code), one of the check is whether a DbMemoryException + is pending, and if so, whether this Dbt might be the cause. In + that case, the Dbt is added to the exception via the "update_dbt" + method. + +* Constant handling has been simplified by making DbConstants an + interface. This allows the Db class to inherit the constants, and + most can be inlined by javac. + + * The danger here is if applications are compiled against one + version of db.jar, but run against another. This danger existed + previously, but was partly ameliorated by a separation of + constants into "case" and "non-case" constants (the non-case + constants were arranged so they could not be inlined). The only + complete solution to this problem is for applications to check the + version returned by DbEnv.get_version* versus the Db.DB_VERSION* + constants. + + +Application-visible changes +=========================== + +* The new API is around 5x faster for many operations. + +* Some internal methods and constructors that were previously public + have been hidden or removed. + +* A few methods that were inconsistent have been cleaned up (e.g., + Db.close now returns void, was an int but always zero). The + synchronized attributed has been toggled on some methods - this is + an attempt to prevent multi-threaded applications shooting + themselves in the foot by calling close() or similar methods + concurrently from multiple threads. diff --git a/libdb_java/db.i b/libdb_java/db.i new file mode 100644 index 0000000..f72fa80 --- /dev/null +++ b/libdb_java/db.i @@ -0,0 +1,1795 @@ +%{ +#include "db_config.h" +#include "db_int.h" +#include "dbinc/txn.h" + +#ifdef HAVE_CRYPTO +#define CRYPTO_ONLY(x) (x); +#else +#define CRYPTO_ONLY(x) +#endif +%} + +#if defined(SWIGJAVA) +%include "db_java.i" +#elif defined(SWIGCSHARP) +%include "db_csharp.i" +#endif + +typedef unsigned char u_int8_t; +typedef long int32_t; +typedef long long db_seq_t; +typedef long long pid_t; +#ifndef SWIGJAVA +typedef long long db_threadid_t; +#endif +typedef unsigned long u_int32_t; +typedef u_int32_t db_recno_t; /* Record number type. */ +typedef u_int32_t db_timeout_t; /* Type of a timeout. */ + +typedef int db_recops; +typedef int db_lockmode_t; +typedef int DBTYPE; +typedef int DB_CACHE_PRIORITY; + +/* Fake typedefs for SWIG */ +typedef int db_ret_t; /* An int that is mapped to a void */ +typedef int int_bool; /* An int that is mapped to a boolean */ + +%{ +typedef int db_ret_t; +typedef int int_bool; + +struct __db_lk_conflicts { + u_int8_t *lk_conflicts; + int lk_modes; +}; + +struct __db_out_stream { + void *handle; + int (*callback) __P((void *, const void *)); +}; + +struct __db_repmgr_sites { + DB_REPMGR_SITE *sites; + u_int32_t nsites; +}; + +#define Db __db +#define Dbc __dbc +#define Dbt __db_dbt +#define DbEnv __db_env +#define DbLock __db_lock_u +#define DbLogc __db_log_cursor +#define DbLsn __db_lsn +#define DbMpoolFile __db_mpoolfile +#define DbSequence __db_sequence +#define DbTxn __db_txn + +/* Suppress a compilation warning for an unused symbol */ +void *unused = (void *)SWIG_JavaThrowException; +%} + +struct Db; typedef struct Db DB; +struct Dbc; typedef struct Dbc DBC; +struct Dbt; typedef struct Dbt DBT; +struct DbEnv; typedef struct DbEnv DB_ENV; +struct DbLock; typedef struct DbLock DB_LOCK; +struct DbLogc; typedef struct DbLogc DB_LOGC; +struct DbLsn; typedef struct DbLsn DB_LSN; +struct DbMpoolFile; typedef struct DbMpoolFile DB_MPOOLFILE; +struct DbSequence; typedef struct Db DB_SEQUENCE; +struct DbTxn; typedef struct DbTxn DB_TXN; + +/* Methods that allocate new objects */ +%newobject Db::join(DBC **curslist, u_int32_t flags); +%newobject Db::dup(u_int32_t flags); +%newobject DbEnv::lock_get(u_int32_t locker, + u_int32_t flags, DBT *object, db_lockmode_t lock_mode); +%newobject DbEnv::log_cursor(u_int32_t flags); + +struct Db +{ +%extend { + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + Db(DB_ENV *dbenv, u_int32_t flags) { + DB *self = NULL; + errno = db_create(&self, dbenv, flags); + if (errno == 0 && dbenv == NULL) + self->env->dbt_usercopy = __dbj_dbt_memcopy; + return self; + } + + JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV) + db_ret_t associate(DB_TXN *txnid, DB *secondary, + int (*callback)(DB *, const DBT *, const DBT *, DBT *), + u_int32_t flags) { + return self->associate(self, txnid, secondary, callback, flags); + } + + db_ret_t associate_foreign(DB *primary, + int (*callback)(DB *, const DBT *, DBT *, const DBT *, int *), u_int32_t flags) { + return self->associate_foreign(self, primary, callback, flags); + } + + db_ret_t compact(DB_TXN *txnid, DBT *start, DBT *stop, + DB_COMPACT *c_data, u_int32_t flags, DBT *end) { + return self->compact(self, txnid, start, stop, c_data, flags, + end); + } + + /* + * Should probably be db_ret_t, but maintaining backwards compatibility + * for now. + */ + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) + int close(u_int32_t flags) { + errno = self->close(self, flags); + return errno; + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DB2JDBENV) + DBC *cursor(DB_TXN *txnid, u_int32_t flags) { + DBC *cursorp = NULL; + errno = self->cursor(self, txnid, &cursorp, flags); + return cursorp; + } + + JAVA_EXCEPT(DB_RETOK_DBDEL, DB2JDBENV) + int del(DB_TXN *txnid, DBT *key, u_int32_t flags) { + return self->del(self, txnid, key, flags); + } + + JAVA_EXCEPT_NONE + void err(int error, const char *message) { + self->err(self, error, message); + } + + void errx(const char *message) { + self->errx(self, message); + } + + JAVA_EXCEPT(DB_RETOK_EXISTS, DB2JDBENV) + int exists(DB_TXN *txnid, DBT *key, u_int32_t flags) { + return self->exists(self, txnid, key, flags); + } + +#ifndef SWIGJAVA + int fd() { + int ret = 0; + errno = self->fd(self, &ret); + return ret; + } +#endif + + JAVA_EXCEPT(DB_RETOK_DBGET, DB2JDBENV) + int get(DB_TXN *txnid, DBT *key, DBT *data, u_int32_t flags) { + return self->get(self, txnid, key, data, flags); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DB2JDBENV) + int_bool get_byteswapped() { + int ret = 0; + errno = self->get_byteswapped(self, &ret); + return ret; + } + + jlong get_cachesize() { + u_int32_t gbytes = 0, bytes = 0; + errno = self->get_cachesize(self, &gbytes, &bytes, NULL); + return (jlong)gbytes * GIGABYTE + bytes; + } + + u_int32_t get_cachesize_ncache() { + int ret = 0; + errno = self->get_cachesize(self, NULL, NULL, &ret); + return ret; + } + + const char *get_create_dir() { + const char *ret; + errno = self->get_create_dir(self, &ret); + return ret; + } + + const char *get_filename() { + const char *ret = NULL; + errno = self->get_dbname(self, &ret, NULL); + return ret; + } + + const char *get_dbname() { + const char *ret = NULL; + errno = self->get_dbname(self, NULL, &ret); + return ret; + } + + u_int32_t get_encrypt_flags() { + u_int32_t ret = 0; + CRYPTO_ONLY(errno = self->get_encrypt_flags(self, &ret)) + return ret; + } + + /* + * This method is implemented in Java to avoid wrapping the object on + * every call. + */ +#ifndef SWIGJAVA + DB_ENV *get_env() { + DB_ENV *env = NULL; + errno = self->get_env(self, &env); + return env; + } + + const char *get_errpfx() { + const char *ret = NULL; + errno = 0; + self->get_errpfx(self, &ret); + return ret; + } +#endif + + u_int32_t get_flags() { + u_int32_t ret = 0; + errno = self->get_flags(self, &ret); + return ret; + } + + int get_lorder() { + int ret = 0; + errno = self->get_lorder(self, &ret); + return ret; + } + + DB_MPOOLFILE *get_mpf() { + errno = 0; + return self->get_mpf(self); + } + + u_int32_t get_open_flags() { + u_int32_t ret = 0; + errno = self->get_open_flags(self, &ret); + return ret; + } + + u_int32_t get_pagesize() { + u_int32_t ret = 0; + errno = self->get_pagesize(self, &ret); + return ret; + } + + u_int32_t get_bt_minkey() { + u_int32_t ret = 0; + errno = self->get_bt_minkey(self, &ret); + return ret; + } + + u_int32_t get_h_ffactor() { + u_int32_t ret = 0; + errno = self->get_h_ffactor(self, &ret); + return ret; + } + + u_int32_t get_h_nelem() { + u_int32_t ret = 0; + errno = self->get_h_nelem(self, &ret); + return ret; + } + + int get_re_delim() { + int ret = 0; + errno = self->get_re_delim(self, &ret); + return ret; + } + + DB_CACHE_PRIORITY get_priority() { + DB_CACHE_PRIORITY ret; + errno = self->get_priority(self, &ret); + return ret; + } + + const char **get_partition_dirs() { + const char **ret; + errno = self->get_partition_dirs(self, &ret); + return ret; + } + + DBT *get_partition_keys() { + DBT *ret = NULL; + errno = self->get_partition_keys(self, NULL, &ret); + return ret; + } + + int get_partition_parts() { + int ret = 0; + errno = self->get_partition_keys(self, &ret, NULL); + /* If not partitioned by range, check by callback. */ + if (ret == 0) + errno = self->get_partition_callback(self, &ret, NULL); + return ret; + } + + u_int32_t get_re_len() { + u_int32_t ret = 0; + errno = self->get_re_len(self, &ret); + return ret; + } + + int get_re_pad() { + int ret = 0; + errno = self->get_re_pad(self, &ret); + return ret; + } + + const char *get_re_source() { + const char *ret = NULL; + errno = self->get_re_source(self, &ret); + return ret; + } + + u_int32_t get_q_extentsize() { + u_int32_t ret = 0; + errno = self->get_q_extentsize(self, &ret); + return ret; + } + + JAVA_EXCEPT_NONE + int_bool get_multiple() { + return self->get_multiple(self); + } + + int_bool get_transactional() { + return self->get_transactional(self); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DB2JDBENV) + DBTYPE get_type() { + DBTYPE type = (DBTYPE)0; + errno = self->get_type(self, &type); + return type; + } + + DBC *join(DBC **curslist, u_int32_t flags) { + DBC *dbcp = NULL; + errno = self->join(self, curslist, &dbcp, flags); + return dbcp; + } + + JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV) + db_ret_t key_range(DB_TXN *txnid, DBT *key, DB_KEY_RANGE *key_range, + u_int32_t flags) { + return self->key_range(self, txnid, key, key_range, flags); + } + + db_ret_t open(DB_TXN *txnid, const char *file, const char *database, + DBTYPE type, u_int32_t flags, int mode) { + return self->open(self, txnid, file, database, + type, flags, mode); + } + + JAVA_EXCEPT(DB_RETOK_DBGET, DB2JDBENV) + int pget(DB_TXN *txnid, DBT *key, DBT *pkey, DBT *data, + u_int32_t flags) { + return self->pget(self, txnid, key, pkey, data, flags); + } + + JAVA_EXCEPT(DB_RETOK_DBPUT, DB2JDBENV) + int put(DB_TXN *txnid, DBT *key, DBT *db_put_data, u_int32_t flags) { + return self->put(self, txnid, key, db_put_data, flags); + } + + JAVA_EXCEPT(DB_RETOK_STD, NULL) + db_ret_t remove(const char *file, const char *database, + u_int32_t flags) { + return self->remove(self, file, database, flags); + } + + db_ret_t rename(const char *file, const char *database, + const char *newname, u_int32_t flags) { + return self->rename(self, file, database, newname, flags); + } + + JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV) + db_ret_t set_append_recno( + int (*db_append_recno_fcn)(DB *, DBT *, db_recno_t)) { + return self->set_append_recno(self, db_append_recno_fcn); + } + + db_ret_t set_bt_compare( + int (*bt_compare_fcn)(DB *, const DBT *, const DBT *)) { + return self->set_bt_compare(self, bt_compare_fcn); + } + + db_ret_t set_bt_minkey(u_int32_t bt_minkey) { + return self->set_bt_minkey(self, bt_minkey); + } + + db_ret_t set_bt_compress( + int (*bt_compress_fcn)(DB *, const DBT *, const DBT *, + const DBT *, const DBT *, DBT *), + int (*bt_decompress_fcn)(DB *, const DBT *, const DBT *, + DBT *, DBT *, DBT *)) { + return self->set_bt_compress( + self, bt_compress_fcn, bt_decompress_fcn); + } + + db_ret_t set_bt_prefix( + size_t (*bt_prefix_fcn)(DB *, const DBT *, const DBT *)) { + return self->set_bt_prefix(self, bt_prefix_fcn); + } + + db_ret_t set_cachesize(jlong bytes, int ncache) { + return self->set_cachesize(self, + (u_int32_t)(bytes / GIGABYTE), + (u_int32_t)(bytes % GIGABYTE), ncache); + } + + db_ret_t set_create_dir(const char *dir) { + return self->set_create_dir(self, dir); + } + + db_ret_t set_dup_compare( + int (*dup_compare_fcn)(DB *, const DBT *, const DBT *)) { + return self->set_dup_compare(self, dup_compare_fcn); + } + + db_ret_t set_encrypt(const char *passwd, u_int32_t flags) { + return self->set_encrypt(self, passwd, flags); + } + + JAVA_EXCEPT_NONE +#ifndef SWIGJAVA + void set_errcall( + void (*db_errcall_fcn)(const DB_ENV *, const char *, const char *)) { + self->set_errcall(self, db_errcall_fcn); + } + + void set_errpfx(const char *errpfx) { + self->set_errpfx(self, errpfx); + } +#endif /* SWIGJAVA */ + + JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV) + db_ret_t set_feedback(void (*db_feedback_fcn)(DB *, int, int)) { + return self->set_feedback(self, db_feedback_fcn); + } + + db_ret_t set_flags(u_int32_t flags) { + return self->set_flags(self, flags); + } + + db_ret_t set_h_compare( + int (*h_compare_fcn)(DB *, const DBT *, const DBT *)) { + return self->set_h_compare(self, h_compare_fcn); + } + + db_ret_t set_h_ffactor(u_int32_t h_ffactor) { + return self->set_h_ffactor(self, h_ffactor); + } + + db_ret_t set_h_hash( + u_int32_t (*h_hash_fcn)(DB *, const void *, u_int32_t)) { + return self->set_h_hash(self, h_hash_fcn); + } + + db_ret_t set_h_nelem(u_int32_t h_nelem) { + return self->set_h_nelem(self, h_nelem); + } + + db_ret_t set_lorder(int lorder) { + return self->set_lorder(self, lorder); + } + +#ifndef SWIGJAVA + void set_msgcall(void (*db_msgcall_fcn)(const DB_ENV *, const char *)) { + self->set_msgcall(self, db_msgcall_fcn); + } +#endif /* SWIGJAVA */ + + db_ret_t set_pagesize(u_int32_t pagesize) { + return self->set_pagesize(self, pagesize); + } + +#ifndef SWIGJAVA + db_ret_t set_paniccall(void (* db_panic_fcn)(DB_ENV *, int)) { + return self->set_paniccall(self, db_panic_fcn); + } +#endif /* SWIGJAVA */ + + db_ret_t set_partition(u_int32_t parts, DBT *keys, + u_int32_t (*db_partition_fcn)(DB *, DBT *)) { + return self->set_partition(self, parts, keys, db_partition_fcn); + } + + db_ret_t set_partition_dirs(const char **dirp) { + return self->set_partition_dirs(self, dirp); + } + + db_ret_t set_priority(DB_CACHE_PRIORITY priority) { + return self->set_priority(self, priority); + } + + db_ret_t set_re_delim(int re_delim) { + return self->set_re_delim(self, re_delim); + } + + db_ret_t set_re_len(u_int32_t re_len) { + return self->set_re_len(self, re_len); + } + + db_ret_t set_re_pad(int re_pad) { + return self->set_re_pad(self, re_pad); + } + + db_ret_t set_re_source(char *source) { + return self->set_re_source(self, source); + } + + db_ret_t set_q_extentsize(u_int32_t extentsize) { + return self->set_q_extentsize(self, extentsize); + } + + db_ret_t sort_multiple(DBT *key, DBT *data) { + return self->sort_multiple(self, key, data, 0); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DB2JDBENV) + void *stat(DB_TXN *txnid, u_int32_t flags) { + void *statp = NULL; + errno = self->stat(self, txnid, &statp, flags); + return statp; + } + + JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV) + db_ret_t sync(u_int32_t flags) { + return self->sync(self, flags); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DB2JDBENV) + int truncate(DB_TXN *txnid, u_int32_t flags) { + u_int32_t count = 0; + errno = self->truncate(self, txnid, &count, flags); + return count; + } + + JAVA_EXCEPT(DB_RETOK_STD, DB2JDBENV) + db_ret_t upgrade(const char *file, u_int32_t flags) { + return self->upgrade(self, file, flags); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) + int_bool verify(const char *file, const char *database, + struct __db_out_stream outfile, u_int32_t flags) { + /* + * We can't easily #include "dbinc/db_ext.h" because of name + * clashes, so we declare this explicitly. + */ + extern int __db_verify_internal __P((DB *, const char *, const + char *, void *, int (*)(void *, const void *), u_int32_t)); + errno = __db_verify_internal(self, file, database, + outfile.handle, outfile.callback, flags); + if (errno == DB_VERIFY_BAD) { + errno = 0; + return 0; + } else + return 1; + } +} +}; + +struct Dbc +{ +%extend { + JAVA_EXCEPT(DB_RETOK_STD, NULL) + db_ret_t close() { + return self->close(self); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DBC2JDBENV) + int cmp(DBC *odbc, u_int32_t flags) { + int result = 0; + errno = self->cmp(self, odbc, &result, flags); + return result; + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DBC2JDBENV) + db_recno_t count(u_int32_t flags) { + db_recno_t count = 0; + errno = self->count(self, &count, flags); + return count; + } + + JAVA_EXCEPT(DB_RETOK_DBCDEL, DBC2JDBENV) + int del(u_int32_t flags) { + return self->del(self, flags); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DBC2JDBENV) + DBC *dup(u_int32_t flags) { + DBC *newcurs = NULL; + errno = self->dup(self, &newcurs, flags); + return newcurs; + } + + JAVA_EXCEPT(DB_RETOK_DBCGET, DBC2JDBENV) + int get(DBT* key, DBT *data, u_int32_t flags) { + return self->get(self, key, data, flags); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DBC2JDBENV) + DB_CACHE_PRIORITY get_priority() { + DB_CACHE_PRIORITY ret; + errno = self->get_priority(self, &ret); + return ret; + } + + JAVA_EXCEPT(DB_RETOK_DBCGET, DBC2JDBENV) + int pget(DBT* key, DBT* pkey, DBT *data, u_int32_t flags) { + return self->pget(self, key, pkey, data, flags); + } + + JAVA_EXCEPT(DB_RETOK_DBCPUT, DBC2JDBENV) + int put(DBT* key, DBT *db_put_data, u_int32_t flags) { + return self->put(self, key, db_put_data, flags); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, DBC2JDBENV) + db_ret_t set_priority(DB_CACHE_PRIORITY priority) { + return self->set_priority(self, priority); + } +} +}; + +struct DbEnv +{ +%extend { + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) + DbEnv(u_int32_t flags) { + DB_ENV *self = NULL; + errno = db_env_create(&self, flags); + if (errno == 0) + self->env->dbt_usercopy = __dbj_dbt_memcopy; + return self; + } + + JAVA_EXCEPT(DB_RETOK_STD, NULL) + db_ret_t close(u_int32_t flags) { + return self->close(self, flags); + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t dbremove(DB_TXN *txnid, const char *file, const char *database, + u_int32_t flags) { + return self->dbremove(self, txnid, file, database, flags); + } + + db_ret_t dbrename(DB_TXN *txnid, const char *file, const char *database, + const char *newname, u_int32_t flags) { + return self->dbrename(self, + txnid, file, database, newname, flags); + } + + JAVA_EXCEPT_NONE + void err(int error, const char *message) { + self->err(self, error, message); + } + + void errx(const char *message) { + self->errx(self, message); + } + +#ifndef SWIGJAVA + u_int32_t get_thread_count() { + u_int32_t ret; + errno = self->get_thread_count(self, &ret); + return ret; + } + + pid_t getpid() { + pid_t ret; + db_threadid_t junk; + __os_id(self, &ret, &junk); + return ret; + } + + db_threadid_t get_threadid() { + pid_t junk; + db_threadid_t ret; + __os_id(self, &junk, &ret); + return ret; + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t failchk(u_int32_t flags) { + return self->failchk(self, flags); + } + + db_ret_t set_isalive( + int (*isalive_fcn)(DB_ENV *, pid_t, db_threadid_t)) { + return self->set_isalive(self, isalive_fcn); + } + + db_ret_t set_thread_count(u_int32_t count) { + return self->set_thread_count(self, count); + } + + db_ret_t set_thread_id(void (*thread_id_fcn)(DB_ENV *, pid_t *, + db_threadid_t *)) { + return self->set_thread_id(self, thread_id_fcn); + } + + db_ret_t set_thread_id_string(char *(*thread_id_string_fcn)(DB_ENV *, + pid_t, db_threadid_t, char *)) { + return self->set_thread_id_string(self, thread_id_string_fcn); + } +#endif + + DB_TXN *cdsgroup_begin() { + DB_TXN *tid = NULL; + errno = self->cdsgroup_begin(self, &tid); + return tid; + } + + db_ret_t fileid_reset(const char *file, u_int32_t flags) { + return self->fileid_reset(self, file, flags); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + const char **get_data_dirs() { + const char **ret; + errno = self->get_data_dirs(self, &ret); + return ret; + } + + u_int32_t get_encrypt_flags() { + u_int32_t ret = 0; + CRYPTO_ONLY(errno = self->get_encrypt_flags(self, &ret)) + return ret; + } + +#ifndef SWIGJAVA + const char *get_errpfx() { + const char *ret; + errno = 0; + self->get_errpfx(self, &ret); + return ret; + } +#endif /* SWIGJAVA */ + + u_int32_t get_flags() { + u_int32_t ret; + errno = self->get_flags(self, &ret); + return ret; + } + + const char *get_home() { + const char *ret; + errno = self->get_home(self, &ret); + return ret; + } + + const char *get_intermediate_dir_mode() { + const char *ret; + errno = self->get_intermediate_dir_mode(self, &ret); + return ret; + } + + u_int32_t get_open_flags() { + u_int32_t ret; + errno = self->get_open_flags(self, &ret); + return ret; + } + + long get_shm_key() { + long ret; + errno = self->get_shm_key(self, &ret); + return ret; + } + + const char *get_tmp_dir() { + const char *ret; + errno = self->get_tmp_dir(self, &ret); + return ret; + } + + int_bool get_verbose(u_int32_t which) { + int ret; + errno = self->get_verbose(self, which, &ret); + return ret; + } + + JAVA_EXCEPT_NONE + int_bool is_bigendian() { + return self->is_bigendian(); + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t lsn_reset(const char *file, u_int32_t flags) { + return self->lsn_reset(self, file, flags); + } + + db_ret_t open(const char *db_home, u_int32_t flags, int mode) { + return self->open(self, db_home, flags, mode); + } + + JAVA_EXCEPT(DB_RETOK_STD, NULL) + db_ret_t remove(const char *db_home, u_int32_t flags) { + return self->remove(self, db_home, flags); + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t set_cachesize(jlong bytes, int ncache) { + return self->set_cachesize(self, + (u_int32_t)(bytes / GIGABYTE), + (u_int32_t)(bytes % GIGABYTE), ncache); + } + + db_ret_t set_cache_max(jlong bytes) { + return self->set_cache_max(self, + (u_int32_t)(bytes / GIGABYTE), + (u_int32_t)(bytes % GIGABYTE)); + } + + db_ret_t set_create_dir(const char *dir) { + return self->set_create_dir(self, dir); + } + + db_ret_t set_data_dir(const char *dir) { + return self->set_data_dir(self, dir); + } + + db_ret_t set_intermediate_dir_mode(const char *mode) { + return self->set_intermediate_dir_mode(self, mode); + } + + db_ret_t set_encrypt(const char *passwd, u_int32_t flags) { + return self->set_encrypt(self, passwd, flags); + } + + JAVA_EXCEPT_NONE + void set_errcall(void (*db_errcall_fcn)(const DB_ENV *, const char *, + const char *)) { + self->set_errcall(self, db_errcall_fcn); + } + +#ifndef SWIGJAVA + void set_errpfx(const char *errpfx) { + self->set_errpfx(self, errpfx); + } +#endif + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t set_flags(u_int32_t flags, int_bool onoff) { + return self->set_flags(self, flags, onoff); + } + + db_ret_t set_feedback(void (*env_feedback_fcn)(DB_ENV *, int, int)) { + return self->set_feedback(self, env_feedback_fcn); + } + + db_ret_t set_mp_max_openfd(int maxopenfd) { + return self->set_mp_max_openfd(self, maxopenfd); + } + + db_ret_t set_mp_max_write(int maxwrite, db_timeout_t maxwrite_sleep) { + return self->set_mp_max_write(self, maxwrite, maxwrite_sleep); + } + + db_ret_t set_mp_mmapsize(size_t mp_mmapsize) { + return self->set_mp_mmapsize(self, mp_mmapsize); + } + + db_ret_t set_mp_pagesize(size_t mp_pagesize) { + return self->set_mp_pagesize(self, mp_pagesize); + } + + db_ret_t set_mp_tablesize(size_t mp_tablesize) { + return self->set_mp_tablesize(self, mp_tablesize); + } + + JAVA_EXCEPT_NONE + void set_msgcall(void (*db_msgcall_fcn)(const DB_ENV *, const char *)) { + self->set_msgcall(self, db_msgcall_fcn); + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t set_paniccall(void (*db_panic_fcn)(DB_ENV *, int)) { + return self->set_paniccall(self, db_panic_fcn); + } + + db_ret_t set_rpc_server(char *host, + long cl_timeout, long sv_timeout, u_int32_t flags) { + return self->set_rpc_server(self, NULL, host, + cl_timeout, sv_timeout, flags); + } + + db_ret_t set_shm_key(long shm_key) { + return self->set_shm_key(self, shm_key); + } + + db_ret_t set_timeout(db_timeout_t timeout, u_int32_t flags) { + return self->set_timeout(self, timeout, flags); + } + + db_ret_t set_tmp_dir(const char *dir) { + return self->set_tmp_dir(self, dir); + } + + db_ret_t set_tx_max(u_int32_t max) { + return self->set_tx_max(self, max); + } + + db_ret_t set_app_dispatch( + int (*tx_recover)(DB_ENV *, DBT *, DB_LSN *, db_recops)) { + return self->set_app_dispatch(self, tx_recover); + } + + db_ret_t set_event_notify( + void (*event_notify)(DB_ENV *, u_int32_t, void *)) { + return self->set_event_notify(self, event_notify); + } + + db_ret_t set_tx_timestamp(time_t *timestamp) { + return self->set_tx_timestamp(self, timestamp); + } + + db_ret_t set_verbose(u_int32_t which, int_bool onoff) { + return self->set_verbose(self, which, onoff); + } + + /* Lock functions */ + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + struct __db_lk_conflicts get_lk_conflicts() { + struct __db_lk_conflicts ret; + errno = self->get_lk_conflicts(self, + (const u_int8_t **)&ret.lk_conflicts, &ret.lk_modes); + return ret; + } + + u_int32_t get_lk_detect() { + u_int32_t ret; + errno = self->get_lk_detect(self, &ret); + return ret; + } + + u_int32_t get_lk_max_locks() { + u_int32_t ret; + errno = self->get_lk_max_locks(self, &ret); + return ret; + } + + u_int32_t get_lk_max_lockers() { + u_int32_t ret; + errno = self->get_lk_max_lockers(self, &ret); + return ret; + } + + u_int32_t get_lk_max_objects() { + u_int32_t ret; + errno = self->get_lk_max_objects(self, &ret); + return ret; + } + + u_int32_t get_lk_partitions() { + u_int32_t ret; + errno = self->get_lk_partitions(self, &ret); + return ret; + } + + int lock_detect(u_int32_t flags, u_int32_t atype) { + int aborted; + errno = self->lock_detect(self, flags, atype, &aborted); + return aborted; + } + + DB_LOCK *lock_get(u_int32_t locker, + u_int32_t flags, DBT *object, db_lockmode_t lock_mode) { + DB_LOCK *lock = NULL; + if ((errno = __os_malloc(self->env, sizeof (DB_LOCK), &lock)) == 0) + errno = self->lock_get(self, locker, flags, object, + lock_mode, lock); + return lock; + } + + u_int32_t lock_id() { + u_int32_t id; + errno = self->lock_id(self, &id); + return id; + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t lock_id_free(u_int32_t id) { + return self->lock_id_free(self, id); + } + + db_ret_t lock_put(DB_LOCK *lock) { + return self->lock_put(self, lock); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + DB_LOCK_STAT *lock_stat(u_int32_t flags) { + DB_LOCK_STAT *statp = NULL; + errno = self->lock_stat(self, &statp, flags); + return statp; + } + +#ifndef SWIGJAVA + /* For Java, this is defined in native code */ + db_ret_t lock_vec(u_int32_t locker, u_int32_t flags, DB_LOCKREQ *list, + int offset, int nlist) + { + DB_LOCKREQ *elistp; + return self->lock_vec(self, locker, flags, list + offset, + nlist, &elistp); + } +#endif + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t set_lk_conflicts(struct __db_lk_conflicts conflicts) { + return self->set_lk_conflicts(self, + conflicts.lk_conflicts, conflicts.lk_modes); + } + + db_ret_t set_lk_detect(u_int32_t detect) { + return self->set_lk_detect(self, detect); + } + + db_ret_t set_lk_max_lockers(u_int32_t max) { + return self->set_lk_max_lockers(self, max); + } + + db_ret_t set_lk_max_locks(u_int32_t max) { + return self->set_lk_max_locks(self, max); + } + + db_ret_t set_lk_max_objects(u_int32_t max) { + return self->set_lk_max_objects(self, max); + } + + db_ret_t set_lk_partitions(u_int32_t partitions) { + return self->set_lk_partitions(self, partitions); + } + + /* Log functions */ + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + u_int32_t get_lg_bsize() { + u_int32_t ret; + errno = self->get_lg_bsize(self, &ret); + return ret; + } + + const char *get_lg_dir() { + const char *ret; + errno = self->get_lg_dir(self, &ret); + return ret; + } + + int get_lg_filemode() { + int ret; + errno = self->get_lg_filemode(self, &ret); + return ret; + } + + u_int32_t get_lg_max() { + u_int32_t ret; + errno = self->get_lg_max(self, &ret); + return ret; + } + + u_int32_t get_lg_regionmax() { + u_int32_t ret; + errno = self->get_lg_regionmax(self, &ret); + return ret; + } + + char **log_archive(u_int32_t flags) { + char **list = NULL; + errno = self->log_archive(self, &list, flags); + return list; + } + + JAVA_EXCEPT_NONE + static int log_compare(const DB_LSN *lsn0, const DB_LSN *lsn1) { + return log_compare(lsn0, lsn1); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + DB_LOGC *log_cursor(u_int32_t flags) { + DB_LOGC *cursor = NULL; + errno = self->log_cursor(self, &cursor, flags); + return cursor; + } + + char *log_file(DB_LSN *lsn) { + char namebuf[DB_MAXPATHLEN]; + errno = self->log_file(self, lsn, namebuf, sizeof namebuf); + return (errno == 0) ? strdup(namebuf) : NULL; + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t log_flush(const DB_LSN *lsn_or_null) { + return self->log_flush(self, lsn_or_null); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + int_bool log_get_config(u_int32_t which) { + int ret; + errno = self->log_get_config(self, which, &ret); + return ret; + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t log_put(DB_LSN *lsn, const DBT *data, u_int32_t flags) { + return self->log_put(self, lsn, data, flags); + } + + db_ret_t log_print(DB_TXN *txn, const char *msg) { + return self->log_printf(self, txn, "%s", msg); + } + + db_ret_t log_set_config(u_int32_t which, int_bool onoff) { + return self->log_set_config(self, which, onoff); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + DB_LOG_STAT *log_stat(u_int32_t flags) { + DB_LOG_STAT *sp = NULL; + errno = self->log_stat(self, &sp, flags); + return sp; + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t set_lg_bsize(u_int32_t lg_bsize) { + return self->set_lg_bsize(self, lg_bsize); + } + + db_ret_t set_lg_dir(const char *dir) { + return self->set_lg_dir(self, dir); + } + + db_ret_t set_lg_filemode(int mode) { + return self->set_lg_filemode(self, mode); + } + + db_ret_t set_lg_max(u_int32_t lg_max) { + return self->set_lg_max(self, lg_max); + } + + db_ret_t set_lg_regionmax(u_int32_t lg_regionmax) { + return self->set_lg_regionmax(self, lg_regionmax); + } + + /* Memory pool functions */ + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + jlong get_cachesize() { + u_int32_t gbytes, bytes; + errno = self->get_cachesize(self, &gbytes, &bytes, NULL); + return (jlong)gbytes * GIGABYTE + bytes; + } + + int get_cachesize_ncache() { + int ret; + errno = self->get_cachesize(self, NULL, NULL, &ret); + return ret; + } + + jlong get_cache_max() { + u_int32_t gbytes, bytes; + errno = self->get_cache_max(self, &gbytes, &bytes); + return (jlong)gbytes * GIGABYTE + bytes; + } + + const char *get_create_dir() { + const char *ret; + errno = self->get_create_dir(self, &ret); + return ret; + } + + int get_mp_max_openfd() { + int ret; + errno = self->get_mp_max_openfd(self, &ret); + return ret; + } + + int get_mp_max_write() { + int maxwrite; + db_timeout_t sleep; + errno = self->get_mp_max_write(self, &maxwrite, &sleep); + return maxwrite; + } + + db_timeout_t get_mp_max_write_sleep() { + int maxwrite; + db_timeout_t sleep; + errno = self->get_mp_max_write(self, &maxwrite, &sleep); + return sleep; + } + + size_t get_mp_mmapsize() { + size_t ret; + errno = self->get_mp_mmapsize(self, &ret); + return ret; + } + + int get_mp_pagesize() { + int ret; + errno = self->get_mp_pagesize(self, &ret); + return ret; + } + + int get_mp_tablesize() { + int ret; + errno = self->get_mp_tablesize(self, &ret); + return ret; + } + + DB_MPOOL_STAT *memp_stat(u_int32_t flags) { + DB_MPOOL_STAT *mp_stat = NULL; + errno = self->memp_stat(self, &mp_stat, NULL, flags); + return mp_stat; + } + + DB_MPOOL_FSTAT **memp_fstat(u_int32_t flags) { + DB_MPOOL_FSTAT **mp_fstat = NULL; + errno = self->memp_stat(self, NULL, &mp_fstat, flags); + return mp_fstat; + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + db_ret_t memp_sync(DB_LSN *lsn) { + return self->memp_sync(self, lsn); + } + + int memp_trickle(int percent) { + int ret; + errno = self->memp_trickle(self, percent, &ret); + return ret; + } + + /* Mutex functions */ + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + u_int32_t mutex_get_align() { + u_int32_t ret; + errno = self->mutex_get_align(self, &ret); + return ret; + } + + u_int32_t mutex_get_increment() { + u_int32_t ret; + errno = self->mutex_get_increment(self, &ret); + return ret; + } + + u_int32_t mutex_get_max() { + u_int32_t ret; + errno = self->mutex_get_max(self, &ret); + return ret; + } + + u_int32_t mutex_get_tas_spins() { + u_int32_t ret; + errno = self->mutex_get_tas_spins(self, &ret); + return ret; + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t mutex_set_align(u_int32_t align) { + return self->mutex_set_align(self, align); + } + + db_ret_t mutex_set_increment(u_int32_t increment) { + return self->mutex_set_increment(self, increment); + } + + db_ret_t mutex_set_max(u_int32_t mutex_max) { + return self->mutex_set_max(self, mutex_max); + } + + db_ret_t mutex_set_tas_spins(u_int32_t tas_spins) { + return self->mutex_set_tas_spins(self, tas_spins); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + DB_MUTEX_STAT *mutex_stat(u_int32_t flags) { + DB_MUTEX_STAT *statp = NULL; + errno = self->mutex_stat(self, &statp, flags); + return statp; + } + + /* Transaction functions */ + u_int32_t get_tx_max() { + u_int32_t ret; + errno = self->get_tx_max(self, &ret); + return ret; + } + + time_t get_tx_timestamp() { + time_t ret; + errno = self->get_tx_timestamp(self, &ret); + return ret; + } + + db_timeout_t get_timeout(u_int32_t flag) { + db_timeout_t ret; + errno = self->get_timeout(self, &ret, flag); + return ret; + } + + DB_TXN *txn_begin(DB_TXN *parent, u_int32_t flags) { + DB_TXN *tid = NULL; + errno = self->txn_begin(self, parent, &tid, flags); + return tid; + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t txn_checkpoint(u_int32_t kbyte, u_int32_t min, + u_int32_t flags) { + return self->txn_checkpoint(self, kbyte, min, flags); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + DB_PREPLIST *txn_recover(int count, u_int32_t flags) { + DB_PREPLIST *preplist; + u_int32_t retcount; + + /* Add a NULL element to terminate the array. */ + if ((errno = __os_malloc(self->env, + (count + 1) * sizeof(DB_PREPLIST), &preplist)) != 0) + return NULL; + + if ((errno = self->txn_recover(self, preplist, count, + &retcount, flags)) != 0) { + __os_free(self->env, preplist); + return NULL; + } + + preplist[retcount].txn = NULL; + return preplist; + } + + DB_TXN_STAT *txn_stat(u_int32_t flags) { + DB_TXN_STAT *statp = NULL; + errno = self->txn_stat(self, &statp, flags); + return statp; + } + + /* Replication functions */ + jlong rep_get_limit() { + u_int32_t gbytes, bytes; + errno = self->rep_get_limit(self, &gbytes, &bytes); + return (jlong)gbytes * GIGABYTE + bytes; + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t rep_elect(u_int32_t nsites, int nvotes, u_int32_t flags) { + return self->rep_elect(self, nsites, nvotes, flags); + } + + JAVA_EXCEPT(DB_RETOK_REPPMSG, JDBENV) + int rep_process_message(DBT *control, DBT *rec, int envid, + DB_LSN *ret_lsn) { + return self->rep_process_message(self, control, rec, envid, + ret_lsn); + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t rep_flush() { + return self->rep_flush(self); + } + + db_ret_t rep_set_config(u_int32_t which, int_bool onoff) { + return self->rep_set_config(self, which, onoff); + } + + db_ret_t rep_set_clockskew(u_int32_t fast_clock, u_int32_t slow_clock) { + return self->rep_set_clockskew(self, fast_clock, slow_clock); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + u_int32_t rep_get_clockskew_fast() { + u_int32_t fast_clock, slow_clock; + errno = self->rep_get_clockskew(self, &fast_clock, &slow_clock); + return fast_clock; + } + + u_int32_t rep_get_clockskew_slow() { + u_int32_t fast_clock, slow_clock; + errno = self->rep_get_clockskew(self, &fast_clock, &slow_clock); + return slow_clock; + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t rep_start(DBT *cdata, u_int32_t flags) { + return self->rep_start(self, cdata, flags); + } + + db_ret_t rep_sync(u_int32_t flags) { + return self->rep_sync(self, flags); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + int_bool rep_get_config(u_int32_t which) { + int ret; + errno = self->rep_get_config(self, which, &ret); + return ret; + } + + DB_REP_STAT *rep_stat(u_int32_t flags) { + DB_REP_STAT *statp = NULL; + errno = self->rep_stat(self, &statp, flags); + return statp; + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t rep_set_limit(jlong bytes) { + return self->rep_set_limit(self, + (u_int32_t)(bytes / GIGABYTE), + (u_int32_t)(bytes % GIGABYTE)); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + u_int32_t rep_get_request_min(){ + u_int32_t min, max; + errno = self->rep_get_request(self, &min, &max); + return min; + } + + u_int32_t rep_get_request_max(){ + u_int32_t min, max; + errno = self->rep_get_request(self, &min, &max); + return max; + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t rep_set_request(u_int32_t min, u_int32_t max) { + return self->rep_set_request(self, min, max); + } + + db_ret_t rep_set_transport(int envid, + int (*send)(DB_ENV *, const DBT *, const DBT *, + const DB_LSN *, int, u_int32_t)) { + return self->rep_set_transport(self, envid, send); + } + + /* Advanced replication functions. */ + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + u_int32_t rep_get_nsites() { + u_int32_t ret; + errno = self->rep_get_nsites(self, &ret); + return ret; + } + + u_int32_t rep_get_priority() { + u_int32_t ret; + errno = self->rep_get_priority(self, &ret); + return ret; + } + + u_int32_t rep_get_timeout(int which) { + u_int32_t ret; + errno = self->rep_get_timeout(self, which, &ret); + return ret; + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t rep_set_nsites(u_int32_t number) { + return self->rep_set_nsites(self, number); + } + + db_ret_t rep_set_priority(u_int32_t priority) { + return self->rep_set_priority(self, priority); + } + + db_ret_t rep_set_timeout(int which, db_timeout_t timeout) { + return self->rep_set_timeout(self, which, timeout); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + int repmgr_add_remote_site(const char * host, u_int32_t port, + u_int32_t flags) { + int eid; + errno = self->repmgr_add_remote_site(self, host, port, &eid, flags); + return eid; + } + + JAVA_EXCEPT(DB_RETOK_STD, JDBENV) + db_ret_t repmgr_get_ack_policy() { + int ret; + errno = self->repmgr_get_ack_policy(self, &ret); + return ret; + } + + db_ret_t repmgr_set_ack_policy(int policy) { + return self->repmgr_set_ack_policy(self, policy); + } + + db_ret_t repmgr_set_local_site(const char * host, u_int32_t port, u_int32_t flags) { + return self->repmgr_set_local_site(self, host, port, flags); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + struct __db_repmgr_sites repmgr_site_list() { + struct __db_repmgr_sites sites; + errno = self->repmgr_site_list(self, + &sites.nsites, &sites.sites); + return sites; + } + + JAVA_EXCEPT(DB_RETOK_REPMGR_START, JDBENV) + db_ret_t repmgr_start(int nthreads, u_int32_t flags) { + return self->repmgr_start(self, nthreads, flags); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, JDBENV) + DB_REPMGR_STAT *repmgr_stat(u_int32_t flags) { + DB_REPMGR_STAT *statp = NULL; + errno = self->repmgr_stat(self, &statp, flags); + return statp; + } + + /* Convert DB errors to strings */ + JAVA_EXCEPT_NONE + static const char *strerror(int error) { + return db_strerror(error); + } + + /* Versioning information */ + static int get_version_major() { + return DB_VERSION_MAJOR; + } + + static int get_version_minor() { + return DB_VERSION_MINOR; + } + + static int get_version_patch() { + return DB_VERSION_PATCH; + } + + static const char *get_version_string() { + return DB_VERSION_STRING; + } +} +}; + +struct DbLock +{ +%extend { + JAVA_EXCEPT_NONE + ~DbLock() { + __os_free(NULL, self); + } +} +}; + +struct DbLogc +{ +%extend { + JAVA_EXCEPT(DB_RETOK_STD, NULL) + db_ret_t close(u_int32_t flags) { + return self->close(self, flags); + } + + JAVA_EXCEPT(DB_RETOK_LGGET, NULL) + int get(DB_LSN *lsn, DBT *data, u_int32_t flags) { + return self->get(self, lsn, data, flags); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) + u_int32_t version(u_int32_t flags) { + u_int32_t result; + errno = self->version(self, &result, flags); + return result; + } +} +}; + +#ifndef SWIGJAVA +struct DbLsn +{ +%extend { + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) + DbLsn(u_int32_t file, u_int32_t offset) { + DB_LSN *self = NULL; + if ((errno = __os_malloc(NULL, sizeof (DB_LSN), &self)) == 0) { + self->file = file; + self->offset = offset; + } + return self; + } + + JAVA_EXCEPT_NONE + ~DbLsn() { + __os_free(NULL, self); + } + + u_int32_t get_file() { + return self->file; + } + + u_int32_t get_offset() { + return self->offset; + } +} +}; +#endif + +struct DbMpoolFile +{ +%extend { + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) + DB_CACHE_PRIORITY get_priority() { + DB_CACHE_PRIORITY ret; + errno = self->get_priority(self, &ret); + return ret; + } + + JAVA_EXCEPT(DB_RETOK_STD, NULL) + db_ret_t set_priority(DB_CACHE_PRIORITY priority) { + return self->set_priority(self, priority); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) + u_int32_t get_flags() { + u_int32_t ret; + errno = self->get_flags(self, &ret); + return ret; + } + + JAVA_EXCEPT(DB_RETOK_STD, NULL) + db_ret_t set_flags(u_int32_t flags, int_bool onoff) { + return self->set_flags(self, flags, onoff); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) + jlong get_maxsize() { + u_int32_t gbytes, bytes; + errno = self->get_maxsize(self, &gbytes, &bytes); + return (jlong)gbytes * GIGABYTE + bytes; + } + + /* New method - no backwards compatibility version */ + JAVA_EXCEPT(DB_RETOK_STD, NULL) + db_ret_t set_maxsize(jlong bytes) { + return self->set_maxsize(self, + (u_int32_t)(bytes / GIGABYTE), + (u_int32_t)(bytes % GIGABYTE)); + } +} +}; + +struct DbSequence +{ +%extend { + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) + DbSequence(DB *db, u_int32_t flags) { + DB_SEQUENCE *self = NULL; + errno = db_sequence_create(&self, db, flags); + return self; + } + + JAVA_EXCEPT(DB_RETOK_STD, NULL) + db_ret_t close(u_int32_t flags) { + return self->close(self, flags); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) + db_seq_t get(DB_TXN *txnid, int32_t delta, u_int32_t flags) { + db_seq_t ret = 0; + errno = self->get(self, txnid, delta, &ret, flags); + return ret; + } + + int32_t get_cachesize() { + int32_t ret = 0; + errno = self->get_cachesize(self, &ret); + return ret; + } + + DB *get_db() { + DB *ret = NULL; + errno = self->get_db(self, &ret); + return ret; + } + + u_int32_t get_flags() { + u_int32_t ret = 0; + errno = self->get_flags(self, &ret); + return ret; + } + + JAVA_EXCEPT(DB_RETOK_STD, NULL) + db_ret_t get_key(DBT *key) { + return self->get_key(self, key); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) + db_seq_t get_range_min() { + db_seq_t ret = 0; + errno = self->get_range(self, &ret, NULL); + return ret; + } + + db_seq_t get_range_max() { + db_seq_t ret = 0; + errno = self->get_range(self, NULL, &ret); + return ret; + } + + JAVA_EXCEPT(DB_RETOK_STD, NULL) + db_ret_t initial_value(db_seq_t val) { + return self->initial_value(self, val); + } + + db_ret_t open(DB_TXN *txnid, DBT *key, u_int32_t flags) { + return self->open(self, txnid, key, flags); + } + + db_ret_t remove(DB_TXN *txnid, u_int32_t flags) { + return self->remove(self, txnid, flags); + } + + db_ret_t set_cachesize(int32_t size) { + return self->set_cachesize(self, size); + } + + db_ret_t set_flags(u_int32_t flags) { + return self->set_flags(self, flags); + } + + db_ret_t set_range(db_seq_t min, db_seq_t max) { + return self->set_range(self, min, max); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, NULL) + DB_SEQUENCE_STAT *stat(u_int32_t flags) { + DB_SEQUENCE_STAT *ret = NULL; + errno = self->stat(self, &ret, flags); + return ret; + } +} +}; + +struct DbTxn +{ +%extend { + JAVA_EXCEPT(DB_RETOK_STD, NULL) + db_ret_t abort() { + return self->abort(self); + } + + db_ret_t commit(u_int32_t flags) { + return self->commit(self, flags); + } + + db_ret_t discard(u_int32_t flags) { + return self->discard(self, flags); + } + + JAVA_EXCEPT_ERRNO(DB_RETOK_STD, TXN2JDBENV) + const char *get_name() { + const char *name = NULL; + errno = self->get_name(self, &name); + return name; + } + + JAVA_EXCEPT_NONE + u_int32_t id() { + return self->id(self); + } + + JAVA_EXCEPT(DB_RETOK_STD, TXN2JDBENV) + db_ret_t prepare(u_int8_t *gid) { + return self->prepare(self, gid); + } + + db_ret_t set_timeout(db_timeout_t timeout, u_int32_t flags) { + return self->set_timeout(self, timeout, flags); + } + + db_ret_t set_name(const char *name) { + return self->set_name(self, name); + } +} +}; + diff --git a/libdb_java/db_java.i b/libdb_java/db_java.i new file mode 100644 index 0000000..28f6f0c --- /dev/null +++ b/libdb_java/db_java.i @@ -0,0 +1,736 @@ +%module db_java + +%include "various.i" +%include "typemaps.i" + +%include "java_util.i" +%include "java_except.i" +%include "java_typemaps.i" +%include "java_stat.i" +%include "java_callbacks.i" + +/* + * No finalize methods in general - most classes have "destructor" methods + * that applications must call explicitly. + */ +%typemap(javafinalize) SWIGTYPE "" + +/* + * These are the exceptions - when there is no "close" method, we need to free + * the native part at finalization time. These are exactly the cases where C + * applications manage the memory for the handles. + */ +%typemap(javafinalize) struct DbLsn, struct DbLock %{ + protected void finalize() { + try { + delete(); + } catch(Exception e) { + System.err.println("Exception during finalization: " + e); + e.printStackTrace(System.err); + } + } +%} + +%typemap(javaimports) SWIGTYPE %{ +import com.sleepycat.db.*; +import java.util.Comparator; +%} + +/* Class names */ +%rename(LogSequenceNumber) DbLsn; + +/* Destructors */ +%rename(close0) close; +%rename(remove0) remove; +%rename(rename0) rename; +%rename(verify0) verify; +%rename(abort0) abort; +%rename(commit0) commit; +%rename(discard0) discard; + +/* Special case methods */ +%rename(set_tx_timestamp0) set_tx_timestamp; + +/* Extra code in the Java classes */ +%typemap(javacode) struct DbEnv %{ + /* + * Internally, the JNI layer creates a global reference to each DbEnv, + * which can potentially be different to this. We keep a copy here so + * we can clean up after destructors. + */ + private long dbenv_ref; + public Environment wrapper; + + private LogRecordHandler app_dispatch_handler; + private EventHandler event_notify_handler; + private FeedbackHandler env_feedback_handler; + private ErrorHandler error_handler; + private String errpfx; + private MessageHandler message_handler; + private PanicHandler panic_handler; + private ReplicationTransport rep_transport_handler; + private java.io.OutputStream error_stream; + private java.io.OutputStream message_stream; + private ThreadLocal errBuf; + + public static class RepProcessMessage { + public int envid; + } + + /* + * Called by the public DbEnv constructor and for private environments + * by the Db constructor. + */ + void initialize() { + dbenv_ref = db_java.initDbEnvRef0(this, this); + errBuf = new ThreadLocal(); + /* Start with System.err as the default error stream. */ + set_error_stream(System.err); + set_message_stream(System.out); + } + + void cleanup() { + swigCPtr = 0; + db_java.deleteRef0(dbenv_ref); + dbenv_ref = 0L; + } + + public synchronized void close(int flags) throws DatabaseException { + try { + close0(flags); + } finally { + cleanup(); + } + } + + private final int handle_app_dispatch(DatabaseEntry dbt, + LogSequenceNumber lsn, + int recops) { + return app_dispatch_handler.handleLogRecord(wrapper, dbt, lsn, + RecoveryOperation.fromFlag(recops)); + } + + public LogRecordHandler get_app_dispatch() { + return app_dispatch_handler; + } + + private final void handle_panic_event_notify() { + event_notify_handler.handlePanicEvent(); + } + + private final void handle_rep_client_event_notify() { + event_notify_handler.handleRepClientEvent(); + } + + private final void handle_rep_elected_event_notify() { + event_notify_handler.handleRepElectedEvent(); + } + + private final void handle_rep_master_event_notify() { + event_notify_handler.handleRepMasterEvent(); + } + + private final void handle_rep_new_master_event_notify(int envid) { + event_notify_handler.handleRepNewMasterEvent(envid); + } + + private final void handle_rep_perm_failed_event_notify() { + event_notify_handler.handleRepPermFailedEvent(); + } + + private final void handle_rep_startup_done_event_notify() { + event_notify_handler.handleRepStartupDoneEvent(); + } + + private final void handle_write_failed_event_notify(int errno) { + event_notify_handler.handleWriteFailedEvent(errno); + } + + public EventHandler get_event_notify() { + return event_notify_handler; + } + + private final void handle_env_feedback(int opcode, int percent) { + if (opcode == DbConstants.DB_RECOVER) + env_feedback_handler.recoveryFeedback(wrapper, percent); + /* No other environment feedback type supported. */ + } + + public FeedbackHandler get_feedback() { + return env_feedback_handler; + } + + public void set_errpfx(String errpfx) { + this.errpfx = errpfx; + } + + public String get_errpfx() { + return errpfx; + } + + private final void handle_error(String msg) { + com.sleepycat.util.ErrorBuffer ebuf = (com.sleepycat.util.ErrorBuffer)errBuf.get(); + if (ebuf == null) { + /* + * Populate the errBuf ThreadLocal on demand, since the + * callback can be made from different threads. + */ + ebuf = new com.sleepycat.util.ErrorBuffer(3); + errBuf.set(ebuf); + } + ebuf.append(msg); + error_handler.error(wrapper, this.errpfx, msg); + } + + private final String get_err_msg(String orig_msg) { + com.sleepycat.util.ErrorBuffer ebuf = (com.sleepycat.util.ErrorBuffer)errBuf.get(); + String ret = null; + if (ebuf != null) { + ret = ebuf.get(); + ebuf.clear(); + } + if (ret != null && ret.length() > 0) + return orig_msg + ": " + ret; + return orig_msg; + } + + public ErrorHandler get_errcall() { + return error_handler; + } + + private final void handle_message(String msg) { + message_handler.message(wrapper, msg); + } + + public MessageHandler get_msgcall() { + return message_handler; + } + + private final void handle_panic(DatabaseException e) { + panic_handler.panic(wrapper, e); + } + + public PanicHandler get_paniccall() { + return panic_handler; + } + + private final int handle_rep_transport(DatabaseEntry control, + DatabaseEntry rec, + LogSequenceNumber lsn, + int envid, int flags) + throws DatabaseException { + return rep_transport_handler.send(wrapper, + control, rec, lsn, envid, + (flags & DbConstants.DB_REP_NOBUFFER) != 0, + (flags & DbConstants.DB_REP_PERMANENT) != 0, + (flags & DbConstants.DB_REP_ANYWHERE) != 0, + (flags & DbConstants.DB_REP_REREQUEST) != 0); + } + + public void lock_vec(/*u_int32_t*/ int locker, int flags, + LockRequest[] list, int offset, int count) + throws DatabaseException { + db_javaJNI.DbEnv_lock_vec(swigCPtr, this, locker, flags, list, + offset, count); + } + + public synchronized void remove(String db_home, int flags) + throws DatabaseException, java.io.FileNotFoundException { + try { + remove0(db_home, flags); + } finally { + cleanup(); + } + } + + public void set_error_stream(java.io.OutputStream stream) { + error_stream = stream; + final java.io.PrintWriter pw = new java.io.PrintWriter(stream); + set_errcall(new ErrorHandler() { + public void error(Environment env, + String prefix, String buf) /* no exception */ { + if (prefix != null) + pw.print(prefix + ": "); + pw.println(buf); + pw.flush(); + } + }); + } + + public java.io.OutputStream get_error_stream() { + return error_stream; + } + + public void set_message_stream(java.io.OutputStream stream) { + message_stream = stream; + final java.io.PrintWriter pw = new java.io.PrintWriter(stream); + set_msgcall(new MessageHandler() { + public void message(Environment env, String msg) + /* no exception */ { + pw.println(msg); + pw.flush(); + } + }); + } + + public java.io.OutputStream get_message_stream() { + return message_stream; + } + + public void set_tx_timestamp(java.util.Date timestamp) { + set_tx_timestamp0(timestamp.getTime()/1000); + } +%} + +%typemap(javacode) struct Db %{ + /* package */ static final int GIGABYTE = 1 << 30; + /* + * Internally, the JNI layer creates a global reference to each Db, + * which can potentially be different to this. We keep a copy here so + * we can clean up after destructors. + */ + private long db_ref; + private DbEnv dbenv; + private boolean private_dbenv; + + public Database wrapper; + private RecordNumberAppender append_recno_handler; + private Comparator bt_compare_handler; + private BtreeCompressor bt_compress_handler; + private BtreeCompressor bt_decompress_handler; + private BtreePrefixCalculator bt_prefix_handler; + private Comparator dup_compare_handler; + private FeedbackHandler db_feedback_handler; + private Comparator h_compare_handler; + private Hasher h_hash_handler; + private PartitionHandler partition_handler; + private SecondaryKeyCreator seckey_create_handler; + private SecondaryMultiKeyCreator secmultikey_create_handler; + private ForeignKeyNullifier foreignkey_nullify_handler; + private ForeignMultiKeyNullifier foreignmultikey_nullify_handler; + + /* Called by the Db constructor */ + private void initialize(DbEnv dbenv) { + if (dbenv == null) { + private_dbenv = true; + dbenv = db_java.getDbEnv0(this); + dbenv.initialize(); + } + this.dbenv = dbenv; + db_ref = db_java.initDbRef0(this, this); + } + + private void cleanup() { + swigCPtr = 0; + db_java.deleteRef0(db_ref); + db_ref = 0L; + if (private_dbenv) + dbenv.cleanup(); + dbenv = null; + } + + public boolean getPrivateDbEnv() { + return private_dbenv; + } + + public synchronized void close(int flags) throws DatabaseException { + try { + close0(flags); + } finally { + cleanup(); + } + } + + public DbEnv get_env() throws DatabaseException { + return dbenv; + } + + private final void handle_append_recno(DatabaseEntry data, int recno) + throws DatabaseException { + append_recno_handler.appendRecordNumber(wrapper, data, recno); + } + + public RecordNumberAppender get_append_recno() { + return append_recno_handler; + } + + private final int handle_bt_compare(byte[] arr1, byte[] arr2) { + return bt_compare_handler.compare(arr1, arr2); + } + + private final int handle_bt_compress(DatabaseEntry dbt1, + DatabaseEntry dbt2, DatabaseEntry dbt3, DatabaseEntry dbt4, + DatabaseEntry dbt5) { + return bt_compress_handler.compress(wrapper, dbt1, dbt2, + dbt3, dbt4, dbt5) ? 0 : DbConstants.DB_BUFFER_SMALL; + } + + private final int handle_bt_decompress(DatabaseEntry dbt1, + DatabaseEntry dbt2, DatabaseEntry dbt3, DatabaseEntry dbt4, + DatabaseEntry dbt5) { + return bt_compress_handler.decompress(wrapper, dbt1, dbt2, + dbt3, dbt4, dbt5) ? 0 : DbConstants.DB_BUFFER_SMALL; + } + + public Comparator get_bt_compare() { + return bt_compare_handler; + } + + public BtreeCompressor get_bt_compress() { + return bt_compress_handler; + } + + public BtreeCompressor get_bt_decompress() { + return bt_decompress_handler; + } + + private final int handle_bt_prefix(DatabaseEntry dbt1, + DatabaseEntry dbt2) { + return bt_prefix_handler.prefix(wrapper, dbt1, dbt2); + } + + public BtreePrefixCalculator get_bt_prefix() { + return bt_prefix_handler; + } + + private final void handle_db_feedback(int opcode, int percent) { + if (opcode == DbConstants.DB_UPGRADE) + db_feedback_handler.upgradeFeedback(wrapper, percent); + else if (opcode == DbConstants.DB_VERIFY) + db_feedback_handler.upgradeFeedback(wrapper, percent); + /* No other database feedback types known. */ + } + + public FeedbackHandler get_feedback() { + return db_feedback_handler; + } + + private final int handle_h_compare(byte[] arr1, byte[] arr2) { + return h_compare_handler.compare(arr1, arr2); + } + + public Comparator get_h_compare() { + return h_compare_handler; + } + + private final int handle_dup_compare(byte[] arr1, byte[] arr2) { + return dup_compare_handler.compare(arr1, arr2); + } + + public Comparator get_dup_compare() { + return dup_compare_handler; + } + + private final int handle_h_hash(byte[] data, int len) { + return h_hash_handler.hash(wrapper, data, len); + } + + public Hasher get_h_hash() { + return h_hash_handler; + } + + private final boolean handle_foreignkey_nullify( + DatabaseEntry key, + DatabaseEntry data, + DatabaseEntry seckey) + throws DatabaseException { + if (foreignmultikey_nullify_handler != null) + return foreignmultikey_nullify_handler.nullifyForeignKey( + (SecondaryDatabase)wrapper, key, data, seckey); + else + return foreignkey_nullify_handler.nullifyForeignKey( + (SecondaryDatabase)wrapper, data); + } + + private final DatabaseEntry[] handle_seckey_create( + DatabaseEntry key, + DatabaseEntry data) + throws DatabaseException { + + if (secmultikey_create_handler != null) { + java.util.HashSet keySet = new java.util.HashSet(); + secmultikey_create_handler.createSecondaryKeys( + (SecondaryDatabase)wrapper, key, data, keySet); + if (!keySet.isEmpty()) + return (DatabaseEntry[])keySet.toArray( + new DatabaseEntry[keySet.size()]); + } else { + DatabaseEntry result = new DatabaseEntry(); + if (seckey_create_handler.createSecondaryKey( + (SecondaryDatabase)wrapper, key, data, result)) { + DatabaseEntry[] results = { result }; + return results; + } + } + + return null; + } + + public SecondaryKeyCreator get_seckey_create() { + return seckey_create_handler; + } + + public SecondaryMultiKeyCreator get_secmultikey_create() { + return secmultikey_create_handler; + } + + public void set_secmultikey_create( + SecondaryMultiKeyCreator secmultikey_create_handler) { + this.secmultikey_create_handler = secmultikey_create_handler; + } + + public void set_foreignmultikey_nullifier(ForeignMultiKeyNullifier nullify){ + this.foreignmultikey_nullify_handler = nullify; + } + + private final int handle_partition(DatabaseEntry dbt1) { + return partition_handler.partition(wrapper, dbt1); + } + + public PartitionHandler get_partition_callback() { + return partition_handler; + } + + public synchronized void remove(String file, String database, int flags) + throws DatabaseException, java.io.FileNotFoundException { + try { + remove0(file, database, flags); + } finally { + cleanup(); + } + } + + public synchronized void rename(String file, String database, + String newname, int flags) + throws DatabaseException, java.io.FileNotFoundException { + try { + rename0(file, database, newname, flags); + } finally { + cleanup(); + } + } + + public synchronized boolean verify(String file, String database, + java.io.OutputStream outfile, int flags) + throws DatabaseException, java.io.FileNotFoundException { + try { + return verify0(file, database, outfile, flags); + } finally { + cleanup(); + } + } + + public ErrorHandler get_errcall() { + return dbenv.get_errcall(); + } + + public void set_errcall(ErrorHandler db_errcall_fcn) { + dbenv.set_errcall(db_errcall_fcn); + } + + public java.io.OutputStream get_error_stream() { + return dbenv.get_error_stream(); + } + + public void set_error_stream(java.io.OutputStream stream) { + dbenv.set_error_stream(stream); + } + + public void set_errpfx(String errpfx) { + dbenv.set_errpfx(errpfx); + } + + public String get_errpfx() { + return dbenv.get_errpfx(); + } + + public java.io.OutputStream get_message_stream() { + return dbenv.get_message_stream(); + } + + public void set_message_stream(java.io.OutputStream stream) { + dbenv.set_message_stream(stream); + } + + public MessageHandler get_msgcall() { + return dbenv.get_msgcall(); + } + + public void set_msgcall(MessageHandler db_msgcall_fcn) { + dbenv.set_msgcall(db_msgcall_fcn); + } + + public void set_paniccall(PanicHandler db_panic_fcn) + throws DatabaseException { + dbenv.set_paniccall(db_panic_fcn); + } + + public PanicHandler get_paniccall() { + return dbenv.get_paniccall(); + } +%} + +%typemap(javacode) struct Dbc %{ + public synchronized void close() throws DatabaseException { + try { + close0(); + } finally { + swigCPtr = 0; + } + } +%} + +%typemap(javacode) struct DbLock %{ + public Lock wrapper; +%} + +%typemap(javacode) struct DbLogc %{ + public synchronized void close(int flags) throws DatabaseException { + try { + close0(flags); + } finally { + swigCPtr = 0; + } + } +%} + +%typemap(javacode) struct DbSequence %{ + public Sequence wrapper; + + public synchronized void close(int flags) throws DatabaseException { + try { + close0(flags); + } finally { + swigCPtr = 0; + } + } + + public synchronized void remove(DbTxn txn, int flags) + throws DatabaseException { + try { + remove0(txn, flags); + } finally { + swigCPtr = 0; + } + } +%} + +%typemap(javacode) struct DbTxn %{ + public void abort() throws DatabaseException { + try { + abort0(); + } finally { + swigCPtr = 0; + } + } + + public void commit(int flags) throws DatabaseException { + try { + commit0(flags); + } finally { + swigCPtr = 0; + } + } + + public void discard(int flags) throws DatabaseException { + try { + discard0(flags); + } finally { + swigCPtr = 0; + } + } + + /* + * We override Object.equals because it is possible for the Java API to + * create multiple DbTxns that reference the same underlying object. + * This can happen for example during DbEnv.txn_recover(). + */ + public boolean equals(Object obj) + { + if (this == obj) + return true; + + if (obj != null && (obj instanceof DbTxn)) { + DbTxn that = (DbTxn)obj; + return (this.swigCPtr == that.swigCPtr); + } + return false; + } + + /* + * We must override Object.hashCode whenever we override + * Object.equals() to enforce the maxim that equal objects have the + * same hashcode. + */ + public int hashCode() + { + return ((int)swigCPtr ^ (int)(swigCPtr >> 32)); + } +%} + +%native(initDbEnvRef0) jlong initDbEnvRef0(DB_ENV *self, void *handle); +%native(initDbRef0) jlong initDbRef0(DB *self, void *handle); +%native(deleteRef0) void deleteRef0(jlong ref); +%native(getDbEnv0) DB_ENV *getDbEnv0(DB *self); + +%{ +SWIGEXPORT jlong JNICALL +Java_com_sleepycat_db_internal_db_1javaJNI_initDbEnvRef0( + JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { + DB_ENV *self = *(DB_ENV **)(void *)&jarg1; + jlong ret; + COMPQUIET(jcls, NULL); + COMPQUIET(jarg1_, NULL); + + DB_ENV_INTERNAL(self) = (void *)(*jenv)->NewGlobalRef(jenv, jarg2); + *(jobject *)(void *)&ret = (jobject)DB_ENV_INTERNAL(self); + return (ret); +} + +SWIGEXPORT jlong JNICALL +Java_com_sleepycat_db_internal_db_1javaJNI_initDbRef0( + JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { + DB *self = *(DB **)(void *)&jarg1; + jlong ret; + COMPQUIET(jcls, NULL); + COMPQUIET(jarg1_, NULL); + + DB_INTERNAL(self) = (void *)(*jenv)->NewGlobalRef(jenv, jarg2); + *(jobject *)(void *)&ret = (jobject)DB_INTERNAL(self); + return (ret); +} + +SWIGEXPORT void JNICALL +Java_com_sleepycat_db_internal_db_1javaJNI_deleteRef0( + JNIEnv *jenv, jclass jcls, jlong jarg1) { + jobject jref = *(jobject *)(void *)&jarg1; + COMPQUIET(jcls, NULL); + + if (jref != 0L) + (*jenv)->DeleteGlobalRef(jenv, jref); +} + +SWIGEXPORT jlong JNICALL +Java_com_sleepycat_db_internal_db_1javaJNI_getDbEnv0( + JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + DB *self = *(DB **)(void *)&jarg1; + jlong ret; + + COMPQUIET(jenv, NULL); + COMPQUIET(jcls, NULL); + COMPQUIET(jarg1_, NULL); + + *(DB_ENV **)(void *)&ret = self->dbenv; + return (ret); +} + +SWIGEXPORT jboolean JNICALL +Java_com_sleepycat_db_internal_DbUtil_is_1big_1endian( + JNIEnv *jenv, jclass clazz) +{ + COMPQUIET(jenv, NULL); + COMPQUIET(clazz, NULL); + + return (__db_isbigendian() ? JNI_TRUE : JNI_FALSE); +} +%} diff --git a/libdb_java/db_java_wrap.c b/libdb_java/db_java_wrap.c new file mode 100644 index 0000000..0deba25 --- /dev/null +++ b/libdb_java/db_java_wrap.c @@ -0,0 +1,11679 @@ +#include "db_config.h" +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 1.3.40 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +#define SWIGJAVA + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# undef _CRT_SECURE_NO_DEPRECATE +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + + + +/* Fix for jlong on some versions of gcc on Windows */ +#if defined(__GNUC__) && !defined(__INTEL_COMPILER) + typedef long long __int64; +#endif + +/* Fix for jlong on 64-bit x86 Solaris */ +#if defined(__x86_64) +# ifdef _LP64 +# undef _LP64 +# endif +#endif + +#include <jni.h> +#include <stdlib.h> +#include <string.h> + + +/* Support for throwing Java exceptions */ +typedef enum { + SWIG_JavaOutOfMemoryError = 1, + SWIG_JavaIOException, + SWIG_JavaRuntimeException, + SWIG_JavaIndexOutOfBoundsException, + SWIG_JavaArithmeticException, + SWIG_JavaIllegalArgumentException, + SWIG_JavaNullPointerException, + SWIG_JavaDirectorPureVirtual, + SWIG_JavaUnknownError +} SWIG_JavaExceptionCodes; + +typedef struct { + SWIG_JavaExceptionCodes code; + const char *java_exception; +} SWIG_JavaExceptions_t; + + +static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) { + jclass excep; + static const SWIG_JavaExceptions_t java_exceptions[] = { + { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" }, + { SWIG_JavaIOException, "java/io/IOException" }, + { SWIG_JavaRuntimeException, "java/lang/RuntimeException" }, + { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" }, + { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" }, + { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" }, + { SWIG_JavaNullPointerException, "java/lang/NullPointerException" }, + { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" }, + { SWIG_JavaUnknownError, "java/lang/UnknownError" }, + { (SWIG_JavaExceptionCodes)0, "java/lang/UnknownError" } + }; + const SWIG_JavaExceptions_t *except_ptr = java_exceptions; + + while (except_ptr->code != code && except_ptr->code) + except_ptr++; + + (*jenv)->ExceptionClear(jenv); + excep = (*jenv)->FindClass(jenv, except_ptr->java_exception); + if (excep) + (*jenv)->ThrowNew(jenv, excep, msg); +} + + +/* Contract support */ + +#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else + + +#include "db_int.h" +#include "dbinc/txn.h" + +#ifdef HAVE_CRYPTO +#define CRYPTO_ONLY(x) (x); +#else +#define CRYPTO_ONLY(x) +#endif + + +/* don't use SWIG's array handling - save code space */ +#define SWIG_NOINCLUDE 1 + +#define DB_ENV_INTERNAL(dbenv) ((dbenv)->api2_internal) +#define DB_INTERNAL(db) ((db)->api_internal) + +#define DB_PKG "com/sleepycat/db/" + +/* Forward declarations */ +static int __dbj_throw(JNIEnv *jenv, + int err, const char *msg, jobject obj, jobject jdbenv); + +/* Global data - JVM handle, classes, fields and methods */ +static JavaVM *javavm; + +static jclass db_class, dbc_class, dbenv_class, dbt_class, dblsn_class; +static jclass dbpreplist_class, dbtxn_class; +static jclass keyrange_class; +static jclass bt_stat_class, compact_class, h_stat_class, lock_stat_class; +static jclass log_stat_class, mpool_stat_class, mpool_fstat_class; +static jclass mutex_stat_class, qam_stat_class, rep_stat_class; +static jclass repmgr_stat_class, repmgr_siteinfo_class, rephost_class; +static jclass seq_stat_class, txn_stat_class; +static jclass txn_active_class; +static jclass lock_class, lockreq_class; +static jclass dbex_class, deadex_class, lockex_class, memex_class; +static jclass repdupmasterex_class, rephandledeadex_class; +static jclass repholdelectionex_class, repjoinfailex_class; +static jclass repleaseexpiredex_class, repleasetimeoutex_class; +static jclass replockoutex_class, repunavailex_class; +static jclass runrecex_class, versionex_class; +static jclass filenotfoundex_class, illegalargex_class, outofmemerr_class; +static jclass bytearray_class, string_class, outputstream_class; + +static jfieldID dbc_cptr_fid; +static jfieldID dblsn_file_fid, dblsn_offset_fid; +static jfieldID dbt_data_fid, dbt_data_nio_fid, dbt_size_fid, dbt_ulen_fid; +static jfieldID dbt_dlen_fid, dbt_doff_fid, dbt_flags_fid, dbt_offset_fid; +static jfieldID kr_less_fid, kr_equal_fid, kr_greater_fid; +static jfieldID lock_cptr_fid; +static jfieldID lockreq_op_fid, lockreq_modeflag_fid, lockreq_timeout_fid; +static jfieldID lockreq_obj_fid, lockreq_lock_fid; +static jfieldID repmgr_siteinfo_status_fid; + +/* BEGIN-STAT-FIELD-DECLS */ +static jfieldID bt_stat_bt_magic_fid; +static jfieldID bt_stat_bt_version_fid; +static jfieldID bt_stat_bt_metaflags_fid; +static jfieldID bt_stat_bt_nkeys_fid; +static jfieldID bt_stat_bt_ndata_fid; +static jfieldID bt_stat_bt_pagecnt_fid; +static jfieldID bt_stat_bt_pagesize_fid; +static jfieldID bt_stat_bt_minkey_fid; +static jfieldID bt_stat_bt_re_len_fid; +static jfieldID bt_stat_bt_re_pad_fid; +static jfieldID bt_stat_bt_levels_fid; +static jfieldID bt_stat_bt_int_pg_fid; +static jfieldID bt_stat_bt_leaf_pg_fid; +static jfieldID bt_stat_bt_dup_pg_fid; +static jfieldID bt_stat_bt_over_pg_fid; +static jfieldID bt_stat_bt_empty_pg_fid; +static jfieldID bt_stat_bt_free_fid; +static jfieldID bt_stat_bt_int_pgfree_fid; +static jfieldID bt_stat_bt_leaf_pgfree_fid; +static jfieldID bt_stat_bt_dup_pgfree_fid; +static jfieldID bt_stat_bt_over_pgfree_fid; +static jfieldID compact_compact_fillpercent_fid; +static jfieldID compact_compact_timeout_fid; +static jfieldID compact_compact_pages_fid; +static jfieldID compact_compact_pages_free_fid; +static jfieldID compact_compact_pages_examine_fid; +static jfieldID compact_compact_levels_fid; +static jfieldID compact_compact_deadlock_fid; +static jfieldID compact_compact_pages_truncated_fid; +static jfieldID compact_compact_truncate_fid; +static jfieldID h_stat_hash_magic_fid; +static jfieldID h_stat_hash_version_fid; +static jfieldID h_stat_hash_metaflags_fid; +static jfieldID h_stat_hash_nkeys_fid; +static jfieldID h_stat_hash_ndata_fid; +static jfieldID h_stat_hash_pagecnt_fid; +static jfieldID h_stat_hash_pagesize_fid; +static jfieldID h_stat_hash_ffactor_fid; +static jfieldID h_stat_hash_buckets_fid; +static jfieldID h_stat_hash_free_fid; +static jfieldID h_stat_hash_bfree_fid; +static jfieldID h_stat_hash_bigpages_fid; +static jfieldID h_stat_hash_big_bfree_fid; +static jfieldID h_stat_hash_overflows_fid; +static jfieldID h_stat_hash_ovfl_free_fid; +static jfieldID h_stat_hash_dup_fid; +static jfieldID h_stat_hash_dup_free_fid; +static jfieldID lock_stat_st_id_fid; +static jfieldID lock_stat_st_cur_maxid_fid; +static jfieldID lock_stat_st_maxlocks_fid; +static jfieldID lock_stat_st_maxlockers_fid; +static jfieldID lock_stat_st_maxobjects_fid; +static jfieldID lock_stat_st_partitions_fid; +static jfieldID lock_stat_st_nmodes_fid; +static jfieldID lock_stat_st_nlockers_fid; +static jfieldID lock_stat_st_nlocks_fid; +static jfieldID lock_stat_st_maxnlocks_fid; +static jfieldID lock_stat_st_maxhlocks_fid; +static jfieldID lock_stat_st_locksteals_fid; +static jfieldID lock_stat_st_maxlsteals_fid; +static jfieldID lock_stat_st_maxnlockers_fid; +static jfieldID lock_stat_st_nobjects_fid; +static jfieldID lock_stat_st_maxnobjects_fid; +static jfieldID lock_stat_st_maxhobjects_fid; +static jfieldID lock_stat_st_objectsteals_fid; +static jfieldID lock_stat_st_maxosteals_fid; +static jfieldID lock_stat_st_nrequests_fid; +static jfieldID lock_stat_st_nreleases_fid; +static jfieldID lock_stat_st_nupgrade_fid; +static jfieldID lock_stat_st_ndowngrade_fid; +static jfieldID lock_stat_st_lock_wait_fid; +static jfieldID lock_stat_st_lock_nowait_fid; +static jfieldID lock_stat_st_ndeadlocks_fid; +static jfieldID lock_stat_st_locktimeout_fid; +static jfieldID lock_stat_st_nlocktimeouts_fid; +static jfieldID lock_stat_st_txntimeout_fid; +static jfieldID lock_stat_st_ntxntimeouts_fid; +static jfieldID lock_stat_st_part_wait_fid; +static jfieldID lock_stat_st_part_nowait_fid; +static jfieldID lock_stat_st_part_max_wait_fid; +static jfieldID lock_stat_st_part_max_nowait_fid; +static jfieldID lock_stat_st_objs_wait_fid; +static jfieldID lock_stat_st_objs_nowait_fid; +static jfieldID lock_stat_st_lockers_wait_fid; +static jfieldID lock_stat_st_lockers_nowait_fid; +static jfieldID lock_stat_st_region_wait_fid; +static jfieldID lock_stat_st_region_nowait_fid; +static jfieldID lock_stat_st_hash_len_fid; +static jfieldID lock_stat_st_regsize_fid; +static jfieldID log_stat_st_magic_fid; +static jfieldID log_stat_st_version_fid; +static jfieldID log_stat_st_mode_fid; +static jfieldID log_stat_st_lg_bsize_fid; +static jfieldID log_stat_st_lg_size_fid; +static jfieldID log_stat_st_wc_bytes_fid; +static jfieldID log_stat_st_wc_mbytes_fid; +static jfieldID log_stat_st_record_fid; +static jfieldID log_stat_st_w_bytes_fid; +static jfieldID log_stat_st_w_mbytes_fid; +static jfieldID log_stat_st_wcount_fid; +static jfieldID log_stat_st_wcount_fill_fid; +static jfieldID log_stat_st_rcount_fid; +static jfieldID log_stat_st_scount_fid; +static jfieldID log_stat_st_region_wait_fid; +static jfieldID log_stat_st_region_nowait_fid; +static jfieldID log_stat_st_cur_file_fid; +static jfieldID log_stat_st_cur_offset_fid; +static jfieldID log_stat_st_disk_file_fid; +static jfieldID log_stat_st_disk_offset_fid; +static jfieldID log_stat_st_maxcommitperflush_fid; +static jfieldID log_stat_st_mincommitperflush_fid; +static jfieldID log_stat_st_regsize_fid; +static jfieldID mpool_fstat_file_name_fid; +static jfieldID mpool_fstat_st_pagesize_fid; +static jfieldID mpool_fstat_st_map_fid; +static jfieldID mpool_fstat_st_cache_hit_fid; +static jfieldID mpool_fstat_st_cache_miss_fid; +static jfieldID mpool_fstat_st_page_create_fid; +static jfieldID mpool_fstat_st_page_in_fid; +static jfieldID mpool_fstat_st_page_out_fid; +static jfieldID mpool_stat_st_gbytes_fid; +static jfieldID mpool_stat_st_bytes_fid; +static jfieldID mpool_stat_st_ncache_fid; +static jfieldID mpool_stat_st_max_ncache_fid; +static jfieldID mpool_stat_st_mmapsize_fid; +static jfieldID mpool_stat_st_maxopenfd_fid; +static jfieldID mpool_stat_st_maxwrite_fid; +static jfieldID mpool_stat_st_maxwrite_sleep_fid; +static jfieldID mpool_stat_st_pages_fid; +static jfieldID mpool_stat_st_map_fid; +static jfieldID mpool_stat_st_cache_hit_fid; +static jfieldID mpool_stat_st_cache_miss_fid; +static jfieldID mpool_stat_st_page_create_fid; +static jfieldID mpool_stat_st_page_in_fid; +static jfieldID mpool_stat_st_page_out_fid; +static jfieldID mpool_stat_st_ro_evict_fid; +static jfieldID mpool_stat_st_rw_evict_fid; +static jfieldID mpool_stat_st_page_trickle_fid; +static jfieldID mpool_stat_st_page_clean_fid; +static jfieldID mpool_stat_st_page_dirty_fid; +static jfieldID mpool_stat_st_hash_buckets_fid; +static jfieldID mpool_stat_st_pagesize_fid; +static jfieldID mpool_stat_st_hash_searches_fid; +static jfieldID mpool_stat_st_hash_longest_fid; +static jfieldID mpool_stat_st_hash_examined_fid; +static jfieldID mpool_stat_st_hash_nowait_fid; +static jfieldID mpool_stat_st_hash_wait_fid; +static jfieldID mpool_stat_st_hash_max_nowait_fid; +static jfieldID mpool_stat_st_hash_max_wait_fid; +static jfieldID mpool_stat_st_region_nowait_fid; +static jfieldID mpool_stat_st_region_wait_fid; +static jfieldID mpool_stat_st_mvcc_frozen_fid; +static jfieldID mpool_stat_st_mvcc_thawed_fid; +static jfieldID mpool_stat_st_mvcc_freed_fid; +static jfieldID mpool_stat_st_alloc_fid; +static jfieldID mpool_stat_st_alloc_buckets_fid; +static jfieldID mpool_stat_st_alloc_max_buckets_fid; +static jfieldID mpool_stat_st_alloc_pages_fid; +static jfieldID mpool_stat_st_alloc_max_pages_fid; +static jfieldID mpool_stat_st_io_wait_fid; +static jfieldID mpool_stat_st_sync_interrupted_fid; +static jfieldID mpool_stat_st_regsize_fid; +static jfieldID mutex_stat_st_mutex_align_fid; +static jfieldID mutex_stat_st_mutex_tas_spins_fid; +static jfieldID mutex_stat_st_mutex_cnt_fid; +static jfieldID mutex_stat_st_mutex_free_fid; +static jfieldID mutex_stat_st_mutex_inuse_fid; +static jfieldID mutex_stat_st_mutex_inuse_max_fid; +static jfieldID mutex_stat_st_region_wait_fid; +static jfieldID mutex_stat_st_region_nowait_fid; +static jfieldID mutex_stat_st_regsize_fid; +static jfieldID qam_stat_qs_magic_fid; +static jfieldID qam_stat_qs_version_fid; +static jfieldID qam_stat_qs_metaflags_fid; +static jfieldID qam_stat_qs_nkeys_fid; +static jfieldID qam_stat_qs_ndata_fid; +static jfieldID qam_stat_qs_pagesize_fid; +static jfieldID qam_stat_qs_extentsize_fid; +static jfieldID qam_stat_qs_pages_fid; +static jfieldID qam_stat_qs_re_len_fid; +static jfieldID qam_stat_qs_re_pad_fid; +static jfieldID qam_stat_qs_pgfree_fid; +static jfieldID qam_stat_qs_first_recno_fid; +static jfieldID qam_stat_qs_cur_recno_fid; +static jfieldID rep_stat_st_log_queued_fid; +static jfieldID rep_stat_st_startup_complete_fid; +static jfieldID rep_stat_st_status_fid; +static jfieldID rep_stat_st_next_lsn_fid; +static jfieldID rep_stat_st_waiting_lsn_fid; +static jfieldID rep_stat_st_max_perm_lsn_fid; +static jfieldID rep_stat_st_next_pg_fid; +static jfieldID rep_stat_st_waiting_pg_fid; +static jfieldID rep_stat_st_dupmasters_fid; +static jfieldID rep_stat_st_env_id_fid; +static jfieldID rep_stat_st_env_priority_fid; +static jfieldID rep_stat_st_bulk_fills_fid; +static jfieldID rep_stat_st_bulk_overflows_fid; +static jfieldID rep_stat_st_bulk_records_fid; +static jfieldID rep_stat_st_bulk_transfers_fid; +static jfieldID rep_stat_st_client_rerequests_fid; +static jfieldID rep_stat_st_client_svc_req_fid; +static jfieldID rep_stat_st_client_svc_miss_fid; +static jfieldID rep_stat_st_gen_fid; +static jfieldID rep_stat_st_egen_fid; +static jfieldID rep_stat_st_log_duplicated_fid; +static jfieldID rep_stat_st_log_queued_max_fid; +static jfieldID rep_stat_st_log_queued_total_fid; +static jfieldID rep_stat_st_log_records_fid; +static jfieldID rep_stat_st_log_requested_fid; +static jfieldID rep_stat_st_master_fid; +static jfieldID rep_stat_st_master_changes_fid; +static jfieldID rep_stat_st_msgs_badgen_fid; +static jfieldID rep_stat_st_msgs_processed_fid; +static jfieldID rep_stat_st_msgs_recover_fid; +static jfieldID rep_stat_st_msgs_send_failures_fid; +static jfieldID rep_stat_st_msgs_sent_fid; +static jfieldID rep_stat_st_newsites_fid; +static jfieldID rep_stat_st_nsites_fid; +static jfieldID rep_stat_st_nthrottles_fid; +static jfieldID rep_stat_st_outdated_fid; +static jfieldID rep_stat_st_pg_duplicated_fid; +static jfieldID rep_stat_st_pg_records_fid; +static jfieldID rep_stat_st_pg_requested_fid; +static jfieldID rep_stat_st_txns_applied_fid; +static jfieldID rep_stat_st_startsync_delayed_fid; +static jfieldID rep_stat_st_elections_fid; +static jfieldID rep_stat_st_elections_won_fid; +static jfieldID rep_stat_st_election_cur_winner_fid; +static jfieldID rep_stat_st_election_gen_fid; +static jfieldID rep_stat_st_election_lsn_fid; +static jfieldID rep_stat_st_election_nsites_fid; +static jfieldID rep_stat_st_election_nvotes_fid; +static jfieldID rep_stat_st_election_priority_fid; +static jfieldID rep_stat_st_election_status_fid; +static jfieldID rep_stat_st_election_tiebreaker_fid; +static jfieldID rep_stat_st_election_votes_fid; +static jfieldID rep_stat_st_election_sec_fid; +static jfieldID rep_stat_st_election_usec_fid; +static jfieldID rep_stat_st_max_lease_sec_fid; +static jfieldID rep_stat_st_max_lease_usec_fid; +static jfieldID repmgr_stat_st_perm_failed_fid; +static jfieldID repmgr_stat_st_msgs_queued_fid; +static jfieldID repmgr_stat_st_msgs_dropped_fid; +static jfieldID repmgr_stat_st_connection_drop_fid; +static jfieldID repmgr_stat_st_connect_fail_fid; +static jfieldID seq_stat_st_wait_fid; +static jfieldID seq_stat_st_nowait_fid; +static jfieldID seq_stat_st_current_fid; +static jfieldID seq_stat_st_value_fid; +static jfieldID seq_stat_st_last_value_fid; +static jfieldID seq_stat_st_min_fid; +static jfieldID seq_stat_st_max_fid; +static jfieldID seq_stat_st_cache_size_fid; +static jfieldID seq_stat_st_flags_fid; +static jfieldID txn_stat_st_nrestores_fid; +static jfieldID txn_stat_st_last_ckp_fid; +static jfieldID txn_stat_st_time_ckp_fid; +static jfieldID txn_stat_st_last_txnid_fid; +static jfieldID txn_stat_st_maxtxns_fid; +static jfieldID txn_stat_st_naborts_fid; +static jfieldID txn_stat_st_nbegins_fid; +static jfieldID txn_stat_st_ncommits_fid; +static jfieldID txn_stat_st_nactive_fid; +static jfieldID txn_stat_st_nsnapshot_fid; +static jfieldID txn_stat_st_maxnactive_fid; +static jfieldID txn_stat_st_maxnsnapshot_fid; +static jfieldID txn_stat_st_txnarray_fid; +static jfieldID txn_stat_st_region_wait_fid; +static jfieldID txn_stat_st_region_nowait_fid; +static jfieldID txn_stat_st_regsize_fid; +static jfieldID txn_active_txnid_fid; +static jfieldID txn_active_parentid_fid; +static jfieldID txn_active_pid_fid; +static jfieldID txn_active_lsn_fid; +static jfieldID txn_active_read_lsn_fid; +static jfieldID txn_active_mvcc_ref_fid; +static jfieldID txn_active_status_fid; +static jfieldID txn_active_gid_fid; +static jfieldID txn_active_name_fid; +/* END-STAT-FIELD-DECLS */ + +static jmethodID dbenv_construct, dbt_construct, dblsn_construct; +static jmethodID dbpreplist_construct, dbtxn_construct; +static jmethodID bt_stat_construct, get_err_msg_method, h_stat_construct; +static jmethodID lock_stat_construct, log_stat_construct; +static jmethodID mpool_stat_construct, mpool_fstat_construct; +static jmethodID mutex_stat_construct, qam_stat_construct; +static jmethodID rep_stat_construct, repmgr_stat_construct, seq_stat_construct; +static jmethodID txn_stat_construct, txn_active_construct; +static jmethodID dbex_construct, deadex_construct, lockex_construct; +static jmethodID memex_construct, memex_update_method; +static jmethodID repdupmasterex_construct, rephandledeadex_construct; +static jmethodID repholdelectionex_construct, repjoinfailex_construct; +static jmethodID repmgr_siteinfo_construct, rephost_construct, repleaseexpiredex_construct; +static jmethodID repleasetimeoutex_construct, replockoutex_construct; +static jmethodID repunavailex_construct; +static jmethodID runrecex_construct, versionex_construct; +static jmethodID filenotfoundex_construct, illegalargex_construct; +static jmethodID outofmemerr_construct; +static jmethodID lock_construct; + +static jmethodID app_dispatch_method, errcall_method, env_feedback_method; +static jmethodID msgcall_method, paniccall_method, rep_transport_method; +static jmethodID panic_event_notify_method, rep_client_event_notify_method; +static jmethodID rep_elected_event_notify_method; +static jmethodID rep_master_event_notify_method; +static jmethodID rep_new_master_event_notify_method; +static jmethodID rep_perm_failed_event_notify_method; +static jmethodID rep_startup_done_event_notify_method; +static jmethodID write_failed_event_notify_method; + +static jmethodID append_recno_method, bt_compare_method, bt_compress_method; +static jmethodID bt_decompress_method, bt_prefix_method; +static jmethodID db_feedback_method, dup_compare_method; +static jmethodID foreignkey_nullify_method, h_compare_method, h_hash_method; +static jmethodID partition_method, seckey_create_method; + +static jmethodID outputstream_write_method; + +const struct { + jclass *cl; + const char *name; +} all_classes[] = { + { &dbenv_class, DB_PKG "internal/DbEnv" }, + { &db_class, DB_PKG "internal/Db" }, + { &dbc_class, DB_PKG "internal/Dbc" }, + { &dbt_class, DB_PKG "DatabaseEntry" }, + { &dblsn_class, DB_PKG "LogSequenceNumber" }, + { &dbpreplist_class, DB_PKG "PreparedTransaction" }, + { &dbtxn_class, DB_PKG "internal/DbTxn" }, + + { &bt_stat_class, DB_PKG "BtreeStats" }, + { &compact_class, DB_PKG "CompactStats" }, + { &h_stat_class, DB_PKG "HashStats" }, + { &lock_stat_class, DB_PKG "LockStats" }, + { &log_stat_class, DB_PKG "LogStats" }, + { &mpool_fstat_class, DB_PKG "CacheFileStats" }, + { &mpool_stat_class, DB_PKG "CacheStats" }, + { &mutex_stat_class, DB_PKG "MutexStats" }, + { &qam_stat_class, DB_PKG "QueueStats" }, + { &rep_stat_class, DB_PKG "ReplicationStats" }, + { &repmgr_stat_class, DB_PKG "ReplicationManagerStats" }, + { &seq_stat_class, DB_PKG "SequenceStats" }, + { &txn_stat_class, DB_PKG "TransactionStats" }, + { &txn_active_class, DB_PKG "TransactionStats$Active" }, + + { &keyrange_class, DB_PKG "KeyRange" }, + { &lock_class, DB_PKG "internal/DbLock" }, + { &lockreq_class, DB_PKG "LockRequest" }, + + { &dbex_class, DB_PKG "DatabaseException" }, + { &deadex_class, DB_PKG "DeadlockException" }, + { &lockex_class, DB_PKG "LockNotGrantedException" }, + { &memex_class, DB_PKG "MemoryException" }, + { &repdupmasterex_class, DB_PKG "ReplicationDuplicateMasterException" }, + { &rephandledeadex_class, DB_PKG "ReplicationHandleDeadException" }, + { &repholdelectionex_class, DB_PKG "ReplicationHoldElectionException" }, + { &rephost_class, DB_PKG "ReplicationHostAddress" }, + { &repmgr_siteinfo_class, DB_PKG "ReplicationManagerSiteInfo" }, + { &repjoinfailex_class, DB_PKG "ReplicationJoinFailureException" }, + { &repleaseexpiredex_class, DB_PKG "ReplicationLeaseExpiredException" }, + { &repleasetimeoutex_class, DB_PKG "ReplicationLeaseTimeoutException" }, + { &replockoutex_class, DB_PKG "ReplicationLockoutException" }, + { &repunavailex_class, DB_PKG "ReplicationSiteUnavailableException" }, + { &runrecex_class, DB_PKG "RunRecoveryException" }, + { &versionex_class, DB_PKG "VersionMismatchException" }, + { &filenotfoundex_class, "java/io/FileNotFoundException" }, + { &illegalargex_class, "java/lang/IllegalArgumentException" }, + { &outofmemerr_class, "java/lang/OutOfMemoryError" }, + + { &bytearray_class, "[B" }, + { &string_class, "java/lang/String" }, + { &outputstream_class, "java/io/OutputStream" } +}; + +const struct { + jfieldID *fid; + jclass *cl; + const char *name; + const char *sig; +} all_fields[] = { + { &dbc_cptr_fid, &dbc_class, "swigCPtr", "J" }, + + { &dblsn_file_fid, &dblsn_class, "file", "I" }, + { &dblsn_offset_fid, &dblsn_class, "offset", "I" }, + + { &dbt_data_fid, &dbt_class, "data", "[B" }, + { &dbt_data_nio_fid, &dbt_class, "data_nio", "Ljava/nio/ByteBuffer;" }, + { &dbt_size_fid, &dbt_class, "size", "I" }, + { &dbt_ulen_fid, &dbt_class, "ulen", "I" }, + { &dbt_dlen_fid, &dbt_class, "dlen", "I" }, + { &dbt_doff_fid, &dbt_class, "doff", "I" }, + { &dbt_flags_fid, &dbt_class, "flags", "I" }, + { &dbt_offset_fid, &dbt_class, "offset", "I" }, + + { &kr_less_fid, &keyrange_class, "less", "D" }, + { &kr_equal_fid, &keyrange_class, "equal", "D" }, + { &kr_greater_fid, &keyrange_class, "greater", "D" }, + + { &lock_cptr_fid, &lock_class, "swigCPtr", "J" }, + + { &lockreq_op_fid, &lockreq_class, "op", "I" }, + { &lockreq_modeflag_fid, &lockreq_class, "modeFlag", "I" }, + { &lockreq_timeout_fid, &lockreq_class, "timeout", "I" }, + { &lockreq_obj_fid, &lockreq_class, "obj", + "L" DB_PKG "DatabaseEntry;" }, + { &lockreq_lock_fid, &lockreq_class, "lock", + "L" DB_PKG "internal/DbLock;" }, + +/* BEGIN-STAT-FIELDS */ + { &bt_stat_bt_magic_fid, &bt_stat_class, "bt_magic", "I" }, + { &bt_stat_bt_version_fid, &bt_stat_class, "bt_version", "I" }, + { &bt_stat_bt_metaflags_fid, &bt_stat_class, "bt_metaflags", "I" }, + { &bt_stat_bt_nkeys_fid, &bt_stat_class, "bt_nkeys", "I" }, + { &bt_stat_bt_ndata_fid, &bt_stat_class, "bt_ndata", "I" }, + { &bt_stat_bt_pagecnt_fid, &bt_stat_class, "bt_pagecnt", "I" }, + { &bt_stat_bt_pagesize_fid, &bt_stat_class, "bt_pagesize", "I" }, + { &bt_stat_bt_minkey_fid, &bt_stat_class, "bt_minkey", "I" }, + { &bt_stat_bt_re_len_fid, &bt_stat_class, "bt_re_len", "I" }, + { &bt_stat_bt_re_pad_fid, &bt_stat_class, "bt_re_pad", "I" }, + { &bt_stat_bt_levels_fid, &bt_stat_class, "bt_levels", "I" }, + { &bt_stat_bt_int_pg_fid, &bt_stat_class, "bt_int_pg", "I" }, + { &bt_stat_bt_leaf_pg_fid, &bt_stat_class, "bt_leaf_pg", "I" }, + { &bt_stat_bt_dup_pg_fid, &bt_stat_class, "bt_dup_pg", "I" }, + { &bt_stat_bt_over_pg_fid, &bt_stat_class, "bt_over_pg", "I" }, + { &bt_stat_bt_empty_pg_fid, &bt_stat_class, "bt_empty_pg", "I" }, + { &bt_stat_bt_free_fid, &bt_stat_class, "bt_free", "I" }, + { &bt_stat_bt_int_pgfree_fid, &bt_stat_class, "bt_int_pgfree", "J" }, + { &bt_stat_bt_leaf_pgfree_fid, &bt_stat_class, "bt_leaf_pgfree", "J" }, + { &bt_stat_bt_dup_pgfree_fid, &bt_stat_class, "bt_dup_pgfree", "J" }, + { &bt_stat_bt_over_pgfree_fid, &bt_stat_class, "bt_over_pgfree", "J" }, + { &compact_compact_fillpercent_fid, &compact_class, "compact_fillpercent", "I" }, + { &compact_compact_timeout_fid, &compact_class, "compact_timeout", "I" }, + { &compact_compact_pages_fid, &compact_class, "compact_pages", "I" }, + { &compact_compact_pages_free_fid, &compact_class, "compact_pages_free", "I" }, + { &compact_compact_pages_examine_fid, &compact_class, "compact_pages_examine", "I" }, + { &compact_compact_levels_fid, &compact_class, "compact_levels", "I" }, + { &compact_compact_deadlock_fid, &compact_class, "compact_deadlock", "I" }, + { &compact_compact_pages_truncated_fid, &compact_class, "compact_pages_truncated", "I" }, + { &compact_compact_truncate_fid, &compact_class, "compact_truncate", "I" }, + { &h_stat_hash_magic_fid, &h_stat_class, "hash_magic", "I" }, + { &h_stat_hash_version_fid, &h_stat_class, "hash_version", "I" }, + { &h_stat_hash_metaflags_fid, &h_stat_class, "hash_metaflags", "I" }, + { &h_stat_hash_nkeys_fid, &h_stat_class, "hash_nkeys", "I" }, + { &h_stat_hash_ndata_fid, &h_stat_class, "hash_ndata", "I" }, + { &h_stat_hash_pagecnt_fid, &h_stat_class, "hash_pagecnt", "I" }, + { &h_stat_hash_pagesize_fid, &h_stat_class, "hash_pagesize", "I" }, + { &h_stat_hash_ffactor_fid, &h_stat_class, "hash_ffactor", "I" }, + { &h_stat_hash_buckets_fid, &h_stat_class, "hash_buckets", "I" }, + { &h_stat_hash_free_fid, &h_stat_class, "hash_free", "I" }, + { &h_stat_hash_bfree_fid, &h_stat_class, "hash_bfree", "J" }, + { &h_stat_hash_bigpages_fid, &h_stat_class, "hash_bigpages", "I" }, + { &h_stat_hash_big_bfree_fid, &h_stat_class, "hash_big_bfree", "J" }, + { &h_stat_hash_overflows_fid, &h_stat_class, "hash_overflows", "I" }, + { &h_stat_hash_ovfl_free_fid, &h_stat_class, "hash_ovfl_free", "J" }, + { &h_stat_hash_dup_fid, &h_stat_class, "hash_dup", "I" }, + { &h_stat_hash_dup_free_fid, &h_stat_class, "hash_dup_free", "J" }, + { &lock_stat_st_id_fid, &lock_stat_class, "st_id", "I" }, + { &lock_stat_st_cur_maxid_fid, &lock_stat_class, "st_cur_maxid", "I" }, + { &lock_stat_st_maxlocks_fid, &lock_stat_class, "st_maxlocks", "I" }, + { &lock_stat_st_maxlockers_fid, &lock_stat_class, "st_maxlockers", "I" }, + { &lock_stat_st_maxobjects_fid, &lock_stat_class, "st_maxobjects", "I" }, + { &lock_stat_st_partitions_fid, &lock_stat_class, "st_partitions", "I" }, + { &lock_stat_st_nmodes_fid, &lock_stat_class, "st_nmodes", "I" }, + { &lock_stat_st_nlockers_fid, &lock_stat_class, "st_nlockers", "I" }, + { &lock_stat_st_nlocks_fid, &lock_stat_class, "st_nlocks", "I" }, + { &lock_stat_st_maxnlocks_fid, &lock_stat_class, "st_maxnlocks", "I" }, + { &lock_stat_st_maxhlocks_fid, &lock_stat_class, "st_maxhlocks", "I" }, + { &lock_stat_st_locksteals_fid, &lock_stat_class, "st_locksteals", "J" }, + { &lock_stat_st_maxlsteals_fid, &lock_stat_class, "st_maxlsteals", "J" }, + { &lock_stat_st_maxnlockers_fid, &lock_stat_class, "st_maxnlockers", "I" }, + { &lock_stat_st_nobjects_fid, &lock_stat_class, "st_nobjects", "I" }, + { &lock_stat_st_maxnobjects_fid, &lock_stat_class, "st_maxnobjects", "I" }, + { &lock_stat_st_maxhobjects_fid, &lock_stat_class, "st_maxhobjects", "I" }, + { &lock_stat_st_objectsteals_fid, &lock_stat_class, "st_objectsteals", "J" }, + { &lock_stat_st_maxosteals_fid, &lock_stat_class, "st_maxosteals", "J" }, + { &lock_stat_st_nrequests_fid, &lock_stat_class, "st_nrequests", "J" }, + { &lock_stat_st_nreleases_fid, &lock_stat_class, "st_nreleases", "J" }, + { &lock_stat_st_nupgrade_fid, &lock_stat_class, "st_nupgrade", "J" }, + { &lock_stat_st_ndowngrade_fid, &lock_stat_class, "st_ndowngrade", "J" }, + { &lock_stat_st_lock_wait_fid, &lock_stat_class, "st_lock_wait", "J" }, + { &lock_stat_st_lock_nowait_fid, &lock_stat_class, "st_lock_nowait", "J" }, + { &lock_stat_st_ndeadlocks_fid, &lock_stat_class, "st_ndeadlocks", "J" }, + { &lock_stat_st_locktimeout_fid, &lock_stat_class, "st_locktimeout", "I" }, + { &lock_stat_st_nlocktimeouts_fid, &lock_stat_class, "st_nlocktimeouts", "J" }, + { &lock_stat_st_txntimeout_fid, &lock_stat_class, "st_txntimeout", "I" }, + { &lock_stat_st_ntxntimeouts_fid, &lock_stat_class, "st_ntxntimeouts", "J" }, + { &lock_stat_st_part_wait_fid, &lock_stat_class, "st_part_wait", "J" }, + { &lock_stat_st_part_nowait_fid, &lock_stat_class, "st_part_nowait", "J" }, + { &lock_stat_st_part_max_wait_fid, &lock_stat_class, "st_part_max_wait", "J" }, + { &lock_stat_st_part_max_nowait_fid, &lock_stat_class, "st_part_max_nowait", "J" }, + { &lock_stat_st_objs_wait_fid, &lock_stat_class, "st_objs_wait", "J" }, + { &lock_stat_st_objs_nowait_fid, &lock_stat_class, "st_objs_nowait", "J" }, + { &lock_stat_st_lockers_wait_fid, &lock_stat_class, "st_lockers_wait", "J" }, + { &lock_stat_st_lockers_nowait_fid, &lock_stat_class, "st_lockers_nowait", "J" }, + { &lock_stat_st_region_wait_fid, &lock_stat_class, "st_region_wait", "J" }, + { &lock_stat_st_region_nowait_fid, &lock_stat_class, "st_region_nowait", "J" }, + { &lock_stat_st_hash_len_fid, &lock_stat_class, "st_hash_len", "I" }, + { &lock_stat_st_regsize_fid, &lock_stat_class, "st_regsize", "I" }, + { &log_stat_st_magic_fid, &log_stat_class, "st_magic", "I" }, + { &log_stat_st_version_fid, &log_stat_class, "st_version", "I" }, + { &log_stat_st_mode_fid, &log_stat_class, "st_mode", "I" }, + { &log_stat_st_lg_bsize_fid, &log_stat_class, "st_lg_bsize", "I" }, + { &log_stat_st_lg_size_fid, &log_stat_class, "st_lg_size", "I" }, + { &log_stat_st_wc_bytes_fid, &log_stat_class, "st_wc_bytes", "I" }, + { &log_stat_st_wc_mbytes_fid, &log_stat_class, "st_wc_mbytes", "I" }, + { &log_stat_st_record_fid, &log_stat_class, "st_record", "J" }, + { &log_stat_st_w_bytes_fid, &log_stat_class, "st_w_bytes", "I" }, + { &log_stat_st_w_mbytes_fid, &log_stat_class, "st_w_mbytes", "I" }, + { &log_stat_st_wcount_fid, &log_stat_class, "st_wcount", "J" }, + { &log_stat_st_wcount_fill_fid, &log_stat_class, "st_wcount_fill", "J" }, + { &log_stat_st_rcount_fid, &log_stat_class, "st_rcount", "J" }, + { &log_stat_st_scount_fid, &log_stat_class, "st_scount", "J" }, + { &log_stat_st_region_wait_fid, &log_stat_class, "st_region_wait", "J" }, + { &log_stat_st_region_nowait_fid, &log_stat_class, "st_region_nowait", "J" }, + { &log_stat_st_cur_file_fid, &log_stat_class, "st_cur_file", "I" }, + { &log_stat_st_cur_offset_fid, &log_stat_class, "st_cur_offset", "I" }, + { &log_stat_st_disk_file_fid, &log_stat_class, "st_disk_file", "I" }, + { &log_stat_st_disk_offset_fid, &log_stat_class, "st_disk_offset", "I" }, + { &log_stat_st_maxcommitperflush_fid, &log_stat_class, "st_maxcommitperflush", "I" }, + { &log_stat_st_mincommitperflush_fid, &log_stat_class, "st_mincommitperflush", "I" }, + { &log_stat_st_regsize_fid, &log_stat_class, "st_regsize", "I" }, + { &mpool_fstat_file_name_fid, &mpool_fstat_class, "file_name", "Ljava/lang/String;" }, + { &mpool_fstat_st_pagesize_fid, &mpool_fstat_class, "st_pagesize", "I" }, + { &mpool_fstat_st_map_fid, &mpool_fstat_class, "st_map", "I" }, + { &mpool_fstat_st_cache_hit_fid, &mpool_fstat_class, "st_cache_hit", "J" }, + { &mpool_fstat_st_cache_miss_fid, &mpool_fstat_class, "st_cache_miss", "J" }, + { &mpool_fstat_st_page_create_fid, &mpool_fstat_class, "st_page_create", "J" }, + { &mpool_fstat_st_page_in_fid, &mpool_fstat_class, "st_page_in", "J" }, + { &mpool_fstat_st_page_out_fid, &mpool_fstat_class, "st_page_out", "J" }, + { &mpool_stat_st_gbytes_fid, &mpool_stat_class, "st_gbytes", "I" }, + { &mpool_stat_st_bytes_fid, &mpool_stat_class, "st_bytes", "I" }, + { &mpool_stat_st_ncache_fid, &mpool_stat_class, "st_ncache", "I" }, + { &mpool_stat_st_max_ncache_fid, &mpool_stat_class, "st_max_ncache", "I" }, + { &mpool_stat_st_mmapsize_fid, &mpool_stat_class, "st_mmapsize", "I" }, + { &mpool_stat_st_maxopenfd_fid, &mpool_stat_class, "st_maxopenfd", "I" }, + { &mpool_stat_st_maxwrite_fid, &mpool_stat_class, "st_maxwrite", "I" }, + { &mpool_stat_st_maxwrite_sleep_fid, &mpool_stat_class, "st_maxwrite_sleep", "I" }, + { &mpool_stat_st_pages_fid, &mpool_stat_class, "st_pages", "I" }, + { &mpool_stat_st_map_fid, &mpool_stat_class, "st_map", "I" }, + { &mpool_stat_st_cache_hit_fid, &mpool_stat_class, "st_cache_hit", "J" }, + { &mpool_stat_st_cache_miss_fid, &mpool_stat_class, "st_cache_miss", "J" }, + { &mpool_stat_st_page_create_fid, &mpool_stat_class, "st_page_create", "J" }, + { &mpool_stat_st_page_in_fid, &mpool_stat_class, "st_page_in", "J" }, + { &mpool_stat_st_page_out_fid, &mpool_stat_class, "st_page_out", "J" }, + { &mpool_stat_st_ro_evict_fid, &mpool_stat_class, "st_ro_evict", "J" }, + { &mpool_stat_st_rw_evict_fid, &mpool_stat_class, "st_rw_evict", "J" }, + { &mpool_stat_st_page_trickle_fid, &mpool_stat_class, "st_page_trickle", "J" }, + { &mpool_stat_st_page_clean_fid, &mpool_stat_class, "st_page_clean", "I" }, + { &mpool_stat_st_page_dirty_fid, &mpool_stat_class, "st_page_dirty", "I" }, + { &mpool_stat_st_hash_buckets_fid, &mpool_stat_class, "st_hash_buckets", "I" }, + { &mpool_stat_st_pagesize_fid, &mpool_stat_class, "st_pagesize", "I" }, + { &mpool_stat_st_hash_searches_fid, &mpool_stat_class, "st_hash_searches", "I" }, + { &mpool_stat_st_hash_longest_fid, &mpool_stat_class, "st_hash_longest", "I" }, + { &mpool_stat_st_hash_examined_fid, &mpool_stat_class, "st_hash_examined", "J" }, + { &mpool_stat_st_hash_nowait_fid, &mpool_stat_class, "st_hash_nowait", "J" }, + { &mpool_stat_st_hash_wait_fid, &mpool_stat_class, "st_hash_wait", "J" }, + { &mpool_stat_st_hash_max_nowait_fid, &mpool_stat_class, "st_hash_max_nowait", "J" }, + { &mpool_stat_st_hash_max_wait_fid, &mpool_stat_class, "st_hash_max_wait", "J" }, + { &mpool_stat_st_region_nowait_fid, &mpool_stat_class, "st_region_nowait", "J" }, + { &mpool_stat_st_region_wait_fid, &mpool_stat_class, "st_region_wait", "J" }, + { &mpool_stat_st_mvcc_frozen_fid, &mpool_stat_class, "st_mvcc_frozen", "J" }, + { &mpool_stat_st_mvcc_thawed_fid, &mpool_stat_class, "st_mvcc_thawed", "J" }, + { &mpool_stat_st_mvcc_freed_fid, &mpool_stat_class, "st_mvcc_freed", "J" }, + { &mpool_stat_st_alloc_fid, &mpool_stat_class, "st_alloc", "J" }, + { &mpool_stat_st_alloc_buckets_fid, &mpool_stat_class, "st_alloc_buckets", "J" }, + { &mpool_stat_st_alloc_max_buckets_fid, &mpool_stat_class, "st_alloc_max_buckets", "J" }, + { &mpool_stat_st_alloc_pages_fid, &mpool_stat_class, "st_alloc_pages", "J" }, + { &mpool_stat_st_alloc_max_pages_fid, &mpool_stat_class, "st_alloc_max_pages", "J" }, + { &mpool_stat_st_io_wait_fid, &mpool_stat_class, "st_io_wait", "J" }, + { &mpool_stat_st_sync_interrupted_fid, &mpool_stat_class, "st_sync_interrupted", "J" }, + { &mpool_stat_st_regsize_fid, &mpool_stat_class, "st_regsize", "I" }, + { &mutex_stat_st_mutex_align_fid, &mutex_stat_class, "st_mutex_align", "I" }, + { &mutex_stat_st_mutex_tas_spins_fid, &mutex_stat_class, "st_mutex_tas_spins", "I" }, + { &mutex_stat_st_mutex_cnt_fid, &mutex_stat_class, "st_mutex_cnt", "I" }, + { &mutex_stat_st_mutex_free_fid, &mutex_stat_class, "st_mutex_free", "I" }, + { &mutex_stat_st_mutex_inuse_fid, &mutex_stat_class, "st_mutex_inuse", "I" }, + { &mutex_stat_st_mutex_inuse_max_fid, &mutex_stat_class, "st_mutex_inuse_max", "I" }, + { &mutex_stat_st_region_wait_fid, &mutex_stat_class, "st_region_wait", "J" }, + { &mutex_stat_st_region_nowait_fid, &mutex_stat_class, "st_region_nowait", "J" }, + { &mutex_stat_st_regsize_fid, &mutex_stat_class, "st_regsize", "I" }, + { &qam_stat_qs_magic_fid, &qam_stat_class, "qs_magic", "I" }, + { &qam_stat_qs_version_fid, &qam_stat_class, "qs_version", "I" }, + { &qam_stat_qs_metaflags_fid, &qam_stat_class, "qs_metaflags", "I" }, + { &qam_stat_qs_nkeys_fid, &qam_stat_class, "qs_nkeys", "I" }, + { &qam_stat_qs_ndata_fid, &qam_stat_class, "qs_ndata", "I" }, + { &qam_stat_qs_pagesize_fid, &qam_stat_class, "qs_pagesize", "I" }, + { &qam_stat_qs_extentsize_fid, &qam_stat_class, "qs_extentsize", "I" }, + { &qam_stat_qs_pages_fid, &qam_stat_class, "qs_pages", "I" }, + { &qam_stat_qs_re_len_fid, &qam_stat_class, "qs_re_len", "I" }, + { &qam_stat_qs_re_pad_fid, &qam_stat_class, "qs_re_pad", "I" }, + { &qam_stat_qs_pgfree_fid, &qam_stat_class, "qs_pgfree", "I" }, + { &qam_stat_qs_first_recno_fid, &qam_stat_class, "qs_first_recno", "I" }, + { &qam_stat_qs_cur_recno_fid, &qam_stat_class, "qs_cur_recno", "I" }, + { &rep_stat_st_log_queued_fid, &rep_stat_class, "st_log_queued", "J" }, + { &rep_stat_st_startup_complete_fid, &rep_stat_class, "st_startup_complete", "I" }, + { &rep_stat_st_status_fid, &rep_stat_class, "st_status", "I" }, + { &rep_stat_st_next_lsn_fid, &rep_stat_class, "st_next_lsn", "L" DB_PKG "LogSequenceNumber;" }, + { &rep_stat_st_waiting_lsn_fid, &rep_stat_class, "st_waiting_lsn", "L" DB_PKG "LogSequenceNumber;" }, + { &rep_stat_st_max_perm_lsn_fid, &rep_stat_class, "st_max_perm_lsn", "L" DB_PKG "LogSequenceNumber;" }, + { &rep_stat_st_next_pg_fid, &rep_stat_class, "st_next_pg", "I" }, + { &rep_stat_st_waiting_pg_fid, &rep_stat_class, "st_waiting_pg", "I" }, + { &rep_stat_st_dupmasters_fid, &rep_stat_class, "st_dupmasters", "I" }, + { &rep_stat_st_env_id_fid, &rep_stat_class, "st_env_id", "I" }, + { &rep_stat_st_env_priority_fid, &rep_stat_class, "st_env_priority", "I" }, + { &rep_stat_st_bulk_fills_fid, &rep_stat_class, "st_bulk_fills", "J" }, + { &rep_stat_st_bulk_overflows_fid, &rep_stat_class, "st_bulk_overflows", "J" }, + { &rep_stat_st_bulk_records_fid, &rep_stat_class, "st_bulk_records", "J" }, + { &rep_stat_st_bulk_transfers_fid, &rep_stat_class, "st_bulk_transfers", "J" }, + { &rep_stat_st_client_rerequests_fid, &rep_stat_class, "st_client_rerequests", "J" }, + { &rep_stat_st_client_svc_req_fid, &rep_stat_class, "st_client_svc_req", "J" }, + { &rep_stat_st_client_svc_miss_fid, &rep_stat_class, "st_client_svc_miss", "J" }, + { &rep_stat_st_gen_fid, &rep_stat_class, "st_gen", "I" }, + { &rep_stat_st_egen_fid, &rep_stat_class, "st_egen", "I" }, + { &rep_stat_st_log_duplicated_fid, &rep_stat_class, "st_log_duplicated", "J" }, + { &rep_stat_st_log_queued_max_fid, &rep_stat_class, "st_log_queued_max", "J" }, + { &rep_stat_st_log_queued_total_fid, &rep_stat_class, "st_log_queued_total", "J" }, + { &rep_stat_st_log_records_fid, &rep_stat_class, "st_log_records", "J" }, + { &rep_stat_st_log_requested_fid, &rep_stat_class, "st_log_requested", "J" }, + { &rep_stat_st_master_fid, &rep_stat_class, "st_master", "I" }, + { &rep_stat_st_master_changes_fid, &rep_stat_class, "st_master_changes", "J" }, + { &rep_stat_st_msgs_badgen_fid, &rep_stat_class, "st_msgs_badgen", "J" }, + { &rep_stat_st_msgs_processed_fid, &rep_stat_class, "st_msgs_processed", "J" }, + { &rep_stat_st_msgs_recover_fid, &rep_stat_class, "st_msgs_recover", "J" }, + { &rep_stat_st_msgs_send_failures_fid, &rep_stat_class, "st_msgs_send_failures", "J" }, + { &rep_stat_st_msgs_sent_fid, &rep_stat_class, "st_msgs_sent", "J" }, + { &rep_stat_st_newsites_fid, &rep_stat_class, "st_newsites", "J" }, + { &rep_stat_st_nsites_fid, &rep_stat_class, "st_nsites", "I" }, + { &rep_stat_st_nthrottles_fid, &rep_stat_class, "st_nthrottles", "J" }, + { &rep_stat_st_outdated_fid, &rep_stat_class, "st_outdated", "J" }, + { &rep_stat_st_pg_duplicated_fid, &rep_stat_class, "st_pg_duplicated", "J" }, + { &rep_stat_st_pg_records_fid, &rep_stat_class, "st_pg_records", "J" }, + { &rep_stat_st_pg_requested_fid, &rep_stat_class, "st_pg_requested", "J" }, + { &rep_stat_st_txns_applied_fid, &rep_stat_class, "st_txns_applied", "J" }, + { &rep_stat_st_startsync_delayed_fid, &rep_stat_class, "st_startsync_delayed", "J" }, + { &rep_stat_st_elections_fid, &rep_stat_class, "st_elections", "J" }, + { &rep_stat_st_elections_won_fid, &rep_stat_class, "st_elections_won", "J" }, + { &rep_stat_st_election_cur_winner_fid, &rep_stat_class, "st_election_cur_winner", "I" }, + { &rep_stat_st_election_gen_fid, &rep_stat_class, "st_election_gen", "I" }, + { &rep_stat_st_election_lsn_fid, &rep_stat_class, "st_election_lsn", "L" DB_PKG "LogSequenceNumber;" }, + { &rep_stat_st_election_nsites_fid, &rep_stat_class, "st_election_nsites", "I" }, + { &rep_stat_st_election_nvotes_fid, &rep_stat_class, "st_election_nvotes", "I" }, + { &rep_stat_st_election_priority_fid, &rep_stat_class, "st_election_priority", "I" }, + { &rep_stat_st_election_status_fid, &rep_stat_class, "st_election_status", "I" }, + { &rep_stat_st_election_tiebreaker_fid, &rep_stat_class, "st_election_tiebreaker", "I" }, + { &rep_stat_st_election_votes_fid, &rep_stat_class, "st_election_votes", "I" }, + { &rep_stat_st_election_sec_fid, &rep_stat_class, "st_election_sec", "I" }, + { &rep_stat_st_election_usec_fid, &rep_stat_class, "st_election_usec", "I" }, + { &rep_stat_st_max_lease_sec_fid, &rep_stat_class, "st_max_lease_sec", "I" }, + { &rep_stat_st_max_lease_usec_fid, &rep_stat_class, "st_max_lease_usec", "I" }, + { &repmgr_stat_st_perm_failed_fid, &repmgr_stat_class, "st_perm_failed", "J" }, + { &repmgr_stat_st_msgs_queued_fid, &repmgr_stat_class, "st_msgs_queued", "J" }, + { &repmgr_stat_st_msgs_dropped_fid, &repmgr_stat_class, "st_msgs_dropped", "J" }, + { &repmgr_stat_st_connection_drop_fid, &repmgr_stat_class, "st_connection_drop", "J" }, + { &repmgr_stat_st_connect_fail_fid, &repmgr_stat_class, "st_connect_fail", "J" }, + { &seq_stat_st_wait_fid, &seq_stat_class, "st_wait", "J" }, + { &seq_stat_st_nowait_fid, &seq_stat_class, "st_nowait", "J" }, + { &seq_stat_st_current_fid, &seq_stat_class, "st_current", "J" }, + { &seq_stat_st_value_fid, &seq_stat_class, "st_value", "J" }, + { &seq_stat_st_last_value_fid, &seq_stat_class, "st_last_value", "J" }, + { &seq_stat_st_min_fid, &seq_stat_class, "st_min", "J" }, + { &seq_stat_st_max_fid, &seq_stat_class, "st_max", "J" }, + { &seq_stat_st_cache_size_fid, &seq_stat_class, "st_cache_size", "I" }, + { &seq_stat_st_flags_fid, &seq_stat_class, "st_flags", "I" }, + { &txn_stat_st_nrestores_fid, &txn_stat_class, "st_nrestores", "I" }, + { &txn_stat_st_last_ckp_fid, &txn_stat_class, "st_last_ckp", "L" DB_PKG "LogSequenceNumber;" }, + { &txn_stat_st_time_ckp_fid, &txn_stat_class, "st_time_ckp", "J" }, + { &txn_stat_st_last_txnid_fid, &txn_stat_class, "st_last_txnid", "I" }, + { &txn_stat_st_maxtxns_fid, &txn_stat_class, "st_maxtxns", "I" }, + { &txn_stat_st_naborts_fid, &txn_stat_class, "st_naborts", "J" }, + { &txn_stat_st_nbegins_fid, &txn_stat_class, "st_nbegins", "J" }, + { &txn_stat_st_ncommits_fid, &txn_stat_class, "st_ncommits", "J" }, + { &txn_stat_st_nactive_fid, &txn_stat_class, "st_nactive", "I" }, + { &txn_stat_st_nsnapshot_fid, &txn_stat_class, "st_nsnapshot", "I" }, + { &txn_stat_st_maxnactive_fid, &txn_stat_class, "st_maxnactive", "I" }, + { &txn_stat_st_maxnsnapshot_fid, &txn_stat_class, "st_maxnsnapshot", "I" }, + { &txn_stat_st_txnarray_fid, &txn_stat_class, "st_txnarray", "[L" DB_PKG "TransactionStats$Active;" }, + { &txn_stat_st_region_wait_fid, &txn_stat_class, "st_region_wait", "J" }, + { &txn_stat_st_region_nowait_fid, &txn_stat_class, "st_region_nowait", "J" }, + { &txn_stat_st_regsize_fid, &txn_stat_class, "st_regsize", "I" }, + { &txn_active_txnid_fid, &txn_active_class, "txnid", "I" }, + { &txn_active_parentid_fid, &txn_active_class, "parentid", "I" }, + { &txn_active_pid_fid, &txn_active_class, "pid", "I" }, + { &txn_active_lsn_fid, &txn_active_class, "lsn", "L" DB_PKG "LogSequenceNumber;" }, + { &txn_active_read_lsn_fid, &txn_active_class, "read_lsn", "L" DB_PKG "LogSequenceNumber;" }, + { &txn_active_mvcc_ref_fid, &txn_active_class, "mvcc_ref", "I" }, + { &txn_active_status_fid, &txn_active_class, "status", "I" }, + { &txn_active_gid_fid, &txn_active_class, "gid", "[B" }, + { &txn_active_name_fid, &txn_active_class, "name", "Ljava/lang/String;" }, +/* END-STAT-FIELDS */ + + { &repmgr_siteinfo_status_fid, &repmgr_siteinfo_class, "status", "I" } +}; + +const struct { + jmethodID *mid; + jclass *cl; + const char *name; + const char *sig; +} all_methods[] = { + { &dbenv_construct, &dbenv_class, "<init>", "(JZ)V" }, + { &dbt_construct, &dbt_class, "<init>", "()V" }, + { &dblsn_construct, &dblsn_class, "<init>", "(II)V" }, + { &dbpreplist_construct, &dbpreplist_class, "<init>", + "(L" DB_PKG "internal/DbTxn;[B)V" }, + { &dbtxn_construct, &dbtxn_class, "<init>", "(JZ)V" }, + + { &bt_stat_construct, &bt_stat_class, "<init>", "()V" }, + { &get_err_msg_method, &dbenv_class, "get_err_msg", + "(Ljava/lang/String;)Ljava/lang/String;" }, + { &h_stat_construct, &h_stat_class, "<init>", "()V" }, + { &lock_stat_construct, &lock_stat_class, "<init>", "()V" }, + { &log_stat_construct, &log_stat_class, "<init>", "()V" }, + { &mpool_stat_construct, &mpool_stat_class, "<init>", "()V" }, + { &mpool_fstat_construct, &mpool_fstat_class, "<init>", "()V" }, + { &mutex_stat_construct, &mutex_stat_class, "<init>", "()V" }, + { &qam_stat_construct, &qam_stat_class, "<init>", "()V" }, + { &rep_stat_construct, &rep_stat_class, "<init>", "()V" }, + { &repmgr_stat_construct, &repmgr_stat_class, "<init>", "()V" }, + { &seq_stat_construct, &seq_stat_class, "<init>", "()V" }, + { &txn_stat_construct, &txn_stat_class, "<init>", "()V" }, + { &txn_active_construct, &txn_active_class, "<init>", "()V" }, + { &rephost_construct, &rephost_class, "<init>", "(Ljava/lang/String;I)V" }, + { &repmgr_siteinfo_construct, &repmgr_siteinfo_class, "<init>", + "(L" DB_PKG "ReplicationHostAddress;I)V" }, + + { &dbex_construct, &dbex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &deadex_construct, &deadex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &lockex_construct, &lockex_class, "<init>", + "(Ljava/lang/String;IIL" DB_PKG "DatabaseEntry;L" + DB_PKG "internal/DbLock;IL" DB_PKG "internal/DbEnv;)V" }, + { &memex_construct, &memex_class, "<init>", + "(Ljava/lang/String;L" DB_PKG "DatabaseEntry;IL" + DB_PKG "internal/DbEnv;)V" }, + { &memex_update_method, &memex_class, "updateDatabaseEntry", + "(L" DB_PKG "DatabaseEntry;)V" }, + { &repdupmasterex_construct, &repdupmasterex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &rephandledeadex_construct, &rephandledeadex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &repholdelectionex_construct, &repholdelectionex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &repjoinfailex_construct, &repjoinfailex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &repleaseexpiredex_construct, &repleaseexpiredex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &repleasetimeoutex_construct, &repleasetimeoutex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &replockoutex_construct, &replockoutex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &repunavailex_construct, &repunavailex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &runrecex_construct, &runrecex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &versionex_construct, &versionex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &filenotfoundex_construct, &filenotfoundex_class, "<init>", + "(Ljava/lang/String;)V" }, + { &illegalargex_construct, &illegalargex_class, "<init>", + "(Ljava/lang/String;)V" }, + { &outofmemerr_construct, &outofmemerr_class, "<init>", + "(Ljava/lang/String;)V" }, + + { &lock_construct, &lock_class, "<init>", "(JZ)V" }, + + { &app_dispatch_method, &dbenv_class, "handle_app_dispatch", + "(L" DB_PKG "DatabaseEntry;L" DB_PKG "LogSequenceNumber;I)I" }, + { &panic_event_notify_method, &dbenv_class, "handle_panic_event_notify", + "()V" }, + { &rep_client_event_notify_method, &dbenv_class, + "handle_rep_client_event_notify", "()V" }, + { &rep_elected_event_notify_method, &dbenv_class, + "handle_rep_elected_event_notify" ,"()V" }, + { &rep_master_event_notify_method, &dbenv_class, + "handle_rep_master_event_notify", "()V" }, + { &rep_new_master_event_notify_method, &dbenv_class, + "handle_rep_new_master_event_notify", "(I)V" }, + { &rep_perm_failed_event_notify_method, &dbenv_class, + "handle_rep_perm_failed_event_notify", "()V" }, + { &rep_startup_done_event_notify_method, &dbenv_class, + "handle_rep_startup_done_event_notify", "()V" }, + { &write_failed_event_notify_method, &dbenv_class, + "handle_write_failed_event_notify", "(I)V" }, + { &env_feedback_method, &dbenv_class, "handle_env_feedback", "(II)V" }, + { &errcall_method, &dbenv_class, "handle_error", + "(Ljava/lang/String;)V" }, + { &msgcall_method, &dbenv_class, "handle_message", + "(Ljava/lang/String;)V" }, + { &paniccall_method, &dbenv_class, "handle_panic", + "(L" DB_PKG "DatabaseException;)V" }, + { &rep_transport_method, &dbenv_class, "handle_rep_transport", + "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" + DB_PKG "LogSequenceNumber;II)I" }, + + { &append_recno_method, &db_class, "handle_append_recno", + "(L" DB_PKG "DatabaseEntry;I)V" }, + { &bt_compare_method, &db_class, "handle_bt_compare", + "([B[B)I" }, + { &bt_compress_method, &db_class, "handle_bt_compress", + "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" DB_PKG + "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" DB_PKG + "DatabaseEntry;)I" }, + { &bt_decompress_method, &db_class, "handle_bt_decompress", + "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" DB_PKG + "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" DB_PKG + "DatabaseEntry;)I" }, + { &bt_prefix_method, &db_class, "handle_bt_prefix", + "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;)I" }, + { &db_feedback_method, &db_class, "handle_db_feedback", "(II)V" }, + { &dup_compare_method, &db_class, "handle_dup_compare", + "([B[B)I" }, + { &foreignkey_nullify_method, &db_class, "handle_foreignkey_nullify", + "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" DB_PKG + "DatabaseEntry;)Z" }, + { &h_compare_method, &db_class, "handle_h_compare", + "([B[B)I" }, + { &h_hash_method, &db_class, "handle_h_hash", "([BI)I" }, + { &partition_method, &db_class, "handle_partition", + "(L" DB_PKG "DatabaseEntry;)I" }, + { &seckey_create_method, &db_class, "handle_seckey_create", + "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;)[L" + DB_PKG "DatabaseEntry;" }, + + { &outputstream_write_method, &outputstream_class, "write", "([BII)V" } +}; + +#define NELEM(x) (sizeof (x) / sizeof (x[0])) + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_initialize( + JNIEnv *jenv, jclass clazz) +{ + jclass cl; + unsigned int i, j; + + COMPQUIET(clazz, NULL); + + if ((*jenv)->GetJavaVM(jenv, &javavm) != 0) { + __db_errx(NULL, "Cannot get Java VM"); + return; + } + + for (i = 0; i < NELEM(all_classes); i++) { + cl = (*jenv)->FindClass(jenv, all_classes[i].name); + if (cl == NULL) { + fprintf(stderr, + "Failed to load class %s - check CLASSPATH\n", + all_classes[i].name); + return; + } + + /* + * Wrap classes in GlobalRefs so we keep the reference between + * calls. + */ + *all_classes[i].cl = (jclass)(*jenv)->NewGlobalRef(jenv, cl); + + if (*all_classes[i].cl == NULL) { + fprintf(stderr, + "Failed to create a global reference for %s\n", + all_classes[i].name); + return; + } + } + + /* Get field IDs */ + for (i = 0; i < NELEM(all_fields); i++) { + *all_fields[i].fid = (*jenv)->GetFieldID(jenv, + *all_fields[i].cl, all_fields[i].name, all_fields[i].sig); + + if (*all_fields[i].fid == NULL) { + fprintf(stderr, + "Failed to look up field %s with sig %s\n", + all_fields[i].name, all_fields[i].sig); + return; + } + } + + /* Get method IDs */ + for (i = 0; i < NELEM(all_methods); i++) { + *all_methods[i].mid = (*jenv)->GetMethodID(jenv, + *all_methods[i].cl, all_methods[i].name, + all_methods[i].sig); + + if (*all_methods[i].mid == NULL) { + for (j = 0; j < NELEM(all_classes); j++) + if (all_methods[i].cl == all_classes[j].cl) + break; + fprintf(stderr, + "Failed to look up method %s.%s with sig %s\n", + all_classes[j].name, all_methods[i].name, + all_methods[i].sig); + return; + } + } +} + +static JNIEnv *__dbj_get_jnienv(int *needDetach) +{ + /* + * Note: Different versions of the JNI disagree on the signature for + * AttachCurrentThreadAsDaemon. The most recent documentation seems to + * say that (JNIEnv **) is correct, but newer JNIs seem to use + * (void **), oddly enough. + */ +#ifdef JNI_VERSION_1_2 + void *jenv = 0; +#else + JNIEnv *jenv = 0; +#endif + + *needDetach = 0; + if ((*javavm)->GetEnv(javavm, &jenv, JNI_VERSION_1_2) == JNI_OK) + return ((JNIEnv *)jenv); + + /* + * This should always succeed, as we are called via some Java activity. + * I think therefore I am (a thread). + */ + if ((*javavm)->AttachCurrentThread(javavm, &jenv, 0) != 0) + return (0); + + *needDetach = 1; + return ((JNIEnv *)jenv); +} + +static void __dbj_detach() +{ + (void)(*javavm)->DetachCurrentThread(javavm); +} + +static jobject __dbj_wrap_DB_LSN(JNIEnv *jenv, DB_LSN *lsn) +{ + return (*jenv)->NewObject(jenv, dblsn_class, dblsn_construct, + lsn->file, lsn->offset); +} + + +/* + * Macros to find the Java DbEnv object for methods in various classes. + * Note that "arg1" is from the code SWIG generates for the "this"/"self". + */ +#define JDBENV (arg1 ? (jobject)DB_ENV_INTERNAL(arg1) : NULL) +#define DB2JDBENV ((jobject)DB_ENV_INTERNAL(arg1->dbenv)) +#define DBC2JDBENV ((jobject)DB_ENV_INTERNAL(arg1->dbp->dbenv)) +#define TXN2JDBENV ((jobject)DB_ENV_INTERNAL(arg1->mgrp->env->dbenv)) + + +static jthrowable __dbj_get_except(JNIEnv *jenv, + int err, const char *msg, jobject obj, jobject jdbenv) { + jobject jmsg; + + if (msg == NULL) + msg = db_strerror(err); + + jmsg = (*jenv)->NewStringUTF(jenv, msg); + + /* Retrieve error message logged by DB */ + if (jdbenv != NULL) { + jmsg = (jstring) (*jenv)->CallNonvirtualObjectMethod(jenv, + jdbenv, dbenv_class, get_err_msg_method, jmsg); + } + + switch (err) { + case EINVAL: + return (jthrowable)(*jenv)->NewObject(jenv, + illegalargex_class, illegalargex_construct, jmsg); + + case ENOENT: + return (jthrowable)(*jenv)->NewObject(jenv, + filenotfoundex_class, filenotfoundex_construct, jmsg); + + case ENOMEM: + return (jthrowable)(*jenv)->NewObject(jenv, + outofmemerr_class, outofmemerr_construct, jmsg); + + case DB_BUFFER_SMALL: + return (jthrowable)(*jenv)->NewObject(jenv, memex_class, + memex_construct, jmsg, obj, err, jdbenv); + + case DB_REP_DUPMASTER: + return (jthrowable)(*jenv)->NewObject(jenv, + repdupmasterex_class, repdupmasterex_construct, + jmsg, err, jdbenv); + + case DB_REP_HANDLE_DEAD: + return (jthrowable)(*jenv)->NewObject(jenv, + rephandledeadex_class, rephandledeadex_construct, + jmsg, err, jdbenv); + + case DB_REP_HOLDELECTION: + return (jthrowable)(*jenv)->NewObject(jenv, + repholdelectionex_class, repholdelectionex_construct, + jmsg, err, jdbenv); + + case DB_REP_JOIN_FAILURE: + return (jthrowable)(*jenv)->NewObject(jenv, + repjoinfailex_class, repjoinfailex_construct, + jmsg, err, jdbenv); + + case DB_REP_LEASE_EXPIRED: + return (jthrowable)(*jenv)->NewObject(jenv, + repleaseexpiredex_class, repleaseexpiredex_construct, + jmsg, err, jdbenv); + + case DB_REP_LEASE_TIMEOUT: + return (jthrowable)(*jenv)->NewObject(jenv, + repleasetimeoutex_class, repleasetimeoutex_construct, + jmsg, err, jdbenv); + + case DB_REP_LOCKOUT: + return (jthrowable)(*jenv)->NewObject(jenv, + replockoutex_class, replockoutex_construct, + jmsg, err, jdbenv); + + case DB_REP_UNAVAIL: + return (jthrowable)(*jenv)->NewObject(jenv, + repunavailex_class, repunavailex_construct, + jmsg, err, jdbenv); + + case DB_RUNRECOVERY: + return (jthrowable)(*jenv)->NewObject(jenv, runrecex_class, + runrecex_construct, jmsg, err, jdbenv); + + case DB_LOCK_DEADLOCK: + return (jthrowable)(*jenv)->NewObject(jenv, deadex_class, + deadex_construct, jmsg, err, jdbenv); + + case DB_LOCK_NOTGRANTED: + return (jthrowable)(*jenv)->NewObject(jenv, lockex_class, + lockex_construct, jmsg, err, 0, NULL, NULL, 0, jdbenv); + + case DB_VERSION_MISMATCH: + return (jthrowable)(*jenv)->NewObject(jenv, versionex_class, + versionex_construct, jmsg, err, jdbenv); + + default: + return (jthrowable)(*jenv)->NewObject(jenv, dbex_class, + dbex_construct, jmsg, err, jdbenv); + } +} + +static int __dbj_throw(JNIEnv *jenv, + int err, const char *msg, jobject obj, jobject jdbenv) +{ + jthrowable t; + + /* If an exception is pending, ignore requests to throw a new one. */ + if ((*jenv)->ExceptionOccurred(jenv) == NULL) { + t = __dbj_get_except(jenv, err, msg, obj, jdbenv); + if (t == NULL) { + /* + * This is a problem - something went wrong creating an + * exception. We have to assume there is an exception + * created by the JVM that is pending as a result + * (e.g., OutOfMemoryError), but we don't want to lose + * this error, so we just call __db_errx here. + */ + if (msg == NULL) + msg = db_strerror(err); + + __db_errx(NULL, "Couldn't create exception for: '%s'", + msg); + } else + (*jenv)->Throw(jenv, t); + } + + return (err); +} + + +typedef struct __dbt_locked { + JNIEnv *jenv; + jobject jdbt; + DBT dbt; + jobject jdata_nio; + jbyteArray jarr; + jint offset; + int reuse; + u_int32_t orig_size; + jsize array_len; +} DBT_LOCKED; + +static int __dbj_dbt_memcopy(DBT *dbt, u_int32_t offset, void *buf, u_int32_t size, u_int32_t flags) { + DBT_LOCKED *ldbt = dbt->app_data; + JNIEnv *jenv = ldbt->jenv; + + if (size == 0) + return (0); + else if (!F_ISSET(dbt, DB_DBT_USERCOPY)) { + /* + * For simplicity, the Java API calls this function directly, + * so it needs to work with regular DBTs. + */ + switch (flags) { + case DB_USERCOPY_GETDATA: + memcpy(buf, (u_int8_t *)dbt->data + offset, size); + return (0); + case DB_USERCOPY_SETDATA: + memcpy((u_int8_t *)dbt->data + offset, buf, size); + return (0); + default: + return (EINVAL); + } + } + + switch (flags) { + case DB_USERCOPY_GETDATA: + (*jenv)->GetByteArrayRegion(jenv, ldbt->jarr, ldbt->offset + + offset, size, buf); + break; + case DB_USERCOPY_SETDATA: + /* + * Check whether this is the first time through the callback by relying + * on the offset being zero. + */ + if (offset == 0 && (!ldbt->reuse || + (jsize)(ldbt->offset + dbt->size) > ldbt->array_len)) { + if (ldbt->jarr != NULL) + (*jenv)->DeleteLocalRef(jenv, ldbt->jarr); + ldbt->jarr = (*jenv)->NewByteArray(jenv, (jsize)dbt->size); + if (ldbt->jarr == NULL) + return (ENOMEM); + (*jenv)->SetObjectField(jenv, ldbt->jdbt, dbt_data_fid, ldbt->jarr); + /* We've allocated a new array, start from the beginning. */ + ldbt->offset = 0; + } + (*jenv)->SetByteArrayRegion(jenv, ldbt->jarr, ldbt->offset + + offset, size, buf); + break; + default: + return (EINVAL); + } + return ((*jenv)->ExceptionOccurred(jenv) ? EINVAL : 0); +} + +static void __dbj_dbt_copyout( + JNIEnv *jenv, const DBT *dbt, jbyteArray *jarr, jobject jdbt) +{ + jbyteArray newarr = (*jenv)->NewByteArray(jenv, (jsize)dbt->size); + if (newarr == NULL) + return; /* An exception is pending */ + (*jenv)->SetByteArrayRegion(jenv, newarr, 0, (jsize)dbt->size, + (jbyte *)dbt->data); + (*jenv)->SetObjectField(jenv, jdbt, dbt_data_fid, newarr); + (*jenv)->SetIntField(jenv, jdbt, dbt_offset_fid, 0); + (*jenv)->SetIntField(jenv, jdbt, dbt_size_fid, (jint)dbt->size); + if (jarr != NULL) + *jarr = newarr; + else + (*jenv)->DeleteLocalRef(jenv, newarr); +} + +static int __dbj_dbt_copyin( + JNIEnv *jenv, DBT_LOCKED *ldbt, DBT **dbtp, jobject jdbt, int allow_null) +{ + DBT *dbt; + jlong capacity; + + memset(ldbt, 0, sizeof (*ldbt)); + ldbt->jenv = jenv; + ldbt->jdbt = jdbt; + + if (jdbt == NULL) { + if (allow_null) { + *dbtp = NULL; + return (0); + } else { + return (__dbj_throw(jenv, EINVAL, + "DatabaseEntry must not be null", NULL, NULL)); + } + } + + dbt = &ldbt->dbt; + if (dbtp != NULL) + *dbtp = dbt; + + ldbt->jdata_nio = (*jenv)->GetObjectField(jenv, jdbt, dbt_data_nio_fid); + if (ldbt->jdata_nio != NULL) + F_SET(dbt, DB_DBT_USERMEM); + else + ldbt->jarr = (jbyteArray)(*jenv)->GetObjectField(jenv, jdbt, dbt_data_fid); + ldbt->offset = (*jenv)->GetIntField(jenv, jdbt, dbt_offset_fid); + dbt->size = (*jenv)->GetIntField(jenv, jdbt, dbt_size_fid); + ldbt->orig_size = dbt->size; + dbt->flags = (*jenv)->GetIntField(jenv, jdbt, dbt_flags_fid); + + if (F_ISSET(dbt, DB_DBT_USERMEM)) + dbt->ulen = (*jenv)->GetIntField(jenv, jdbt, dbt_ulen_fid); + if (F_ISSET(dbt, DB_DBT_PARTIAL)) { + dbt->dlen = (*jenv)->GetIntField(jenv, jdbt, dbt_dlen_fid); + dbt->doff = (*jenv)->GetIntField(jenv, jdbt, dbt_doff_fid); + + if ((jint)dbt->doff < 0) + return (__dbj_throw(jenv, EINVAL, "DatabaseEntry doff illegal", + NULL, NULL)); + } + + /* + * We don't support DB_DBT_REALLOC - map anything that's not USERMEM to + * MALLOC. + */ + if (!F_ISSET(dbt, DB_DBT_USERMEM)) { + ldbt->reuse = !F_ISSET(dbt, DB_DBT_MALLOC); + F_CLR(dbt, DB_DBT_MALLOC | DB_DBT_REALLOC); + } + + /* Verify parameters before allocating or locking data. */ + if (ldbt->jdata_nio != NULL) { + capacity = (*jenv)->GetDirectBufferCapacity(jenv, + ldbt->jdata_nio); + if (capacity > (jlong)UINT32_MAX) + return (__dbj_throw(jenv, EINVAL, + "DirectBuffer may not be larger than 4GB", + NULL, NULL)); + ldbt->array_len = (u_int32_t)capacity; + } else if (ldbt->jarr == NULL) { + /* + * Some code makes the assumption that if a DBT's size or ulen + * is non-zero, there is data to copy from dbt->data. + * + * Clean up the dbt fields so we don't run into trouble. + * (Note that doff, dlen, and flags all may contain + * meaningful values.) + */ + dbt->data = NULL; + ldbt->array_len = ldbt->offset = dbt->size = dbt->ulen = 0; + } else + ldbt->array_len = (*jenv)->GetArrayLength(jenv, ldbt->jarr); + + if (F_ISSET(dbt, DB_DBT_USERMEM)) { + if (ldbt->offset < 0) + return (__dbj_throw(jenv, EINVAL, + "offset cannot be negative", + NULL, NULL)); + if (dbt->size > dbt->ulen) + return (__dbj_throw(jenv, EINVAL, + "size must be less than or equal to ulen", + NULL, NULL)); + if ((jsize)(ldbt->offset + dbt->ulen) > ldbt->array_len) + return (__dbj_throw(jenv, EINVAL, + "offset + ulen greater than array length", + NULL, NULL)); + } + + if (ldbt->jdata_nio) { + dbt->data = (*jenv)->GetDirectBufferAddress(jenv, + ldbt->jdata_nio); + dbt->data = (u_int8_t *)dbt->data + ldbt->offset; + } else if (F_ISSET(dbt, DB_DBT_USERMEM)) { + if (ldbt->jarr != NULL && + (dbt->data = (*jenv)->GetByteArrayElements(jenv, + ldbt->jarr, NULL)) == NULL) + return (EINVAL); /* an exception will be pending */ + dbt->data = (u_int8_t *)dbt->data + ldbt->offset; + } else + F_SET(dbt, DB_DBT_USERCOPY); + dbt->app_data = ldbt; + + return (0); +} + +static void __dbj_dbt_release( + JNIEnv *jenv, jobject jdbt, DBT *dbt, DBT_LOCKED *ldbt) { + jthrowable t; + + if (dbt == NULL) + return; + + if (dbt->size != ldbt->orig_size) + (*jenv)->SetIntField(jenv, jdbt, dbt_size_fid, (jint)dbt->size); + + if (F_ISSET(dbt, DB_DBT_USERMEM)) { + if (ldbt->jarr != NULL) + (*jenv)->ReleaseByteArrayElements(jenv, ldbt->jarr, + (jbyte *)dbt->data - ldbt->offset, 0); + + if (dbt->size > dbt->ulen && + (t = (*jenv)->ExceptionOccurred(jenv)) != NULL && + (*jenv)->IsInstanceOf(jenv, t, memex_class)) { + (*jenv)->CallNonvirtualVoidMethod(jenv, t, memex_class, + memex_update_method, jdbt); + /* + * We have to rethrow the exception because calling + * into Java clears it. + */ + (*jenv)->Throw(jenv, t); + } + } +} + + +struct __dbj_verify_data { + JNIEnv *jenv; + jobject streamobj; + jbyteArray bytes; + int nbytes; +}; + +static int __dbj_verify_callback(void *handle, const void *str_arg) { + char *str; + struct __dbj_verify_data *vd; + int len; + JNIEnv *jenv; + + str = (char *)str_arg; + vd = (struct __dbj_verify_data *)handle; + jenv = vd->jenv; + len = (int)strlen(str) + 1; + if (len > vd->nbytes) { + vd->nbytes = len; + if (vd->bytes != NULL) + (*jenv)->DeleteLocalRef(jenv, vd->bytes); + if ((vd->bytes = (*jenv)->NewByteArray(jenv, (jsize)len)) + == NULL) + return (ENOMEM); + } + + if (vd->bytes != NULL) { + (*jenv)->SetByteArrayRegion(jenv, vd->bytes, 0, (jsize)len, + (jbyte*)str); + (*jenv)->CallVoidMethod(jenv, vd->streamobj, + outputstream_write_method, vd->bytes, 0, len - 1); + } + + if ((*jenv)->ExceptionOccurred(jenv) != NULL) + return (EIO); + + return (0); +} + + +SWIGEXPORT void JNICALL +Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1lock_1vec(JNIEnv *jenv, + jclass jcls, jlong jdbenvp, jobject jdbenv, jint locker, jint flags, + jobjectArray list, jint offset, jint count) { + DB_ENV *dbenv; + DB_LOCKREQ *lockreq; + DB_LOCKREQ *prereq; /* preprocessed requests */ + DB_LOCKREQ *failedreq; + DB_LOCK *lockp; + DBT_LOCKED *locked_dbts; + DBT *obj; + ENV *env; + int err, alloc_err, i; + size_t bytesize, ldbtsize; + jobject jlockreq; + db_lockop_t op; + jobject jobj, jlock; + jlong jlockp; + int completed; + + /* + * We can't easily #include "dbinc/db_ext.h" because of name + * clashes, so we declare this explicitly. + */ + extern int __dbt_usercopy __P((ENV *, DBT *)); + extern void __dbt_userfree __P((ENV *, DBT *, DBT *, DBT *)); + + COMPQUIET(jcls, NULL); + dbenv = *(DB_ENV **)(void *)&jdbenvp; + env = dbenv->env; + locked_dbts = NULL; + lockreq = NULL; + + if (dbenv == NULL) { + __dbj_throw(jenv, EINVAL, "null object", NULL, jdbenv); + return; + } + + if ((*jenv)->GetArrayLength(jenv, list) < offset + count) { + __dbj_throw(jenv, EINVAL, + "DbEnv.lock_vec array not large enough", NULL, jdbenv); + return; + } + + bytesize = sizeof(DB_LOCKREQ) * count; + if ((err = __os_malloc(env, bytesize, &lockreq)) != 0) { + __dbj_throw(jenv, err, NULL, NULL, jdbenv); + return; + } + memset(lockreq, 0, bytesize); + + ldbtsize = sizeof(DBT_LOCKED) * count; + if ((err = __os_malloc(env, ldbtsize, &locked_dbts)) != 0) { + __dbj_throw(jenv, err, NULL, NULL, jdbenv); + goto err; + } + memset(locked_dbts, 0, ldbtsize); + prereq = &lockreq[0]; + + /* fill in the lockreq array */ + for (i = 0, prereq = &lockreq[0]; i < count; i++, prereq++) { + jlockreq = (*jenv)->GetObjectArrayElement(jenv, list, + offset + i); + if (jlockreq == NULL) { + __dbj_throw(jenv, EINVAL, + "DbEnv.lock_vec list entry is null", NULL, jdbenv); + goto err; + } + op = (db_lockop_t)(*jenv)->GetIntField( + jenv, jlockreq, lockreq_op_fid); + prereq->op = op; + + switch (op) { + case DB_LOCK_GET_TIMEOUT: + /* Needed: mode, timeout, obj. Returned: lock. */ + prereq->op = (db_lockop_t)(*jenv)->GetIntField( + jenv, jlockreq, lockreq_timeout_fid); + /* FALLTHROUGH */ + case DB_LOCK_GET: + /* Needed: mode, obj. Returned: lock. */ + prereq->mode = (db_lockmode_t)(*jenv)->GetIntField( + jenv, jlockreq, lockreq_modeflag_fid); + jobj = (*jenv)->GetObjectField(jenv, jlockreq, + lockreq_obj_fid); + if ((err = __dbj_dbt_copyin(jenv, + &locked_dbts[i], &obj, jobj, 0)) != 0 || + (err = __dbt_usercopy(env, obj)) != 0) + goto err; + prereq->obj = obj; + break; + case DB_LOCK_PUT: + /* Needed: lock. Ignored: mode, obj. */ + jlock = (*jenv)->GetObjectField(jenv, jlockreq, + lockreq_lock_fid); + if (jlock == NULL || + (jlockp = (*jenv)->GetLongField(jenv, jlock, + lock_cptr_fid)) == 0L) { + __dbj_throw(jenv, EINVAL, + "LockRequest lock field is NULL", NULL, + jdbenv); + goto err; + } + lockp = *(DB_LOCK **)(void *)&jlockp; + prereq->lock = *lockp; + break; + case DB_LOCK_PUT_ALL: + case DB_LOCK_TIMEOUT: + /* Needed: (none). Ignored: lock, mode, obj. */ + break; + case DB_LOCK_PUT_OBJ: + /* Needed: obj. Ignored: lock, mode. */ + jobj = (*jenv)->GetObjectField(jenv, jlockreq, + lockreq_obj_fid); + if ((err = __dbj_dbt_copyin(jenv, + &locked_dbts[i], &obj, jobj, 0)) != 0 || + (err = __dbt_usercopy(env, obj)) != 0) + goto err; + prereq->obj = obj; + break; + default: + __dbj_throw(jenv, EINVAL, + "DbEnv.lock_vec bad op value", NULL, jdbenv); + goto err; + } + } + + err = dbenv->lock_vec(dbenv, (u_int32_t)locker, (u_int32_t)flags, + lockreq, count, &failedreq); + if (err == 0) + completed = count; + else + completed = (int)(failedreq - lockreq); + + /* do post processing for any and all requests that completed */ + for (i = 0; i < completed; i++) { + op = lockreq[i].op; + if (op == DB_LOCK_PUT) { + /* + * After a successful put, the DbLock can no longer be + * used, so we release the storage related to it. + */ + jlockreq = (*jenv)->GetObjectArrayElement(jenv, + list, i + offset); + jlock = (*jenv)->GetObjectField(jenv, jlockreq, + lockreq_lock_fid); + jlockp = (*jenv)->GetLongField(jenv, jlock, + lock_cptr_fid); + lockp = *(DB_LOCK **)(void *)&jlockp; + __os_free(NULL, lockp); + (*jenv)->SetLongField(jenv, jlock, lock_cptr_fid, + (jlong)0); + } else if (op == DB_LOCK_GET_TIMEOUT || op == DB_LOCK_GET) { + /* + * Store the lock that was obtained. We need to create + * storage for it since the lockreq array only exists + * during this method call. + */ + if ((alloc_err = + __os_malloc(env, sizeof(DB_LOCK), &lockp)) != 0) { + __dbj_throw(jenv, alloc_err, NULL, NULL, + jdbenv); + goto err; + } + + *lockp = lockreq[i].lock; + *(DB_LOCK **)(void *)&jlockp = lockp; + + jlockreq = (*jenv)->GetObjectArrayElement(jenv, + list, i + offset); + jlock = (*jenv)->NewObject(jenv, lock_class, + lock_construct, jlockp, JNI_TRUE); + if (jlock == NULL) + goto err; /* An exception is pending */ + (*jenv)->SetLongField(jenv, jlock, lock_cptr_fid, + jlockp); + (*jenv)->SetObjectField(jenv, jlockreq, + lockreq_lock_fid, jlock); + } + } + + /* If one of the locks was not granted, build the exception now. */ + if (err == DB_LOCK_NOTGRANTED && i < count) { + jlockreq = (*jenv)->GetObjectArrayElement(jenv, list, + i + offset); + jobj = (*jenv)->GetObjectField(jenv, jlockreq, lockreq_obj_fid); + jlock = (*jenv)->GetObjectField(jenv, jlockreq, + lockreq_lock_fid); + (*jenv)->Throw(jenv, + (*jenv)->NewObject(jenv, lockex_class, lockex_construct, + (*jenv)->NewStringUTF(jenv, "DbEnv.lock_vec incomplete"), + lockreq[i].op, lockreq[i].mode, jobj, jlock, i, jdbenv)); + } else if (err != 0) + __dbj_throw(jenv, err, NULL, NULL, jdbenv); + +err: for (i = 0, prereq = &lockreq[0]; i < count; i++, prereq++) + if (prereq->op == DB_LOCK_GET_TIMEOUT || + prereq->op == DB_LOCK_GET || + prereq->op == DB_LOCK_PUT_OBJ) { + jlockreq = (*jenv)->GetObjectArrayElement(jenv, + list, i + offset); + jobj = (*jenv)->GetObjectField(jenv, + jlockreq, lockreq_obj_fid); + __dbt_userfree(env, prereq->obj, NULL, NULL); + __dbj_dbt_release(jenv, jobj, prereq->obj, &locked_dbts[i]); + } + if (locked_dbts != NULL) + __os_free(env, locked_dbts); + if (lockreq != NULL) + __os_free(env, lockreq); +} + + +/* + * These macros are used by code generated by the s_java script. + */ +#define JAVADB_STAT_INT(jenv, jobj, fid, statp, name) \ + (*jenv)->SetIntField(jenv, jobj, fid, (jint)statp->name) + +#define JAVADB_STAT_STRING(jenv, jobj, fid, statp, name) \ + (*jenv)->SetObjectField(jenv, jobj, fid, \ + (*jenv)->NewStringUTF(jenv, statp->name)) + +#define JAVADB_STAT_LSN(jenv, jobj, fid, statp, name) \ + (*jenv)->SetObjectField(jenv, jobj, fid, \ + __dbj_wrap_DB_LSN(jenv, &statp->name)) + +#define JAVADB_STAT_LONG(jenv, jobj, fid, statp, name) \ + (*jenv)->SetLongField(jenv, jobj, fid, \ + (jlong)statp->name) + +#define JAVADB_STAT_GID(jenv, jobj, fid, statp, name) { \ + jobject jarr = \ + (*jenv)->NewByteArray(jenv, (jsize)DB_GID_SIZE); \ + (*jenv)->SetByteArrayRegion(jenv, jarr, \ + 0, (jsize)DB_GID_SIZE, (jbyte *)statp->name); \ + (*jenv)->SetObjectField(jenv, jobj, fid, jarr); \ + } + +/* + * We build the active list separately. + */ +#define JAVADB_STAT_ACTIVE(jenv, cl, jobj, statp, name) \ + do {} while(0) + +#include "java_stat_auto.c" + + +static void __dbj_error(const DB_ENV *dbenv, + const char *prefix, const char *msg) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); + jobject jmsg; + + COMPQUIET(prefix, NULL); + + if (jdbenv != NULL){ + jmsg = (*jenv)->NewStringUTF(jenv, msg); + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, dbenv_class, + errcall_method, jmsg); + (*jenv)->DeleteLocalRef(jenv, jmsg); + } + + if (detach) + __dbj_detach(); +} + +static void __dbj_env_feedback(DB_ENV *dbenv, int opcode, int percent) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); + + if (jdbenv != NULL) + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, dbenv_class, + env_feedback_method, opcode, percent); + + if (detach) + __dbj_detach(); +} + +static void __dbj_message(const DB_ENV *dbenv, const char *msg) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); + jobject jmsg; + + if (jdbenv != NULL){ + jmsg = (*jenv)->NewStringUTF(jenv, msg); + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, dbenv_class, + msgcall_method, jmsg); + (*jenv)->DeleteLocalRef(jenv, jmsg); + } + + if (detach) + __dbj_detach(); +} + +static void __dbj_panic(DB_ENV *dbenv, int err) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); + + if (jdbenv != NULL) + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, dbenv_class, + paniccall_method, + __dbj_get_except(jenv, err, NULL, NULL, jdbenv)); + + if (detach) + __dbj_detach(); +} + +static int __dbj_app_dispatch(DB_ENV *dbenv, + DBT *dbt, DB_LSN *lsn, db_recops recops) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); + jobject jdbt, jlsn; + jbyteArray jdbtarr; + int ret; + + if (jdbenv == NULL) { + ret = EINVAL; + goto err; + } + + jdbt = (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + __dbj_dbt_copyout(jenv, dbt, &jdbtarr, jdbt); + if (jdbt == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + + jlsn = (lsn == NULL) ? NULL : __dbj_wrap_DB_LSN(jenv, lsn); + + ret = (*jenv)->CallNonvirtualIntMethod(jenv, jdbenv, dbenv_class, + app_dispatch_method, jdbt, jlsn, recops); + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + } + + (*jenv)->DeleteLocalRef(jenv, jdbtarr); + (*jenv)->DeleteLocalRef(jenv, jdbt); + if (jlsn != NULL) + (*jenv)->DeleteLocalRef(jenv, jlsn); + +err: if (detach) + __dbj_detach(); + return (ret); +} + +static void __dbj_event_notify(DB_ENV *dbenv, u_int32_t event_id, void * info) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); + + if (jdbenv == NULL) + goto done; + + switch (event_id) { + case DB_EVENT_PANIC: + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, + dbenv_class, panic_event_notify_method); + break; + case DB_EVENT_REP_CLIENT: + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, + dbenv_class, rep_client_event_notify_method); + break; + case DB_EVENT_REP_ELECTED: + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, + dbenv_class, rep_elected_event_notify_method); + break; + case DB_EVENT_REP_MASTER: + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, + dbenv_class, rep_master_event_notify_method); + break; + case DB_EVENT_REP_NEWMASTER: + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, + dbenv_class, rep_new_master_event_notify_method, + *(int*)info); + break; + case DB_EVENT_REP_PERM_FAILED: + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, + dbenv_class, rep_perm_failed_event_notify_method); + break; + case DB_EVENT_REP_STARTUPDONE: + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, + dbenv_class, rep_startup_done_event_notify_method); + break; + case DB_EVENT_WRITE_FAILED: + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, + dbenv_class, write_failed_event_notify_method, + *(int*)info); + break; + default: + dbenv->errx(dbenv, "Unhandled event callback in the Java API"); + DB_ASSERT(dbenv->env, 0); + } + +done: if (detach) + __dbj_detach(); +} + +static int __dbj_rep_transport(DB_ENV *dbenv, + const DBT *control, const DBT *rec, const DB_LSN *lsn, int envid, + u_int32_t flags) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); + jobject jcontrol, jrec, jlsn; + jbyteArray jcontrolarr, jrecarr; + int ret; + + if (jdbenv == NULL) { + ret = EINVAL; + goto err; + } + + jcontrol = (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + jrec = (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + if (jcontrol == NULL || jrec == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + + __dbj_dbt_copyout(jenv, control, &jcontrolarr, jcontrol); + __dbj_dbt_copyout(jenv, rec, &jrecarr, jrec); + jlsn = (lsn == NULL) ? NULL : __dbj_wrap_DB_LSN(jenv, (DB_LSN *)lsn); + + if (jcontrolarr == NULL || jrecarr == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + + ret = (*jenv)->CallNonvirtualIntMethod(jenv, jdbenv, dbenv_class, + rep_transport_method, jcontrol, jrec, jlsn, envid, flags); + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + } + + (*jenv)->DeleteLocalRef(jenv, jrecarr); + (*jenv)->DeleteLocalRef(jenv, jcontrolarr); + (*jenv)->DeleteLocalRef(jenv, jrec); + (*jenv)->DeleteLocalRef(jenv, jcontrol); + if (jlsn != NULL) + (*jenv)->DeleteLocalRef(jenv, jlsn); + +err: if (detach) + __dbj_detach(); + return (ret); +} + +static int __dbj_foreignkey_nullify(DB *db, + const DBT *key, DBT *data, const DBT *skey, int *changed) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + DBT_LOCKED lresult; + jobject jdb = (jobject)DB_INTERNAL(db); + jobject jkey, jdata, jskey; + jbyteArray jkeyarr, jdataarr, jskeyarr; + jboolean jresult; + int ret; + + if (jdb == NULL) { + ret = EINVAL; + goto err; + } + + jkey = (key->app_data != NULL) ? + ((DBT_LOCKED *)key->app_data)->jdbt : + (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + jdata = (data->app_data != NULL) ? + ((DBT_LOCKED *)data->app_data)->jdbt : + (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + jskey = (skey->app_data != NULL) ? + ((DBT_LOCKED *)skey->app_data)->jdbt : + (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + if (jkey == NULL || jdata == NULL || jskey == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + + if (key->app_data == NULL) { + __dbj_dbt_copyout(jenv, key, &jkeyarr, jkey); + if (jkeyarr == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + } + if (data->app_data == NULL) { + __dbj_dbt_copyout(jenv, data, &jdataarr, jdata); + if (jdataarr == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + } + if (skey->app_data == NULL) { + __dbj_dbt_copyout(jenv, skey, &jskeyarr, jskey); + if (jskeyarr == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + } + + jresult = (*jenv)->CallNonvirtualBooleanMethod(jenv, jdb, db_class, foreignkey_nullify_method, jkey, jdata, jskey); + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + goto err; + } + + if (jresult == JNI_FALSE) + *changed = ret = 0; + else{ + *changed = 1; + /* copy jdata into data */ + if ((ret = __dbj_dbt_copyin(jenv, &lresult, NULL, jdata, 0)) != 0) + goto err; + if (lresult.dbt.size != 0){ + data->size = lresult.dbt.size; + if ((ret = __os_umalloc( + NULL, data->size, &data->data)) != 0) + goto err; + if ((ret = __dbj_dbt_memcopy(&lresult.dbt, 0, + data->data, data->size, DB_USERCOPY_GETDATA)) != 0) + goto err; + __dbj_dbt_release(jenv, jdata, &lresult.dbt, &lresult); + (*jenv)->DeleteLocalRef(jenv, lresult.jarr); + F_SET(data, DB_DBT_APPMALLOC); + } + } + +err: if (key->app_data == NULL) { + (*jenv)->DeleteLocalRef(jenv, jkeyarr); + (*jenv)->DeleteLocalRef(jenv, jkey); + } + if (data->app_data == NULL) { + (*jenv)->DeleteLocalRef(jenv, jdataarr); + (*jenv)->DeleteLocalRef(jenv, jdata); + } + + if (detach) + __dbj_detach(); + return ret; +} + +static int __dbj_seckey_create(DB *db, + const DBT *key, const DBT *data, DBT *result) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jobject jkey, jdata, jresult; + jobjectArray jskeys; + jsize i, num_skeys; + jbyteArray jkeyarr, jdataarr; + DBT_LOCKED lresult; + DBT *tresult; + int ret; + + if (jdb == NULL) { + ret = EINVAL; + goto err; + } + + jkey = (key->app_data != NULL) ? + ((DBT_LOCKED *)key->app_data)->jdbt : + (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + jdata = (data->app_data != NULL) ? + ((DBT_LOCKED *)data->app_data)->jdbt : + (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + if (jkey == NULL || jdata == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + + if (key->app_data == NULL) { + __dbj_dbt_copyout(jenv, key, &jkeyarr, jkey); + if (jkeyarr == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + } + if (data->app_data == NULL) { + __dbj_dbt_copyout(jenv, data, &jdataarr, jdata); + if (jdataarr == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + } + + jskeys = (jobjectArray)(*jenv)->CallNonvirtualObjectMethod(jenv, + jdb, db_class, seckey_create_method, jkey, jdata); + + if (jskeys == NULL || + (num_skeys = (*jenv)->GetArrayLength(jenv, jskeys)) == 0) { + ret = DB_DONOTINDEX; + goto err; + } else if (num_skeys == 1) { + memset(result, 0, sizeof (DBT)); + tresult = result; + } else { + if ((ret = __os_umalloc(db->env, + num_skeys * sizeof (DBT), &result->data)) != 0) + goto err; + memset(result->data, 0, num_skeys * sizeof (DBT)); + result->size = num_skeys; + F_SET(result, DB_DBT_APPMALLOC | DB_DBT_MULTIPLE); + tresult = (DBT *)result->data; + } + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + goto err; + } + + for (i = 0; i < num_skeys; i++, tresult++) { + jresult = (*jenv)->GetObjectArrayElement(jenv, jskeys, i); + + if ((ret = + __dbj_dbt_copyin(jenv, &lresult, NULL, jresult, 0)) != 0) + goto err; + + if (lresult.dbt.size != 0) { + /* If there's data, we need to take a copy of it. */ + tresult->size = lresult.dbt.size; + if ((ret = __os_umalloc(NULL, + tresult->size, &tresult->data)) != 0) + goto err; + if ((ret = __dbj_dbt_memcopy(&lresult.dbt, 0, + tresult->data, tresult->size, + DB_USERCOPY_GETDATA)) != 0) + goto err; + __dbj_dbt_release(jenv, + jresult, &lresult.dbt, &lresult); + (*jenv)->DeleteLocalRef(jenv, lresult.jarr); + F_SET(tresult, DB_DBT_APPMALLOC); + } + + (*jenv)->DeleteLocalRef(jenv, jresult); + } + +err: if (key->app_data == NULL) { + (*jenv)->DeleteLocalRef(jenv, jkeyarr); + (*jenv)->DeleteLocalRef(jenv, jkey); + } + if (data->app_data == NULL) { + (*jenv)->DeleteLocalRef(jenv, jdataarr); + (*jenv)->DeleteLocalRef(jenv, jdata); + } + if (jskeys != NULL) { + (*jenv)->DeleteLocalRef(jenv, jskeys); + } + + if (detach) + __dbj_detach(); + return (ret); +} + +static int __dbj_append_recno(DB *db, DBT *dbt, db_recno_t recno) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jobject jdbt; + DBT_LOCKED lresult; + jbyteArray jdbtarr; + int ret; + + if (jdb == NULL) { + ret = EINVAL; + goto err; + } + + /* + * The dbt we're passed will be from the application, but we can't + * just reuse it, since we will have already taken a copy of the data. + * Make a new DatabaseEntry object here for the callback. + */ + jdbt = (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + if (jdbt == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + + __dbj_dbt_copyout(jenv, dbt, &jdbtarr, jdbt); + if (jdbtarr == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + + ret = 0; + (*jenv)->CallNonvirtualVoidMethod(jenv, jdb, db_class, + append_recno_method, jdbt, recno); + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + goto err; + } + + ret = __dbj_dbt_copyin(jenv, &lresult, NULL, jdbt, 0); + memset(dbt, 0, sizeof (DBT)); + + if (ret == 0 && lresult.dbt.size != 0) { + /* If there's data, we need to take a copy of it. */ + dbt->size = lresult.dbt.size; + if ((ret = + __os_umalloc(NULL, dbt->size, &dbt->data)) != 0) + goto err; + if ((ret = __dbj_dbt_memcopy(&lresult.dbt, 0, + dbt->data, dbt->size, + DB_USERCOPY_GETDATA)) != 0) + goto err; + __dbj_dbt_release(jenv, jdbt, &lresult.dbt, &lresult); + (*jenv)->DeleteLocalRef(jenv, lresult.jarr); + F_SET(dbt, DB_DBT_APPMALLOC); + } + +err: (*jenv)->DeleteLocalRef(jenv, jdbtarr); + (*jenv)->DeleteLocalRef(jenv, jdbt); + + if (detach) + __dbj_detach(); + return (ret); +} + +/* + * Shared by __dbj_bt_compare and __dbj_h_compare + */ +static int __dbj_am_compare(DB *db, const DBT *dbt1, const DBT *dbt2, + jmethodID compare_method) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jbyteArray jdbtarr1, jdbtarr2; + int ret; + + if (jdb == NULL) { + ret = EINVAL; + goto err; + } + + if (dbt1->app_data != NULL) + jdbtarr1 = ((DBT_LOCKED *)dbt1->app_data)->jarr; + else { + jdbtarr1 = (*jenv)->NewByteArray(jenv, (jsize)dbt1->size); + if (jdbtarr1 == NULL) { + ret = ENOMEM; + goto err; + } + (*jenv)->SetByteArrayRegion(jenv, jdbtarr1, 0, + (jsize)dbt1->size, (jbyte *)dbt1->data); + } + + if (dbt2->app_data != NULL) + jdbtarr2 = ((DBT_LOCKED *)dbt2->app_data)->jarr; + else { + jdbtarr2 = (*jenv)->NewByteArray(jenv, (jsize)dbt2->size); + if (jdbtarr2 == NULL) { + ret = ENOMEM; + goto err; + } + (*jenv)->SetByteArrayRegion(jenv, jdbtarr2, 0, + (jsize)dbt2->size, (jbyte *)dbt2->data); + } + + ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, + compare_method, jdbtarr1, jdbtarr2); + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + } + +err: if (dbt1->app_data == NULL) + (*jenv)->DeleteLocalRef(jenv, jdbtarr1); + if (dbt2->app_data == NULL) + (*jenv)->DeleteLocalRef(jenv, jdbtarr2); + + if (detach) + __dbj_detach(); + return (ret); +} + +static int __dbj_bt_compare(DB *db, const DBT *dbt1, const DBT *dbt2) +{ + return __dbj_am_compare(db, dbt1, dbt2, bt_compare_method); +} + +#define DBT_COPYOUT(num) \ + if (dbt##num->app_data != NULL) \ + jdbt##num = ((DBT_LOCKED *)dbt##num->app_data)->jdbt; \ + else { \ + if ((jdbt##num = (*jenv)->NewObject( \ + jenv, dbt_class, dbt_construct)) == NULL) { \ + ret = ENOMEM; /* An exception is pending */ \ + goto err; \ + } \ + __dbj_dbt_copyout(jenv, dbt##num, &jdbtarr##num, jdbt##num);\ + if (jdbtarr##num == NULL) { \ + ret = ENOMEM; /* An exception is pending */ \ + goto err; \ + } \ + } + +#define DBT_COPIED_FREE(num) \ + if (dbt##num->app_data == NULL) { \ + (*jenv)->DeleteLocalRef(jenv, jdbtarr##num); \ + (*jenv)->DeleteLocalRef(jenv, jdbt##num); \ + } + +#define DBT_COPYIN_DATA(num) \ + ret = __dbj_dbt_copyin(jenv, &lresult, NULL, jdbt##num, 0); \ + memset(dbt##num, 0, sizeof (DBT)); \ + if (ret == 0 && lresult.dbt.size != 0) { \ + /* If there's data, we need to take a copy of it. */ \ + dbt##num->size = lresult.dbt.size; \ + if ((ret = __os_umalloc( \ + NULL, dbt##num->size, &dbt##num->data)) != 0) \ + goto err; \ + if ((ret = __dbj_dbt_memcopy(&lresult.dbt, 0, \ + dbt##num->data, dbt##num->size, \ + DB_USERCOPY_GETDATA)) != 0) \ + goto err; \ + __dbj_dbt_release(jenv, jdbt##num, &lresult.dbt, &lresult);\ + (*jenv)->DeleteLocalRef(jenv, lresult.jarr); \ + F_SET(dbt##num, DB_DBT_APPMALLOC); \ + } + +static int __dbj_bt_compress(DB *db, const DBT *dbt1, const DBT *dbt2, + const DBT *dbt3, const DBT *dbt4, DBT *dbt5) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jobject jdbt1, jdbt2, jdbt3, jdbt4, jdbt5; + jbyteArray jdbtarr1, jdbtarr2, jdbtarr3, jdbtarr4, jdbtarr5; + DBT_LOCKED lresult; + int ret; + + if (jdb == NULL) { + ret = EINVAL; + goto err; + } + + DBT_COPYOUT(1) + DBT_COPYOUT(2) + DBT_COPYOUT(3) + DBT_COPYOUT(4) + DBT_COPYOUT(5) + + ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, + bt_compress_method, jdbt1, jdbt2, jdbt3, jdbt4, jdbt5); + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + goto err; + } + + DBT_COPYIN_DATA(5) + +err: DBT_COPIED_FREE(1) + DBT_COPIED_FREE(2) + DBT_COPIED_FREE(3) + DBT_COPIED_FREE(4) + DBT_COPIED_FREE(5) + if (detach) + __dbj_detach(); + return (ret); +} + +static int __dbj_bt_decompress(DB *db, const DBT *dbt1, const DBT *dbt2, + DBT *dbt3, DBT *dbt4, DBT *dbt5) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jobject jdbt1, jdbt2, jdbt3, jdbt4, jdbt5; + jbyteArray jdbtarr1, jdbtarr2, jdbtarr3, jdbtarr4, jdbtarr5; + DBT_LOCKED lresult; + int ret; + + if (jdb == NULL) { + ret = EINVAL; + goto err; + } + + DBT_COPYOUT(1) + DBT_COPYOUT(2) + DBT_COPYOUT(3) + DBT_COPYOUT(4) + DBT_COPYOUT(5) + + ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, + bt_decompress_method, jdbt1, jdbt2, jdbt3, jdbt4, jdbt5); + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + goto err; + } + + DBT_COPYIN_DATA(3) + DBT_COPYIN_DATA(4) + DBT_COPYIN_DATA(5) + +err: DBT_COPIED_FREE(1) + DBT_COPIED_FREE(2) + DBT_COPIED_FREE(3) + DBT_COPIED_FREE(4) + DBT_COPIED_FREE(5) + if (detach) + __dbj_detach(); + return (ret); +} + +static size_t __dbj_bt_prefix(DB *db, const DBT *dbt1, const DBT *dbt2) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jobject jdbt1, jdbt2; + jbyteArray jdbtarr1, jdbtarr2; + int ret; + + if (jdb == NULL) { + ret = EINVAL; + goto err; + } + + if (dbt1->app_data != NULL) + jdbt1 = ((DBT_LOCKED *)dbt1->app_data)->jdbt; + else { + if ((jdbt1 = + (*jenv)->NewObject(jenv, dbt_class, dbt_construct)) == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + __dbj_dbt_copyout(jenv, dbt1, &jdbtarr1, jdbt1); + if (jdbtarr1 == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + } + + if (dbt2->app_data != NULL) + jdbt2 = ((DBT_LOCKED *)dbt2->app_data)->jdbt; + else { + if ((jdbt2 = + (*jenv)->NewObject(jenv, dbt_class, dbt_construct)) == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + __dbj_dbt_copyout(jenv, dbt2, &jdbtarr2, jdbt2); + if (jdbtarr2 == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + } + + ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, + bt_prefix_method, jdbt1, jdbt2); + +err: if (dbt1->app_data == NULL) { + (*jenv)->DeleteLocalRef(jenv, jdbtarr1); + (*jenv)->DeleteLocalRef(jenv, jdbt1); + } + if (dbt2->app_data == NULL) { + (*jenv)->DeleteLocalRef(jenv, jdbtarr2); + (*jenv)->DeleteLocalRef(jenv, jdbt2); + } + + if (detach) + __dbj_detach(); + return (ret); +} + +static int __dbj_dup_compare(DB *db, const DBT *dbt1, const DBT *dbt2) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jbyteArray jdbtarr1, jdbtarr2; + int ret; + + if (jdb == NULL) + return (EINVAL); + + jdbtarr1 = (*jenv)->NewByteArray(jenv, (jsize)dbt1->size); + if (jdbtarr1 == NULL) + return (ENOMEM); + (*jenv)->SetByteArrayRegion(jenv, jdbtarr1, 0, (jsize)dbt1->size, + (jbyte *)dbt1->data); + + jdbtarr2 = (*jenv)->NewByteArray(jenv, (jsize)dbt2->size); + if (jdbtarr2 == NULL) + return (ENOMEM); + (*jenv)->SetByteArrayRegion(jenv, jdbtarr2, 0, (jsize)dbt2->size, + (jbyte *)dbt2->data); + + ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, + dup_compare_method, jdbtarr1, jdbtarr2); + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + } + + (*jenv)->DeleteLocalRef(jenv, jdbtarr2); + (*jenv)->DeleteLocalRef(jenv, jdbtarr1); + + if (detach) + __dbj_detach(); + return (ret); +} + +static void __dbj_db_feedback(DB *db, int opcode, int percent) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + + if (jdb != NULL) + (*jenv)->CallNonvirtualVoidMethod(jenv, jdb, db_class, + db_feedback_method, opcode, percent); + + if (detach) + __dbj_detach(); +} + +static int __dbj_h_compare(DB *db, const DBT *dbt1, const DBT *dbt2) +{ + return __dbj_am_compare(db, dbt1, dbt2, h_compare_method); +} + +static u_int32_t __dbj_h_hash(DB *db, const void *data, u_int32_t len) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jbyteArray jarr = (*jenv)->NewByteArray(jenv, (jsize)len); + int ret; + + if (jdb == NULL) + return (EINVAL); + + if ((jarr = (*jenv)->NewByteArray(jenv, (jsize)len)) == NULL) + return (ENOMEM); /* An exception is pending */ + + (*jenv)->SetByteArrayRegion(jenv, jarr, 0, (jsize)len, (jbyte *)data); + + ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, + h_hash_method, jarr, len); + + (*jenv)->DeleteLocalRef(jenv, jarr); + + if (detach) + __dbj_detach(); + return (ret); +} + +static u_int32_t __dbj_partition(DB *db, DBT *dbt1) +{ + int detach, ret; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jobject jdbt1; + jbyteArray jdbtarr1; + DBT_LOCKED lresult; + + DBT_COPYOUT(1) + + ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, + partition_method, jdbt1); + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + goto err; + } + + DBT_COPYIN_DATA(1) +err: DBT_COPIED_FREE(1) + + if (detach) + __dbj_detach(); + return (ret); +} + + +SWIGEXPORT jlong JNICALL +Java_com_sleepycat_db_internal_db_1javaJNI_initDbEnvRef0( + JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { + DB_ENV *self = *(DB_ENV **)(void *)&jarg1; + jlong ret; + COMPQUIET(jcls, NULL); + COMPQUIET(jarg1_, NULL); + + DB_ENV_INTERNAL(self) = (void *)(*jenv)->NewGlobalRef(jenv, jarg2); + *(jobject *)(void *)&ret = (jobject)DB_ENV_INTERNAL(self); + return (ret); +} + +SWIGEXPORT jlong JNICALL +Java_com_sleepycat_db_internal_db_1javaJNI_initDbRef0( + JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { + DB *self = *(DB **)(void *)&jarg1; + jlong ret; + COMPQUIET(jcls, NULL); + COMPQUIET(jarg1_, NULL); + + DB_INTERNAL(self) = (void *)(*jenv)->NewGlobalRef(jenv, jarg2); + *(jobject *)(void *)&ret = (jobject)DB_INTERNAL(self); + return (ret); +} + +SWIGEXPORT void JNICALL +Java_com_sleepycat_db_internal_db_1javaJNI_deleteRef0( + JNIEnv *jenv, jclass jcls, jlong jarg1) { + jobject jref = *(jobject *)(void *)&jarg1; + COMPQUIET(jcls, NULL); + + if (jref != 0L) + (*jenv)->DeleteGlobalRef(jenv, jref); +} + +SWIGEXPORT jlong JNICALL +Java_com_sleepycat_db_internal_db_1javaJNI_getDbEnv0( + JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + DB *self = *(DB **)(void *)&jarg1; + jlong ret; + + COMPQUIET(jenv, NULL); + COMPQUIET(jcls, NULL); + COMPQUIET(jarg1_, NULL); + + *(DB_ENV **)(void *)&ret = self->dbenv; + return (ret); +} + +SWIGEXPORT jboolean JNICALL +Java_com_sleepycat_db_internal_DbUtil_is_1big_1endian( + JNIEnv *jenv, jclass clazz) +{ + COMPQUIET(jenv, NULL); + COMPQUIET(clazz, NULL); + + return (__db_isbigendian() ? JNI_TRUE : JNI_FALSE); +} + + +typedef int db_ret_t; +typedef int int_bool; + +struct __db_lk_conflicts { + u_int8_t *lk_conflicts; + int lk_modes; +}; + +struct __db_out_stream { + void *handle; + int (*callback) __P((void *, const void *)); +}; + +struct __db_repmgr_sites { + DB_REPMGR_SITE *sites; + u_int32_t nsites; +}; + +#define Db __db +#define Dbc __dbc +#define Dbt __db_dbt +#define DbEnv __db_env +#define DbLock __db_lock_u +#define DbLogc __db_log_cursor +#define DbLsn __db_lsn +#define DbMpoolFile __db_mpoolfile +#define DbSequence __db_sequence +#define DbTxn __db_txn + +/* Suppress a compilation warning for an unused symbol */ +void *unused = (void *)SWIG_JavaThrowException; + +SWIGINTERN struct Db *new_Db(DB_ENV *dbenv,u_int32_t flags){ + DB *self = NULL; + errno = db_create(&self, dbenv, flags); + if (errno == 0 && dbenv == NULL) + self->env->dbt_usercopy = __dbj_dbt_memcopy; + return self; + } +SWIGINTERN 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){ + return self->associate(self, txnid, secondary, callback, flags); + } +SWIGINTERN db_ret_t Db_associate_foreign(struct Db *self,DB *primary,int (*callback)(DB *,DBT const *,DBT *,DBT const *,int *),u_int32_t flags){ + return self->associate_foreign(self, primary, callback, flags); + } +SWIGINTERN 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){ + return self->compact(self, txnid, start, stop, c_data, flags, + end); + } +SWIGINTERN int Db_close(struct Db *self,u_int32_t flags){ + errno = self->close(self, flags); + return errno; + } +SWIGINTERN DBC *Db_cursor(struct Db *self,DB_TXN *txnid,u_int32_t flags){ + DBC *cursorp = NULL; + errno = self->cursor(self, txnid, &cursorp, flags); + return cursorp; + } +SWIGINTERN int Db_del(struct Db *self,DB_TXN *txnid,DBT *key,u_int32_t flags){ + return self->del(self, txnid, key, flags); + } +SWIGINTERN void Db_err(struct Db *self,int error,char const *message){ + self->err(self, error, message); + } +SWIGINTERN void Db_errx(struct Db *self,char const *message){ + self->errx(self, message); + } +SWIGINTERN int Db_exists(struct Db *self,DB_TXN *txnid,DBT *key,u_int32_t flags){ + return self->exists(self, txnid, key, flags); + } +SWIGINTERN int Db_get(struct Db *self,DB_TXN *txnid,DBT *key,DBT *data,u_int32_t flags){ + return self->get(self, txnid, key, data, flags); + } +SWIGINTERN int_bool Db_get_byteswapped(struct Db *self){ + int ret = 0; + errno = self->get_byteswapped(self, &ret); + return ret; + } +SWIGINTERN jlong Db_get_cachesize(struct Db *self){ + u_int32_t gbytes = 0, bytes = 0; + errno = self->get_cachesize(self, &gbytes, &bytes, NULL); + return (jlong)gbytes * GIGABYTE + bytes; + } +SWIGINTERN u_int32_t Db_get_cachesize_ncache(struct Db *self){ + int ret = 0; + errno = self->get_cachesize(self, NULL, NULL, &ret); + return ret; + } +SWIGINTERN char const *Db_get_create_dir(struct Db *self){ + const char *ret; + errno = self->get_create_dir(self, &ret); + return ret; + } +SWIGINTERN char const *Db_get_filename(struct Db *self){ + const char *ret = NULL; + errno = self->get_dbname(self, &ret, NULL); + return ret; + } +SWIGINTERN char const *Db_get_dbname(struct Db *self){ + const char *ret = NULL; + errno = self->get_dbname(self, NULL, &ret); + return ret; + } +SWIGINTERN u_int32_t Db_get_encrypt_flags(struct Db *self){ + u_int32_t ret = 0; + CRYPTO_ONLY(errno = self->get_encrypt_flags(self, &ret)) + return ret; + } +SWIGINTERN u_int32_t Db_get_flags(struct Db *self){ + u_int32_t ret = 0; + errno = self->get_flags(self, &ret); + return ret; + } +SWIGINTERN int Db_get_lorder(struct Db *self){ + int ret = 0; + errno = self->get_lorder(self, &ret); + return ret; + } +SWIGINTERN DB_MPOOLFILE *Db_get_mpf(struct Db *self){ + errno = 0; + return self->get_mpf(self); + } +SWIGINTERN u_int32_t Db_get_open_flags(struct Db *self){ + u_int32_t ret = 0; + errno = self->get_open_flags(self, &ret); + return ret; + } +SWIGINTERN u_int32_t Db_get_pagesize(struct Db *self){ + u_int32_t ret = 0; + errno = self->get_pagesize(self, &ret); + return ret; + } +SWIGINTERN u_int32_t Db_get_bt_minkey(struct Db *self){ + u_int32_t ret = 0; + errno = self->get_bt_minkey(self, &ret); + return ret; + } +SWIGINTERN u_int32_t Db_get_h_ffactor(struct Db *self){ + u_int32_t ret = 0; + errno = self->get_h_ffactor(self, &ret); + return ret; + } +SWIGINTERN u_int32_t Db_get_h_nelem(struct Db *self){ + u_int32_t ret = 0; + errno = self->get_h_nelem(self, &ret); + return ret; + } +SWIGINTERN int Db_get_re_delim(struct Db *self){ + int ret = 0; + errno = self->get_re_delim(self, &ret); + return ret; + } +SWIGINTERN DB_CACHE_PRIORITY Db_get_priority(struct Db *self){ + DB_CACHE_PRIORITY ret; + errno = self->get_priority(self, &ret); + return ret; + } +SWIGINTERN char const **Db_get_partition_dirs(struct Db *self){ + const char **ret; + errno = self->get_partition_dirs(self, &ret); + return ret; + } +SWIGINTERN DBT *Db_get_partition_keys(struct Db *self){ + DBT *ret = NULL; + errno = self->get_partition_keys(self, NULL, &ret); + return ret; + } +SWIGINTERN int Db_get_partition_parts(struct Db *self){ + int ret = 0; + errno = self->get_partition_keys(self, &ret, NULL); + /* If not partitioned by range, check by callback. */ + if (ret == 0) + errno = self->get_partition_callback(self, &ret, NULL); + return ret; + } +SWIGINTERN u_int32_t Db_get_re_len(struct Db *self){ + u_int32_t ret = 0; + errno = self->get_re_len(self, &ret); + return ret; + } +SWIGINTERN int Db_get_re_pad(struct Db *self){ + int ret = 0; + errno = self->get_re_pad(self, &ret); + return ret; + } +SWIGINTERN char const *Db_get_re_source(struct Db *self){ + const char *ret = NULL; + errno = self->get_re_source(self, &ret); + return ret; + } +SWIGINTERN u_int32_t Db_get_q_extentsize(struct Db *self){ + u_int32_t ret = 0; + errno = self->get_q_extentsize(self, &ret); + return ret; + } +SWIGINTERN int_bool Db_get_multiple(struct Db *self){ + return self->get_multiple(self); + } +SWIGINTERN int_bool Db_get_transactional(struct Db *self){ + return self->get_transactional(self); + } +SWIGINTERN DBTYPE Db_get_type(struct Db *self){ + DBTYPE type = (DBTYPE)0; + errno = self->get_type(self, &type); + return type; + } +SWIGINTERN DBC *Db_join(struct Db *self,DBC **curslist,u_int32_t flags){ + DBC *dbcp = NULL; + errno = self->join(self, curslist, &dbcp, flags); + return dbcp; + } +SWIGINTERN db_ret_t Db_key_range(struct Db *self,DB_TXN *txnid,DBT *key,DB_KEY_RANGE *key_range,u_int32_t flags){ + return self->key_range(self, txnid, key, key_range, flags); + } +SWIGINTERN 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){ + return self->open(self, txnid, file, database, + type, flags, mode); + } +SWIGINTERN int Db_pget(struct Db *self,DB_TXN *txnid,DBT *key,DBT *pkey,DBT *data,u_int32_t flags){ + return self->pget(self, txnid, key, pkey, data, flags); + } +SWIGINTERN int Db_put(struct Db *self,DB_TXN *txnid,DBT *key,DBT *db_put_data,u_int32_t flags){ + return self->put(self, txnid, key, db_put_data, flags); + } +SWIGINTERN db_ret_t Db_remove(struct Db *self,char const *file,char const *database,u_int32_t flags){ + return self->remove(self, file, database, flags); + } +SWIGINTERN db_ret_t Db_rename(struct Db *self,char const *file,char const *database,char const *newname,u_int32_t flags){ + return self->rename(self, file, database, newname, flags); + } +SWIGINTERN db_ret_t Db_set_append_recno(struct Db *self,int (*db_append_recno_fcn)(DB *,DBT *,db_recno_t)){ + return self->set_append_recno(self, db_append_recno_fcn); + } +SWIGINTERN db_ret_t Db_set_bt_compare(struct Db *self,int (*bt_compare_fcn)(DB *,DBT const *,DBT const *)){ + return self->set_bt_compare(self, bt_compare_fcn); + } +SWIGINTERN db_ret_t Db_set_bt_minkey(struct Db *self,u_int32_t bt_minkey){ + return self->set_bt_minkey(self, bt_minkey); + } +SWIGINTERN db_ret_t Db_set_bt_compress(struct Db *self,int (*bt_compress_fcn)(DB *,DBT const *,DBT const *,DBT const *,DBT const *,DBT *),int (*bt_decompress_fcn)(DB *,DBT const *,DBT const *,DBT *,DBT *,DBT *)){ + return self->set_bt_compress( + self, bt_compress_fcn, bt_decompress_fcn); + } +SWIGINTERN db_ret_t Db_set_bt_prefix(struct Db *self,size_t (*bt_prefix_fcn)(DB *,DBT const *,DBT const *)){ + return self->set_bt_prefix(self, bt_prefix_fcn); + } +SWIGINTERN db_ret_t Db_set_cachesize(struct Db *self,jlong bytes,int ncache){ + return self->set_cachesize(self, + (u_int32_t)(bytes / GIGABYTE), + (u_int32_t)(bytes % GIGABYTE), ncache); + } +SWIGINTERN db_ret_t Db_set_create_dir(struct Db *self,char const *dir){ + return self->set_create_dir(self, dir); + } +SWIGINTERN db_ret_t Db_set_dup_compare(struct Db *self,int (*dup_compare_fcn)(DB *,DBT const *,DBT const *)){ + return self->set_dup_compare(self, dup_compare_fcn); + } +SWIGINTERN db_ret_t Db_set_encrypt(struct Db *self,char const *passwd,u_int32_t flags){ + return self->set_encrypt(self, passwd, flags); + } +SWIGINTERN db_ret_t Db_set_feedback(struct Db *self,void (*db_feedback_fcn)(DB *,int,int)){ + return self->set_feedback(self, db_feedback_fcn); + } +SWIGINTERN db_ret_t Db_set_flags(struct Db *self,u_int32_t flags){ + return self->set_flags(self, flags); + } +SWIGINTERN db_ret_t Db_set_h_compare(struct Db *self,int (*h_compare_fcn)(DB *,DBT const *,DBT const *)){ + return self->set_h_compare(self, h_compare_fcn); + } +SWIGINTERN db_ret_t Db_set_h_ffactor(struct Db *self,u_int32_t h_ffactor){ + return self->set_h_ffactor(self, h_ffactor); + } +SWIGINTERN db_ret_t Db_set_h_hash(struct Db *self,u_int32_t (*h_hash_fcn)(DB *,void const *,u_int32_t)){ + return self->set_h_hash(self, h_hash_fcn); + } +SWIGINTERN db_ret_t Db_set_h_nelem(struct Db *self,u_int32_t h_nelem){ + return self->set_h_nelem(self, h_nelem); + } +SWIGINTERN db_ret_t Db_set_lorder(struct Db *self,int lorder){ + return self->set_lorder(self, lorder); + } +SWIGINTERN db_ret_t Db_set_pagesize(struct Db *self,u_int32_t pagesize){ + return self->set_pagesize(self, pagesize); + } +SWIGINTERN db_ret_t Db_set_partition(struct Db *self,u_int32_t parts,DBT *keys,u_int32_t (*db_partition_fcn)(DB *,DBT *)){ + return self->set_partition(self, parts, keys, db_partition_fcn); + } +SWIGINTERN db_ret_t Db_set_partition_dirs(struct Db *self,char const **dirp){ + return self->set_partition_dirs(self, dirp); + } +SWIGINTERN db_ret_t Db_set_priority(struct Db *self,DB_CACHE_PRIORITY priority){ + return self->set_priority(self, priority); + } +SWIGINTERN db_ret_t Db_set_re_delim(struct Db *self,int re_delim){ + return self->set_re_delim(self, re_delim); + } +SWIGINTERN db_ret_t Db_set_re_len(struct Db *self,u_int32_t re_len){ + return self->set_re_len(self, re_len); + } +SWIGINTERN db_ret_t Db_set_re_pad(struct Db *self,int re_pad){ + return self->set_re_pad(self, re_pad); + } +SWIGINTERN db_ret_t Db_set_re_source(struct Db *self,char *source){ + return self->set_re_source(self, source); + } +SWIGINTERN db_ret_t Db_set_q_extentsize(struct Db *self,u_int32_t extentsize){ + return self->set_q_extentsize(self, extentsize); + } +SWIGINTERN db_ret_t Db_sort_multiple(struct Db *self,DBT *key,DBT *data){ + return self->sort_multiple(self, key, data, 0); + } +SWIGINTERN void *Db_stat(struct Db *self,DB_TXN *txnid,u_int32_t flags){ + void *statp = NULL; + errno = self->stat(self, txnid, &statp, flags); + return statp; + } +SWIGINTERN db_ret_t Db_sync(struct Db *self,u_int32_t flags){ + return self->sync(self, flags); + } +SWIGINTERN int Db_truncate(struct Db *self,DB_TXN *txnid,u_int32_t flags){ + u_int32_t count = 0; + errno = self->truncate(self, txnid, &count, flags); + return count; + } +SWIGINTERN db_ret_t Db_upgrade(struct Db *self,char const *file,u_int32_t flags){ + return self->upgrade(self, file, flags); + } +SWIGINTERN int_bool Db_verify(struct Db *self,char const *file,char const *database,struct __db_out_stream outfile,u_int32_t flags){ + /* + * We can't easily #include "dbinc/db_ext.h" because of name + * clashes, so we declare this explicitly. + */ + extern int __db_verify_internal __P((DB *, const char *, const + char *, void *, int (*)(void *, const void *), u_int32_t)); + errno = __db_verify_internal(self, file, database, + outfile.handle, outfile.callback, flags); + if (errno == DB_VERIFY_BAD) { + errno = 0; + return 0; + } else + return 1; + } +SWIGINTERN db_ret_t Dbc_close(struct Dbc *self){ + return self->close(self); + } +SWIGINTERN int Dbc_cmp(struct Dbc *self,DBC *odbc,u_int32_t flags){ + int result = 0; + errno = self->cmp(self, odbc, &result, flags); + return result; + } +SWIGINTERN db_recno_t Dbc_count(struct Dbc *self,u_int32_t flags){ + db_recno_t count = 0; + errno = self->count(self, &count, flags); + return count; + } +SWIGINTERN int Dbc_del(struct Dbc *self,u_int32_t flags){ + return self->del(self, flags); + } +SWIGINTERN DBC *Dbc_dup(struct Dbc *self,u_int32_t flags){ + DBC *newcurs = NULL; + errno = self->dup(self, &newcurs, flags); + return newcurs; + } +SWIGINTERN int Dbc_get(struct Dbc *self,DBT *key,DBT *data,u_int32_t flags){ + return self->get(self, key, data, flags); + } +SWIGINTERN DB_CACHE_PRIORITY Dbc_get_priority(struct Dbc *self){ + DB_CACHE_PRIORITY ret; + errno = self->get_priority(self, &ret); + return ret; + } +SWIGINTERN int Dbc_pget(struct Dbc *self,DBT *key,DBT *pkey,DBT *data,u_int32_t flags){ + return self->pget(self, key, pkey, data, flags); + } +SWIGINTERN int Dbc_put(struct Dbc *self,DBT *key,DBT *db_put_data,u_int32_t flags){ + return self->put(self, key, db_put_data, flags); + } +SWIGINTERN db_ret_t Dbc_set_priority(struct Dbc *self,DB_CACHE_PRIORITY priority){ + return self->set_priority(self, priority); + } +SWIGINTERN struct DbEnv *new_DbEnv(u_int32_t flags){ + DB_ENV *self = NULL; + errno = db_env_create(&self, flags); + if (errno == 0) + self->env->dbt_usercopy = __dbj_dbt_memcopy; + return self; + } +SWIGINTERN db_ret_t DbEnv_close(struct DbEnv *self,u_int32_t flags){ + return self->close(self, flags); + } +SWIGINTERN db_ret_t DbEnv_dbremove(struct DbEnv *self,DB_TXN *txnid,char const *file,char const *database,u_int32_t flags){ + return self->dbremove(self, txnid, file, database, flags); + } +SWIGINTERN db_ret_t DbEnv_dbrename(struct DbEnv *self,DB_TXN *txnid,char const *file,char const *database,char const *newname,u_int32_t flags){ + return self->dbrename(self, + txnid, file, database, newname, flags); + } +SWIGINTERN void DbEnv_err(struct DbEnv *self,int error,char const *message){ + self->err(self, error, message); + } +SWIGINTERN void DbEnv_errx(struct DbEnv *self,char const *message){ + self->errx(self, message); + } +SWIGINTERN DB_TXN *DbEnv_cdsgroup_begin(struct DbEnv *self){ + DB_TXN *tid = NULL; + errno = self->cdsgroup_begin(self, &tid); + return tid; + } +SWIGINTERN db_ret_t DbEnv_fileid_reset(struct DbEnv *self,char const *file,u_int32_t flags){ + return self->fileid_reset(self, file, flags); + } +SWIGINTERN char const **DbEnv_get_data_dirs(struct DbEnv *self){ + const char **ret; + errno = self->get_data_dirs(self, &ret); + return ret; + } +SWIGINTERN u_int32_t DbEnv_get_encrypt_flags(struct DbEnv *self){ + u_int32_t ret = 0; + CRYPTO_ONLY(errno = self->get_encrypt_flags(self, &ret)) + return ret; + } +SWIGINTERN u_int32_t DbEnv_get_flags(struct DbEnv *self){ + u_int32_t ret; + errno = self->get_flags(self, &ret); + return ret; + } +SWIGINTERN char const *DbEnv_get_home(struct DbEnv *self){ + const char *ret; + errno = self->get_home(self, &ret); + return ret; + } +SWIGINTERN char const *DbEnv_get_intermediate_dir_mode(struct DbEnv *self){ + const char *ret; + errno = self->get_intermediate_dir_mode(self, &ret); + return ret; + } +SWIGINTERN u_int32_t DbEnv_get_open_flags(struct DbEnv *self){ + u_int32_t ret; + errno = self->get_open_flags(self, &ret); + return ret; + } +SWIGINTERN long DbEnv_get_shm_key(struct DbEnv *self){ + long ret; + errno = self->get_shm_key(self, &ret); + return ret; + } +SWIGINTERN char const *DbEnv_get_tmp_dir(struct DbEnv *self){ + const char *ret; + errno = self->get_tmp_dir(self, &ret); + return ret; + } +SWIGINTERN int_bool DbEnv_get_verbose(struct DbEnv *self,u_int32_t which){ + int ret; + errno = self->get_verbose(self, which, &ret); + return ret; + } +SWIGINTERN int_bool DbEnv_is_bigendian(struct DbEnv *self){ + return self->is_bigendian(); + } +SWIGINTERN db_ret_t DbEnv_lsn_reset(struct DbEnv *self,char const *file,u_int32_t flags){ + return self->lsn_reset(self, file, flags); + } +SWIGINTERN db_ret_t DbEnv_open(struct DbEnv *self,char const *db_home,u_int32_t flags,int mode){ + return self->open(self, db_home, flags, mode); + } +SWIGINTERN db_ret_t DbEnv_remove(struct DbEnv *self,char const *db_home,u_int32_t flags){ + return self->remove(self, db_home, flags); + } +SWIGINTERN db_ret_t DbEnv_set_cachesize(struct DbEnv *self,jlong bytes,int ncache){ + return self->set_cachesize(self, + (u_int32_t)(bytes / GIGABYTE), + (u_int32_t)(bytes % GIGABYTE), ncache); + } +SWIGINTERN db_ret_t DbEnv_set_cache_max(struct DbEnv *self,jlong bytes){ + return self->set_cache_max(self, + (u_int32_t)(bytes / GIGABYTE), + (u_int32_t)(bytes % GIGABYTE)); + } +SWIGINTERN db_ret_t DbEnv_set_create_dir(struct DbEnv *self,char const *dir){ + return self->set_create_dir(self, dir); + } +SWIGINTERN db_ret_t DbEnv_set_data_dir(struct DbEnv *self,char const *dir){ + return self->set_data_dir(self, dir); + } +SWIGINTERN db_ret_t DbEnv_set_intermediate_dir_mode(struct DbEnv *self,char const *mode){ + return self->set_intermediate_dir_mode(self, mode); + } +SWIGINTERN db_ret_t DbEnv_set_encrypt(struct DbEnv *self,char const *passwd,u_int32_t flags){ + return self->set_encrypt(self, passwd, flags); + } +SWIGINTERN void DbEnv_set_errcall(struct DbEnv *self,void (*db_errcall_fcn)(DB_ENV const *,char const *,char const *)){ + self->set_errcall(self, db_errcall_fcn); + } +SWIGINTERN db_ret_t DbEnv_set_flags(struct DbEnv *self,u_int32_t flags,int_bool onoff){ + return self->set_flags(self, flags, onoff); + } +SWIGINTERN db_ret_t DbEnv_set_feedback(struct DbEnv *self,void (*env_feedback_fcn)(DB_ENV *,int,int)){ + return self->set_feedback(self, env_feedback_fcn); + } +SWIGINTERN db_ret_t DbEnv_set_mp_max_openfd(struct DbEnv *self,int maxopenfd){ + return self->set_mp_max_openfd(self, maxopenfd); + } +SWIGINTERN db_ret_t DbEnv_set_mp_max_write(struct DbEnv *self,int maxwrite,db_timeout_t maxwrite_sleep){ + return self->set_mp_max_write(self, maxwrite, maxwrite_sleep); + } +SWIGINTERN db_ret_t DbEnv_set_mp_mmapsize(struct DbEnv *self,size_t mp_mmapsize){ + return self->set_mp_mmapsize(self, mp_mmapsize); + } +SWIGINTERN db_ret_t DbEnv_set_mp_pagesize(struct DbEnv *self,size_t mp_pagesize){ + return self->set_mp_pagesize(self, mp_pagesize); + } +SWIGINTERN db_ret_t DbEnv_set_mp_tablesize(struct DbEnv *self,size_t mp_tablesize){ + return self->set_mp_tablesize(self, mp_tablesize); + } +SWIGINTERN void DbEnv_set_msgcall(struct DbEnv *self,void (*db_msgcall_fcn)(DB_ENV const *,char const *)){ + self->set_msgcall(self, db_msgcall_fcn); + } +SWIGINTERN db_ret_t DbEnv_set_paniccall(struct DbEnv *self,void (*db_panic_fcn)(DB_ENV *,int)){ + return self->set_paniccall(self, db_panic_fcn); + } +SWIGINTERN db_ret_t DbEnv_set_rpc_server(struct DbEnv *self,char *host,long cl_timeout,long sv_timeout,u_int32_t flags){ + return self->set_rpc_server(self, NULL, host, + cl_timeout, sv_timeout, flags); + } +SWIGINTERN db_ret_t DbEnv_set_shm_key(struct DbEnv *self,long shm_key){ + return self->set_shm_key(self, shm_key); + } +SWIGINTERN db_ret_t DbEnv_set_timeout(struct DbEnv *self,db_timeout_t timeout,u_int32_t flags){ + return self->set_timeout(self, timeout, flags); + } +SWIGINTERN db_ret_t DbEnv_set_tmp_dir(struct DbEnv *self,char const *dir){ + return self->set_tmp_dir(self, dir); + } +SWIGINTERN db_ret_t DbEnv_set_tx_max(struct DbEnv *self,u_int32_t max){ + return self->set_tx_max(self, max); + } +SWIGINTERN db_ret_t DbEnv_set_app_dispatch(struct DbEnv *self,int (*tx_recover)(DB_ENV *,DBT *,DB_LSN *,db_recops)){ + return self->set_app_dispatch(self, tx_recover); + } +SWIGINTERN db_ret_t DbEnv_set_event_notify(struct DbEnv *self,void (*event_notify)(DB_ENV *,u_int32_t,void *)){ + return self->set_event_notify(self, event_notify); + } +SWIGINTERN db_ret_t DbEnv_set_tx_timestamp(struct DbEnv *self,time_t *timestamp){ + return self->set_tx_timestamp(self, timestamp); + } +SWIGINTERN db_ret_t DbEnv_set_verbose(struct DbEnv *self,u_int32_t which,int_bool onoff){ + return self->set_verbose(self, which, onoff); + } +SWIGINTERN struct __db_lk_conflicts DbEnv_get_lk_conflicts(struct DbEnv *self){ + struct __db_lk_conflicts ret; + errno = self->get_lk_conflicts(self, + (const u_int8_t **)&ret.lk_conflicts, &ret.lk_modes); + return ret; + } +SWIGINTERN u_int32_t DbEnv_get_lk_detect(struct DbEnv *self){ + u_int32_t ret; + errno = self->get_lk_detect(self, &ret); + return ret; + } +SWIGINTERN u_int32_t DbEnv_get_lk_max_locks(struct DbEnv *self){ + u_int32_t ret; + errno = self->get_lk_max_locks(self, &ret); + return ret; + } +SWIGINTERN u_int32_t DbEnv_get_lk_max_lockers(struct DbEnv *self){ + u_int32_t ret; + errno = self->get_lk_max_lockers(self, &ret); + return ret; + } +SWIGINTERN u_int32_t DbEnv_get_lk_max_objects(struct DbEnv *self){ + u_int32_t ret; + errno = self->get_lk_max_objects(self, &ret); + return ret; + } +SWIGINTERN u_int32_t DbEnv_get_lk_partitions(struct DbEnv *self){ + u_int32_t ret; + errno = self->get_lk_partitions(self, &ret); + return ret; + } +SWIGINTERN int DbEnv_lock_detect(struct DbEnv *self,u_int32_t flags,u_int32_t atype){ + int aborted; + errno = self->lock_detect(self, flags, atype, &aborted); + return aborted; + } +SWIGINTERN DB_LOCK *DbEnv_lock_get(struct DbEnv *self,u_int32_t locker,u_int32_t flags,DBT *object,db_lockmode_t lock_mode){ + DB_LOCK *lock = NULL; + if ((errno = __os_malloc(self->env, sizeof (DB_LOCK), &lock)) == 0) + errno = self->lock_get(self, locker, flags, object, + lock_mode, lock); + return lock; + } +SWIGINTERN u_int32_t DbEnv_lock_id(struct DbEnv *self){ + u_int32_t id; + errno = self->lock_id(self, &id); + return id; + } +SWIGINTERN db_ret_t DbEnv_lock_id_free(struct DbEnv *self,u_int32_t id){ + return self->lock_id_free(self, id); + } +SWIGINTERN db_ret_t DbEnv_lock_put(struct DbEnv *self,DB_LOCK *lock){ + return self->lock_put(self, lock); + } +SWIGINTERN DB_LOCK_STAT *DbEnv_lock_stat(struct DbEnv *self,u_int32_t flags){ + DB_LOCK_STAT *statp = NULL; + errno = self->lock_stat(self, &statp, flags); + return statp; + } +SWIGINTERN db_ret_t DbEnv_set_lk_conflicts(struct DbEnv *self,struct __db_lk_conflicts conflicts){ + return self->set_lk_conflicts(self, + conflicts.lk_conflicts, conflicts.lk_modes); + } +SWIGINTERN db_ret_t DbEnv_set_lk_detect(struct DbEnv *self,u_int32_t detect){ + return self->set_lk_detect(self, detect); + } +SWIGINTERN db_ret_t DbEnv_set_lk_max_lockers(struct DbEnv *self,u_int32_t max){ + return self->set_lk_max_lockers(self, max); + } +SWIGINTERN db_ret_t DbEnv_set_lk_max_locks(struct DbEnv *self,u_int32_t max){ + return self->set_lk_max_locks(self, max); + } +SWIGINTERN db_ret_t DbEnv_set_lk_max_objects(struct DbEnv *self,u_int32_t max){ + return self->set_lk_max_objects(self, max); + } +SWIGINTERN db_ret_t DbEnv_set_lk_partitions(struct DbEnv *self,u_int32_t partitions){ + return self->set_lk_partitions(self, partitions); + } +SWIGINTERN u_int32_t DbEnv_get_lg_bsize(struct DbEnv *self){ + u_int32_t ret; + errno = self->get_lg_bsize(self, &ret); + return ret; + } +SWIGINTERN char const *DbEnv_get_lg_dir(struct DbEnv *self){ + const char *ret; + errno = self->get_lg_dir(self, &ret); + return ret; + } +SWIGINTERN int DbEnv_get_lg_filemode(struct DbEnv *self){ + int ret; + errno = self->get_lg_filemode(self, &ret); + return ret; + } +SWIGINTERN u_int32_t DbEnv_get_lg_max(struct DbEnv *self){ + u_int32_t ret; + errno = self->get_lg_max(self, &ret); + return ret; + } +SWIGINTERN u_int32_t DbEnv_get_lg_regionmax(struct DbEnv *self){ + u_int32_t ret; + errno = self->get_lg_regionmax(self, &ret); + return ret; + } +SWIGINTERN char **DbEnv_log_archive(struct DbEnv *self,u_int32_t flags){ + char **list = NULL; + errno = self->log_archive(self, &list, flags); + return list; + } +SWIGINTERN int DbEnv_log_compare(DB_LSN const *lsn0,DB_LSN const *lsn1){ + return log_compare(lsn0, lsn1); + } +SWIGINTERN DB_LOGC *DbEnv_log_cursor(struct DbEnv *self,u_int32_t flags){ + DB_LOGC *cursor = NULL; + errno = self->log_cursor(self, &cursor, flags); + return cursor; + } +SWIGINTERN char *DbEnv_log_file(struct DbEnv *self,DB_LSN *lsn){ + char namebuf[DB_MAXPATHLEN]; + errno = self->log_file(self, lsn, namebuf, sizeof namebuf); + return (errno == 0) ? strdup(namebuf) : NULL; + } +SWIGINTERN db_ret_t DbEnv_log_flush(struct DbEnv *self,DB_LSN const *lsn_or_null){ + return self->log_flush(self, lsn_or_null); + } +SWIGINTERN int_bool DbEnv_log_get_config(struct DbEnv *self,u_int32_t which){ + int ret; + errno = self->log_get_config(self, which, &ret); + return ret; + } +SWIGINTERN db_ret_t DbEnv_log_put(struct DbEnv *self,DB_LSN *lsn,DBT const *data,u_int32_t flags){ + return self->log_put(self, lsn, data, flags); + } +SWIGINTERN db_ret_t DbEnv_log_print(struct DbEnv *self,DB_TXN *txn,char const *msg){ + return self->log_printf(self, txn, "%s", msg); + } +SWIGINTERN db_ret_t DbEnv_log_set_config(struct DbEnv *self,u_int32_t which,int_bool onoff){ + return self->log_set_config(self, which, onoff); + } +SWIGINTERN DB_LOG_STAT *DbEnv_log_stat(struct DbEnv *self,u_int32_t flags){ + DB_LOG_STAT *sp = NULL; + errno = self->log_stat(self, &sp, flags); + return sp; + } +SWIGINTERN db_ret_t DbEnv_set_lg_bsize(struct DbEnv *self,u_int32_t lg_bsize){ + return self->set_lg_bsize(self, lg_bsize); + } +SWIGINTERN db_ret_t DbEnv_set_lg_dir(struct DbEnv *self,char const *dir){ + return self->set_lg_dir(self, dir); + } +SWIGINTERN db_ret_t DbEnv_set_lg_filemode(struct DbEnv *self,int mode){ + return self->set_lg_filemode(self, mode); + } +SWIGINTERN db_ret_t DbEnv_set_lg_max(struct DbEnv *self,u_int32_t lg_max){ + return self->set_lg_max(self, lg_max); + } +SWIGINTERN db_ret_t DbEnv_set_lg_regionmax(struct DbEnv *self,u_int32_t lg_regionmax){ + return self->set_lg_regionmax(self, lg_regionmax); + } +SWIGINTERN jlong DbEnv_get_cachesize(struct DbEnv *self){ + u_int32_t gbytes, bytes; + errno = self->get_cachesize(self, &gbytes, &bytes, NULL); + return (jlong)gbytes * GIGABYTE + bytes; + } +SWIGINTERN int DbEnv_get_cachesize_ncache(struct DbEnv *self){ + int ret; + errno = self->get_cachesize(self, NULL, NULL, &ret); + return ret; + } +SWIGINTERN jlong DbEnv_get_cache_max(struct DbEnv *self){ + u_int32_t gbytes, bytes; + errno = self->get_cache_max(self, &gbytes, &bytes); + return (jlong)gbytes * GIGABYTE + bytes; + } +SWIGINTERN char const *DbEnv_get_create_dir(struct DbEnv *self){ + const char *ret; + errno = self->get_create_dir(self, &ret); + return ret; + } +SWIGINTERN int DbEnv_get_mp_max_openfd(struct DbEnv *self){ + int ret; + errno = self->get_mp_max_openfd(self, &ret); + return ret; + } +SWIGINTERN int DbEnv_get_mp_max_write(struct DbEnv *self){ + int maxwrite; + db_timeout_t sleep; + errno = self->get_mp_max_write(self, &maxwrite, &sleep); + return maxwrite; + } +SWIGINTERN db_timeout_t DbEnv_get_mp_max_write_sleep(struct DbEnv *self){ + int maxwrite; + db_timeout_t sleep; + errno = self->get_mp_max_write(self, &maxwrite, &sleep); + return sleep; + } +SWIGINTERN size_t DbEnv_get_mp_mmapsize(struct DbEnv *self){ + size_t ret; + errno = self->get_mp_mmapsize(self, &ret); + return ret; + } +SWIGINTERN int DbEnv_get_mp_pagesize(struct DbEnv *self){ + int ret; + errno = self->get_mp_pagesize(self, &ret); + return ret; + } +SWIGINTERN int DbEnv_get_mp_tablesize(struct DbEnv *self){ + int ret; + errno = self->get_mp_tablesize(self, &ret); + return ret; + } +SWIGINTERN DB_MPOOL_STAT *DbEnv_memp_stat(struct DbEnv *self,u_int32_t flags){ + DB_MPOOL_STAT *mp_stat = NULL; + errno = self->memp_stat(self, &mp_stat, NULL, flags); + return mp_stat; + } +SWIGINTERN DB_MPOOL_FSTAT **DbEnv_memp_fstat(struct DbEnv *self,u_int32_t flags){ + DB_MPOOL_FSTAT **mp_fstat = NULL; + errno = self->memp_stat(self, NULL, &mp_fstat, flags); + return mp_fstat; + } +SWIGINTERN db_ret_t DbEnv_memp_sync(struct DbEnv *self,DB_LSN *lsn){ + return self->memp_sync(self, lsn); + } +SWIGINTERN int DbEnv_memp_trickle(struct DbEnv *self,int percent){ + int ret; + errno = self->memp_trickle(self, percent, &ret); + return ret; + } +SWIGINTERN u_int32_t DbEnv_mutex_get_align(struct DbEnv *self){ + u_int32_t ret; + errno = self->mutex_get_align(self, &ret); + return ret; + } +SWIGINTERN u_int32_t DbEnv_mutex_get_increment(struct DbEnv *self){ + u_int32_t ret; + errno = self->mutex_get_increment(self, &ret); + return ret; + } +SWIGINTERN u_int32_t DbEnv_mutex_get_max(struct DbEnv *self){ + u_int32_t ret; + errno = self->mutex_get_max(self, &ret); + return ret; + } +SWIGINTERN u_int32_t DbEnv_mutex_get_tas_spins(struct DbEnv *self){ + u_int32_t ret; + errno = self->mutex_get_tas_spins(self, &ret); + return ret; + } +SWIGINTERN db_ret_t DbEnv_mutex_set_align(struct DbEnv *self,u_int32_t align){ + return self->mutex_set_align(self, align); + } +SWIGINTERN db_ret_t DbEnv_mutex_set_increment(struct DbEnv *self,u_int32_t increment){ + return self->mutex_set_increment(self, increment); + } +SWIGINTERN db_ret_t DbEnv_mutex_set_max(struct DbEnv *self,u_int32_t mutex_max){ + return self->mutex_set_max(self, mutex_max); + } +SWIGINTERN db_ret_t DbEnv_mutex_set_tas_spins(struct DbEnv *self,u_int32_t tas_spins){ + return self->mutex_set_tas_spins(self, tas_spins); + } +SWIGINTERN DB_MUTEX_STAT *DbEnv_mutex_stat(struct DbEnv *self,u_int32_t flags){ + DB_MUTEX_STAT *statp = NULL; + errno = self->mutex_stat(self, &statp, flags); + return statp; + } +SWIGINTERN u_int32_t DbEnv_get_tx_max(struct DbEnv *self){ + u_int32_t ret; + errno = self->get_tx_max(self, &ret); + return ret; + } +SWIGINTERN time_t DbEnv_get_tx_timestamp(struct DbEnv *self){ + time_t ret; + errno = self->get_tx_timestamp(self, &ret); + return ret; + } +SWIGINTERN db_timeout_t DbEnv_get_timeout(struct DbEnv *self,u_int32_t flag){ + db_timeout_t ret; + errno = self->get_timeout(self, &ret, flag); + return ret; + } +SWIGINTERN DB_TXN *DbEnv_txn_begin(struct DbEnv *self,DB_TXN *parent,u_int32_t flags){ + DB_TXN *tid = NULL; + errno = self->txn_begin(self, parent, &tid, flags); + return tid; + } +SWIGINTERN db_ret_t DbEnv_txn_checkpoint(struct DbEnv *self,u_int32_t kbyte,u_int32_t min,u_int32_t flags){ + return self->txn_checkpoint(self, kbyte, min, flags); + } +SWIGINTERN DB_PREPLIST *DbEnv_txn_recover(struct DbEnv *self,int count,u_int32_t flags){ + DB_PREPLIST *preplist; + u_int32_t retcount; + + /* Add a NULL element to terminate the array. */ + if ((errno = __os_malloc(self->env, + (count + 1) * sizeof(DB_PREPLIST), &preplist)) != 0) + return NULL; + + if ((errno = self->txn_recover(self, preplist, count, + &retcount, flags)) != 0) { + __os_free(self->env, preplist); + return NULL; + } + + preplist[retcount].txn = NULL; + return preplist; + } +SWIGINTERN DB_TXN_STAT *DbEnv_txn_stat(struct DbEnv *self,u_int32_t flags){ + DB_TXN_STAT *statp = NULL; + errno = self->txn_stat(self, &statp, flags); + return statp; + } +SWIGINTERN jlong DbEnv_rep_get_limit(struct DbEnv *self){ + u_int32_t gbytes, bytes; + errno = self->rep_get_limit(self, &gbytes, &bytes); + return (jlong)gbytes * GIGABYTE + bytes; + } +SWIGINTERN db_ret_t DbEnv_rep_elect(struct DbEnv *self,u_int32_t nsites,int nvotes,u_int32_t flags){ + return self->rep_elect(self, nsites, nvotes, flags); + } +SWIGINTERN int DbEnv_rep_process_message(struct DbEnv *self,DBT *control,DBT *rec,int envid,DB_LSN *ret_lsn){ + return self->rep_process_message(self, control, rec, envid, + ret_lsn); + } +SWIGINTERN db_ret_t DbEnv_rep_flush(struct DbEnv *self){ + return self->rep_flush(self); + } +SWIGINTERN db_ret_t DbEnv_rep_set_config(struct DbEnv *self,u_int32_t which,int_bool onoff){ + return self->rep_set_config(self, which, onoff); + } +SWIGINTERN db_ret_t DbEnv_rep_set_clockskew(struct DbEnv *self,u_int32_t fast_clock,u_int32_t slow_clock){ + return self->rep_set_clockskew(self, fast_clock, slow_clock); + } +SWIGINTERN u_int32_t DbEnv_rep_get_clockskew_fast(struct DbEnv *self){ + u_int32_t fast_clock, slow_clock; + errno = self->rep_get_clockskew(self, &fast_clock, &slow_clock); + return fast_clock; + } +SWIGINTERN u_int32_t DbEnv_rep_get_clockskew_slow(struct DbEnv *self){ + u_int32_t fast_clock, slow_clock; + errno = self->rep_get_clockskew(self, &fast_clock, &slow_clock); + return slow_clock; + } +SWIGINTERN db_ret_t DbEnv_rep_start(struct DbEnv *self,DBT *cdata,u_int32_t flags){ + return self->rep_start(self, cdata, flags); + } +SWIGINTERN db_ret_t DbEnv_rep_sync(struct DbEnv *self,u_int32_t flags){ + return self->rep_sync(self, flags); + } +SWIGINTERN int_bool DbEnv_rep_get_config(struct DbEnv *self,u_int32_t which){ + int ret; + errno = self->rep_get_config(self, which, &ret); + return ret; + } +SWIGINTERN DB_REP_STAT *DbEnv_rep_stat(struct DbEnv *self,u_int32_t flags){ + DB_REP_STAT *statp = NULL; + errno = self->rep_stat(self, &statp, flags); + return statp; + } +SWIGINTERN db_ret_t DbEnv_rep_set_limit(struct DbEnv *self,jlong bytes){ + return self->rep_set_limit(self, + (u_int32_t)(bytes / GIGABYTE), + (u_int32_t)(bytes % GIGABYTE)); + } +SWIGINTERN u_int32_t DbEnv_rep_get_request_min(struct DbEnv *self){ + u_int32_t min, max; + errno = self->rep_get_request(self, &min, &max); + return min; + } +SWIGINTERN u_int32_t DbEnv_rep_get_request_max(struct DbEnv *self){ + u_int32_t min, max; + errno = self->rep_get_request(self, &min, &max); + return max; + } +SWIGINTERN db_ret_t DbEnv_rep_set_request(struct DbEnv *self,u_int32_t min,u_int32_t max){ + return self->rep_set_request(self, min, max); + } +SWIGINTERN 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)){ + return self->rep_set_transport(self, envid, send); + } +SWIGINTERN u_int32_t DbEnv_rep_get_nsites(struct DbEnv *self){ + u_int32_t ret; + errno = self->rep_get_nsites(self, &ret); + return ret; + } +SWIGINTERN u_int32_t DbEnv_rep_get_priority(struct DbEnv *self){ + u_int32_t ret; + errno = self->rep_get_priority(self, &ret); + return ret; + } +SWIGINTERN u_int32_t DbEnv_rep_get_timeout(struct DbEnv *self,int which){ + u_int32_t ret; + errno = self->rep_get_timeout(self, which, &ret); + return ret; + } +SWIGINTERN db_ret_t DbEnv_rep_set_nsites(struct DbEnv *self,u_int32_t number){ + return self->rep_set_nsites(self, number); + } +SWIGINTERN db_ret_t DbEnv_rep_set_priority(struct DbEnv *self,u_int32_t priority){ + return self->rep_set_priority(self, priority); + } +SWIGINTERN db_ret_t DbEnv_rep_set_timeout(struct DbEnv *self,int which,db_timeout_t timeout){ + return self->rep_set_timeout(self, which, timeout); + } +SWIGINTERN int DbEnv_repmgr_add_remote_site(struct DbEnv *self,char const *host,u_int32_t port,u_int32_t flags){ + int eid; + errno = self->repmgr_add_remote_site(self, host, port, &eid, flags); + return eid; + } +SWIGINTERN db_ret_t DbEnv_repmgr_get_ack_policy(struct DbEnv *self){ + int ret; + errno = self->repmgr_get_ack_policy(self, &ret); + return ret; + } +SWIGINTERN db_ret_t DbEnv_repmgr_set_ack_policy(struct DbEnv *self,int policy){ + return self->repmgr_set_ack_policy(self, policy); + } +SWIGINTERN db_ret_t DbEnv_repmgr_set_local_site(struct DbEnv *self,char const *host,u_int32_t port,u_int32_t flags){ + return self->repmgr_set_local_site(self, host, port, flags); + } +SWIGINTERN struct __db_repmgr_sites DbEnv_repmgr_site_list(struct DbEnv *self){ + struct __db_repmgr_sites sites; + errno = self->repmgr_site_list(self, + &sites.nsites, &sites.sites); + return sites; + } +SWIGINTERN db_ret_t DbEnv_repmgr_start(struct DbEnv *self,int nthreads,u_int32_t flags){ + return self->repmgr_start(self, nthreads, flags); + } +SWIGINTERN DB_REPMGR_STAT *DbEnv_repmgr_stat(struct DbEnv *self,u_int32_t flags){ + DB_REPMGR_STAT *statp = NULL; + errno = self->repmgr_stat(self, &statp, flags); + return statp; + } +SWIGINTERN char const *DbEnv_strerror(int error){ + return db_strerror(error); + } +SWIGINTERN int DbEnv_get_version_major(){ + return DB_VERSION_MAJOR; + } +SWIGINTERN int DbEnv_get_version_minor(){ + return DB_VERSION_MINOR; + } +SWIGINTERN int DbEnv_get_version_patch(){ + return DB_VERSION_PATCH; + } +SWIGINTERN char const *DbEnv_get_version_string(){ + return DB_VERSION_STRING; + } +SWIGINTERN void delete_DbLock(struct DbLock *self){ + __os_free(NULL, self); + } +SWIGINTERN db_ret_t DbLogc_close(struct DbLogc *self,u_int32_t flags){ + return self->close(self, flags); + } +SWIGINTERN int DbLogc_get(struct DbLogc *self,DB_LSN *lsn,DBT *data,u_int32_t flags){ + return self->get(self, lsn, data, flags); + } +SWIGINTERN u_int32_t DbLogc_version(struct DbLogc *self,u_int32_t flags){ + u_int32_t result; + errno = self->version(self, &result, flags); + return result; + } +SWIGINTERN DB_CACHE_PRIORITY DbMpoolFile_get_priority(struct DbMpoolFile *self){ + DB_CACHE_PRIORITY ret; + errno = self->get_priority(self, &ret); + return ret; + } +SWIGINTERN db_ret_t DbMpoolFile_set_priority(struct DbMpoolFile *self,DB_CACHE_PRIORITY priority){ + return self->set_priority(self, priority); + } +SWIGINTERN u_int32_t DbMpoolFile_get_flags(struct DbMpoolFile *self){ + u_int32_t ret; + errno = self->get_flags(self, &ret); + return ret; + } +SWIGINTERN db_ret_t DbMpoolFile_set_flags(struct DbMpoolFile *self,u_int32_t flags,int_bool onoff){ + return self->set_flags(self, flags, onoff); + } +SWIGINTERN jlong DbMpoolFile_get_maxsize(struct DbMpoolFile *self){ + u_int32_t gbytes, bytes; + errno = self->get_maxsize(self, &gbytes, &bytes); + return (jlong)gbytes * GIGABYTE + bytes; + } +SWIGINTERN db_ret_t DbMpoolFile_set_maxsize(struct DbMpoolFile *self,jlong bytes){ + return self->set_maxsize(self, + (u_int32_t)(bytes / GIGABYTE), + (u_int32_t)(bytes % GIGABYTE)); + } +SWIGINTERN struct DbSequence *new_DbSequence(DB *db,u_int32_t flags){ + DB_SEQUENCE *self = NULL; + errno = db_sequence_create(&self, db, flags); + return self; + } +SWIGINTERN db_ret_t DbSequence_close(struct DbSequence *self,u_int32_t flags){ + return self->close(self, flags); + } +SWIGINTERN db_seq_t DbSequence_get(struct DbSequence *self,DB_TXN *txnid,int32_t delta,u_int32_t flags){ + db_seq_t ret = 0; + errno = self->get(self, txnid, delta, &ret, flags); + return ret; + } +SWIGINTERN int32_t DbSequence_get_cachesize(struct DbSequence *self){ + int32_t ret = 0; + errno = self->get_cachesize(self, &ret); + return ret; + } +SWIGINTERN DB *DbSequence_get_db(struct DbSequence *self){ + DB *ret = NULL; + errno = self->get_db(self, &ret); + return ret; + } +SWIGINTERN u_int32_t DbSequence_get_flags(struct DbSequence *self){ + u_int32_t ret = 0; + errno = self->get_flags(self, &ret); + return ret; + } +SWIGINTERN db_ret_t DbSequence_get_key(struct DbSequence *self,DBT *key){ + return self->get_key(self, key); + } +SWIGINTERN db_seq_t DbSequence_get_range_min(struct DbSequence *self){ + db_seq_t ret = 0; + errno = self->get_range(self, &ret, NULL); + return ret; + } +SWIGINTERN db_seq_t DbSequence_get_range_max(struct DbSequence *self){ + db_seq_t ret = 0; + errno = self->get_range(self, NULL, &ret); + return ret; + } +SWIGINTERN db_ret_t DbSequence_initial_value(struct DbSequence *self,db_seq_t val){ + return self->initial_value(self, val); + } +SWIGINTERN db_ret_t DbSequence_open(struct DbSequence *self,DB_TXN *txnid,DBT *key,u_int32_t flags){ + return self->open(self, txnid, key, flags); + } +SWIGINTERN db_ret_t DbSequence_remove(struct DbSequence *self,DB_TXN *txnid,u_int32_t flags){ + return self->remove(self, txnid, flags); + } +SWIGINTERN db_ret_t DbSequence_set_cachesize(struct DbSequence *self,int32_t size){ + return self->set_cachesize(self, size); + } +SWIGINTERN db_ret_t DbSequence_set_flags(struct DbSequence *self,u_int32_t flags){ + return self->set_flags(self, flags); + } +SWIGINTERN db_ret_t DbSequence_set_range(struct DbSequence *self,db_seq_t min,db_seq_t max){ + return self->set_range(self, min, max); + } +SWIGINTERN DB_SEQUENCE_STAT *DbSequence_stat(struct DbSequence *self,u_int32_t flags){ + DB_SEQUENCE_STAT *ret = NULL; + errno = self->stat(self, &ret, flags); + return ret; + } +SWIGINTERN db_ret_t DbTxn_abort(struct DbTxn *self){ + return self->abort(self); + } +SWIGINTERN db_ret_t DbTxn_commit(struct DbTxn *self,u_int32_t flags){ + return self->commit(self, flags); + } +SWIGINTERN db_ret_t DbTxn_discard(struct DbTxn *self,u_int32_t flags){ + return self->discard(self, flags); + } +SWIGINTERN char const *DbTxn_get_name(struct DbTxn *self){ + const char *name = NULL; + errno = self->get_name(self, &name); + return name; + } +SWIGINTERN u_int32_t DbTxn_id(struct DbTxn *self){ + return self->id(self); + } +SWIGINTERN db_ret_t DbTxn_prepare(struct DbTxn *self,u_int8_t *gid){ + return self->prepare(self, gid); + } +SWIGINTERN db_ret_t DbTxn_set_timeout(struct DbTxn *self,db_timeout_t timeout,u_int32_t flags){ + return self->set_timeout(self, timeout, flags); + } +SWIGINTERN db_ret_t DbTxn_set_name(struct DbTxn *self,char const *name){ + return self->set_name(self, name); + } + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_new_1Db(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jlong jresult = 0 ; + DB_ENV *arg1 = (DB_ENV *) 0 ; + u_int32_t arg2 ; + struct Db *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(DB_ENV **)&jarg1; + arg2 = (u_int32_t)jarg2; + + errno = 0; + result = (struct Db *)new_Db(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + *(struct Db **)&jresult = result; + return jresult; +} + + +SWIGEXPORT 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) { + struct Db *arg1 = (struct Db *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + DB *arg3 = (DB *) 0 ; + int (*arg4)(DB *,DBT const *,DBT const *,DBT *) = (int (*)(DB *,DBT const *,DBT const *,DBT *)) 0 ; + u_int32_t arg5 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + (void)jarg3_; + arg1 = *(struct Db **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + arg3 = *(DB **)&jarg3; + + arg4 = (jarg4 == JNI_TRUE) ? __dbj_seckey_create : NULL; + + arg5 = (u_int32_t)jarg5; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_associate(arg1,arg2,arg3,arg4,arg5); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT 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) { + struct Db *arg1 = (struct Db *) 0 ; + DB *arg2 = (DB *) 0 ; + int (*arg3)(DB *,DBT const *,DBT *,DBT const *,int *) = (int (*)(DB *,DBT const *,DBT *,DBT const *,int *)) 0 ; + u_int32_t arg4 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct Db **)&jarg1; + arg2 = *(DB **)&jarg2; + + arg3 = (jarg3 == JNI_TRUE) ? __dbj_foreignkey_nullify : NULL; + + arg4 = (u_int32_t)jarg4; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_associate_foreign(arg1,arg2,arg3,arg4); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT 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) { + struct Db *arg1 = (struct Db *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + DBT *arg3 = (DBT *) 0 ; + DBT *arg4 = (DBT *) 0 ; + DB_COMPACT *arg5 = (DB_COMPACT *) 0 ; + u_int32_t arg6 ; + DBT *arg7 = (DBT *) 0 ; + DBT_LOCKED ldbt3 ; + DBT_LOCKED ldbt4 ; + DB_COMPACT compact5 ; + DBT_LOCKED ldbt7 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct Db **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + + if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 1) != 0) { + return ; /* An exception will be pending. */ + } + + if (__dbj_dbt_copyin(jenv, &ldbt4, &arg4, jarg4, 1) != 0) { + return ; /* An exception will be pending. */ + } + + memset(&compact5, 0, sizeof (DB_COMPACT)); + arg5 = &compact5; + arg5->compact_fillpercent = (*jenv)->GetIntField(jenv, jarg5, + compact_compact_fillpercent_fid); + arg5->compact_timeout = (*jenv)->GetIntField(jenv, jarg5, + compact_compact_timeout_fid); + arg5->compact_pages = (*jenv)->GetIntField(jenv, jarg5, + compact_compact_pages_fid); + + arg6 = (u_int32_t)jarg6; + + if (__dbj_dbt_copyin(jenv, &ldbt7, &arg7, jarg7, 1) != 0) { + return ; /* An exception will be pending. */ + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_compact(arg1,arg2,arg3,arg4,arg5,arg6,arg7); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + + __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); + __dbj_dbt_release(jenv, jarg4, arg4, &ldbt4); + __dbj_fill_compact(jenv, jarg5, arg5); + __dbj_dbt_release(jenv, jarg7, arg7, &ldbt7); +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1close0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t arg2 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int)Db_close(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, NULL); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT 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) { + jlong jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + u_int32_t arg3 ; + DBC *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct Db **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DBC *)Db_cursor(arg1,arg2,arg3); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + *(DBC **)&jresult = result; + return jresult; +} + + +SWIGEXPORT 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) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + DBT *arg3 = (DBT *) 0 ; + u_int32_t arg4 ; + DBT_LOCKED ldbt3 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct Db **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + + if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { + return 0; /* An exception will be pending. */ + } + arg4 = (u_int32_t)jarg4; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + result = (int)Db_del(arg1,arg2,arg3,arg4); + if (!DB_RETOK_DBDEL(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1err(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) { + struct Db *arg1 = (struct Db *) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = (int)jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return ; + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + Db_err(arg1,arg2,(char const *)arg3); + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1errx(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + char *arg2 = (char *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + Db_errx(arg1,(char const *)arg2); + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT 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) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + DBT *arg3 = (DBT *) 0 ; + u_int32_t arg4 ; + DBT_LOCKED ldbt3 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct Db **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + + if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { + return 0; /* An exception will be pending. */ + } + arg4 = (u_int32_t)jarg4; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + result = (int)Db_exists(arg1,arg2,arg3,arg4); + if (!DB_RETOK_EXISTS(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); + return jresult; +} + + +SWIGEXPORT 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) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + DBT *arg3 = (DBT *) 0 ; + DBT *arg4 = (DBT *) 0 ; + u_int32_t arg5 ; + DBT_LOCKED ldbt3 ; + DBT_LOCKED ldbt4 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct Db **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + + if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { + return 0; /* An exception will be pending. */ + } + + if (__dbj_dbt_copyin(jenv, &ldbt4, &arg4, jarg4, 0) != 0) { + return 0; /* An exception will be pending. */ + } + arg5 = (u_int32_t)jarg5; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + result = (int)Db_get(arg1,arg2,arg3,arg4,arg5); + if (!DB_RETOK_DBGET(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); + __dbj_dbt_release(jenv, jarg4, arg4, &ldbt4); + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1byteswapped(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + int_bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int_bool)Db_get_byteswapped(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (result) ? JNI_TRUE : JNI_FALSE; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1cachesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + jlong result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = Db_get_cachesize(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1cachesize_1ncache(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)Db_get_cachesize_ncache(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1create_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (char *)Db_get_create_dir(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1filename(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (char *)Db_get_filename(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1dbname(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (char *)Db_get_dbname(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1encrypt_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)Db_get_encrypt_flags(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)Db_get_flags(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1lorder(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int)Db_get_lorder(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1mpf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + DB_MPOOLFILE *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_MPOOLFILE *)Db_get_mpf(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + *(DB_MPOOLFILE **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1open_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)Db_get_open_flags(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1pagesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)Db_get_pagesize(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1bt_1minkey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)Db_get_bt_minkey(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1h_1ffactor(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)Db_get_h_ffactor(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1h_1nelem(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)Db_get_h_nelem(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1re_1delim(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int)Db_get_re_delim(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1priority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + DB_CACHE_PRIORITY result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_CACHE_PRIORITY)Db_get_priority(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jobjectArray JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1partition_1dirs(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jobjectArray jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + char **result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (char **)Db_get_partition_dirs(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + { + if (result != NULL) { + /*@SWIG:../libdb_java/java_typemaps.i,367,STRING_ARRAY_OUT@*/ int i, len; + + len = 0; + while (result[len] != NULL) + len++; + if ((jresult = (*jenv)->NewObjectArray(jenv, (jsize)len, string_class, + NULL)) == NULL) + return 0; /* an exception is pending */ + for (i = 0; i < len; i++) { + jstring str = (*jenv)->NewStringUTF(jenv, result[i]); + (*jenv)->SetObjectArrayElement(jenv, jresult, (jsize)i, str); + } + /*@SWIG@*/ + } + } + return jresult; +} + + +SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1partition_1keys(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jobject jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + DBT *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DBT *)Db_get_partition_keys(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jobject)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1partition_1parts(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int)Db_get_partition_parts(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1re_1len(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)Db_get_re_len(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1re_1pad(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int)Db_get_re_pad(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1re_1source(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (char *)Db_get_re_source(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1q_1extentsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)Db_get_q_extentsize(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1multiple(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + int_bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + result = (int_bool)Db_get_multiple(arg1); + jresult = (result) ? JNI_TRUE : JNI_FALSE; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1transactional(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + int_bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + result = (int_bool)Db_get_transactional(arg1); + jresult = (result) ? JNI_TRUE : JNI_FALSE; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1get_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + DBTYPE result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DBTYPE)Db_get_type(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1join(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2, jint jarg3) { + jlong jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + DBC **arg2 = (DBC **) 0 ; + u_int32_t arg3 ; + DBC *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + { + int i, count, err; + + count = (*jenv)->GetArrayLength(jenv, jarg2); + if ((err = __os_malloc(NULL, (count + 1) * sizeof(DBC *), &arg2)) != 0) { + __dbj_throw(jenv, err, NULL, NULL, DB2JDBENV); + return 0; + } + for (i = 0; i < count; i++) { + jobject jobj = (*jenv)->GetObjectArrayElement(jenv, jarg2, i); + /* + * A null in the array is treated as an endpoint. + */ + if (jobj == NULL) { + arg2[i] = NULL; + break; + } else { + jlong jptr = (*jenv)->GetLongField(jenv, jobj, + dbc_cptr_fid); + arg2[i] = *(DBC **)(void *)&jptr; + } + } + arg2[count] = NULL; + } + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DBC *)Db_join(arg1,arg2,arg3); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + *(DBC **)&jresult = result; + + __os_free(NULL, arg2); + + return jresult; +} + + +SWIGEXPORT 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) { + struct Db *arg1 = (struct Db *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + DBT *arg3 = (DBT *) 0 ; + DB_KEY_RANGE *arg4 = (DB_KEY_RANGE *) 0 ; + u_int32_t arg5 ; + DBT_LOCKED ldbt3 ; + DB_KEY_RANGE range4 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct Db **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + + if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { + return ; /* An exception will be pending. */ + } + { + arg4 = &range4; + } + arg5 = (u_int32_t)jarg5; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_key_range(arg1,arg2,arg3,arg4,arg5); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + + { + (*jenv)->SetDoubleField(jenv, jarg4, kr_less_fid, arg4->less); + (*jenv)->SetDoubleField(jenv, jarg4, kr_equal_fid, arg4->equal); + (*jenv)->SetDoubleField(jenv, jarg4, kr_greater_fid, arg4->greater); + } + __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); +} + + +SWIGEXPORT 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) { + struct Db *arg1 = (struct Db *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + char *arg3 = (char *) 0 ; + char *arg4 = (char *) 0 ; + DBTYPE arg5 ; + u_int32_t arg6 ; + int arg7 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct Db **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return ; + } + arg4 = 0; + if (jarg4) { + arg4 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg4, 0); + if (!arg4) return ; + } + arg5 = (DBTYPE)jarg5; + arg6 = (u_int32_t)jarg6; + arg7 = (int)jarg7; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_open(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); + if (arg4) (*jenv)->ReleaseStringUTFChars(jenv, jarg4, (const char *)arg4); +} + + +SWIGEXPORT 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) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + DBT *arg3 = (DBT *) 0 ; + DBT *arg4 = (DBT *) 0 ; + DBT *arg5 = (DBT *) 0 ; + u_int32_t arg6 ; + DBT_LOCKED ldbt3 ; + DBT_LOCKED ldbt4 ; + DBT_LOCKED ldbt5 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct Db **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + + if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { + return 0; /* An exception will be pending. */ + } + + if (__dbj_dbt_copyin(jenv, &ldbt4, &arg4, jarg4, 0) != 0) { + return 0; /* An exception will be pending. */ + } + + if (__dbj_dbt_copyin(jenv, &ldbt5, &arg5, jarg5, 0) != 0) { + return 0; /* An exception will be pending. */ + } + arg6 = (u_int32_t)jarg6; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + result = (int)Db_pget(arg1,arg2,arg3,arg4,arg5,arg6); + if (!DB_RETOK_DBGET(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); + __dbj_dbt_release(jenv, jarg4, arg4, &ldbt4); + __dbj_dbt_release(jenv, jarg5, arg5, &ldbt5); + return jresult; +} + + +SWIGEXPORT 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) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + DBT *arg3 = (DBT *) 0 ; + DBT *arg4 = (DBT *) 0 ; + u_int32_t arg5 ; + DBT_LOCKED ldbt3 ; + DBT_LOCKED ldbt4 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct Db **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + + if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { + return 0; /* An exception will be pending. */ + } + + if (__dbj_dbt_copyin(jenv, &ldbt4, &arg4, jarg4, 1) != 0) { + return 0; /* An exception will be pending. */ + } + arg5 = (u_int32_t)jarg5; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + result = (int)Db_put(arg1,arg2,arg3,arg4,arg5); + if (!DB_RETOK_DBPUT(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); + __dbj_dbt_release(jenv, jarg4, arg4, &ldbt4); + return jresult; +} + + +SWIGEXPORT 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) { + struct Db *arg1 = (struct Db *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + u_int32_t arg4 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return ; + } + arg4 = (u_int32_t)jarg4; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_remove(arg1,(char const *)arg2,(char const *)arg3,arg4); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); +} + + +SWIGEXPORT 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) { + struct Db *arg1 = (struct Db *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + char *arg4 = (char *) 0 ; + u_int32_t arg5 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return ; + } + arg4 = 0; + if (jarg4) { + arg4 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg4, 0); + if (!arg4) return ; + } + arg5 = (u_int32_t)jarg5; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_rename(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); + if (arg4) (*jenv)->ReleaseStringUTFChars(jenv, jarg4, (const char *)arg4); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1append_1recno(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + int (*arg2)(DB *,DBT *,db_recno_t) = (int (*)(DB *,DBT *,db_recno_t)) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + arg2 = (jarg2 == JNI_TRUE) ? __dbj_append_recno : NULL; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_append_recno(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1bt_1compare(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + int (*arg2)(DB *,DBT const *,DBT const *) = (int (*)(DB *,DBT const *,DBT const *)) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + arg2 = (jarg2 == JNI_TRUE) ? __dbj_bt_compare : NULL; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_bt_compare(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1bt_1minkey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_bt_minkey(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1bt_1compress(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2, jboolean jarg3) { + struct Db *arg1 = (struct Db *) 0 ; + int (*arg2)(DB *,DBT const *,DBT const *,DBT const *,DBT const *,DBT *) = (int (*)(DB *,DBT const *,DBT const *,DBT const *,DBT const *,DBT *)) 0 ; + int (*arg3)(DB *,DBT const *,DBT const *,DBT *,DBT *,DBT *) = (int (*)(DB *,DBT const *,DBT const *,DBT *,DBT *,DBT *)) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + arg2 = (jarg2 == JNI_TRUE) ? __dbj_bt_compress : NULL; + + + arg3 = (jarg3 == JNI_TRUE) ? __dbj_bt_decompress : NULL; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_bt_compress(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1bt_1prefix(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + size_t (*arg2)(DB *,DBT const *,DBT const *) = (size_t (*)(DB *,DBT const *,DBT const *)) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + arg2 = (jarg2 == JNI_TRUE) ? __dbj_bt_prefix : NULL; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_bt_prefix(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1cachesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) { + struct Db *arg1 = (struct Db *) 0 ; + jlong arg2 ; + int arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = jarg2; + arg3 = (int)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_cachesize(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1create_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + char *arg2 = (char *) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_create_dir(arg1,(char const *)arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1dup_1compare(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + int (*arg2)(DB *,DBT const *,DBT const *) = (int (*)(DB *,DBT const *,DBT const *)) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + arg2 = (jarg2 == JNI_TRUE) ? __dbj_dup_compare : NULL; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_dup_compare(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1encrypt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) { + struct Db *arg1 = (struct Db *) 0 ; + char *arg2 = (char *) 0 ; + u_int32_t arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_encrypt(arg1,(char const *)arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1feedback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + void (*arg2)(DB *,int,int) = (void (*)(DB *,int,int)) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + arg2 = (jarg2 == JNI_TRUE) ? __dbj_db_feedback : NULL; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_feedback(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_flags(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1h_1compare(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + int (*arg2)(DB *,DBT const *,DBT const *) = (int (*)(DB *,DBT const *,DBT const *)) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + arg2 = (jarg2 == JNI_TRUE) ? __dbj_h_compare : NULL; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_h_compare(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1h_1ffactor(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_h_ffactor(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1h_1hash(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t (*arg2)(DB *,void const *,u_int32_t) = (u_int32_t (*)(DB *,void const *,u_int32_t)) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + arg2 = (jarg2 == JNI_TRUE) ? __dbj_h_hash : NULL; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_h_hash(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1h_1nelem(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_h_nelem(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1lorder(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + int arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = (int)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_lorder(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1pagesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_pagesize(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1partition(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jobject jarg3, jboolean jarg4) { + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t arg2 ; + DBT *arg3 = (DBT *) 0 ; + u_int32_t (*arg4)(DB *,DBT *) = (u_int32_t (*)(DB *,DBT *)) 0 ; + DBT_LOCKED ldbt3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 1) != 0) { + return ; /* An exception will be pending. */ + } + + arg4 = (jarg4 == JNI_TRUE) ? __dbj_partition : NULL; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_partition(arg1,arg2,arg3,arg4); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + + __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1partition_1dirs(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + char **arg2 = (char **) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = *(char ***)&jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_partition_dirs(arg1,(char const **)arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1priority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + DB_CACHE_PRIORITY arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = (DB_CACHE_PRIORITY)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_priority(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1re_1delim(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + int arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = (int)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_re_delim(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1re_1len(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_re_len(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1re_1pad(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + int arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = (int)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_re_pad(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1re_1source(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + char *arg2 = (char *) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_re_source(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1set_1q_1extentsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_set_q_extentsize(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1sort_1multiple(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jobject jarg3) { + struct Db *arg1 = (struct Db *) 0 ; + DBT *arg2 = (DBT *) 0 ; + DBT *arg3 = (DBT *) 0 ; + DBT_LOCKED ldbt2 ; + DBT_LOCKED ldbt3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + + if (__dbj_dbt_copyin(jenv, &ldbt2, &arg2, jarg2, 0) != 0) { + return ; /* An exception will be pending. */ + } + + if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { + return ; /* An exception will be pending. */ + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_sort_multiple(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + + __dbj_dbt_release(jenv, jarg2, arg2, &ldbt2); + __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); +} + + +SWIGEXPORT 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) { + jobject jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + u_int32_t arg3 ; + void *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct Db **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (void *)Db_stat(arg1,arg2,arg3); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + + if (result == NULL) + jresult = NULL; + else { + DB *db = (DB *)arg1; + DBTYPE dbtype; + int err; + + if ((err = db->get_type(db, &dbtype)) != 0) { + __dbj_throw(jenv, err, NULL, NULL, DB2JDBENV); + return 0; + } + + switch (dbtype) { + /* Btree and recno share the same stat structure */ + case DB_BTREE: + case DB_RECNO: + jresult = (*jenv)->NewObject(jenv, bt_stat_class, + bt_stat_construct); + if (jresult != NULL) + __dbj_fill_bt_stat(jenv, jresult, + (DB_BTREE_STAT *)result); + break; + + /* Hash stat structure */ + case DB_HASH: + jresult = (*jenv)->NewObject(jenv, h_stat_class, + h_stat_construct); + if (jresult != NULL) + __dbj_fill_h_stat(jenv, jresult, + (DB_HASH_STAT *)result); + break; + + case DB_QUEUE: + jresult = (*jenv)->NewObject(jenv, qam_stat_class, + qam_stat_construct); + if (jresult != NULL) + __dbj_fill_qam_stat(jenv, jresult, + (DB_QUEUE_STAT *)result); + break; + + /* That's all the database types we're aware of! */ + default: + __dbj_throw(jenv, EINVAL, "Db.stat only implemented for" + " BTREE, HASH, QUEUE and RECNO", NULL, DB2JDBENV); + break; + } + + __os_ufree(db->env, result); + } + + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1sync(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct Db *arg1 = (struct Db *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_sync(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + +} + + +SWIGEXPORT 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) { + jint jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + u_int32_t arg3 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct Db **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int)Db_truncate(arg1,arg2,arg3); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DB2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Db_1upgrade(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) { + struct Db *arg1 = (struct Db *) 0 ; + char *arg2 = (char *) 0 ; + u_int32_t arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Db_upgrade(arg1,(char const *)arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, DB2JDBENV); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT 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) { + jboolean jresult = 0 ; + struct Db *arg1 = (struct Db *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + struct __db_out_stream arg4 ; + u_int32_t arg5 ; + struct __dbj_verify_data data4 ; + int_bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Db **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return 0; + } + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return 0; + } + { + data4.jenv = jenv; + data4.streamobj = jarg4; + data4.bytes = NULL; + data4.nbytes = 0; + (&arg4)->handle = &data4; + (&arg4)->callback = __dbj_verify_callback; + } + arg5 = (u_int32_t)jarg5; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int_bool)Db_verify(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, NULL); + } + + jresult = (result) ? JNI_TRUE : JNI_FALSE; + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1close0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + struct Dbc *arg1 = (struct Dbc *) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Dbc **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)Dbc_close(arg1); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1cmp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3) { + jint jresult = 0 ; + struct Dbc *arg1 = (struct Dbc *) 0 ; + DBC *arg2 = (DBC *) 0 ; + u_int32_t arg3 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct Dbc **)&jarg1; + arg2 = *(DBC **)&jarg2; + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int)Dbc_cmp(arg1,arg2,arg3); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DBC2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1count(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jint jresult = 0 ; + struct Dbc *arg1 = (struct Dbc *) 0 ; + u_int32_t arg2 ; + db_recno_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Dbc **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (db_recno_t)Dbc_count(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DBC2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1del(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jint jresult = 0 ; + struct Dbc *arg1 = (struct Dbc *) 0 ; + u_int32_t arg2 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Dbc **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + result = (int)Dbc_del(arg1,arg2); + if (!DB_RETOK_DBCDEL(result)) { + __dbj_throw(jenv, result, NULL, NULL, DBC2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1dup(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jlong jresult = 0 ; + struct Dbc *arg1 = (struct Dbc *) 0 ; + u_int32_t arg2 ; + DBC *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Dbc **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DBC *)Dbc_dup(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DBC2JDBENV); + } + + *(DBC **)&jresult = result; + return jresult; +} + + +SWIGEXPORT 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) { + jint jresult = 0 ; + struct Dbc *arg1 = (struct Dbc *) 0 ; + DBT *arg2 = (DBT *) 0 ; + DBT *arg3 = (DBT *) 0 ; + u_int32_t arg4 ; + DBT_LOCKED ldbt2 ; + DBT_LOCKED ldbt3 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Dbc **)&jarg1; + + if (__dbj_dbt_copyin(jenv, &ldbt2, &arg2, jarg2, 0) != 0) { + return 0; /* An exception will be pending. */ + } + + if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { + return 0; /* An exception will be pending. */ + } + arg4 = (u_int32_t)jarg4; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + result = (int)Dbc_get(arg1,arg2,arg3,arg4); + if (!DB_RETOK_DBCGET(result)) { + __dbj_throw(jenv, result, NULL, NULL, DBC2JDBENV); + } + + jresult = (jint)result; + __dbj_dbt_release(jenv, jarg2, arg2, &ldbt2); + __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1get_1priority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct Dbc *arg1 = (struct Dbc *) 0 ; + DB_CACHE_PRIORITY result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Dbc **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_CACHE_PRIORITY)Dbc_get_priority(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DBC2JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT 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) { + jint jresult = 0 ; + struct Dbc *arg1 = (struct Dbc *) 0 ; + DBT *arg2 = (DBT *) 0 ; + DBT *arg3 = (DBT *) 0 ; + DBT *arg4 = (DBT *) 0 ; + u_int32_t arg5 ; + DBT_LOCKED ldbt2 ; + DBT_LOCKED ldbt3 ; + DBT_LOCKED ldbt4 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Dbc **)&jarg1; + + if (__dbj_dbt_copyin(jenv, &ldbt2, &arg2, jarg2, 0) != 0) { + return 0; /* An exception will be pending. */ + } + + if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { + return 0; /* An exception will be pending. */ + } + + if (__dbj_dbt_copyin(jenv, &ldbt4, &arg4, jarg4, 0) != 0) { + return 0; /* An exception will be pending. */ + } + arg5 = (u_int32_t)jarg5; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + result = (int)Dbc_pget(arg1,arg2,arg3,arg4,arg5); + if (!DB_RETOK_DBCGET(result)) { + __dbj_throw(jenv, result, NULL, NULL, DBC2JDBENV); + } + + jresult = (jint)result; + __dbj_dbt_release(jenv, jarg2, arg2, &ldbt2); + __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); + __dbj_dbt_release(jenv, jarg4, arg4, &ldbt4); + return jresult; +} + + +SWIGEXPORT 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) { + jint jresult = 0 ; + struct Dbc *arg1 = (struct Dbc *) 0 ; + DBT *arg2 = (DBT *) 0 ; + DBT *arg3 = (DBT *) 0 ; + u_int32_t arg4 ; + DBT_LOCKED ldbt2 ; + DBT_LOCKED ldbt3 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Dbc **)&jarg1; + + if (__dbj_dbt_copyin(jenv, &ldbt2, &arg2, jarg2, 0) != 0) { + return 0; /* An exception will be pending. */ + } + + if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 1) != 0) { + return 0; /* An exception will be pending. */ + } + arg4 = (u_int32_t)jarg4; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + result = (int)Dbc_put(arg1,arg2,arg3,arg4); + if (!DB_RETOK_DBCPUT(result)) { + __dbj_throw(jenv, result, NULL, NULL, DBC2JDBENV); + } + + jresult = (jint)result; + __dbj_dbt_release(jenv, jarg2, arg2, &ldbt2); + __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_Dbc_1set_1priority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct Dbc *arg1 = (struct Dbc *) 0 ; + DB_CACHE_PRIORITY arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct Dbc **)&jarg1; + arg2 = (DB_CACHE_PRIORITY)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + errno = 0; + result = (db_ret_t)Dbc_set_priority(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, DBC2JDBENV); + } + +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_new_1DbEnv(JNIEnv *jenv, jclass jcls, jint jarg1) { + jlong jresult = 0 ; + u_int32_t arg1 ; + struct DbEnv *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (u_int32_t)jarg1; + + errno = 0; + result = (struct DbEnv *)new_DbEnv(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, NULL); + } + + *(struct DbEnv **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1close0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_close(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + +} + + +SWIGEXPORT 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) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + char *arg3 = (char *) 0 ; + char *arg4 = (char *) 0 ; + u_int32_t arg5 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return ; + } + arg4 = 0; + if (jarg4) { + arg4 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg4, 0); + if (!arg4) return ; + } + arg5 = (u_int32_t)jarg5; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_dbremove(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); + if (arg4) (*jenv)->ReleaseStringUTFChars(jenv, jarg4, (const char *)arg4); +} + + +SWIGEXPORT 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) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + char *arg3 = (char *) 0 ; + char *arg4 = (char *) 0 ; + char *arg5 = (char *) 0 ; + u_int32_t arg6 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return ; + } + arg4 = 0; + if (jarg4) { + arg4 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg4, 0); + if (!arg4) return ; + } + arg5 = 0; + if (jarg5) { + arg5 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg5, 0); + if (!arg5) return ; + } + arg6 = (u_int32_t)jarg6; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_dbrename(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,arg6); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); + if (arg4) (*jenv)->ReleaseStringUTFChars(jenv, jarg4, (const char *)arg4); + if (arg5) (*jenv)->ReleaseStringUTFChars(jenv, jarg5, (const char *)arg5); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1err(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (int)jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return ; + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + DbEnv_err(arg1,arg2,(char const *)arg3); + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1errx(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *arg2 = (char *) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + DbEnv_errx(arg1,(char const *)arg2); + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1cdsgroup_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + DB_TXN *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + result = (DB_TXN *)DbEnv_cdsgroup_begin(arg1); + *(DB_TXN **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1fileid_1reset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *arg2 = (char *) 0 ; + u_int32_t arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + result = (db_ret_t)DbEnv_fileid_reset(arg1,(char const *)arg2,arg3); + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT jobjectArray JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1data_1dirs(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jobjectArray jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char **result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (char **)DbEnv_get_data_dirs(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + { + if (result != NULL) { + /*@SWIG:../libdb_java/java_typemaps.i,367,STRING_ARRAY_OUT@*/ int i, len; + + len = 0; + while (result[len] != NULL) + len++; + if ((jresult = (*jenv)->NewObjectArray(jenv, (jsize)len, string_class, + NULL)) == NULL) + return 0; /* an exception is pending */ + for (i = 0; i < len; i++) { + jstring str = (*jenv)->NewStringUTF(jenv, result[i]); + (*jenv)->SetObjectArrayElement(jenv, jresult, (jsize)i, str); + } + /*@SWIG@*/ + } + } + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1encrypt_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_get_encrypt_flags(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_get_flags(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1home(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (char *)DbEnv_get_home(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1intermediate_1dir_1mode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (char *)DbEnv_get_intermediate_dir_mode(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1open_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_get_open_flags(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1shm_1key(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + long result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (long)DbEnv_get_shm_key(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1tmp_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (char *)DbEnv_get_tmp_dir(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1verbose(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jboolean jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + int_bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int_bool)DbEnv_get_verbose(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (result) ? JNI_TRUE : JNI_FALSE; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1is_1bigendian(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int_bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + result = (int_bool)DbEnv_is_bigendian(arg1); + jresult = (result) ? JNI_TRUE : JNI_FALSE; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1lsn_1reset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *arg2 = (char *) 0 ; + u_int32_t arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_lsn_reset(arg1,(char const *)arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT 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) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *arg2 = (char *) 0 ; + u_int32_t arg3 ; + int arg4 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + arg3 = (u_int32_t)jarg3; + arg4 = (int)jarg4; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_open(arg1,(char const *)arg2,arg3,arg4); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1remove0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *arg2 = (char *) 0 ; + u_int32_t arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_remove(arg1,(char const *)arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1cachesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + jlong arg2 ; + int arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = jarg2; + arg3 = (int)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_cachesize(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1cache_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + jlong arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_cache_max(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1create_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *arg2 = (char *) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_create_dir(arg1,(char const *)arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1data_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *arg2 = (char *) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_data_dir(arg1,(char const *)arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1intermediate_1dir_1mode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *arg2 = (char *) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_intermediate_dir_mode(arg1,(char const *)arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1encrypt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *arg2 = (char *) 0 ; + u_int32_t arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_encrypt(arg1,(char const *)arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1errcall(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + void (*arg2)(DB_ENV const *,char const *,char const *) = (void (*)(DB_ENV const *,char const *,char const *)) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + arg2 = (jarg2 == JNI_TRUE) ? __dbj_error : NULL; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + DbEnv_set_errcall(arg1,arg2); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + int_bool arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + arg3 = (jarg3 == JNI_TRUE); + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_flags(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1feedback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + void (*arg2)(DB_ENV *,int,int) = (void (*)(DB_ENV *,int,int)) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + arg2 = (jarg2 == JNI_TRUE) ? __dbj_env_feedback : NULL; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_feedback(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1mp_1max_1openfd(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (int)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_mp_max_openfd(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT 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) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int arg2 ; + db_timeout_t arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (int)jarg2; + arg3 = (db_timeout_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_mp_max_write(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1mp_1mmapsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + size_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (size_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_mp_mmapsize(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1mp_1pagesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + size_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (size_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_mp_pagesize(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1mp_1tablesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + size_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (size_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_mp_tablesize(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1msgcall(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + void (*arg2)(DB_ENV const *,char const *) = (void (*)(DB_ENV const *,char const *)) 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + arg2 = (jarg2 == JNI_TRUE) ? __dbj_message : NULL; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + DbEnv_set_msgcall(arg1,arg2); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1paniccall(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + void (*arg2)(DB_ENV *,int) = (void (*)(DB_ENV *,int)) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + arg2 = (jarg2 == JNI_TRUE) ? __dbj_panic : NULL; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_paniccall(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT 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) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *arg2 = (char *) 0 ; + long arg3 ; + long arg4 ; + u_int32_t arg5 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + arg3 = (long)jarg3; + arg4 = (long)jarg4; + arg5 = (u_int32_t)jarg5; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_rpc_server(arg1,arg2,arg3,arg4,arg5); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1shm_1key(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + long arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (long)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_shm_key(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1timeout(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + db_timeout_t arg2 ; + u_int32_t arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (db_timeout_t)jarg2; + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_timeout(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1tmp_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *arg2 = (char *) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_tmp_dir(arg1,(char const *)arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1tx_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_tx_max(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1app_1dispatch(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int (*arg2)(DB_ENV *,DBT *,DB_LSN *,db_recops) = (int (*)(DB_ENV *,DBT *,DB_LSN *,db_recops)) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + arg2 = (jarg2 == JNI_TRUE) ? __dbj_app_dispatch : NULL; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_app_dispatch(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1event_1notify(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + void (*arg2)(DB_ENV *,u_int32_t,void *) = (void (*)(DB_ENV *,u_int32_t,void *)) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + arg2 = (jarg2 == JNI_TRUE) ? __dbj_event_notify : NULL; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_event_notify(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1tx_1timestamp0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + time_t *arg2 = (time_t *) 0 ; + time_t time2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + time2 = (time_t)jarg2; + arg2 = &time2; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_tx_timestamp(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1verbose(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + int_bool arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + arg3 = (jarg3 == JNI_TRUE); + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_verbose(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT jobjectArray JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lk_1conflicts(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jobjectArray jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + struct __db_lk_conflicts result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = DbEnv_get_lk_conflicts(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + { + int i; + jbyteArray bytes; + + jresult = (*jenv)->NewObjectArray(jenv, + (jsize)(&result)->lk_modes, bytearray_class, NULL); + if (jresult == NULL) + return 0; /* an exception is pending */ + for (i = 0; i < (&result)->lk_modes; i++) { + bytes = (*jenv)->NewByteArray(jenv, (jsize)(&result)->lk_modes); + if (bytes == NULL) + return 0; /* an exception is pending */ + (*jenv)->SetByteArrayRegion(jenv, bytes, 0, (jsize)(&result)->lk_modes, + (jbyte *)((&result)->lk_conflicts + i * (&result)->lk_modes)); + (*jenv)->SetObjectArrayElement(jenv, jresult, (jsize)i, bytes); + } + } + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lk_1detect(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_get_lk_detect(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lk_1max_1locks(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_get_lk_max_locks(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lk_1max_1lockers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_get_lk_max_lockers(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lk_1max_1objects(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_get_lk_max_objects(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lk_1partitions(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_get_lk_partitions(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1lock_1detect(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + u_int32_t arg3 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int)DbEnv_lock_detect(arg1,arg2,arg3); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT 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) { + jlong jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + u_int32_t arg3 ; + DBT *arg4 = (DBT *) 0 ; + db_lockmode_t arg5 ; + DBT_LOCKED ldbt4 ; + DB_LOCK *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + arg3 = (u_int32_t)jarg3; + + if (__dbj_dbt_copyin(jenv, &ldbt4, &arg4, jarg4, 0) != 0) { + return 0; /* An exception will be pending. */ + } + arg5 = (db_lockmode_t)jarg5; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_LOCK *)DbEnv_lock_get(arg1,arg2,arg3,arg4,arg5); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + *(DB_LOCK **)&jresult = result; + __dbj_dbt_release(jenv, jarg4, arg4, &ldbt4); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1lock_1id(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_lock_id(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1lock_1id_1free(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_lock_id_free(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1lock_1put(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + DB_LOCK *arg2 = (DB_LOCK *) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = *(DB_LOCK **)&jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_lock_put(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1lock_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jobject jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + DB_LOCK_STAT *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_LOCK_STAT *)DbEnv_lock_stat(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + + jresult = (*jenv)->NewObject(jenv, lock_stat_class, lock_stat_construct); + if (jresult != NULL) + __dbj_fill_lock_stat(jenv, jresult, result); + __os_ufree(NULL, result); + + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lk_1conflicts(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + struct __db_lk_conflicts arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + { + int i, len, err; + size_t bytesize; + + len = (&arg2)->lk_modes = (*jenv)->GetArrayLength(jenv, jarg2); + bytesize = sizeof(u_char) * len * len; + + if ((err = __os_malloc(NULL, bytesize, &(&arg2)->lk_conflicts)) != 0) { + __dbj_throw(jenv, err, NULL, NULL, JDBENV); + return ; + } + + for (i = 0; i < len; i++) { + jobject sub_array = (*jenv)->GetObjectArrayElement(jenv, + jarg2, i); + (*jenv)->GetByteArrayRegion(jenv,(jbyteArray)sub_array, 0, len, + (jbyte *)&(&arg2)->lk_conflicts[i * len]); + } + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_lk_conflicts(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + + __os_free(NULL, (&arg2)->lk_conflicts); + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lk_1detect(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_lk_detect(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lk_1max_1lockers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_lk_max_lockers(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lk_1max_1locks(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_lk_max_locks(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lk_1max_1objects(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_lk_max_objects(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lk_1partitions(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_lk_partitions(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lg_1bsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_get_lg_bsize(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lg_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (char *)DbEnv_get_lg_dir(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lg_1filemode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int)DbEnv_get_lg_filemode(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lg_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_get_lg_max(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1lg_1regionmax(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_get_lg_regionmax(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jobjectArray JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1archive(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jobjectArray jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + char **result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (char **)DbEnv_log_archive(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + { + if (result != NULL) { + /*@SWIG:../libdb_java/java_typemaps.i,367,STRING_ARRAY_OUT@*/ int i, len; + + len = 0; + while (result[len] != NULL) + len++; + if ((jresult = (*jenv)->NewObjectArray(jenv, (jsize)len, string_class, + NULL)) == NULL) + return 0; /* an exception is pending */ + for (i = 0; i < len; i++) { + jstring str = (*jenv)->NewStringUTF(jenv, result[i]); + (*jenv)->SetObjectArrayElement(jenv, jresult, (jsize)i, str); + } + /*@SWIG@*/ + __os_ufree(NULL, result); + } + } + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1compare(JNIEnv *jenv, jclass jcls, jobject jarg1, jobject jarg2) { + jint jresult = 0 ; + DB_LSN *arg1 = (DB_LSN *) 0 ; + DB_LSN *arg2 = (DB_LSN *) 0 ; + DB_LSN lsn1 ; + DB_LSN lsn2 ; + int result; + + (void)jenv; + (void)jcls; + + if (jarg1 == NULL) { + arg1 = NULL; + } else { + arg1 = &lsn1; + arg1->file = (*jenv)->GetIntField(jenv, jarg1, dblsn_file_fid); + arg1->offset = (*jenv)->GetIntField(jenv, jarg1, + dblsn_offset_fid); + } + + + if (jarg2 == NULL) { + arg2 = NULL; + } else { + arg2 = &lsn2; + arg2->file = (*jenv)->GetIntField(jenv, jarg2, dblsn_file_fid); + arg2->offset = (*jenv)->GetIntField(jenv, jarg2, + dblsn_offset_fid); + } + + + if (arg1 == NULL) { + __dbj_throw(jenv, EINVAL, "null LogSequenceNumber", NULL, NULL); + return 0; + } + + + if (arg2 == NULL) { + __dbj_throw(jenv, EINVAL, "null LogSequenceNumber", NULL, NULL); + return 0; + } + + result = (int)DbEnv_log_compare((struct DbLsn const *)arg1,(struct DbLsn const *)arg2); + jresult = (jint)result; + + if (jarg1 != NULL) { + (*jenv)->SetIntField(jenv, jarg1, dblsn_file_fid, arg1->file); + (*jenv)->SetIntField(jenv, jarg1, + dblsn_offset_fid, arg1->offset); + } + + + if (jarg2 != NULL) { + (*jenv)->SetIntField(jenv, jarg2, dblsn_file_fid, arg2->file); + (*jenv)->SetIntField(jenv, jarg2, + dblsn_offset_fid, arg2->offset); + } + + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1cursor(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jlong jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + DB_LOGC *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_LOGC *)DbEnv_log_cursor(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + *(DB_LOGC **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { + jstring jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + DB_LSN *arg2 = (DB_LSN *) 0 ; + DB_LSN lsn2 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg2 == NULL) { + arg2 = NULL; + } else { + arg2 = &lsn2; + arg2->file = (*jenv)->GetIntField(jenv, jarg2, dblsn_file_fid); + arg2->offset = (*jenv)->GetIntField(jenv, jarg2, + dblsn_offset_fid); + } + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + if (arg2 == NULL) { + __dbj_throw(jenv, EINVAL, "null LogSequenceNumber", NULL, NULL); + return 0; + } + + + errno = 0; + result = (char *)DbEnv_log_file(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + + if (jarg2 != NULL) { + (*jenv)->SetIntField(jenv, jarg2, dblsn_file_fid, arg2->file); + (*jenv)->SetIntField(jenv, jarg2, + dblsn_offset_fid, arg2->offset); + } + + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1flush(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + DB_LSN *arg2 = (DB_LSN *) 0 ; + DB_LSN lsn2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg2 == NULL) { + arg2 = NULL; + } else { + arg2 = &lsn2; + arg2->file = (*jenv)->GetIntField(jenv, jarg2, dblsn_file_fid); + arg2->offset = (*jenv)->GetIntField(jenv, jarg2, + dblsn_offset_fid); + } + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + + result = (db_ret_t)DbEnv_log_flush(arg1,(struct DbLsn const *)arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + + if (jarg2 != NULL) { + (*jenv)->SetIntField(jenv, jarg2, dblsn_file_fid, arg2->file); + (*jenv)->SetIntField(jenv, jarg2, + dblsn_offset_fid, arg2->offset); + } + +} + + +SWIGEXPORT jboolean JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1get_1config(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jboolean jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + int_bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int_bool)DbEnv_log_get_config(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (result) ? JNI_TRUE : JNI_FALSE; + return jresult; +} + + +SWIGEXPORT 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) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + DB_LSN *arg2 = (DB_LSN *) 0 ; + DBT *arg3 = (DBT *) 0 ; + u_int32_t arg4 ; + DB_LSN lsn2 ; + DBT_LOCKED ldbt3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg2 == NULL) { + arg2 = NULL; + } else { + arg2 = &lsn2; + arg2->file = (*jenv)->GetIntField(jenv, jarg2, dblsn_file_fid); + arg2->offset = (*jenv)->GetIntField(jenv, jarg2, + dblsn_offset_fid); + } + + + if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { + return ; /* An exception will be pending. */ + } + arg4 = (u_int32_t)jarg4; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + if (arg2 == NULL) { + __dbj_throw(jenv, EINVAL, "null LogSequenceNumber", NULL, NULL); + return ; + } + + + result = (db_ret_t)DbEnv_log_put(arg1,arg2,(struct Dbt const *)arg3,arg4); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + + if (jarg2 != NULL) { + (*jenv)->SetIntField(jenv, jarg2, dblsn_file_fid, arg2->file); + (*jenv)->SetIntField(jenv, jarg2, + dblsn_offset_fid, arg2->offset); + } + + __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); +} + + +SWIGEXPORT 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) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + char *arg3 = (char *) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + arg3 = 0; + if (jarg3) { + arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0); + if (!arg3) return ; + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_log_print(arg1,arg2,(char const *)arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, (const char *)arg3); +} + + +SWIGEXPORT 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) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + int_bool arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + arg3 = (jarg3 == JNI_TRUE); + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_log_set_config(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1log_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jobject jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + DB_LOG_STAT *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_LOG_STAT *)DbEnv_log_stat(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + + jresult = (*jenv)->NewObject(jenv, log_stat_class, log_stat_construct); + if (jresult != NULL) + __dbj_fill_log_stat(jenv, jresult, result); + __os_ufree(NULL, result); + + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lg_1bsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_lg_bsize(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lg_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *arg2 = (char *) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_lg_dir(arg1,(char const *)arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lg_1filemode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (int)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_lg_filemode(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lg_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_lg_max(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1set_1lg_1regionmax(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_set_lg_regionmax(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1cachesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + jlong result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = DbEnv_get_cachesize(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1cachesize_1ncache(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int)DbEnv_get_cachesize_ncache(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1cache_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + jlong result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = DbEnv_get_cache_max(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1create_1dir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (char *)DbEnv_get_create_dir(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1mp_1max_1openfd(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int)DbEnv_get_mp_max_openfd(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1mp_1max_1write(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int)DbEnv_get_mp_max_write(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1mp_1max_1write_1sleep(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + db_timeout_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (db_timeout_t)DbEnv_get_mp_max_write_sleep(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1mp_1mmapsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = DbEnv_get_mp_mmapsize(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1mp_1pagesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int)DbEnv_get_mp_pagesize(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1mp_1tablesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int)DbEnv_get_mp_tablesize(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1memp_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jobject jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + DB_MPOOL_STAT *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_MPOOL_STAT *)DbEnv_memp_stat(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + + jresult = (*jenv)->NewObject(jenv, mpool_stat_class, mpool_stat_construct); + if (jresult != NULL) + __dbj_fill_mpool_stat(jenv, jresult, result); + __os_ufree(NULL, result); + + return jresult; +} + + +SWIGEXPORT jobjectArray JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1memp_1fstat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jobjectArray jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + DB_MPOOL_FSTAT **result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_MPOOL_FSTAT **)DbEnv_memp_fstat(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + { + int i, len; + + len = 0; + while (result[len] != NULL) + len++; + jresult = (*jenv)->NewObjectArray(jenv, (jsize)len, + mpool_fstat_class, 0); + if (jresult == NULL) { + __os_ufree(NULL, result); + return 0; + } + for (i = 0; i < len; i++) { + jobject obj = (*jenv)->NewObject(jenv, mpool_fstat_class, + mpool_fstat_construct); + if (obj == NULL) { + __os_ufree(NULL, result); + return 0; /* an exception is pending */ + } + (*jenv)->SetObjectArrayElement(jenv, jresult, i, obj); + __dbj_fill_mpool_fstat(jenv, obj, result[i]); + } + __os_ufree(NULL, result); + } + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1memp_1sync(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + DB_LSN *arg2 = (DB_LSN *) 0 ; + DB_LSN lsn2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg2 == NULL) { + arg2 = NULL; + } else { + arg2 = &lsn2; + arg2->file = (*jenv)->GetIntField(jenv, jarg2, dblsn_file_fid); + arg2->offset = (*jenv)->GetIntField(jenv, jarg2, + dblsn_offset_fid); + } + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + if (arg2 == NULL) { + __dbj_throw(jenv, EINVAL, "null LogSequenceNumber", NULL, NULL); + return ; + } + + + errno = 0; + result = (db_ret_t)DbEnv_memp_sync(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + + if (jarg2 != NULL) { + (*jenv)->SetIntField(jenv, jarg2, dblsn_file_fid, arg2->file); + (*jenv)->SetIntField(jenv, jarg2, + dblsn_offset_fid, arg2->offset); + } + +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1memp_1trickle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int arg2 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (int)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int)DbEnv_memp_trickle(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1get_1align(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_mutex_get_align(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1get_1increment(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_mutex_get_increment(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1get_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_mutex_get_max(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1get_1tas_1spins(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_mutex_get_tas_spins(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1set_1align(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_mutex_set_align(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1set_1increment(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_mutex_set_increment(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1set_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_mutex_set_max(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1set_1tas_1spins(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_mutex_set_tas_spins(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1mutex_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jobject jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + DB_MUTEX_STAT *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_MUTEX_STAT *)DbEnv_mutex_stat(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + + jresult = (*jenv)->NewObject(jenv, mutex_stat_class, mutex_stat_construct); + if (jresult != NULL) + __dbj_fill_mutex_stat(jenv, jresult, result); + __os_ufree(NULL, result); + + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1tx_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_get_tx_max(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1tx_1timestamp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + time_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = DbEnv_get_tx_timestamp(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1timeout(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jlong jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_timeout_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (db_timeout_t)DbEnv_get_timeout(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT 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) { + jlong jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + u_int32_t arg3 ; + DB_TXN *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_TXN *)DbEnv_txn_begin(arg1,arg2,arg3); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + *(DB_TXN **)&jresult = result; + return jresult; +} + + +SWIGEXPORT 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) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + u_int32_t arg3 ; + u_int32_t arg4 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + arg3 = (u_int32_t)jarg3; + arg4 = (u_int32_t)jarg4; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_txn_checkpoint(arg1,arg2,arg3,arg4); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT jobjectArray JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1txn_1recover(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { + jobjectArray jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int arg2 ; + u_int32_t arg3 ; + DB_PREPLIST *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (int)jarg2; + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_PREPLIST *)DbEnv_txn_recover(arg1,arg2,arg3); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + { + int i, len; + + len = 0; + while (result[len].txn != NULL) + len++; + jresult = (*jenv)->NewObjectArray(jenv, (jsize)len, dbpreplist_class, + NULL); + if (jresult == NULL) + return 0; /* an exception is pending */ + for (i = 0; i < len; i++) { + jobject jtxn = (*jenv)->NewObject(jenv, dbtxn_class, + dbtxn_construct, result[i].txn, JNI_FALSE); + jobject bytearr = (*jenv)->NewByteArray(jenv, + (jsize)sizeof(result[i].gid)); + jobject obj = (*jenv)->NewObject(jenv, dbpreplist_class, + dbpreplist_construct, jtxn, bytearr); + + if (jtxn == NULL || bytearr == NULL || obj == NULL) + return 0; /* An exception is pending */ + + (*jenv)->SetByteArrayRegion(jenv, bytearr, 0, + (jsize)sizeof(result[i].gid), (jbyte *)result[i].gid); + (*jenv)->SetObjectArrayElement(jenv, jresult, i, obj); + } + __os_ufree(NULL, result); + } + return jresult; +} + + +SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1txn_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jobject jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + DB_TXN_STAT *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_TXN_STAT *)DbEnv_txn_stat(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + { + unsigned int i; + jobjectArray actives; + jresult = (*jenv)->NewObject(jenv, txn_stat_class, txn_stat_construct); + if (jresult != NULL) + __dbj_fill_txn_stat(jenv, jresult, result); + + actives = (*jenv)->NewObjectArray(jenv, (jsize)result->st_nactive, + txn_active_class, 0); + if (actives == NULL) { + __os_ufree(NULL, result); + return 0; + } + (*jenv)->SetObjectField(jenv, jresult, + txn_stat_st_txnarray_fid, actives); + for (i = 0; i < result->st_nactive; i++) { + jobject obj = (*jenv)->NewObject(jenv, txn_active_class, + txn_active_construct); + if (obj == NULL) { + __os_ufree(NULL, result); + return 0; /* an exception is pending */ + } + (*jenv)->SetObjectArrayElement(jenv, actives, (jsize)i, obj); + __dbj_fill_txn_active(jenv, obj, &result->st_txnarray[i]); + } + __os_ufree(NULL, result); + } + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1limit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + jlong result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = DbEnv_rep_get_limit(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT 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) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + int arg3 ; + u_int32_t arg4 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + arg3 = (int)jarg3; + arg4 = (u_int32_t)jarg4; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_rep_elect(arg1,arg2,arg3,arg4); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT 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) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + DBT *arg2 = (DBT *) 0 ; + DBT *arg3 = (DBT *) 0 ; + int arg4 ; + DB_LSN *arg5 = (DB_LSN *) 0 ; + DBT_LOCKED ldbt2 ; + DBT_LOCKED ldbt3 ; + DB_LSN lsn5 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (__dbj_dbt_copyin(jenv, &ldbt2, &arg2, jarg2, 0) != 0) { + return 0; /* An exception will be pending. */ + } + + if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { + return 0; /* An exception will be pending. */ + } + arg4 = (int)jarg4; + + if (jarg5 == NULL) { + arg5 = NULL; + } else { + arg5 = &lsn5; + arg5->file = (*jenv)->GetIntField(jenv, jarg5, dblsn_file_fid); + arg5->offset = (*jenv)->GetIntField(jenv, jarg5, + dblsn_offset_fid); + } + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + if (arg5 == NULL) { + __dbj_throw(jenv, EINVAL, "null LogSequenceNumber", NULL, NULL); + return 0; + } + + + result = (int)DbEnv_rep_process_message(arg1,arg2,arg3,arg4,arg5); + if (!DB_RETOK_REPPMSG(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + __dbj_dbt_release(jenv, jarg2, arg2, &ldbt2); + __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); + + if (jarg5 != NULL) { + (*jenv)->SetIntField(jenv, jarg5, dblsn_file_fid, arg5->file); + (*jenv)->SetIntField(jenv, jarg5, + dblsn_offset_fid, arg5->offset); + } + + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1flush(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_rep_flush(arg1); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT 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) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + int_bool arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + arg3 = (jarg3 == JNI_TRUE); + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_rep_set_config(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT 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) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + u_int32_t arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_rep_set_clockskew(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1clockskew_1fast(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_rep_get_clockskew_fast(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1clockskew_1slow(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_rep_get_clockskew_slow(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1start(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jint jarg3) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + DBT *arg2 = (DBT *) 0 ; + u_int32_t arg3 ; + DBT_LOCKED ldbt2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (__dbj_dbt_copyin(jenv, &ldbt2, &arg2, jarg2, 1) != 0) { + return ; /* An exception will be pending. */ + } + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_rep_start(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + __dbj_dbt_release(jenv, jarg2, arg2, &ldbt2); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1sync(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_rep_sync(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT jboolean JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1config(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jboolean jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + int_bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int_bool)DbEnv_rep_get_config(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (result) ? JNI_TRUE : JNI_FALSE; + return jresult; +} + + +SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jobject jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + DB_REP_STAT *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_REP_STAT *)DbEnv_rep_stat(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + + jresult = (*jenv)->NewObject(jenv, rep_stat_class, rep_stat_construct); + if (jresult != NULL) + __dbj_fill_rep_stat(jenv, jresult, result); + __os_ufree(NULL, result); + + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1set_1limit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + jlong arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_rep_set_limit(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1request_1min(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_rep_get_request_min(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1request_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_rep_get_request_max(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT 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) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + u_int32_t arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_rep_set_request(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT 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) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int arg2 ; + 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 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (int)jarg2; + + arg3 = (jarg3 == JNI_TRUE) ? __dbj_rep_transport : NULL; + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_rep_set_transport(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1nsites(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_rep_get_nsites(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1priority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_rep_get_priority(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1get_1timeout(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int arg2 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (int)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbEnv_rep_get_timeout(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1set_1nsites(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_rep_set_nsites(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1rep_1set_1priority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_rep_set_priority(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT 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) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int arg2 ; + db_timeout_t arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (int)jarg2; + arg3 = (db_timeout_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_rep_set_timeout(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT 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) { + jint jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *arg2 = (char *) 0 ; + u_int32_t arg3 ; + u_int32_t arg4 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return 0; + } + arg3 = (u_int32_t)jarg3; + arg4 = (u_int32_t)jarg4; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int)DbEnv_repmgr_add_remote_site(arg1,(char const *)arg2,arg3,arg4); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + jresult = (jint)result; + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1repmgr_1get_1ack_1policy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_repmgr_get_ack_policy(arg1); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1repmgr_1set_1ack_1policy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (int)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_repmgr_set_ack_policy(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT 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) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + char *arg2 = (char *) 0 ; + u_int32_t arg3 ; + u_int32_t arg4 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + arg3 = (u_int32_t)jarg3; + arg4 = (u_int32_t)jarg4; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_repmgr_set_local_site(arg1,(char const *)arg2,arg3,arg4); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +SWIGEXPORT jobjectArray JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1repmgr_1site_1list(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jobjectArray jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + struct __db_repmgr_sites result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = DbEnv_repmgr_site_list(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + { + int i, len; + jobject jrep_addr, jrep_info; + + len = (&result)->nsites; + jresult = (*jenv)->NewObjectArray(jenv, (jsize)len, repmgr_siteinfo_class, + NULL); + if (jresult == NULL) + return 0; /* an exception is pending */ + for (i = 0; i < len; i++) { + jstring addr_host = (*jenv)->NewStringUTF(jenv, (&result)->sites[i].host); + if (addr_host == NULL) + return 0; /* An exception is pending */ + jrep_addr = (*jenv)->NewObject(jenv, + rephost_class, rephost_construct, addr_host, (&result)->sites[i].port); + if (jrep_addr == NULL) + return 0; /* An exception is pending */ + + jrep_info = (*jenv)->NewObject(jenv, + repmgr_siteinfo_class, repmgr_siteinfo_construct, jrep_addr, (&result)->sites[i].eid); + (*jenv)->SetIntField(jenv, jrep_info, repmgr_siteinfo_status_fid, + (&result)->sites[i].status); + if (jrep_info == NULL) + return 0; /* An exception is pending */ + + (*jenv)->SetObjectArrayElement(jenv, jresult, i, jrep_info); + } + __os_ufree(NULL, (&result)->sites); + } + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1repmgr_1start(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + int arg2 ; + u_int32_t arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (int)jarg2; + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbEnv_repmgr_start(arg1,arg2,arg3); + if (!DB_RETOK_REPMGR_START(result)) { + __dbj_throw(jenv, result, NULL, NULL, JDBENV); + } + +} + + +SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1repmgr_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jobject jresult = 0 ; + struct DbEnv *arg1 = (struct DbEnv *) 0 ; + u_int32_t arg2 ; + DB_REPMGR_STAT *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbEnv **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_REPMGR_STAT *)DbEnv_repmgr_stat(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } + + + jresult = (*jenv)->NewObject(jenv, repmgr_stat_class, repmgr_stat_construct); + if (jresult != NULL) + __dbj_fill_repmgr_stat(jenv, jresult, result); + __os_ufree(NULL, result); + + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1strerror(JNIEnv *jenv, jclass jcls, jint jarg1) { + jstring jresult = 0 ; + int arg1 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (int)jarg1; + result = (char *)DbEnv_strerror(arg1); + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1version_1major(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)DbEnv_get_version_major(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1version_1minor(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)DbEnv_get_version_minor(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1version_1patch(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)DbEnv_get_version_patch(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1get_1version_1string(JNIEnv *jenv, jclass jcls) { + jstring jresult = 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + result = (char *)DbEnv_get_version_string(); + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_delete_1DbLock(JNIEnv *jenv, jclass jcls, jlong jarg1) { + struct DbLock *arg1 = (struct DbLock *) 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(struct DbLock **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + delete_DbLock(arg1); +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbLogc_1close0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbLogc *arg1 = (struct DbLogc *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbLogc **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbLogc_close(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + +} + + +SWIGEXPORT 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) { + jint jresult = 0 ; + struct DbLogc *arg1 = (struct DbLogc *) 0 ; + DB_LSN *arg2 = (DB_LSN *) 0 ; + DBT *arg3 = (DBT *) 0 ; + u_int32_t arg4 ; + DB_LSN lsn2 ; + DBT_LOCKED ldbt3 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbLogc **)&jarg1; + + if (jarg2 == NULL) { + arg2 = NULL; + } else { + arg2 = &lsn2; + arg2->file = (*jenv)->GetIntField(jenv, jarg2, dblsn_file_fid); + arg2->offset = (*jenv)->GetIntField(jenv, jarg2, + dblsn_offset_fid); + } + + + if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { + return 0; /* An exception will be pending. */ + } + arg4 = (u_int32_t)jarg4; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + if (arg2 == NULL) { + __dbj_throw(jenv, EINVAL, "null LogSequenceNumber", NULL, NULL); + return 0; + } + + + result = (int)DbLogc_get(arg1,arg2,arg3,arg4); + if (!DB_RETOK_LGGET(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + + jresult = (jint)result; + + if (jarg2 != NULL) { + (*jenv)->SetIntField(jenv, jarg2, dblsn_file_fid, arg2->file); + (*jenv)->SetIntField(jenv, jarg2, + dblsn_offset_fid, arg2->offset); + } + + __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbLogc_1version(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jint jresult = 0 ; + struct DbLogc *arg1 = (struct DbLogc *) 0 ; + u_int32_t arg2 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbLogc **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbLogc_version(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, NULL); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbMpoolFile_1get_1priority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbMpoolFile *arg1 = (struct DbMpoolFile *) 0 ; + DB_CACHE_PRIORITY result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbMpoolFile **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_CACHE_PRIORITY)DbMpoolFile_get_priority(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, NULL); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbMpoolFile_1set_1priority(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbMpoolFile *arg1 = (struct DbMpoolFile *) 0 ; + DB_CACHE_PRIORITY arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbMpoolFile **)&jarg1; + arg2 = (DB_CACHE_PRIORITY)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbMpoolFile_set_priority(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbMpoolFile_1get_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbMpoolFile *arg1 = (struct DbMpoolFile *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbMpoolFile **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbMpoolFile_get_flags(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, NULL); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbMpoolFile_1set_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) { + struct DbMpoolFile *arg1 = (struct DbMpoolFile *) 0 ; + u_int32_t arg2 ; + int_bool arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbMpoolFile **)&jarg1; + arg2 = (u_int32_t)jarg2; + arg3 = (jarg3 == JNI_TRUE); + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbMpoolFile_set_flags(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbMpoolFile_1get_1maxsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + struct DbMpoolFile *arg1 = (struct DbMpoolFile *) 0 ; + jlong result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbMpoolFile **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = DbMpoolFile_get_maxsize(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, NULL); + } + + jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbMpoolFile_1set_1maxsize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + struct DbMpoolFile *arg1 = (struct DbMpoolFile *) 0 ; + jlong arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbMpoolFile **)&jarg1; + arg2 = jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbMpoolFile_set_maxsize(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_new_1DbSequence(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jlong jresult = 0 ; + DB *arg1 = (DB *) 0 ; + u_int32_t arg2 ; + struct DbSequence *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(DB **)&jarg1; + arg2 = (u_int32_t)jarg2; + + errno = 0; + result = (struct DbSequence *)new_DbSequence(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, NULL); + } + + *(struct DbSequence **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1close0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbSequence *arg1 = (struct DbSequence *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbSequence **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbSequence_close(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + +} + + +SWIGEXPORT 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) { + jlong jresult = 0 ; + struct DbSequence *arg1 = (struct DbSequence *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + int32_t arg3 ; + u_int32_t arg4 ; + db_seq_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct DbSequence **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + arg3 = (int32_t)jarg3; + arg4 = (u_int32_t)jarg4; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (db_seq_t)DbSequence_get(arg1,arg2,arg3,arg4); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, NULL); + } + + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1get_1cachesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbSequence *arg1 = (struct DbSequence *) 0 ; + int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbSequence **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (int32_t)DbSequence_get_cachesize(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, NULL); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1get_1db(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + struct DbSequence *arg1 = (struct DbSequence *) 0 ; + DB *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbSequence **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB *)DbSequence_get_db(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, NULL); + } + + *(DB **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1get_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbSequence *arg1 = (struct DbSequence *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbSequence **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (u_int32_t)DbSequence_get_flags(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, NULL); + } + + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1get_1key(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) { + struct DbSequence *arg1 = (struct DbSequence *) 0 ; + DBT *arg2 = (DBT *) 0 ; + DBT_LOCKED ldbt2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbSequence **)&jarg1; + + if (__dbj_dbt_copyin(jenv, &ldbt2, &arg2, jarg2, 0) != 0) { + return ; /* An exception will be pending. */ + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbSequence_get_key(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + + __dbj_dbt_release(jenv, jarg2, arg2, &ldbt2); +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1get_1range_1min(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + struct DbSequence *arg1 = (struct DbSequence *) 0 ; + db_seq_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbSequence **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (db_seq_t)DbSequence_get_range_min(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, NULL); + } + + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1get_1range_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + struct DbSequence *arg1 = (struct DbSequence *) 0 ; + db_seq_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbSequence **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (db_seq_t)DbSequence_get_range_max(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, NULL); + } + + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1initial_1value(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + struct DbSequence *arg1 = (struct DbSequence *) 0 ; + db_seq_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbSequence **)&jarg1; + arg2 = (db_seq_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbSequence_initial_value(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + +} + + +SWIGEXPORT 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) { + struct DbSequence *arg1 = (struct DbSequence *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + DBT *arg3 = (DBT *) 0 ; + u_int32_t arg4 ; + DBT_LOCKED ldbt3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct DbSequence **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + + if (__dbj_dbt_copyin(jenv, &ldbt3, &arg3, jarg3, 0) != 0) { + return ; /* An exception will be pending. */ + } + arg4 = (u_int32_t)jarg4; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbSequence_open(arg1,arg2,arg3,arg4); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + + __dbj_dbt_release(jenv, jarg3, arg3, &ldbt3); +} + + +SWIGEXPORT 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) { + struct DbSequence *arg1 = (struct DbSequence *) 0 ; + DB_TXN *arg2 = (DB_TXN *) 0 ; + u_int32_t arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(struct DbSequence **)&jarg1; + arg2 = *(DB_TXN **)&jarg2; + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbSequence_remove(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1set_1cachesize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbSequence *arg1 = (struct DbSequence *) 0 ; + int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbSequence **)&jarg1; + arg2 = (int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbSequence_set_cachesize(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1set_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbSequence *arg1 = (struct DbSequence *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbSequence **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbSequence_set_flags(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1set_1range(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { + struct DbSequence *arg1 = (struct DbSequence *) 0 ; + db_seq_t arg2 ; + db_seq_t arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbSequence **)&jarg1; + arg2 = (db_seq_t)jarg2; + arg3 = (db_seq_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbSequence_set_range(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + +} + + +SWIGEXPORT jobject JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbSequence_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jobject jresult = 0 ; + struct DbSequence *arg1 = (struct DbSequence *) 0 ; + u_int32_t arg2 ; + DB_SEQUENCE_STAT *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbSequence **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (DB_SEQUENCE_STAT *)DbSequence_stat(arg1,arg2); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, NULL); + } + + + jresult = (*jenv)->NewObject(jenv, seq_stat_class, seq_stat_construct); + if (jresult != NULL) + __dbj_fill_seq_stat(jenv, jresult, result); + __os_ufree(NULL, result); + + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbTxn_1abort0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + struct DbTxn *arg1 = (struct DbTxn *) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbTxn **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbTxn_abort(arg1); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbTxn_1commit0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbTxn *arg1 = (struct DbTxn *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbTxn **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbTxn_commit(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbTxn_1discard0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + struct DbTxn *arg1 = (struct DbTxn *) 0 ; + u_int32_t arg2 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbTxn **)&jarg1; + arg2 = (u_int32_t)jarg2; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbTxn_discard(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, NULL); + } + +} + + +SWIGEXPORT jstring JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbTxn_1get_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + struct DbTxn *arg1 = (struct DbTxn *) 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbTxn **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + + errno = 0; + result = (char *)DbTxn_get_name(arg1); + if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, TXN2JDBENV); + } + + if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbTxn_1id(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + struct DbTxn *arg1 = (struct DbTxn *) 0 ; + u_int32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbTxn **)&jarg1; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return 0; + } + result = (u_int32_t)DbTxn_id(arg1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbTxn_1prepare(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jbyteArray jarg2) { + struct DbTxn *arg1 = (struct DbTxn *) 0 ; + u_int8_t *arg2 = (u_int8_t *) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbTxn **)&jarg1; + + arg2 = (u_int8_t *)(*jenv)->GetByteArrayElements(jenv, jarg2, NULL); + + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + if ((*jenv)->GetArrayLength(jenv, jarg2) < DB_GID_SIZE) { + __dbj_throw(jenv, EINVAL, + "DbTxn.prepare gid array must be >= 128 bytes", NULL, + TXN2JDBENV); + return ; + } + + + result = (db_ret_t)DbTxn_prepare(arg1,arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, TXN2JDBENV); + } + + + (*jenv)->ReleaseByteArrayElements(jenv, jarg2, (jbyte *)arg2, 0); + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbTxn_1set_1timeout(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3) { + struct DbTxn *arg1 = (struct DbTxn *) 0 ; + db_timeout_t arg2 ; + u_int32_t arg3 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbTxn **)&jarg1; + arg2 = (db_timeout_t)jarg2; + arg3 = (u_int32_t)jarg3; + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbTxn_set_timeout(arg1,arg2,arg3); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, TXN2JDBENV); + } + +} + + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_DbTxn_1set_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + struct DbTxn *arg1 = (struct DbTxn *) 0 ; + char *arg2 = (char *) 0 ; + db_ret_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(struct DbTxn **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0); + if (!arg2) return ; + } + + if (jarg1 == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return ; + } + + result = (db_ret_t)DbTxn_set_name(arg1,(char const *)arg2); + if (!DB_RETOK_STD(result)) { + __dbj_throw(jenv, result, NULL, NULL, TXN2JDBENV); + } + + if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, (const char *)arg2); +} + + +#ifdef __cplusplus +} +#endif + diff --git a/libdb_java/java-post.pl b/libdb_java/java-post.pl new file mode 100644 index 0000000..f54d392 --- /dev/null +++ b/libdb_java/java-post.pl @@ -0,0 +1,23 @@ +#!/usr/bin/env perl -p + +# Hide some symbols +s!public (class db_java|[^(]* delete|[^(]* [A-Za-z_]*0\()!/* package */ $1!; + +# Mark methods that don't throw exceptions +s!public [^(]*get_version_[a-z]*\([^)]*\)!$& /* no exception */!; +s!public [^(]*[ _]err[a-z_]*\([^)]*\)!$& /* no exception */!; +s!public [^(]*[ _]msg[a-z_]*\([^)]*\)!$& /* no exception */!; +s!public [^(]*[ _]message[a-z_]*\([^)]*\)!$& /* no exception */!; +s!public [^(]*[ _]strerror\([^)]*\)!$& /* no exception */!; +s!public [^(]*log_compare\([^)]*\)!$& /* no exception */!; +s!public [^(]* feedback\([^)]*\)!$& /* no exception */!; + +# Mark methods that throw special exceptions +m/DbSequence/ || s!(public [^(]*(open|remove|rename)0?\([^)]*\))( {|;)!$1 throws com.sleepycat.db.DatabaseException, java.io.FileNotFoundException$3!; + +# Everything else throws a DbException +s!(public [^(]*\([^)]*\))(;| {)!$1 throws com.sleepycat.db.DatabaseException$2!; + +# Add initialize methods for Java parts of Db and DbEnv +s!\.new_DbEnv\(.*$!$&\n initialize();!; +s!\.new_Db\(.*$!$&\n initialize(dbenv);!; diff --git a/libdb_java/java_callbacks.i b/libdb_java/java_callbacks.i new file mode 100644 index 0000000..b854fd1 --- /dev/null +++ b/libdb_java/java_callbacks.i @@ -0,0 +1,930 @@ +/* Callbacks */ +%define JAVA_CALLBACK(_sig, _jclass, _name) +JAVA_TYPEMAP(_sig, _jclass, jboolean) +%typemap(jtype) _sig "boolean" +%typemap(javain) _sig %{ (_name##_handler = $javainput) != null %} + +/* + * The Java object is stored in the Db or DbEnv class. + * Here we only care whether it is non-NULL. + */ +%typemap(in) _sig %{ + $1 = ($input == JNI_TRUE) ? __dbj_##_name : NULL; +%} +%enddef + +%{ +static void __dbj_error(const DB_ENV *dbenv, + const char *prefix, const char *msg) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); + jobject jmsg; + + COMPQUIET(prefix, NULL); + + if (jdbenv != NULL){ + jmsg = (*jenv)->NewStringUTF(jenv, msg); + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, dbenv_class, + errcall_method, jmsg); + (*jenv)->DeleteLocalRef(jenv, jmsg); + } + + if (detach) + __dbj_detach(); +} + +static void __dbj_env_feedback(DB_ENV *dbenv, int opcode, int percent) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); + + if (jdbenv != NULL) + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, dbenv_class, + env_feedback_method, opcode, percent); + + if (detach) + __dbj_detach(); +} + +static void __dbj_message(const DB_ENV *dbenv, const char *msg) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); + jobject jmsg; + + if (jdbenv != NULL){ + jmsg = (*jenv)->NewStringUTF(jenv, msg); + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, dbenv_class, + msgcall_method, jmsg); + (*jenv)->DeleteLocalRef(jenv, jmsg); + } + + if (detach) + __dbj_detach(); +} + +static void __dbj_panic(DB_ENV *dbenv, int err) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); + + if (jdbenv != NULL) + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, dbenv_class, + paniccall_method, + __dbj_get_except(jenv, err, NULL, NULL, jdbenv)); + + if (detach) + __dbj_detach(); +} + +static int __dbj_app_dispatch(DB_ENV *dbenv, + DBT *dbt, DB_LSN *lsn, db_recops recops) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); + jobject jdbt, jlsn; + jbyteArray jdbtarr; + int ret; + + if (jdbenv == NULL) { + ret = EINVAL; + goto err; + } + + jdbt = (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + __dbj_dbt_copyout(jenv, dbt, &jdbtarr, jdbt); + if (jdbt == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + + jlsn = (lsn == NULL) ? NULL : __dbj_wrap_DB_LSN(jenv, lsn); + + ret = (*jenv)->CallNonvirtualIntMethod(jenv, jdbenv, dbenv_class, + app_dispatch_method, jdbt, jlsn, recops); + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + } + + (*jenv)->DeleteLocalRef(jenv, jdbtarr); + (*jenv)->DeleteLocalRef(jenv, jdbt); + if (jlsn != NULL) + (*jenv)->DeleteLocalRef(jenv, jlsn); + +err: if (detach) + __dbj_detach(); + return (ret); +} + +static void __dbj_event_notify(DB_ENV *dbenv, u_int32_t event_id, void * info) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); + + if (jdbenv == NULL) + goto done; + + switch (event_id) { + case DB_EVENT_PANIC: + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, + dbenv_class, panic_event_notify_method); + break; + case DB_EVENT_REP_CLIENT: + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, + dbenv_class, rep_client_event_notify_method); + break; + case DB_EVENT_REP_ELECTED: + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, + dbenv_class, rep_elected_event_notify_method); + break; + case DB_EVENT_REP_MASTER: + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, + dbenv_class, rep_master_event_notify_method); + break; + case DB_EVENT_REP_NEWMASTER: + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, + dbenv_class, rep_new_master_event_notify_method, + *(int*)info); + break; + case DB_EVENT_REP_PERM_FAILED: + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, + dbenv_class, rep_perm_failed_event_notify_method); + break; + case DB_EVENT_REP_STARTUPDONE: + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, + dbenv_class, rep_startup_done_event_notify_method); + break; + case DB_EVENT_WRITE_FAILED: + (*jenv)->CallNonvirtualVoidMethod(jenv, jdbenv, + dbenv_class, write_failed_event_notify_method, + *(int*)info); + break; + default: + dbenv->errx(dbenv, "Unhandled event callback in the Java API"); + DB_ASSERT(dbenv->env, 0); + } + +done: if (detach) + __dbj_detach(); +} + +static int __dbj_rep_transport(DB_ENV *dbenv, + const DBT *control, const DBT *rec, const DB_LSN *lsn, int envid, + u_int32_t flags) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdbenv = (jobject)DB_ENV_INTERNAL(dbenv); + jobject jcontrol, jrec, jlsn; + jbyteArray jcontrolarr, jrecarr; + int ret; + + if (jdbenv == NULL) { + ret = EINVAL; + goto err; + } + + jcontrol = (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + jrec = (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + if (jcontrol == NULL || jrec == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + + __dbj_dbt_copyout(jenv, control, &jcontrolarr, jcontrol); + __dbj_dbt_copyout(jenv, rec, &jrecarr, jrec); + jlsn = (lsn == NULL) ? NULL : __dbj_wrap_DB_LSN(jenv, (DB_LSN *)lsn); + + if (jcontrolarr == NULL || jrecarr == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + + ret = (*jenv)->CallNonvirtualIntMethod(jenv, jdbenv, dbenv_class, + rep_transport_method, jcontrol, jrec, jlsn, envid, flags); + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + } + + (*jenv)->DeleteLocalRef(jenv, jrecarr); + (*jenv)->DeleteLocalRef(jenv, jcontrolarr); + (*jenv)->DeleteLocalRef(jenv, jrec); + (*jenv)->DeleteLocalRef(jenv, jcontrol); + if (jlsn != NULL) + (*jenv)->DeleteLocalRef(jenv, jlsn); + +err: if (detach) + __dbj_detach(); + return (ret); +} + +static int __dbj_foreignkey_nullify(DB *db, + const DBT *key, DBT *data, const DBT *skey, int *changed) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + DBT_LOCKED lresult; + jobject jdb = (jobject)DB_INTERNAL(db); + jobject jkey, jdata, jskey; + jbyteArray jkeyarr, jdataarr, jskeyarr; + jboolean jresult; + int ret; + + if (jdb == NULL) { + ret = EINVAL; + goto err; + } + + jkey = (key->app_data != NULL) ? + ((DBT_LOCKED *)key->app_data)->jdbt : + (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + jdata = (data->app_data != NULL) ? + ((DBT_LOCKED *)data->app_data)->jdbt : + (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + jskey = (skey->app_data != NULL) ? + ((DBT_LOCKED *)skey->app_data)->jdbt : + (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + if (jkey == NULL || jdata == NULL || jskey == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + + if (key->app_data == NULL) { + __dbj_dbt_copyout(jenv, key, &jkeyarr, jkey); + if (jkeyarr == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + } + if (data->app_data == NULL) { + __dbj_dbt_copyout(jenv, data, &jdataarr, jdata); + if (jdataarr == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + } + if (skey->app_data == NULL) { + __dbj_dbt_copyout(jenv, skey, &jskeyarr, jskey); + if (jskeyarr == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + } + + jresult = (*jenv)->CallNonvirtualBooleanMethod(jenv, jdb, db_class, foreignkey_nullify_method, jkey, jdata, jskey); + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + goto err; + } + + if (jresult == JNI_FALSE) + *changed = ret = 0; + else{ + *changed = 1; + /* copy jdata into data */ + if ((ret = __dbj_dbt_copyin(jenv, &lresult, NULL, jdata, 0)) != 0) + goto err; + if (lresult.dbt.size != 0){ + data->size = lresult.dbt.size; + if ((ret = __os_umalloc( + NULL, data->size, &data->data)) != 0) + goto err; + if ((ret = __dbj_dbt_memcopy(&lresult.dbt, 0, + data->data, data->size, DB_USERCOPY_GETDATA)) != 0) + goto err; + __dbj_dbt_release(jenv, jdata, &lresult.dbt, &lresult); + (*jenv)->DeleteLocalRef(jenv, lresult.jarr); + F_SET(data, DB_DBT_APPMALLOC); + } + } + +err: if (key->app_data == NULL) { + (*jenv)->DeleteLocalRef(jenv, jkeyarr); + (*jenv)->DeleteLocalRef(jenv, jkey); + } + if (data->app_data == NULL) { + (*jenv)->DeleteLocalRef(jenv, jdataarr); + (*jenv)->DeleteLocalRef(jenv, jdata); + } + + if (detach) + __dbj_detach(); + return ret; +} + +static int __dbj_seckey_create(DB *db, + const DBT *key, const DBT *data, DBT *result) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jobject jkey, jdata, jresult; + jobjectArray jskeys; + jsize i, num_skeys; + jbyteArray jkeyarr, jdataarr; + DBT_LOCKED lresult; + DBT *tresult; + int ret; + + if (jdb == NULL) { + ret = EINVAL; + goto err; + } + + jkey = (key->app_data != NULL) ? + ((DBT_LOCKED *)key->app_data)->jdbt : + (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + jdata = (data->app_data != NULL) ? + ((DBT_LOCKED *)data->app_data)->jdbt : + (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + if (jkey == NULL || jdata == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + + if (key->app_data == NULL) { + __dbj_dbt_copyout(jenv, key, &jkeyarr, jkey); + if (jkeyarr == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + } + if (data->app_data == NULL) { + __dbj_dbt_copyout(jenv, data, &jdataarr, jdata); + if (jdataarr == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + } + + jskeys = (jobjectArray)(*jenv)->CallNonvirtualObjectMethod(jenv, + jdb, db_class, seckey_create_method, jkey, jdata); + + if (jskeys == NULL || + (num_skeys = (*jenv)->GetArrayLength(jenv, jskeys)) == 0) { + ret = DB_DONOTINDEX; + goto err; + } else if (num_skeys == 1) { + memset(result, 0, sizeof (DBT)); + tresult = result; + } else { + if ((ret = __os_umalloc(db->env, + num_skeys * sizeof (DBT), &result->data)) != 0) + goto err; + memset(result->data, 0, num_skeys * sizeof (DBT)); + result->size = num_skeys; + F_SET(result, DB_DBT_APPMALLOC | DB_DBT_MULTIPLE); + tresult = (DBT *)result->data; + } + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + goto err; + } + + for (i = 0; i < num_skeys; i++, tresult++) { + jresult = (*jenv)->GetObjectArrayElement(jenv, jskeys, i); + + if ((ret = + __dbj_dbt_copyin(jenv, &lresult, NULL, jresult, 0)) != 0) + goto err; + + if (lresult.dbt.size != 0) { + /* If there's data, we need to take a copy of it. */ + tresult->size = lresult.dbt.size; + if ((ret = __os_umalloc(NULL, + tresult->size, &tresult->data)) != 0) + goto err; + if ((ret = __dbj_dbt_memcopy(&lresult.dbt, 0, + tresult->data, tresult->size, + DB_USERCOPY_GETDATA)) != 0) + goto err; + __dbj_dbt_release(jenv, + jresult, &lresult.dbt, &lresult); + (*jenv)->DeleteLocalRef(jenv, lresult.jarr); + F_SET(tresult, DB_DBT_APPMALLOC); + } + + (*jenv)->DeleteLocalRef(jenv, jresult); + } + +err: if (key->app_data == NULL) { + (*jenv)->DeleteLocalRef(jenv, jkeyarr); + (*jenv)->DeleteLocalRef(jenv, jkey); + } + if (data->app_data == NULL) { + (*jenv)->DeleteLocalRef(jenv, jdataarr); + (*jenv)->DeleteLocalRef(jenv, jdata); + } + if (jskeys != NULL) { + (*jenv)->DeleteLocalRef(jenv, jskeys); + } + + if (detach) + __dbj_detach(); + return (ret); +} + +static int __dbj_append_recno(DB *db, DBT *dbt, db_recno_t recno) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jobject jdbt; + DBT_LOCKED lresult; + jbyteArray jdbtarr; + int ret; + + if (jdb == NULL) { + ret = EINVAL; + goto err; + } + + /* + * The dbt we're passed will be from the application, but we can't + * just reuse it, since we will have already taken a copy of the data. + * Make a new DatabaseEntry object here for the callback. + */ + jdbt = (*jenv)->NewObject(jenv, dbt_class, dbt_construct); + if (jdbt == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + + __dbj_dbt_copyout(jenv, dbt, &jdbtarr, jdbt); + if (jdbtarr == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + + ret = 0; + (*jenv)->CallNonvirtualVoidMethod(jenv, jdb, db_class, + append_recno_method, jdbt, recno); + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + goto err; + } + + ret = __dbj_dbt_copyin(jenv, &lresult, NULL, jdbt, 0); + memset(dbt, 0, sizeof (DBT)); + + if (ret == 0 && lresult.dbt.size != 0) { + /* If there's data, we need to take a copy of it. */ + dbt->size = lresult.dbt.size; + if ((ret = + __os_umalloc(NULL, dbt->size, &dbt->data)) != 0) + goto err; + if ((ret = __dbj_dbt_memcopy(&lresult.dbt, 0, + dbt->data, dbt->size, + DB_USERCOPY_GETDATA)) != 0) + goto err; + __dbj_dbt_release(jenv, jdbt, &lresult.dbt, &lresult); + (*jenv)->DeleteLocalRef(jenv, lresult.jarr); + F_SET(dbt, DB_DBT_APPMALLOC); + } + +err: (*jenv)->DeleteLocalRef(jenv, jdbtarr); + (*jenv)->DeleteLocalRef(jenv, jdbt); + + if (detach) + __dbj_detach(); + return (ret); +} + +/* + * Shared by __dbj_bt_compare and __dbj_h_compare + */ +static int __dbj_am_compare(DB *db, const DBT *dbt1, const DBT *dbt2, + jmethodID compare_method) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jbyteArray jdbtarr1, jdbtarr2; + int ret; + + if (jdb == NULL) { + ret = EINVAL; + goto err; + } + + if (dbt1->app_data != NULL) + jdbtarr1 = ((DBT_LOCKED *)dbt1->app_data)->jarr; + else { + jdbtarr1 = (*jenv)->NewByteArray(jenv, (jsize)dbt1->size); + if (jdbtarr1 == NULL) { + ret = ENOMEM; + goto err; + } + (*jenv)->SetByteArrayRegion(jenv, jdbtarr1, 0, + (jsize)dbt1->size, (jbyte *)dbt1->data); + } + + if (dbt2->app_data != NULL) + jdbtarr2 = ((DBT_LOCKED *)dbt2->app_data)->jarr; + else { + jdbtarr2 = (*jenv)->NewByteArray(jenv, (jsize)dbt2->size); + if (jdbtarr2 == NULL) { + ret = ENOMEM; + goto err; + } + (*jenv)->SetByteArrayRegion(jenv, jdbtarr2, 0, + (jsize)dbt2->size, (jbyte *)dbt2->data); + } + + ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, + compare_method, jdbtarr1, jdbtarr2); + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + } + +err: if (dbt1->app_data == NULL) + (*jenv)->DeleteLocalRef(jenv, jdbtarr1); + if (dbt2->app_data == NULL) + (*jenv)->DeleteLocalRef(jenv, jdbtarr2); + + if (detach) + __dbj_detach(); + return (ret); +} + +static int __dbj_bt_compare(DB *db, const DBT *dbt1, const DBT *dbt2) +{ + return __dbj_am_compare(db, dbt1, dbt2, bt_compare_method); +} + +#define DBT_COPYOUT(num) \ + if (dbt##num->app_data != NULL) \ + jdbt##num = ((DBT_LOCKED *)dbt##num->app_data)->jdbt; \ + else { \ + if ((jdbt##num = (*jenv)->NewObject( \ + jenv, dbt_class, dbt_construct)) == NULL) { \ + ret = ENOMEM; /* An exception is pending */ \ + goto err; \ + } \ + __dbj_dbt_copyout(jenv, dbt##num, &jdbtarr##num, jdbt##num);\ + if (jdbtarr##num == NULL) { \ + ret = ENOMEM; /* An exception is pending */ \ + goto err; \ + } \ + } + +#define DBT_COPIED_FREE(num) \ + if (dbt##num->app_data == NULL) { \ + (*jenv)->DeleteLocalRef(jenv, jdbtarr##num); \ + (*jenv)->DeleteLocalRef(jenv, jdbt##num); \ + } + +#define DBT_COPYIN_DATA(num) \ + ret = __dbj_dbt_copyin(jenv, &lresult, NULL, jdbt##num, 0); \ + memset(dbt##num, 0, sizeof (DBT)); \ + if (ret == 0 && lresult.dbt.size != 0) { \ + /* If there's data, we need to take a copy of it. */ \ + dbt##num->size = lresult.dbt.size; \ + if ((ret = __os_umalloc( \ + NULL, dbt##num->size, &dbt##num->data)) != 0) \ + goto err; \ + if ((ret = __dbj_dbt_memcopy(&lresult.dbt, 0, \ + dbt##num->data, dbt##num->size, \ + DB_USERCOPY_GETDATA)) != 0) \ + goto err; \ + __dbj_dbt_release(jenv, jdbt##num, &lresult.dbt, &lresult);\ + (*jenv)->DeleteLocalRef(jenv, lresult.jarr); \ + F_SET(dbt##num, DB_DBT_APPMALLOC); \ + } + +static int __dbj_bt_compress(DB *db, const DBT *dbt1, const DBT *dbt2, + const DBT *dbt3, const DBT *dbt4, DBT *dbt5) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jobject jdbt1, jdbt2, jdbt3, jdbt4, jdbt5; + jbyteArray jdbtarr1, jdbtarr2, jdbtarr3, jdbtarr4, jdbtarr5; + DBT_LOCKED lresult; + int ret; + + if (jdb == NULL) { + ret = EINVAL; + goto err; + } + + DBT_COPYOUT(1) + DBT_COPYOUT(2) + DBT_COPYOUT(3) + DBT_COPYOUT(4) + DBT_COPYOUT(5) + + ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, + bt_compress_method, jdbt1, jdbt2, jdbt3, jdbt4, jdbt5); + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + goto err; + } + + DBT_COPYIN_DATA(5) + +err: DBT_COPIED_FREE(1) + DBT_COPIED_FREE(2) + DBT_COPIED_FREE(3) + DBT_COPIED_FREE(4) + DBT_COPIED_FREE(5) + if (detach) + __dbj_detach(); + return (ret); +} + +static int __dbj_bt_decompress(DB *db, const DBT *dbt1, const DBT *dbt2, + DBT *dbt3, DBT *dbt4, DBT *dbt5) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jobject jdbt1, jdbt2, jdbt3, jdbt4, jdbt5; + jbyteArray jdbtarr1, jdbtarr2, jdbtarr3, jdbtarr4, jdbtarr5; + DBT_LOCKED lresult; + int ret; + + if (jdb == NULL) { + ret = EINVAL; + goto err; + } + + DBT_COPYOUT(1) + DBT_COPYOUT(2) + DBT_COPYOUT(3) + DBT_COPYOUT(4) + DBT_COPYOUT(5) + + ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, + bt_decompress_method, jdbt1, jdbt2, jdbt3, jdbt4, jdbt5); + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + goto err; + } + + DBT_COPYIN_DATA(3) + DBT_COPYIN_DATA(4) + DBT_COPYIN_DATA(5) + +err: DBT_COPIED_FREE(1) + DBT_COPIED_FREE(2) + DBT_COPIED_FREE(3) + DBT_COPIED_FREE(4) + DBT_COPIED_FREE(5) + if (detach) + __dbj_detach(); + return (ret); +} + +static size_t __dbj_bt_prefix(DB *db, const DBT *dbt1, const DBT *dbt2) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jobject jdbt1, jdbt2; + jbyteArray jdbtarr1, jdbtarr2; + int ret; + + if (jdb == NULL) { + ret = EINVAL; + goto err; + } + + if (dbt1->app_data != NULL) + jdbt1 = ((DBT_LOCKED *)dbt1->app_data)->jdbt; + else { + if ((jdbt1 = + (*jenv)->NewObject(jenv, dbt_class, dbt_construct)) == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + __dbj_dbt_copyout(jenv, dbt1, &jdbtarr1, jdbt1); + if (jdbtarr1 == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + } + + if (dbt2->app_data != NULL) + jdbt2 = ((DBT_LOCKED *)dbt2->app_data)->jdbt; + else { + if ((jdbt2 = + (*jenv)->NewObject(jenv, dbt_class, dbt_construct)) == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + __dbj_dbt_copyout(jenv, dbt2, &jdbtarr2, jdbt2); + if (jdbtarr2 == NULL) { + ret = ENOMEM; /* An exception is pending */ + goto err; + } + } + + ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, + bt_prefix_method, jdbt1, jdbt2); + +err: if (dbt1->app_data == NULL) { + (*jenv)->DeleteLocalRef(jenv, jdbtarr1); + (*jenv)->DeleteLocalRef(jenv, jdbt1); + } + if (dbt2->app_data == NULL) { + (*jenv)->DeleteLocalRef(jenv, jdbtarr2); + (*jenv)->DeleteLocalRef(jenv, jdbt2); + } + + if (detach) + __dbj_detach(); + return (ret); +} + +static int __dbj_dup_compare(DB *db, const DBT *dbt1, const DBT *dbt2) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jbyteArray jdbtarr1, jdbtarr2; + int ret; + + if (jdb == NULL) + return (EINVAL); + + jdbtarr1 = (*jenv)->NewByteArray(jenv, (jsize)dbt1->size); + if (jdbtarr1 == NULL) + return (ENOMEM); + (*jenv)->SetByteArrayRegion(jenv, jdbtarr1, 0, (jsize)dbt1->size, + (jbyte *)dbt1->data); + + jdbtarr2 = (*jenv)->NewByteArray(jenv, (jsize)dbt2->size); + if (jdbtarr2 == NULL) + return (ENOMEM); + (*jenv)->SetByteArrayRegion(jenv, jdbtarr2, 0, (jsize)dbt2->size, + (jbyte *)dbt2->data); + + ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, + dup_compare_method, jdbtarr1, jdbtarr2); + + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + } + + (*jenv)->DeleteLocalRef(jenv, jdbtarr2); + (*jenv)->DeleteLocalRef(jenv, jdbtarr1); + + if (detach) + __dbj_detach(); + return (ret); +} + +static void __dbj_db_feedback(DB *db, int opcode, int percent) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + + if (jdb != NULL) + (*jenv)->CallNonvirtualVoidMethod(jenv, jdb, db_class, + db_feedback_method, opcode, percent); + + if (detach) + __dbj_detach(); +} + +static int __dbj_h_compare(DB *db, const DBT *dbt1, const DBT *dbt2) +{ + return __dbj_am_compare(db, dbt1, dbt2, h_compare_method); +} + +static u_int32_t __dbj_h_hash(DB *db, const void *data, u_int32_t len) +{ + int detach; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jbyteArray jarr = (*jenv)->NewByteArray(jenv, (jsize)len); + int ret; + + if (jdb == NULL) + return (EINVAL); + + if ((jarr = (*jenv)->NewByteArray(jenv, (jsize)len)) == NULL) + return (ENOMEM); /* An exception is pending */ + + (*jenv)->SetByteArrayRegion(jenv, jarr, 0, (jsize)len, (jbyte *)data); + + ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, + h_hash_method, jarr, len); + + (*jenv)->DeleteLocalRef(jenv, jarr); + + if (detach) + __dbj_detach(); + return (ret); +} + +static u_int32_t __dbj_partition(DB *db, DBT *dbt1) +{ + int detach, ret; + JNIEnv *jenv = __dbj_get_jnienv(&detach); + jobject jdb = (jobject)DB_INTERNAL(db); + jobject jdbt1; + jbyteArray jdbtarr1; + DBT_LOCKED lresult; + + DBT_COPYOUT(1) + + ret = (int)(*jenv)->CallNonvirtualIntMethod(jenv, jdb, db_class, + partition_method, jdbt1); + if ((*jenv)->ExceptionOccurred(jenv)) { + /* The exception will be thrown, so this could be any error. */ + ret = EINVAL; + goto err; + } + + DBT_COPYIN_DATA(1) +err: DBT_COPIED_FREE(1) + + if (detach) + __dbj_detach(); + return (ret); +} +%} + +JAVA_CALLBACK(void (*db_errcall_fcn)(const DB_ENV *, + const char *, const char *), com.sleepycat.db.ErrorHandler, error) +JAVA_CALLBACK(void (*env_feedback_fcn)(DB_ENV *, int, int), + com.sleepycat.db.FeedbackHandler, env_feedback) +JAVA_CALLBACK(void (*db_msgcall_fcn)(const DB_ENV *, const char *), + com.sleepycat.db.MessageHandler, message) +JAVA_CALLBACK(void (*db_panic_fcn)(DB_ENV *, int), + com.sleepycat.db.PanicHandler, panic) +JAVA_CALLBACK(void (*event_notify)(DB_ENV *, u_int32_t, void *), + com.sleepycat.db.EventHandler, event_notify) +JAVA_CALLBACK(int (*tx_recover)(DB_ENV *, DBT *, DB_LSN *, db_recops), + com.sleepycat.db.LogRecordHandler, app_dispatch) +JAVA_CALLBACK(int (*send)(DB_ENV *, const DBT *, const DBT *, + const DB_LSN *, int, u_int32_t), + com.sleepycat.db.ReplicationTransport, rep_transport) + +/* + * Db.associate is a special case, because the handler must be set in the + * secondary DB - that's what we have in the callback. In addition, there + * are two flavors of callback (single key and multi-key), so we need to + * check for both types when working out whether the C callback should + * be NULL. Note that this implies that the multi-key callback will be set + * on the secondary database *before* associate is called. + */ +JAVA_CALLBACK(int (*callback)(DB *, const DBT *, const DBT *, DBT *), + com.sleepycat.db.SecondaryKeyCreator, seckey_create) +%typemap(javain) int (*callback)(DB *, const DBT *, const DBT *, DBT *) + %{ (secondary.seckey_create_handler = $javainput) != null || + (secondary.secmultikey_create_handler != null) %} +JAVA_CALLBACK(int (*callback)(DB *, const DBT *, DBT *, const DBT *, int *), + com.sleepycat.db.ForeignKeyNullifier, foreignkey_nullify) +%typemap(javain) int (*callback)(DB *, const DBT *, DBT *, const DBT *, int *) + %{ (primary.foreignkey_nullify_handler = $javainput) != null || + (primary.foreignmultikey_nullify_handler != null) %} + +JAVA_CALLBACK(int (*db_append_recno_fcn)(DB *, DBT *, db_recno_t), + com.sleepycat.db.RecordNumberAppender, append_recno) +JAVA_CALLBACK(int (*bt_compare_fcn)(DB *, const DBT *, const DBT *), + java.util.Comparator, bt_compare) +JAVA_CALLBACK(int (*bt_compress_fcn)(DB *, const DBT *, const DBT *, + const DBT *, const DBT *, DBT *), + com.sleepycat.db.BtreeCompressor, bt_compress) +JAVA_CALLBACK(int (*bt_decompress_fcn)(DB *, const DBT *, const DBT *, + DBT *, DBT *, DBT *), com.sleepycat.db.BtreeCompressor, bt_decompress) +JAVA_CALLBACK(u_int32_t (*db_partition_fcn)(DB *, DBT *), + com.sleepycat.db.PartitionHandler, partition) +JAVA_CALLBACK(size_t (*bt_prefix_fcn)(DB *, const DBT *, const DBT *), + com.sleepycat.db.BtreePrefixCalculator, bt_prefix) +JAVA_CALLBACK(int (*dup_compare_fcn)(DB *, const DBT *, const DBT *), + java.util.Comparator, dup_compare) +JAVA_CALLBACK(void (*db_feedback_fcn)(DB *, int, int), + com.sleepycat.db.FeedbackHandler, db_feedback) +JAVA_CALLBACK(int (*h_compare_fcn)(DB *, const DBT *, const DBT *), + java.util.Comparator, h_compare) +JAVA_CALLBACK(u_int32_t (*h_hash_fcn)(DB *, const void *, u_int32_t), + com.sleepycat.db.Hasher, h_hash) diff --git a/libdb_java/java_except.i b/libdb_java/java_except.i new file mode 100644 index 0000000..2ea416b --- /dev/null +++ b/libdb_java/java_except.i @@ -0,0 +1,180 @@ +%{ +/* + * Macros to find the Java DbEnv object for methods in various classes. + * Note that "arg1" is from the code SWIG generates for the "this"/"self". + */ +#define JDBENV (arg1 ? (jobject)DB_ENV_INTERNAL(arg1) : NULL) +#define DB2JDBENV ((jobject)DB_ENV_INTERNAL(arg1->dbenv)) +#define DBC2JDBENV ((jobject)DB_ENV_INTERNAL(arg1->dbp->dbenv)) +#define TXN2JDBENV ((jobject)DB_ENV_INTERNAL(arg1->mgrp->env->dbenv)) +%} + +/* Common case exception handling */ +%typemap(check) SWIGTYPE *self %{ + if ($input == 0) { + __dbj_throw(jenv, EINVAL, "call on closed handle", NULL, NULL); + return $null; + }%} + +%define JAVA_EXCEPT_NONE +%exception %{ $action %} +%enddef + +/* Most methods return an error code. */ +%define JAVA_EXCEPT(_retcheck, _jdbenv) +%exception %{ + $action + if (!_retcheck(result)) { + __dbj_throw(jenv, result, NULL, NULL, _jdbenv); + } +%} +%enddef + +/* For everything else, errno is set in db.i. */ +%define JAVA_EXCEPT_ERRNO(_retcheck, _jdbenv) +%exception %{ + errno = 0; + $action + if (!_retcheck(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, _jdbenv); + } +%} +%enddef + +/* And then there are these (extra) special cases. */ +%exception __db_env::lock_get %{ + errno = 0; + $action + if (errno == DB_LOCK_NOTGRANTED) { + (*jenv)->Throw(jenv, + (*jenv)->NewObject(jenv, lockex_class, lockex_construct, + (*jenv)->NewStringUTF(jenv, "DbEnv.lock_get not granted"), + DB_LOCK_GET, arg5, jarg4, NULL, -1, JDBENV)); + } else if (!DB_RETOK_STD(errno)) { + __dbj_throw(jenv, errno, NULL, NULL, JDBENV); + } +%} + +%{ +static jthrowable __dbj_get_except(JNIEnv *jenv, + int err, const char *msg, jobject obj, jobject jdbenv) { + jobject jmsg; + + if (msg == NULL) + msg = db_strerror(err); + + jmsg = (*jenv)->NewStringUTF(jenv, msg); + + /* Retrieve error message logged by DB */ + if (jdbenv != NULL) { + jmsg = (jstring) (*jenv)->CallNonvirtualObjectMethod(jenv, + jdbenv, dbenv_class, get_err_msg_method, jmsg); + } + + switch (err) { + case EINVAL: + return (jthrowable)(*jenv)->NewObject(jenv, + illegalargex_class, illegalargex_construct, jmsg); + + case ENOENT: + return (jthrowable)(*jenv)->NewObject(jenv, + filenotfoundex_class, filenotfoundex_construct, jmsg); + + case ENOMEM: + return (jthrowable)(*jenv)->NewObject(jenv, + outofmemerr_class, outofmemerr_construct, jmsg); + + case DB_BUFFER_SMALL: + return (jthrowable)(*jenv)->NewObject(jenv, memex_class, + memex_construct, jmsg, obj, err, jdbenv); + + case DB_REP_DUPMASTER: + return (jthrowable)(*jenv)->NewObject(jenv, + repdupmasterex_class, repdupmasterex_construct, + jmsg, err, jdbenv); + + case DB_REP_HANDLE_DEAD: + return (jthrowable)(*jenv)->NewObject(jenv, + rephandledeadex_class, rephandledeadex_construct, + jmsg, err, jdbenv); + + case DB_REP_HOLDELECTION: + return (jthrowable)(*jenv)->NewObject(jenv, + repholdelectionex_class, repholdelectionex_construct, + jmsg, err, jdbenv); + + case DB_REP_JOIN_FAILURE: + return (jthrowable)(*jenv)->NewObject(jenv, + repjoinfailex_class, repjoinfailex_construct, + jmsg, err, jdbenv); + + case DB_REP_LEASE_EXPIRED: + return (jthrowable)(*jenv)->NewObject(jenv, + repleaseexpiredex_class, repleaseexpiredex_construct, + jmsg, err, jdbenv); + + case DB_REP_LEASE_TIMEOUT: + return (jthrowable)(*jenv)->NewObject(jenv, + repleasetimeoutex_class, repleasetimeoutex_construct, + jmsg, err, jdbenv); + + case DB_REP_LOCKOUT: + return (jthrowable)(*jenv)->NewObject(jenv, + replockoutex_class, replockoutex_construct, + jmsg, err, jdbenv); + + case DB_REP_UNAVAIL: + return (jthrowable)(*jenv)->NewObject(jenv, + repunavailex_class, repunavailex_construct, + jmsg, err, jdbenv); + + case DB_RUNRECOVERY: + return (jthrowable)(*jenv)->NewObject(jenv, runrecex_class, + runrecex_construct, jmsg, err, jdbenv); + + case DB_LOCK_DEADLOCK: + return (jthrowable)(*jenv)->NewObject(jenv, deadex_class, + deadex_construct, jmsg, err, jdbenv); + + case DB_LOCK_NOTGRANTED: + return (jthrowable)(*jenv)->NewObject(jenv, lockex_class, + lockex_construct, jmsg, err, 0, NULL, NULL, 0, jdbenv); + + case DB_VERSION_MISMATCH: + return (jthrowable)(*jenv)->NewObject(jenv, versionex_class, + versionex_construct, jmsg, err, jdbenv); + + default: + return (jthrowable)(*jenv)->NewObject(jenv, dbex_class, + dbex_construct, jmsg, err, jdbenv); + } +} + +static int __dbj_throw(JNIEnv *jenv, + int err, const char *msg, jobject obj, jobject jdbenv) +{ + jthrowable t; + + /* If an exception is pending, ignore requests to throw a new one. */ + if ((*jenv)->ExceptionOccurred(jenv) == NULL) { + t = __dbj_get_except(jenv, err, msg, obj, jdbenv); + if (t == NULL) { + /* + * This is a problem - something went wrong creating an + * exception. We have to assume there is an exception + * created by the JVM that is pending as a result + * (e.g., OutOfMemoryError), but we don't want to lose + * this error, so we just call __db_errx here. + */ + if (msg == NULL) + msg = db_strerror(err); + + __db_errx(NULL, "Couldn't create exception for: '%s'", + msg); + } else + (*jenv)->Throw(jenv, t); + } + + return (err); +} +%} diff --git a/libdb_java/java_stat.i b/libdb_java/java_stat.i new file mode 100644 index 0000000..6875520 --- /dev/null +++ b/libdb_java/java_stat.i @@ -0,0 +1,176 @@ +/* Statistics classes */ +%{ +/* + * These macros are used by code generated by the s_java script. + */ +#define JAVADB_STAT_INT(jenv, jobj, fid, statp, name) \ + (*jenv)->SetIntField(jenv, jobj, fid, (jint)statp->name) + +#define JAVADB_STAT_STRING(jenv, jobj, fid, statp, name) \ + (*jenv)->SetObjectField(jenv, jobj, fid, \ + (*jenv)->NewStringUTF(jenv, statp->name)) + +#define JAVADB_STAT_LSN(jenv, jobj, fid, statp, name) \ + (*jenv)->SetObjectField(jenv, jobj, fid, \ + __dbj_wrap_DB_LSN(jenv, &statp->name)) + +#define JAVADB_STAT_LONG(jenv, jobj, fid, statp, name) \ + (*jenv)->SetLongField(jenv, jobj, fid, \ + (jlong)statp->name) + +#define JAVADB_STAT_GID(jenv, jobj, fid, statp, name) { \ + jobject jarr = \ + (*jenv)->NewByteArray(jenv, (jsize)DB_GID_SIZE); \ + (*jenv)->SetByteArrayRegion(jenv, jarr, \ + 0, (jsize)DB_GID_SIZE, (jbyte *)statp->name); \ + (*jenv)->SetObjectField(jenv, jobj, fid, jarr); \ + } + +/* + * We build the active list separately. + */ +#define JAVADB_STAT_ACTIVE(jenv, cl, jobj, statp, name) \ + do {} while(0) + +#include "java_stat_auto.c" +%} + +%define JAVA_STAT_CLASS(_ctype, _jtype, _name) +JAVA_TYPEMAP(_ctype, _jtype, jobject) +%typemap(out) _ctype %{ + $result = (*jenv)->NewObject(jenv, _name##_class, _name##_construct); + if ($result != NULL) + __dbj_fill_##_name(jenv, $result, $1); + __os_ufree(NULL, $1); +%} +%enddef + +JAVA_STAT_CLASS(DB_COMPACT *, com.sleepycat.db.CompactStats, compact) +%typemap(freearg) DB_COMPACT * %{ __dbj_fill_compact(jenv, $input, $1); %} +%typemap(in) DB_COMPACT * (DB_COMPACT compact) %{ + memset(&compact, 0, sizeof (DB_COMPACT)); + $1 = &compact; + $1->compact_fillpercent = (*jenv)->GetIntField(jenv, $input, + compact_compact_fillpercent_fid); + $1->compact_timeout = (*jenv)->GetIntField(jenv, $input, + compact_compact_timeout_fid); + $1->compact_pages = (*jenv)->GetIntField(jenv, $input, + compact_compact_pages_fid); +%} + +JAVA_STAT_CLASS(DB_LOCK_STAT *, com.sleepycat.db.LockStats, lock_stat) +JAVA_STAT_CLASS(DB_LOG_STAT *, com.sleepycat.db.LogStats, log_stat) +JAVA_STAT_CLASS(DB_MPOOL_STAT *, com.sleepycat.db.CacheStats, mpool_stat) + +JAVA_TYPEMAP(DB_MPOOL_FSTAT **, com.sleepycat.db.CacheFileStats[], jobjectArray) +%typemap(out) DB_MPOOL_FSTAT ** { + int i, len; + + len = 0; + while ($1[len] != NULL) + len++; + $result = (*jenv)->NewObjectArray(jenv, (jsize)len, + mpool_fstat_class, 0); + if ($result == NULL) { + __os_ufree(NULL, $1); + return $null; + } + for (i = 0; i < len; i++) { + jobject obj = (*jenv)->NewObject(jenv, mpool_fstat_class, + mpool_fstat_construct); + if (obj == NULL) { + __os_ufree(NULL, $1); + return $null; /* an exception is pending */ + } + (*jenv)->SetObjectArrayElement(jenv, $result, i, obj); + __dbj_fill_mpool_fstat(jenv, obj, $1[i]); + } + __os_ufree(NULL, $1); +} + +JAVA_STAT_CLASS(DB_MUTEX_STAT *, com.sleepycat.db.MutexStats, mutex_stat) +JAVA_STAT_CLASS(DB_REP_STAT *, com.sleepycat.db.ReplicationStats, rep_stat) +JAVA_STAT_CLASS(DB_REPMGR_STAT *, com.sleepycat.db.ReplicationManagerStats, repmgr_stat) +JAVA_STAT_CLASS(DB_SEQUENCE_STAT *, com.sleepycat.db.SequenceStats, seq_stat) +JAVA_TYPEMAP(DB_TXN_STAT *, com.sleepycat.db.TransactionStats, jobject) +%typemap(out) DB_TXN_STAT * { + unsigned int i; + jobjectArray actives; + $result = (*jenv)->NewObject(jenv, txn_stat_class, txn_stat_construct); + if ($result != NULL) + __dbj_fill_txn_stat(jenv, $result, $1); + + actives = (*jenv)->NewObjectArray(jenv, (jsize)$1->st_nactive, + txn_active_class, 0); + if (actives == NULL) { + __os_ufree(NULL, $1); + return $null; + } + (*jenv)->SetObjectField(jenv, $result, + txn_stat_st_txnarray_fid, actives); + for (i = 0; i < $1->st_nactive; i++) { + jobject obj = (*jenv)->NewObject(jenv, txn_active_class, + txn_active_construct); + if (obj == NULL) { + __os_ufree(NULL, $1); + return $null; /* an exception is pending */ + } + (*jenv)->SetObjectArrayElement(jenv, actives, (jsize)i, obj); + __dbj_fill_txn_active(jenv, obj, &$1->st_txnarray[i]); + } + __os_ufree(NULL, $1); +} + +/* Db.stat return - special case */ +%typemap(out) void * %{ + if ($1 == NULL) + $result = NULL; + else { + DB *db = (DB *)arg1; + DBTYPE dbtype; + int err; + + if ((err = db->get_type(db, &dbtype)) != 0) { + __dbj_throw(jenv, err, NULL, NULL, DB2JDBENV); + return $null; + } + + switch (dbtype) { + /* Btree and recno share the same stat structure */ + case DB_BTREE: + case DB_RECNO: + $result = (*jenv)->NewObject(jenv, bt_stat_class, + bt_stat_construct); + if ($result != NULL) + __dbj_fill_bt_stat(jenv, $result, + (DB_BTREE_STAT *)$1); + break; + + /* Hash stat structure */ + case DB_HASH: + $result = (*jenv)->NewObject(jenv, h_stat_class, + h_stat_construct); + if ($result != NULL) + __dbj_fill_h_stat(jenv, $result, + (DB_HASH_STAT *)$1); + break; + + case DB_QUEUE: + $result = (*jenv)->NewObject(jenv, qam_stat_class, + qam_stat_construct); + if ($result != NULL) + __dbj_fill_qam_stat(jenv, $result, + (DB_QUEUE_STAT *)$1); + break; + + /* That's all the database types we're aware of! */ + default: + __dbj_throw(jenv, EINVAL, "Db.stat only implemented for" + " BTREE, HASH, QUEUE and RECNO", NULL, DB2JDBENV); + break; + } + + __os_ufree(db->env, $1); + } +%} + diff --git a/libdb_java/java_stat_auto.c b/libdb_java/java_stat_auto.c new file mode 100644 index 0000000..c18f7db --- /dev/null +++ b/libdb_java/java_stat_auto.c @@ -0,0 +1,343 @@ +/*- + * Automatically built by dist/s_java_stat. + * Only the javadoc comments can be edited. + * + * See the file LICENSE for redistribution information. + * + * Copyright (c) 2002-2009 Oracle. All rights reserved. + */ +static int __dbj_fill_bt_stat(JNIEnv *jnienv, + jobject jobj, struct __db_bt_stat *statp) { + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_magic_fid, statp, bt_magic); + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_version_fid, statp, bt_version); + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_metaflags_fid, statp, bt_metaflags); + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_nkeys_fid, statp, bt_nkeys); + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_ndata_fid, statp, bt_ndata); + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_pagecnt_fid, statp, bt_pagecnt); + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_pagesize_fid, statp, bt_pagesize); + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_minkey_fid, statp, bt_minkey); + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_re_len_fid, statp, bt_re_len); + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_re_pad_fid, statp, bt_re_pad); + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_levels_fid, statp, bt_levels); + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_int_pg_fid, statp, bt_int_pg); + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_leaf_pg_fid, statp, bt_leaf_pg); + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_dup_pg_fid, statp, bt_dup_pg); + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_over_pg_fid, statp, bt_over_pg); + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_empty_pg_fid, statp, bt_empty_pg); + JAVADB_STAT_INT(jnienv, jobj, bt_stat_bt_free_fid, statp, bt_free); + JAVADB_STAT_LONG(jnienv, jobj, bt_stat_bt_int_pgfree_fid, statp, bt_int_pgfree); + JAVADB_STAT_LONG(jnienv, jobj, bt_stat_bt_leaf_pgfree_fid, statp, bt_leaf_pgfree); + JAVADB_STAT_LONG(jnienv, jobj, bt_stat_bt_dup_pgfree_fid, statp, bt_dup_pgfree); + JAVADB_STAT_LONG(jnienv, jobj, bt_stat_bt_over_pgfree_fid, statp, bt_over_pgfree); + return (0); +} +static int __dbj_fill_compact(JNIEnv *jnienv, + jobject jobj, struct __db_compact *statp) { + JAVADB_STAT_INT(jnienv, jobj, compact_compact_fillpercent_fid, statp, compact_fillpercent); + JAVADB_STAT_INT(jnienv, jobj, compact_compact_timeout_fid, statp, compact_timeout); + JAVADB_STAT_INT(jnienv, jobj, compact_compact_pages_fid, statp, compact_pages); + JAVADB_STAT_INT(jnienv, jobj, compact_compact_pages_free_fid, statp, compact_pages_free); + JAVADB_STAT_INT(jnienv, jobj, compact_compact_pages_examine_fid, statp, compact_pages_examine); + JAVADB_STAT_INT(jnienv, jobj, compact_compact_levels_fid, statp, compact_levels); + JAVADB_STAT_INT(jnienv, jobj, compact_compact_deadlock_fid, statp, compact_deadlock); + JAVADB_STAT_INT(jnienv, jobj, compact_compact_pages_truncated_fid, statp, compact_pages_truncated); + JAVADB_STAT_INT(jnienv, jobj, compact_compact_truncate_fid, statp, compact_truncate); + return (0); +} +static int __dbj_fill_h_stat(JNIEnv *jnienv, + jobject jobj, struct __db_h_stat *statp) { + JAVADB_STAT_INT(jnienv, jobj, h_stat_hash_magic_fid, statp, hash_magic); + JAVADB_STAT_INT(jnienv, jobj, h_stat_hash_version_fid, statp, hash_version); + JAVADB_STAT_INT(jnienv, jobj, h_stat_hash_metaflags_fid, statp, hash_metaflags); + JAVADB_STAT_INT(jnienv, jobj, h_stat_hash_nkeys_fid, statp, hash_nkeys); + JAVADB_STAT_INT(jnienv, jobj, h_stat_hash_ndata_fid, statp, hash_ndata); + JAVADB_STAT_INT(jnienv, jobj, h_stat_hash_pagecnt_fid, statp, hash_pagecnt); + JAVADB_STAT_INT(jnienv, jobj, h_stat_hash_pagesize_fid, statp, hash_pagesize); + JAVADB_STAT_INT(jnienv, jobj, h_stat_hash_ffactor_fid, statp, hash_ffactor); + JAVADB_STAT_INT(jnienv, jobj, h_stat_hash_buckets_fid, statp, hash_buckets); + JAVADB_STAT_INT(jnienv, jobj, h_stat_hash_free_fid, statp, hash_free); + JAVADB_STAT_LONG(jnienv, jobj, h_stat_hash_bfree_fid, statp, hash_bfree); + JAVADB_STAT_INT(jnienv, jobj, h_stat_hash_bigpages_fid, statp, hash_bigpages); + JAVADB_STAT_LONG(jnienv, jobj, h_stat_hash_big_bfree_fid, statp, hash_big_bfree); + JAVADB_STAT_INT(jnienv, jobj, h_stat_hash_overflows_fid, statp, hash_overflows); + JAVADB_STAT_LONG(jnienv, jobj, h_stat_hash_ovfl_free_fid, statp, hash_ovfl_free); + JAVADB_STAT_INT(jnienv, jobj, h_stat_hash_dup_fid, statp, hash_dup); + JAVADB_STAT_LONG(jnienv, jobj, h_stat_hash_dup_free_fid, statp, hash_dup_free); + return (0); +} +static int __dbj_fill_lock_stat(JNIEnv *jnienv, + jobject jobj, struct __db_lock_stat *statp) { + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_id_fid, statp, st_id); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_cur_maxid_fid, statp, st_cur_maxid); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_maxlocks_fid, statp, st_maxlocks); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_maxlockers_fid, statp, st_maxlockers); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_maxobjects_fid, statp, st_maxobjects); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_partitions_fid, statp, st_partitions); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_nmodes_fid, statp, st_nmodes); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_nlockers_fid, statp, st_nlockers); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_nlocks_fid, statp, st_nlocks); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_maxnlocks_fid, statp, st_maxnlocks); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_maxhlocks_fid, statp, st_maxhlocks); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_locksteals_fid, statp, st_locksteals); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_maxlsteals_fid, statp, st_maxlsteals); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_maxnlockers_fid, statp, st_maxnlockers); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_nobjects_fid, statp, st_nobjects); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_maxnobjects_fid, statp, st_maxnobjects); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_maxhobjects_fid, statp, st_maxhobjects); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_objectsteals_fid, statp, st_objectsteals); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_maxosteals_fid, statp, st_maxosteals); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_nrequests_fid, statp, st_nrequests); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_nreleases_fid, statp, st_nreleases); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_nupgrade_fid, statp, st_nupgrade); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_ndowngrade_fid, statp, st_ndowngrade); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_lock_wait_fid, statp, st_lock_wait); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_lock_nowait_fid, statp, st_lock_nowait); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_ndeadlocks_fid, statp, st_ndeadlocks); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_locktimeout_fid, statp, st_locktimeout); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_nlocktimeouts_fid, statp, st_nlocktimeouts); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_txntimeout_fid, statp, st_txntimeout); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_ntxntimeouts_fid, statp, st_ntxntimeouts); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_part_wait_fid, statp, st_part_wait); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_part_nowait_fid, statp, st_part_nowait); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_part_max_wait_fid, statp, st_part_max_wait); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_part_max_nowait_fid, statp, st_part_max_nowait); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_objs_wait_fid, statp, st_objs_wait); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_objs_nowait_fid, statp, st_objs_nowait); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_lockers_wait_fid, statp, st_lockers_wait); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_lockers_nowait_fid, statp, st_lockers_nowait); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_region_wait_fid, statp, st_region_wait); + JAVADB_STAT_LONG(jnienv, jobj, lock_stat_st_region_nowait_fid, statp, st_region_nowait); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_hash_len_fid, statp, st_hash_len); + JAVADB_STAT_INT(jnienv, jobj, lock_stat_st_regsize_fid, statp, st_regsize); + return (0); +} +static int __dbj_fill_log_stat(JNIEnv *jnienv, + jobject jobj, struct __db_log_stat *statp) { + JAVADB_STAT_INT(jnienv, jobj, log_stat_st_magic_fid, statp, st_magic); + JAVADB_STAT_INT(jnienv, jobj, log_stat_st_version_fid, statp, st_version); + JAVADB_STAT_INT(jnienv, jobj, log_stat_st_mode_fid, statp, st_mode); + JAVADB_STAT_INT(jnienv, jobj, log_stat_st_lg_bsize_fid, statp, st_lg_bsize); + JAVADB_STAT_INT(jnienv, jobj, log_stat_st_lg_size_fid, statp, st_lg_size); + JAVADB_STAT_INT(jnienv, jobj, log_stat_st_wc_bytes_fid, statp, st_wc_bytes); + JAVADB_STAT_INT(jnienv, jobj, log_stat_st_wc_mbytes_fid, statp, st_wc_mbytes); + JAVADB_STAT_LONG(jnienv, jobj, log_stat_st_record_fid, statp, st_record); + JAVADB_STAT_INT(jnienv, jobj, log_stat_st_w_bytes_fid, statp, st_w_bytes); + JAVADB_STAT_INT(jnienv, jobj, log_stat_st_w_mbytes_fid, statp, st_w_mbytes); + JAVADB_STAT_LONG(jnienv, jobj, log_stat_st_wcount_fid, statp, st_wcount); + JAVADB_STAT_LONG(jnienv, jobj, log_stat_st_wcount_fill_fid, statp, st_wcount_fill); + JAVADB_STAT_LONG(jnienv, jobj, log_stat_st_rcount_fid, statp, st_rcount); + JAVADB_STAT_LONG(jnienv, jobj, log_stat_st_scount_fid, statp, st_scount); + JAVADB_STAT_LONG(jnienv, jobj, log_stat_st_region_wait_fid, statp, st_region_wait); + JAVADB_STAT_LONG(jnienv, jobj, log_stat_st_region_nowait_fid, statp, st_region_nowait); + JAVADB_STAT_INT(jnienv, jobj, log_stat_st_cur_file_fid, statp, st_cur_file); + JAVADB_STAT_INT(jnienv, jobj, log_stat_st_cur_offset_fid, statp, st_cur_offset); + JAVADB_STAT_INT(jnienv, jobj, log_stat_st_disk_file_fid, statp, st_disk_file); + JAVADB_STAT_INT(jnienv, jobj, log_stat_st_disk_offset_fid, statp, st_disk_offset); + JAVADB_STAT_INT(jnienv, jobj, log_stat_st_maxcommitperflush_fid, statp, st_maxcommitperflush); + JAVADB_STAT_INT(jnienv, jobj, log_stat_st_mincommitperflush_fid, statp, st_mincommitperflush); + JAVADB_STAT_INT(jnienv, jobj, log_stat_st_regsize_fid, statp, st_regsize); + return (0); +} +static int __dbj_fill_mpool_fstat(JNIEnv *jnienv, + jobject jobj, struct __db_mpool_fstat *statp) { + JAVADB_STAT_STRING(jnienv, jobj, mpool_fstat_file_name_fid, statp, file_name); + JAVADB_STAT_INT(jnienv, jobj, mpool_fstat_st_pagesize_fid, statp, st_pagesize); + JAVADB_STAT_INT(jnienv, jobj, mpool_fstat_st_map_fid, statp, st_map); + JAVADB_STAT_LONG(jnienv, jobj, mpool_fstat_st_cache_hit_fid, statp, st_cache_hit); + JAVADB_STAT_LONG(jnienv, jobj, mpool_fstat_st_cache_miss_fid, statp, st_cache_miss); + JAVADB_STAT_LONG(jnienv, jobj, mpool_fstat_st_page_create_fid, statp, st_page_create); + JAVADB_STAT_LONG(jnienv, jobj, mpool_fstat_st_page_in_fid, statp, st_page_in); + JAVADB_STAT_LONG(jnienv, jobj, mpool_fstat_st_page_out_fid, statp, st_page_out); + return (0); +} +static int __dbj_fill_mpool_stat(JNIEnv *jnienv, + jobject jobj, struct __db_mpool_stat *statp) { + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_gbytes_fid, statp, st_gbytes); + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_bytes_fid, statp, st_bytes); + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_ncache_fid, statp, st_ncache); + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_max_ncache_fid, statp, st_max_ncache); + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_mmapsize_fid, statp, st_mmapsize); + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_maxopenfd_fid, statp, st_maxopenfd); + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_maxwrite_fid, statp, st_maxwrite); + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_maxwrite_sleep_fid, statp, st_maxwrite_sleep); + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_pages_fid, statp, st_pages); + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_map_fid, statp, st_map); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_cache_hit_fid, statp, st_cache_hit); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_cache_miss_fid, statp, st_cache_miss); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_page_create_fid, statp, st_page_create); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_page_in_fid, statp, st_page_in); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_page_out_fid, statp, st_page_out); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_ro_evict_fid, statp, st_ro_evict); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_rw_evict_fid, statp, st_rw_evict); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_page_trickle_fid, statp, st_page_trickle); + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_page_clean_fid, statp, st_page_clean); + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_page_dirty_fid, statp, st_page_dirty); + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_hash_buckets_fid, statp, st_hash_buckets); + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_pagesize_fid, statp, st_pagesize); + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_hash_searches_fid, statp, st_hash_searches); + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_hash_longest_fid, statp, st_hash_longest); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_hash_examined_fid, statp, st_hash_examined); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_hash_nowait_fid, statp, st_hash_nowait); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_hash_wait_fid, statp, st_hash_wait); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_hash_max_nowait_fid, statp, st_hash_max_nowait); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_hash_max_wait_fid, statp, st_hash_max_wait); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_region_nowait_fid, statp, st_region_nowait); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_region_wait_fid, statp, st_region_wait); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_mvcc_frozen_fid, statp, st_mvcc_frozen); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_mvcc_thawed_fid, statp, st_mvcc_thawed); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_mvcc_freed_fid, statp, st_mvcc_freed); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_alloc_fid, statp, st_alloc); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_alloc_buckets_fid, statp, st_alloc_buckets); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_alloc_max_buckets_fid, statp, st_alloc_max_buckets); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_alloc_pages_fid, statp, st_alloc_pages); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_alloc_max_pages_fid, statp, st_alloc_max_pages); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_io_wait_fid, statp, st_io_wait); + JAVADB_STAT_LONG(jnienv, jobj, mpool_stat_st_sync_interrupted_fid, statp, st_sync_interrupted); + JAVADB_STAT_INT(jnienv, jobj, mpool_stat_st_regsize_fid, statp, st_regsize); + return (0); +} +static int __dbj_fill_mutex_stat(JNIEnv *jnienv, + jobject jobj, struct __db_mutex_stat *statp) { + JAVADB_STAT_INT(jnienv, jobj, mutex_stat_st_mutex_align_fid, statp, st_mutex_align); + JAVADB_STAT_INT(jnienv, jobj, mutex_stat_st_mutex_tas_spins_fid, statp, st_mutex_tas_spins); + JAVADB_STAT_INT(jnienv, jobj, mutex_stat_st_mutex_cnt_fid, statp, st_mutex_cnt); + JAVADB_STAT_INT(jnienv, jobj, mutex_stat_st_mutex_free_fid, statp, st_mutex_free); + JAVADB_STAT_INT(jnienv, jobj, mutex_stat_st_mutex_inuse_fid, statp, st_mutex_inuse); + JAVADB_STAT_INT(jnienv, jobj, mutex_stat_st_mutex_inuse_max_fid, statp, st_mutex_inuse_max); + JAVADB_STAT_LONG(jnienv, jobj, mutex_stat_st_region_wait_fid, statp, st_region_wait); + JAVADB_STAT_LONG(jnienv, jobj, mutex_stat_st_region_nowait_fid, statp, st_region_nowait); + JAVADB_STAT_INT(jnienv, jobj, mutex_stat_st_regsize_fid, statp, st_regsize); + return (0); +} +static int __dbj_fill_qam_stat(JNIEnv *jnienv, + jobject jobj, struct __db_qam_stat *statp) { + JAVADB_STAT_INT(jnienv, jobj, qam_stat_qs_magic_fid, statp, qs_magic); + JAVADB_STAT_INT(jnienv, jobj, qam_stat_qs_version_fid, statp, qs_version); + JAVADB_STAT_INT(jnienv, jobj, qam_stat_qs_metaflags_fid, statp, qs_metaflags); + JAVADB_STAT_INT(jnienv, jobj, qam_stat_qs_nkeys_fid, statp, qs_nkeys); + JAVADB_STAT_INT(jnienv, jobj, qam_stat_qs_ndata_fid, statp, qs_ndata); + JAVADB_STAT_INT(jnienv, jobj, qam_stat_qs_pagesize_fid, statp, qs_pagesize); + JAVADB_STAT_INT(jnienv, jobj, qam_stat_qs_extentsize_fid, statp, qs_extentsize); + JAVADB_STAT_INT(jnienv, jobj, qam_stat_qs_pages_fid, statp, qs_pages); + JAVADB_STAT_INT(jnienv, jobj, qam_stat_qs_re_len_fid, statp, qs_re_len); + JAVADB_STAT_INT(jnienv, jobj, qam_stat_qs_re_pad_fid, statp, qs_re_pad); + JAVADB_STAT_INT(jnienv, jobj, qam_stat_qs_pgfree_fid, statp, qs_pgfree); + JAVADB_STAT_INT(jnienv, jobj, qam_stat_qs_first_recno_fid, statp, qs_first_recno); + JAVADB_STAT_INT(jnienv, jobj, qam_stat_qs_cur_recno_fid, statp, qs_cur_recno); + return (0); +} +static int __dbj_fill_rep_stat(JNIEnv *jnienv, + jobject jobj, struct __db_rep_stat *statp) { + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_log_queued_fid, statp, st_log_queued); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_startup_complete_fid, statp, st_startup_complete); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_status_fid, statp, st_status); + JAVADB_STAT_LSN(jnienv, jobj, rep_stat_st_next_lsn_fid, statp, st_next_lsn); + JAVADB_STAT_LSN(jnienv, jobj, rep_stat_st_waiting_lsn_fid, statp, st_waiting_lsn); + JAVADB_STAT_LSN(jnienv, jobj, rep_stat_st_max_perm_lsn_fid, statp, st_max_perm_lsn); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_next_pg_fid, statp, st_next_pg); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_waiting_pg_fid, statp, st_waiting_pg); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_dupmasters_fid, statp, st_dupmasters); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_env_id_fid, statp, st_env_id); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_env_priority_fid, statp, st_env_priority); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_bulk_fills_fid, statp, st_bulk_fills); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_bulk_overflows_fid, statp, st_bulk_overflows); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_bulk_records_fid, statp, st_bulk_records); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_bulk_transfers_fid, statp, st_bulk_transfers); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_client_rerequests_fid, statp, st_client_rerequests); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_client_svc_req_fid, statp, st_client_svc_req); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_client_svc_miss_fid, statp, st_client_svc_miss); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_gen_fid, statp, st_gen); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_egen_fid, statp, st_egen); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_log_duplicated_fid, statp, st_log_duplicated); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_log_queued_max_fid, statp, st_log_queued_max); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_log_queued_total_fid, statp, st_log_queued_total); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_log_records_fid, statp, st_log_records); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_log_requested_fid, statp, st_log_requested); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_master_fid, statp, st_master); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_master_changes_fid, statp, st_master_changes); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_msgs_badgen_fid, statp, st_msgs_badgen); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_msgs_processed_fid, statp, st_msgs_processed); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_msgs_recover_fid, statp, st_msgs_recover); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_msgs_send_failures_fid, statp, st_msgs_send_failures); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_msgs_sent_fid, statp, st_msgs_sent); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_newsites_fid, statp, st_newsites); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_nsites_fid, statp, st_nsites); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_nthrottles_fid, statp, st_nthrottles); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_outdated_fid, statp, st_outdated); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_pg_duplicated_fid, statp, st_pg_duplicated); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_pg_records_fid, statp, st_pg_records); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_pg_requested_fid, statp, st_pg_requested); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_txns_applied_fid, statp, st_txns_applied); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_startsync_delayed_fid, statp, st_startsync_delayed); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_elections_fid, statp, st_elections); + JAVADB_STAT_LONG(jnienv, jobj, rep_stat_st_elections_won_fid, statp, st_elections_won); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_election_cur_winner_fid, statp, st_election_cur_winner); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_election_gen_fid, statp, st_election_gen); + JAVADB_STAT_LSN(jnienv, jobj, rep_stat_st_election_lsn_fid, statp, st_election_lsn); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_election_nsites_fid, statp, st_election_nsites); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_election_nvotes_fid, statp, st_election_nvotes); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_election_priority_fid, statp, st_election_priority); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_election_status_fid, statp, st_election_status); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_election_tiebreaker_fid, statp, st_election_tiebreaker); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_election_votes_fid, statp, st_election_votes); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_election_sec_fid, statp, st_election_sec); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_election_usec_fid, statp, st_election_usec); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_max_lease_sec_fid, statp, st_max_lease_sec); + JAVADB_STAT_INT(jnienv, jobj, rep_stat_st_max_lease_usec_fid, statp, st_max_lease_usec); + return (0); +} +static int __dbj_fill_repmgr_stat(JNIEnv *jnienv, + jobject jobj, struct __db_repmgr_stat *statp) { + JAVADB_STAT_LONG(jnienv, jobj, repmgr_stat_st_perm_failed_fid, statp, st_perm_failed); + JAVADB_STAT_LONG(jnienv, jobj, repmgr_stat_st_msgs_queued_fid, statp, st_msgs_queued); + JAVADB_STAT_LONG(jnienv, jobj, repmgr_stat_st_msgs_dropped_fid, statp, st_msgs_dropped); + JAVADB_STAT_LONG(jnienv, jobj, repmgr_stat_st_connection_drop_fid, statp, st_connection_drop); + JAVADB_STAT_LONG(jnienv, jobj, repmgr_stat_st_connect_fail_fid, statp, st_connect_fail); + return (0); +} +static int __dbj_fill_seq_stat(JNIEnv *jnienv, + jobject jobj, struct __db_seq_stat *statp) { + JAVADB_STAT_LONG(jnienv, jobj, seq_stat_st_wait_fid, statp, st_wait); + JAVADB_STAT_LONG(jnienv, jobj, seq_stat_st_nowait_fid, statp, st_nowait); + JAVADB_STAT_LONG(jnienv, jobj, seq_stat_st_current_fid, statp, st_current); + JAVADB_STAT_LONG(jnienv, jobj, seq_stat_st_value_fid, statp, st_value); + JAVADB_STAT_LONG(jnienv, jobj, seq_stat_st_last_value_fid, statp, st_last_value); + JAVADB_STAT_LONG(jnienv, jobj, seq_stat_st_min_fid, statp, st_min); + JAVADB_STAT_LONG(jnienv, jobj, seq_stat_st_max_fid, statp, st_max); + JAVADB_STAT_INT(jnienv, jobj, seq_stat_st_cache_size_fid, statp, st_cache_size); + JAVADB_STAT_INT(jnienv, jobj, seq_stat_st_flags_fid, statp, st_flags); + return (0); +} +static int __dbj_fill_txn_stat(JNIEnv *jnienv, + jobject jobj, struct __db_txn_stat *statp) { + JAVADB_STAT_INT(jnienv, jobj, txn_stat_st_nrestores_fid, statp, st_nrestores); + JAVADB_STAT_LSN(jnienv, jobj, txn_stat_st_last_ckp_fid, statp, st_last_ckp); + JAVADB_STAT_LONG(jnienv, jobj, txn_stat_st_time_ckp_fid, statp, st_time_ckp); + JAVADB_STAT_INT(jnienv, jobj, txn_stat_st_last_txnid_fid, statp, st_last_txnid); + JAVADB_STAT_INT(jnienv, jobj, txn_stat_st_maxtxns_fid, statp, st_maxtxns); + JAVADB_STAT_LONG(jnienv, jobj, txn_stat_st_naborts_fid, statp, st_naborts); + JAVADB_STAT_LONG(jnienv, jobj, txn_stat_st_nbegins_fid, statp, st_nbegins); + JAVADB_STAT_LONG(jnienv, jobj, txn_stat_st_ncommits_fid, statp, st_ncommits); + JAVADB_STAT_INT(jnienv, jobj, txn_stat_st_nactive_fid, statp, st_nactive); + JAVADB_STAT_INT(jnienv, jobj, txn_stat_st_nsnapshot_fid, statp, st_nsnapshot); + JAVADB_STAT_INT(jnienv, jobj, txn_stat_st_maxnactive_fid, statp, st_maxnactive); + JAVADB_STAT_INT(jnienv, jobj, txn_stat_st_maxnsnapshot_fid, statp, st_maxnsnapshot); + JAVADB_STAT_ACTIVE(jnienv, jobj, txn_stat_st_txnarray_fid, statp, st_txnarray); + JAVADB_STAT_LONG(jnienv, jobj, txn_stat_st_region_wait_fid, statp, st_region_wait); + JAVADB_STAT_LONG(jnienv, jobj, txn_stat_st_region_nowait_fid, statp, st_region_nowait); + JAVADB_STAT_INT(jnienv, jobj, txn_stat_st_regsize_fid, statp, st_regsize); + return (0); +} +static int __dbj_fill_txn_active(JNIEnv *jnienv, + jobject jobj, struct __db_txn_active *statp) { + JAVADB_STAT_INT(jnienv, jobj, txn_active_txnid_fid, statp, txnid); + JAVADB_STAT_INT(jnienv, jobj, txn_active_parentid_fid, statp, parentid); + JAVADB_STAT_INT(jnienv, jobj, txn_active_pid_fid, statp, pid); + JAVADB_STAT_LSN(jnienv, jobj, txn_active_lsn_fid, statp, lsn); + JAVADB_STAT_LSN(jnienv, jobj, txn_active_read_lsn_fid, statp, read_lsn); + JAVADB_STAT_INT(jnienv, jobj, txn_active_mvcc_ref_fid, statp, mvcc_ref); + JAVADB_STAT_INT(jnienv, jobj, txn_active_status_fid, statp, status); + JAVADB_STAT_GID(jnienv, jobj, txn_active_gid_fid, statp, gid); + JAVADB_STAT_STRING(jnienv, jobj, txn_active_name_fid, statp, name); + return (0); +} diff --git a/libdb_java/java_typemaps.i b/libdb_java/java_typemaps.i new file mode 100644 index 0000000..9e70bf3 --- /dev/null +++ b/libdb_java/java_typemaps.i @@ -0,0 +1,769 @@ +/* Typemaps */ +%define JAVA_TYPEMAP(_ctype, _jtype, _jnitype) +%typemap(jstype) _ctype #_jtype +%typemap(jtype) _ctype #_jtype +%typemap(jni) _ctype #_jnitype +%typemap(out) _ctype %{ $result = (_jnitype)$1; %} +%typemap(javain) _ctype "$javainput" +%typemap(javaout) _ctype { return $jnicall; } +%enddef + +JAVA_TYPEMAP(int32_t, int, jint) +JAVA_TYPEMAP(u_int32_t, int, jint) +JAVA_TYPEMAP(u_int32_t pagesize, long, jlong) +JAVA_TYPEMAP(long, long, jlong) +JAVA_TYPEMAP(db_seq_t, long, jlong) +JAVA_TYPEMAP(pid_t, long, jlong) +#ifndef SWIGJAVA +JAVA_TYPEMAP(db_threadid_t, long, jlong) +#endif +JAVA_TYPEMAP(db_timeout_t, long, jlong) +JAVA_TYPEMAP(size_t, long, jlong) +JAVA_TYPEMAP(db_ret_t, void, void) +%typemap(javaout) db_ret_t { $jnicall; } +%typemap(out) db_ret_t "" + +JAVA_TYPEMAP(int_bool, boolean, jboolean) +%typemap(in) int_bool %{ $1 = ($input == JNI_TRUE); %} +%typemap(out) int_bool %{ $result = ($1) ? JNI_TRUE : JNI_FALSE; %} + +/* Dbt handling */ +JAVA_TYPEMAP(DBT *, com.sleepycat.db.DatabaseEntry, jobject) + +%{ +typedef struct __dbt_locked { + JNIEnv *jenv; + jobject jdbt; + DBT dbt; + jobject jdata_nio; + jbyteArray jarr; + jint offset; + int reuse; + u_int32_t orig_size; + jsize array_len; +} DBT_LOCKED; + +static int __dbj_dbt_memcopy(DBT *dbt, u_int32_t offset, void *buf, u_int32_t size, u_int32_t flags) { + DBT_LOCKED *ldbt = dbt->app_data; + JNIEnv *jenv = ldbt->jenv; + + if (size == 0) + return (0); + else if (!F_ISSET(dbt, DB_DBT_USERCOPY)) { + /* + * For simplicity, the Java API calls this function directly, + * so it needs to work with regular DBTs. + */ + switch (flags) { + case DB_USERCOPY_GETDATA: + memcpy(buf, (u_int8_t *)dbt->data + offset, size); + return (0); + case DB_USERCOPY_SETDATA: + memcpy((u_int8_t *)dbt->data + offset, buf, size); + return (0); + default: + return (EINVAL); + } + } + + switch (flags) { + case DB_USERCOPY_GETDATA: + (*jenv)->GetByteArrayRegion(jenv, ldbt->jarr, ldbt->offset + + offset, size, buf); + break; + case DB_USERCOPY_SETDATA: + /* + * Check whether this is the first time through the callback by relying + * on the offset being zero. + */ + if (offset == 0 && (!ldbt->reuse || + (jsize)(ldbt->offset + dbt->size) > ldbt->array_len)) { + if (ldbt->jarr != NULL) + (*jenv)->DeleteLocalRef(jenv, ldbt->jarr); + ldbt->jarr = (*jenv)->NewByteArray(jenv, (jsize)dbt->size); + if (ldbt->jarr == NULL) + return (ENOMEM); + (*jenv)->SetObjectField(jenv, ldbt->jdbt, dbt_data_fid, ldbt->jarr); + /* We've allocated a new array, start from the beginning. */ + ldbt->offset = 0; + } + (*jenv)->SetByteArrayRegion(jenv, ldbt->jarr, ldbt->offset + + offset, size, buf); + break; + default: + return (EINVAL); + } + return ((*jenv)->ExceptionOccurred(jenv) ? EINVAL : 0); +} + +static void __dbj_dbt_copyout( + JNIEnv *jenv, const DBT *dbt, jbyteArray *jarr, jobject jdbt) +{ + jbyteArray newarr = (*jenv)->NewByteArray(jenv, (jsize)dbt->size); + if (newarr == NULL) + return; /* An exception is pending */ + (*jenv)->SetByteArrayRegion(jenv, newarr, 0, (jsize)dbt->size, + (jbyte *)dbt->data); + (*jenv)->SetObjectField(jenv, jdbt, dbt_data_fid, newarr); + (*jenv)->SetIntField(jenv, jdbt, dbt_offset_fid, 0); + (*jenv)->SetIntField(jenv, jdbt, dbt_size_fid, (jint)dbt->size); + if (jarr != NULL) + *jarr = newarr; + else + (*jenv)->DeleteLocalRef(jenv, newarr); +} + +static int __dbj_dbt_copyin( + JNIEnv *jenv, DBT_LOCKED *ldbt, DBT **dbtp, jobject jdbt, int allow_null) +{ + DBT *dbt; + jlong capacity; + + memset(ldbt, 0, sizeof (*ldbt)); + ldbt->jenv = jenv; + ldbt->jdbt = jdbt; + + if (jdbt == NULL) { + if (allow_null) { + *dbtp = NULL; + return (0); + } else { + return (__dbj_throw(jenv, EINVAL, + "DatabaseEntry must not be null", NULL, NULL)); + } + } + + dbt = &ldbt->dbt; + if (dbtp != NULL) + *dbtp = dbt; + + ldbt->jdata_nio = (*jenv)->GetObjectField(jenv, jdbt, dbt_data_nio_fid); + if (ldbt->jdata_nio != NULL) + F_SET(dbt, DB_DBT_USERMEM); + else + ldbt->jarr = (jbyteArray)(*jenv)->GetObjectField(jenv, jdbt, dbt_data_fid); + ldbt->offset = (*jenv)->GetIntField(jenv, jdbt, dbt_offset_fid); + dbt->size = (*jenv)->GetIntField(jenv, jdbt, dbt_size_fid); + ldbt->orig_size = dbt->size; + dbt->flags = (*jenv)->GetIntField(jenv, jdbt, dbt_flags_fid); + + if (F_ISSET(dbt, DB_DBT_USERMEM)) + dbt->ulen = (*jenv)->GetIntField(jenv, jdbt, dbt_ulen_fid); + if (F_ISSET(dbt, DB_DBT_PARTIAL)) { + dbt->dlen = (*jenv)->GetIntField(jenv, jdbt, dbt_dlen_fid); + dbt->doff = (*jenv)->GetIntField(jenv, jdbt, dbt_doff_fid); + + if ((jint)dbt->doff < 0) + return (__dbj_throw(jenv, EINVAL, "DatabaseEntry doff illegal", + NULL, NULL)); + } + + /* + * We don't support DB_DBT_REALLOC - map anything that's not USERMEM to + * MALLOC. + */ + if (!F_ISSET(dbt, DB_DBT_USERMEM)) { + ldbt->reuse = !F_ISSET(dbt, DB_DBT_MALLOC); + F_CLR(dbt, DB_DBT_MALLOC | DB_DBT_REALLOC); + } + + /* Verify parameters before allocating or locking data. */ + if (ldbt->jdata_nio != NULL) { + capacity = (*jenv)->GetDirectBufferCapacity(jenv, + ldbt->jdata_nio); + if (capacity > (jlong)UINT32_MAX) + return (__dbj_throw(jenv, EINVAL, + "DirectBuffer may not be larger than 4GB", + NULL, NULL)); + ldbt->array_len = (u_int32_t)capacity; + } else if (ldbt->jarr == NULL) { + /* + * Some code makes the assumption that if a DBT's size or ulen + * is non-zero, there is data to copy from dbt->data. + * + * Clean up the dbt fields so we don't run into trouble. + * (Note that doff, dlen, and flags all may contain + * meaningful values.) + */ + dbt->data = NULL; + ldbt->array_len = ldbt->offset = dbt->size = dbt->ulen = 0; + } else + ldbt->array_len = (*jenv)->GetArrayLength(jenv, ldbt->jarr); + + if (F_ISSET(dbt, DB_DBT_USERMEM)) { + if (ldbt->offset < 0) + return (__dbj_throw(jenv, EINVAL, + "offset cannot be negative", + NULL, NULL)); + if (dbt->size > dbt->ulen) + return (__dbj_throw(jenv, EINVAL, + "size must be less than or equal to ulen", + NULL, NULL)); + if ((jsize)(ldbt->offset + dbt->ulen) > ldbt->array_len) + return (__dbj_throw(jenv, EINVAL, + "offset + ulen greater than array length", + NULL, NULL)); + } + + if (ldbt->jdata_nio) { + dbt->data = (*jenv)->GetDirectBufferAddress(jenv, + ldbt->jdata_nio); + dbt->data = (u_int8_t *)dbt->data + ldbt->offset; + } else if (F_ISSET(dbt, DB_DBT_USERMEM)) { + if (ldbt->jarr != NULL && + (dbt->data = (*jenv)->GetByteArrayElements(jenv, + ldbt->jarr, NULL)) == NULL) + return (EINVAL); /* an exception will be pending */ + dbt->data = (u_int8_t *)dbt->data + ldbt->offset; + } else + F_SET(dbt, DB_DBT_USERCOPY); + dbt->app_data = ldbt; + + return (0); +} + +static void __dbj_dbt_release( + JNIEnv *jenv, jobject jdbt, DBT *dbt, DBT_LOCKED *ldbt) { + jthrowable t; + + if (dbt == NULL) + return; + + if (dbt->size != ldbt->orig_size) + (*jenv)->SetIntField(jenv, jdbt, dbt_size_fid, (jint)dbt->size); + + if (F_ISSET(dbt, DB_DBT_USERMEM)) { + if (ldbt->jarr != NULL) + (*jenv)->ReleaseByteArrayElements(jenv, ldbt->jarr, + (jbyte *)dbt->data - ldbt->offset, 0); + + if (dbt->size > dbt->ulen && + (t = (*jenv)->ExceptionOccurred(jenv)) != NULL && + (*jenv)->IsInstanceOf(jenv, t, memex_class)) { + (*jenv)->CallNonvirtualVoidMethod(jenv, t, memex_class, + memex_update_method, jdbt); + /* + * We have to rethrow the exception because calling + * into Java clears it. + */ + (*jenv)->Throw(jenv, t); + } + } +} +%} + +%typemap(in) DBT * (DBT_LOCKED ldbt) %{ + if (__dbj_dbt_copyin(jenv, &ldbt, &$1, $input, 0) != 0) { + return $null; /* An exception will be pending. */ + }%} + +/* Special cases for DBTs that may be null: DbEnv.rep_start, Db.compact Db.set_partition */ +%typemap(in) DBT *data_or_null (DBT_LOCKED ldbt) %{ + if (__dbj_dbt_copyin(jenv, &ldbt, &$1, $input, 1) != 0) { + return $null; /* An exception will be pending. */ + }%} + +%apply DBT *data_or_null {DBT *cdata, DBT *start, DBT *stop, DBT *end, DBT *db_put_data, DBT *keys}; + +%typemap(freearg) DBT * %{ __dbj_dbt_release(jenv, $input, $1, &ldbt$argnum); %} + +/* DbLsn handling */ +JAVA_TYPEMAP(DB_LSN *, com.sleepycat.db.LogSequenceNumber, jobject) + +%typemap(check) DB_LSN *lsn_or_null "" + +%typemap(check) DB_LSN * %{ + if ($1 == NULL) { + __dbj_throw(jenv, EINVAL, "null LogSequenceNumber", NULL, NULL); + return $null; + } +%} + +%typemap(in) DB_LSN * (DB_LSN lsn) %{ + if ($input == NULL) { + $1 = NULL; + } else { + $1 = &lsn; + $1->file = (*jenv)->GetIntField(jenv, $input, dblsn_file_fid); + $1->offset = (*jenv)->GetIntField(jenv, $input, + dblsn_offset_fid); + } +%} + +%typemap(freearg) DB_LSN * %{ + if ($input != NULL) { + (*jenv)->SetIntField(jenv, $input, dblsn_file_fid, $1->file); + (*jenv)->SetIntField(jenv, $input, + dblsn_offset_fid, $1->offset); + } +%} + +/* Various typemaps */ +JAVA_TYPEMAP(time_t, long, jlong) +JAVA_TYPEMAP(time_t *, long, jlong) +%typemap(in) time_t * (time_t time) %{ + time = (time_t)$input; + $1 = &time; +%} + +JAVA_TYPEMAP(DB_KEY_RANGE *, com.sleepycat.db.KeyRange, jobject) +%typemap(in) DB_KEY_RANGE * (DB_KEY_RANGE range) { + $1 = ⦥ +} +%typemap(argout) DB_KEY_RANGE * { + (*jenv)->SetDoubleField(jenv, $input, kr_less_fid, $1->less); + (*jenv)->SetDoubleField(jenv, $input, kr_equal_fid, $1->equal); + (*jenv)->SetDoubleField(jenv, $input, kr_greater_fid, $1->greater); +} + +JAVA_TYPEMAP(DBC **, Dbc[], jobjectArray) +%typemap(in) DBC ** { + int i, count, err; + + count = (*jenv)->GetArrayLength(jenv, $input); + if ((err = __os_malloc(NULL, (count + 1) * sizeof(DBC *), &$1)) != 0) { + __dbj_throw(jenv, err, NULL, NULL, DB2JDBENV); + return $null; + } + for (i = 0; i < count; i++) { + jobject jobj = (*jenv)->GetObjectArrayElement(jenv, $input, i); + /* + * A null in the array is treated as an endpoint. + */ + if (jobj == NULL) { + $1[i] = NULL; + break; + } else { + jlong jptr = (*jenv)->GetLongField(jenv, jobj, + dbc_cptr_fid); + $1[i] = *(DBC **)(void *)&jptr; + } + } + $1[count] = NULL; +} + +%typemap(freearg) DBC ** %{ + __os_free(NULL, $1); +%} + +JAVA_TYPEMAP(u_int8_t *gid, byte[], jbyteArray) +%typemap(check) u_int8_t *gid %{ + if ((*jenv)->GetArrayLength(jenv, $input) < DB_GID_SIZE) { + __dbj_throw(jenv, EINVAL, + "DbTxn.prepare gid array must be >= 128 bytes", NULL, + TXN2JDBENV); + return $null; + } +%} + +%typemap(in) u_int8_t *gid %{ + $1 = (u_int8_t *)(*jenv)->GetByteArrayElements(jenv, $input, NULL); +%} + +%typemap(freearg) u_int8_t *gid %{ + (*jenv)->ReleaseByteArrayElements(jenv, $input, (jbyte *)$1, 0); +%} + +%define STRING_ARRAY_OUT + int i, len; + + len = 0; + while ($1[len] != NULL) + len++; + if (($result = (*jenv)->NewObjectArray(jenv, (jsize)len, string_class, + NULL)) == NULL) + return $null; /* an exception is pending */ + for (i = 0; i < len; i++) { + jstring str = (*jenv)->NewStringUTF(jenv, $1[i]); + (*jenv)->SetObjectArrayElement(jenv, $result, (jsize)i, str); + } +%enddef + +JAVA_TYPEMAP(char **, String[], jobjectArray) +%typemap(out) const char ** { + if ($1 != NULL) { + STRING_ARRAY_OUT + } +} +%typemap(out) char ** { + if ($1 != NULL) { + STRING_ARRAY_OUT + __os_ufree(NULL, $1); + } +} + +JAVA_TYPEMAP(struct __db_lk_conflicts, byte[][], jobjectArray) +%typemap(in) struct __db_lk_conflicts { + int i, len, err; + size_t bytesize; + + len = $1.lk_modes = (*jenv)->GetArrayLength(jenv, $input); + bytesize = sizeof(u_char) * len * len; + + if ((err = __os_malloc(NULL, bytesize, &$1.lk_conflicts)) != 0) { + __dbj_throw(jenv, err, NULL, NULL, JDBENV); + return $null; + } + + for (i = 0; i < len; i++) { + jobject sub_array = (*jenv)->GetObjectArrayElement(jenv, + $input, i); + (*jenv)->GetByteArrayRegion(jenv,(jbyteArray)sub_array, 0, len, + (jbyte *)&$1.lk_conflicts[i * len]); + } +} + +%typemap(freearg) struct __db_lk_conflicts %{ + __os_free(NULL, $1.lk_conflicts); +%} + +%typemap(out) struct __db_lk_conflicts { + int i; + jbyteArray bytes; + + $result = (*jenv)->NewObjectArray(jenv, + (jsize)$1.lk_modes, bytearray_class, NULL); + if ($result == NULL) + return $null; /* an exception is pending */ + for (i = 0; i < $1.lk_modes; i++) { + bytes = (*jenv)->NewByteArray(jenv, (jsize)$1.lk_modes); + if (bytes == NULL) + return $null; /* an exception is pending */ + (*jenv)->SetByteArrayRegion(jenv, bytes, 0, (jsize)$1.lk_modes, + (jbyte *)($1.lk_conflicts + i * $1.lk_modes)); + (*jenv)->SetObjectArrayElement(jenv, $result, (jsize)i, bytes); + } +} + +%{ +struct __dbj_verify_data { + JNIEnv *jenv; + jobject streamobj; + jbyteArray bytes; + int nbytes; +}; + +static int __dbj_verify_callback(void *handle, const void *str_arg) { + char *str; + struct __dbj_verify_data *vd; + int len; + JNIEnv *jenv; + + str = (char *)str_arg; + vd = (struct __dbj_verify_data *)handle; + jenv = vd->jenv; + len = (int)strlen(str) + 1; + if (len > vd->nbytes) { + vd->nbytes = len; + if (vd->bytes != NULL) + (*jenv)->DeleteLocalRef(jenv, vd->bytes); + if ((vd->bytes = (*jenv)->NewByteArray(jenv, (jsize)len)) + == NULL) + return (ENOMEM); + } + + if (vd->bytes != NULL) { + (*jenv)->SetByteArrayRegion(jenv, vd->bytes, 0, (jsize)len, + (jbyte*)str); + (*jenv)->CallVoidMethod(jenv, vd->streamobj, + outputstream_write_method, vd->bytes, 0, len - 1); + } + + if ((*jenv)->ExceptionOccurred(jenv) != NULL) + return (EIO); + + return (0); +} +%} + +JAVA_TYPEMAP(struct __db_out_stream, java.io.OutputStream, jobject) +%typemap(in) struct __db_out_stream (struct __dbj_verify_data data) { + data.jenv = jenv; + data.streamobj = $input; + data.bytes = NULL; + data.nbytes = 0; + $1.handle = &data; + $1.callback = __dbj_verify_callback; +} + +JAVA_TYPEMAP(DB_PREPLIST *, com.sleepycat.db.PreparedTransaction[], + jobjectArray) +%typemap(out) DB_PREPLIST * { + int i, len; + + len = 0; + while ($1[len].txn != NULL) + len++; + $result = (*jenv)->NewObjectArray(jenv, (jsize)len, dbpreplist_class, + NULL); + if ($result == NULL) + return $null; /* an exception is pending */ + for (i = 0; i < len; i++) { + jobject jtxn = (*jenv)->NewObject(jenv, dbtxn_class, + dbtxn_construct, $1[i].txn, JNI_FALSE); + jobject bytearr = (*jenv)->NewByteArray(jenv, + (jsize)sizeof($1[i].gid)); + jobject obj = (*jenv)->NewObject(jenv, dbpreplist_class, + dbpreplist_construct, jtxn, bytearr); + + if (jtxn == NULL || bytearr == NULL || obj == NULL) + return $null; /* An exception is pending */ + + (*jenv)->SetByteArrayRegion(jenv, bytearr, 0, + (jsize)sizeof($1[i].gid), (jbyte *)$1[i].gid); + (*jenv)->SetObjectArrayElement(jenv, $result, i, obj); + } + __os_ufree(NULL, $1); +} + +JAVA_TYPEMAP(DB_LOCKREQ *, com.sleepycat.db.LockRequest[], jobjectArray) + +%native(DbEnv_lock_vec) void DbEnv_lock_vec(DB_ENV *dbenv, u_int32_t locker, + u_int32_t flags, DB_LOCKREQ *list, int offset, int nlist); +%{ +SWIGEXPORT void JNICALL +Java_com_sleepycat_db_internal_db_1javaJNI_DbEnv_1lock_1vec(JNIEnv *jenv, + jclass jcls, jlong jdbenvp, jobject jdbenv, jint locker, jint flags, + jobjectArray list, jint offset, jint count) { + DB_ENV *dbenv; + DB_LOCKREQ *lockreq; + DB_LOCKREQ *prereq; /* preprocessed requests */ + DB_LOCKREQ *failedreq; + DB_LOCK *lockp; + DBT_LOCKED *locked_dbts; + DBT *obj; + ENV *env; + int err, alloc_err, i; + size_t bytesize, ldbtsize; + jobject jlockreq; + db_lockop_t op; + jobject jobj, jlock; + jlong jlockp; + int completed; + + /* + * We can't easily #include "dbinc/db_ext.h" because of name + * clashes, so we declare this explicitly. + */ + extern int __dbt_usercopy __P((ENV *, DBT *)); + extern void __dbt_userfree __P((ENV *, DBT *, DBT *, DBT *)); + + COMPQUIET(jcls, NULL); + dbenv = *(DB_ENV **)(void *)&jdbenvp; + env = dbenv->env; + locked_dbts = NULL; + lockreq = NULL; + + if (dbenv == NULL) { + __dbj_throw(jenv, EINVAL, "null object", NULL, jdbenv); + return; + } + + if ((*jenv)->GetArrayLength(jenv, list) < offset + count) { + __dbj_throw(jenv, EINVAL, + "DbEnv.lock_vec array not large enough", NULL, jdbenv); + return; + } + + bytesize = sizeof(DB_LOCKREQ) * count; + if ((err = __os_malloc(env, bytesize, &lockreq)) != 0) { + __dbj_throw(jenv, err, NULL, NULL, jdbenv); + return; + } + memset(lockreq, 0, bytesize); + + ldbtsize = sizeof(DBT_LOCKED) * count; + if ((err = __os_malloc(env, ldbtsize, &locked_dbts)) != 0) { + __dbj_throw(jenv, err, NULL, NULL, jdbenv); + goto err; + } + memset(locked_dbts, 0, ldbtsize); + prereq = &lockreq[0]; + + /* fill in the lockreq array */ + for (i = 0, prereq = &lockreq[0]; i < count; i++, prereq++) { + jlockreq = (*jenv)->GetObjectArrayElement(jenv, list, + offset + i); + if (jlockreq == NULL) { + __dbj_throw(jenv, EINVAL, + "DbEnv.lock_vec list entry is null", NULL, jdbenv); + goto err; + } + op = (db_lockop_t)(*jenv)->GetIntField( + jenv, jlockreq, lockreq_op_fid); + prereq->op = op; + + switch (op) { + case DB_LOCK_GET_TIMEOUT: + /* Needed: mode, timeout, obj. Returned: lock. */ + prereq->op = (db_lockop_t)(*jenv)->GetIntField( + jenv, jlockreq, lockreq_timeout_fid); + /* FALLTHROUGH */ + case DB_LOCK_GET: + /* Needed: mode, obj. Returned: lock. */ + prereq->mode = (db_lockmode_t)(*jenv)->GetIntField( + jenv, jlockreq, lockreq_modeflag_fid); + jobj = (*jenv)->GetObjectField(jenv, jlockreq, + lockreq_obj_fid); + if ((err = __dbj_dbt_copyin(jenv, + &locked_dbts[i], &obj, jobj, 0)) != 0 || + (err = __dbt_usercopy(env, obj)) != 0) + goto err; + prereq->obj = obj; + break; + case DB_LOCK_PUT: + /* Needed: lock. Ignored: mode, obj. */ + jlock = (*jenv)->GetObjectField(jenv, jlockreq, + lockreq_lock_fid); + if (jlock == NULL || + (jlockp = (*jenv)->GetLongField(jenv, jlock, + lock_cptr_fid)) == 0L) { + __dbj_throw(jenv, EINVAL, + "LockRequest lock field is NULL", NULL, + jdbenv); + goto err; + } + lockp = *(DB_LOCK **)(void *)&jlockp; + prereq->lock = *lockp; + break; + case DB_LOCK_PUT_ALL: + case DB_LOCK_TIMEOUT: + /* Needed: (none). Ignored: lock, mode, obj. */ + break; + case DB_LOCK_PUT_OBJ: + /* Needed: obj. Ignored: lock, mode. */ + jobj = (*jenv)->GetObjectField(jenv, jlockreq, + lockreq_obj_fid); + if ((err = __dbj_dbt_copyin(jenv, + &locked_dbts[i], &obj, jobj, 0)) != 0 || + (err = __dbt_usercopy(env, obj)) != 0) + goto err; + prereq->obj = obj; + break; + default: + __dbj_throw(jenv, EINVAL, + "DbEnv.lock_vec bad op value", NULL, jdbenv); + goto err; + } + } + + err = dbenv->lock_vec(dbenv, (u_int32_t)locker, (u_int32_t)flags, + lockreq, count, &failedreq); + if (err == 0) + completed = count; + else + completed = (int)(failedreq - lockreq); + + /* do post processing for any and all requests that completed */ + for (i = 0; i < completed; i++) { + op = lockreq[i].op; + if (op == DB_LOCK_PUT) { + /* + * After a successful put, the DbLock can no longer be + * used, so we release the storage related to it. + */ + jlockreq = (*jenv)->GetObjectArrayElement(jenv, + list, i + offset); + jlock = (*jenv)->GetObjectField(jenv, jlockreq, + lockreq_lock_fid); + jlockp = (*jenv)->GetLongField(jenv, jlock, + lock_cptr_fid); + lockp = *(DB_LOCK **)(void *)&jlockp; + __os_free(NULL, lockp); + (*jenv)->SetLongField(jenv, jlock, lock_cptr_fid, + (jlong)0); + } else if (op == DB_LOCK_GET_TIMEOUT || op == DB_LOCK_GET) { + /* + * Store the lock that was obtained. We need to create + * storage for it since the lockreq array only exists + * during this method call. + */ + if ((alloc_err = + __os_malloc(env, sizeof(DB_LOCK), &lockp)) != 0) { + __dbj_throw(jenv, alloc_err, NULL, NULL, + jdbenv); + goto err; + } + + *lockp = lockreq[i].lock; + *(DB_LOCK **)(void *)&jlockp = lockp; + + jlockreq = (*jenv)->GetObjectArrayElement(jenv, + list, i + offset); + jlock = (*jenv)->NewObject(jenv, lock_class, + lock_construct, jlockp, JNI_TRUE); + if (jlock == NULL) + goto err; /* An exception is pending */ + (*jenv)->SetLongField(jenv, jlock, lock_cptr_fid, + jlockp); + (*jenv)->SetObjectField(jenv, jlockreq, + lockreq_lock_fid, jlock); + } + } + + /* If one of the locks was not granted, build the exception now. */ + if (err == DB_LOCK_NOTGRANTED && i < count) { + jlockreq = (*jenv)->GetObjectArrayElement(jenv, list, + i + offset); + jobj = (*jenv)->GetObjectField(jenv, jlockreq, lockreq_obj_fid); + jlock = (*jenv)->GetObjectField(jenv, jlockreq, + lockreq_lock_fid); + (*jenv)->Throw(jenv, + (*jenv)->NewObject(jenv, lockex_class, lockex_construct, + (*jenv)->NewStringUTF(jenv, "DbEnv.lock_vec incomplete"), + lockreq[i].op, lockreq[i].mode, jobj, jlock, i, jdbenv)); + } else if (err != 0) + __dbj_throw(jenv, err, NULL, NULL, jdbenv); + +err: for (i = 0, prereq = &lockreq[0]; i < count; i++, prereq++) + if (prereq->op == DB_LOCK_GET_TIMEOUT || + prereq->op == DB_LOCK_GET || + prereq->op == DB_LOCK_PUT_OBJ) { + jlockreq = (*jenv)->GetObjectArrayElement(jenv, + list, i + offset); + jobj = (*jenv)->GetObjectField(jenv, + jlockreq, lockreq_obj_fid); + __dbt_userfree(env, prereq->obj, NULL, NULL); + __dbj_dbt_release(jenv, jobj, prereq->obj, &locked_dbts[i]); + } + if (locked_dbts != NULL) + __os_free(env, locked_dbts); + if (lockreq != NULL) + __os_free(env, lockreq); +} +%} + +JAVA_TYPEMAP(struct __db_repmgr_sites, + com.sleepycat.db.ReplicationManagerSiteInfo[], jobjectArray) +%typemap(out) struct __db_repmgr_sites +{ + int i, len; + jobject jrep_addr, jrep_info; + + len = $1.nsites; + $result = (*jenv)->NewObjectArray(jenv, (jsize)len, repmgr_siteinfo_class, + NULL); + if ($result == NULL) + return $null; /* an exception is pending */ + for (i = 0; i < len; i++) { + jstring addr_host = (*jenv)->NewStringUTF(jenv, $1.sites[i].host); + if (addr_host == NULL) + return $null; /* An exception is pending */ + jrep_addr = (*jenv)->NewObject(jenv, + rephost_class, rephost_construct, addr_host, $1.sites[i].port); + if (jrep_addr == NULL) + return $null; /* An exception is pending */ + + jrep_info = (*jenv)->NewObject(jenv, + repmgr_siteinfo_class, repmgr_siteinfo_construct, jrep_addr, $1.sites[i].eid); + (*jenv)->SetIntField(jenv, jrep_info, repmgr_siteinfo_status_fid, + $1.sites[i].status); + if (jrep_info == NULL) + return $null; /* An exception is pending */ + + (*jenv)->SetObjectArrayElement(jenv, $result, i, jrep_info); + } + __os_ufree(NULL, $1.sites); +} + +JAVA_TYPEMAP(void *, Object, jobject) diff --git a/libdb_java/java_util.i b/libdb_java/java_util.i new file mode 100644 index 0000000..1880d2d --- /dev/null +++ b/libdb_java/java_util.i @@ -0,0 +1,1046 @@ +%pragma(java) jniclasscode=%{ + static { + /* An alternate library name can be specified via a property. */ + String libname; + int v_major, v_minor, v_patch; + + v_major = DbConstants.DB_VERSION_MAJOR; + v_minor = DbConstants.DB_VERSION_MINOR; + v_patch = DbConstants.DB_VERSION_PATCH; + + if ((libname = + System.getProperty("sleepycat.db.libfile")) != null) + System.load(libname); + else if ((libname = + System.getProperty("sleepycat.db.libname")) != null) + System.loadLibrary(libname); + else { + String os = System.getProperty("os.name"); + if (os != null && os.startsWith("Windows")) { + /* + * On Windows, library name is something like + * "libdb_java42.dll" or "libdb_java42d.dll". + */ + libname = "libdb_java" + v_major + v_minor; + + try { + System.loadLibrary(libname); + } catch (UnsatisfiedLinkError e) { + try { + libname += "d"; + System.loadLibrary(libname); + } catch (UnsatisfiedLinkError e2) { + throw e; + } + } + } else { + /* + * On UNIX, library name is something like + * "libdb_java-3.0.so". + */ + System.loadLibrary("db_java-" + + v_major + "." + v_minor); + } + } + + initialize(); + + if (DbEnv_get_version_major() != v_major || + DbEnv_get_version_minor() != v_minor || + DbEnv_get_version_patch() != v_patch) + throw new RuntimeException( + "Berkeley DB library version " + + DbEnv_get_version_major() + "." + + DbEnv_get_version_minor() + "." + + DbEnv_get_version_patch() + + " doesn't match Java class library version " + + v_major + "." + v_minor + "." + v_patch); + } + + static native final void initialize(); +%} + +%{ +/* don't use SWIG's array handling - save code space */ +#define SWIG_NOINCLUDE 1 + +#define DB_ENV_INTERNAL(dbenv) ((dbenv)->api2_internal) +#define DB_INTERNAL(db) ((db)->api_internal) + +#define DB_PKG "com/sleepycat/db/" + +/* Forward declarations */ +static int __dbj_throw(JNIEnv *jenv, + int err, const char *msg, jobject obj, jobject jdbenv); + +/* Global data - JVM handle, classes, fields and methods */ +static JavaVM *javavm; + +static jclass db_class, dbc_class, dbenv_class, dbt_class, dblsn_class; +static jclass dbpreplist_class, dbtxn_class; +static jclass keyrange_class; +static jclass bt_stat_class, compact_class, h_stat_class, lock_stat_class; +static jclass log_stat_class, mpool_stat_class, mpool_fstat_class; +static jclass mutex_stat_class, qam_stat_class, rep_stat_class; +static jclass repmgr_stat_class, repmgr_siteinfo_class, rephost_class; +static jclass seq_stat_class, txn_stat_class; +static jclass txn_active_class; +static jclass lock_class, lockreq_class; +static jclass dbex_class, deadex_class, lockex_class, memex_class; +static jclass repdupmasterex_class, rephandledeadex_class; +static jclass repholdelectionex_class, repjoinfailex_class; +static jclass repleaseexpiredex_class, repleasetimeoutex_class; +static jclass replockoutex_class, repunavailex_class; +static jclass runrecex_class, versionex_class; +static jclass filenotfoundex_class, illegalargex_class, outofmemerr_class; +static jclass bytearray_class, string_class, outputstream_class; + +static jfieldID dbc_cptr_fid; +static jfieldID dblsn_file_fid, dblsn_offset_fid; +static jfieldID dbt_data_fid, dbt_data_nio_fid, dbt_size_fid, dbt_ulen_fid; +static jfieldID dbt_dlen_fid, dbt_doff_fid, dbt_flags_fid, dbt_offset_fid; +static jfieldID kr_less_fid, kr_equal_fid, kr_greater_fid; +static jfieldID lock_cptr_fid; +static jfieldID lockreq_op_fid, lockreq_modeflag_fid, lockreq_timeout_fid; +static jfieldID lockreq_obj_fid, lockreq_lock_fid; +static jfieldID repmgr_siteinfo_status_fid; + +/* BEGIN-STAT-FIELD-DECLS */ +static jfieldID bt_stat_bt_magic_fid; +static jfieldID bt_stat_bt_version_fid; +static jfieldID bt_stat_bt_metaflags_fid; +static jfieldID bt_stat_bt_nkeys_fid; +static jfieldID bt_stat_bt_ndata_fid; +static jfieldID bt_stat_bt_pagecnt_fid; +static jfieldID bt_stat_bt_pagesize_fid; +static jfieldID bt_stat_bt_minkey_fid; +static jfieldID bt_stat_bt_re_len_fid; +static jfieldID bt_stat_bt_re_pad_fid; +static jfieldID bt_stat_bt_levels_fid; +static jfieldID bt_stat_bt_int_pg_fid; +static jfieldID bt_stat_bt_leaf_pg_fid; +static jfieldID bt_stat_bt_dup_pg_fid; +static jfieldID bt_stat_bt_over_pg_fid; +static jfieldID bt_stat_bt_empty_pg_fid; +static jfieldID bt_stat_bt_free_fid; +static jfieldID bt_stat_bt_int_pgfree_fid; +static jfieldID bt_stat_bt_leaf_pgfree_fid; +static jfieldID bt_stat_bt_dup_pgfree_fid; +static jfieldID bt_stat_bt_over_pgfree_fid; +static jfieldID compact_compact_fillpercent_fid; +static jfieldID compact_compact_timeout_fid; +static jfieldID compact_compact_pages_fid; +static jfieldID compact_compact_pages_free_fid; +static jfieldID compact_compact_pages_examine_fid; +static jfieldID compact_compact_levels_fid; +static jfieldID compact_compact_deadlock_fid; +static jfieldID compact_compact_pages_truncated_fid; +static jfieldID compact_compact_truncate_fid; +static jfieldID h_stat_hash_magic_fid; +static jfieldID h_stat_hash_version_fid; +static jfieldID h_stat_hash_metaflags_fid; +static jfieldID h_stat_hash_nkeys_fid; +static jfieldID h_stat_hash_ndata_fid; +static jfieldID h_stat_hash_pagecnt_fid; +static jfieldID h_stat_hash_pagesize_fid; +static jfieldID h_stat_hash_ffactor_fid; +static jfieldID h_stat_hash_buckets_fid; +static jfieldID h_stat_hash_free_fid; +static jfieldID h_stat_hash_bfree_fid; +static jfieldID h_stat_hash_bigpages_fid; +static jfieldID h_stat_hash_big_bfree_fid; +static jfieldID h_stat_hash_overflows_fid; +static jfieldID h_stat_hash_ovfl_free_fid; +static jfieldID h_stat_hash_dup_fid; +static jfieldID h_stat_hash_dup_free_fid; +static jfieldID lock_stat_st_id_fid; +static jfieldID lock_stat_st_cur_maxid_fid; +static jfieldID lock_stat_st_maxlocks_fid; +static jfieldID lock_stat_st_maxlockers_fid; +static jfieldID lock_stat_st_maxobjects_fid; +static jfieldID lock_stat_st_partitions_fid; +static jfieldID lock_stat_st_nmodes_fid; +static jfieldID lock_stat_st_nlockers_fid; +static jfieldID lock_stat_st_nlocks_fid; +static jfieldID lock_stat_st_maxnlocks_fid; +static jfieldID lock_stat_st_maxhlocks_fid; +static jfieldID lock_stat_st_locksteals_fid; +static jfieldID lock_stat_st_maxlsteals_fid; +static jfieldID lock_stat_st_maxnlockers_fid; +static jfieldID lock_stat_st_nobjects_fid; +static jfieldID lock_stat_st_maxnobjects_fid; +static jfieldID lock_stat_st_maxhobjects_fid; +static jfieldID lock_stat_st_objectsteals_fid; +static jfieldID lock_stat_st_maxosteals_fid; +static jfieldID lock_stat_st_nrequests_fid; +static jfieldID lock_stat_st_nreleases_fid; +static jfieldID lock_stat_st_nupgrade_fid; +static jfieldID lock_stat_st_ndowngrade_fid; +static jfieldID lock_stat_st_lock_wait_fid; +static jfieldID lock_stat_st_lock_nowait_fid; +static jfieldID lock_stat_st_ndeadlocks_fid; +static jfieldID lock_stat_st_locktimeout_fid; +static jfieldID lock_stat_st_nlocktimeouts_fid; +static jfieldID lock_stat_st_txntimeout_fid; +static jfieldID lock_stat_st_ntxntimeouts_fid; +static jfieldID lock_stat_st_part_wait_fid; +static jfieldID lock_stat_st_part_nowait_fid; +static jfieldID lock_stat_st_part_max_wait_fid; +static jfieldID lock_stat_st_part_max_nowait_fid; +static jfieldID lock_stat_st_objs_wait_fid; +static jfieldID lock_stat_st_objs_nowait_fid; +static jfieldID lock_stat_st_lockers_wait_fid; +static jfieldID lock_stat_st_lockers_nowait_fid; +static jfieldID lock_stat_st_region_wait_fid; +static jfieldID lock_stat_st_region_nowait_fid; +static jfieldID lock_stat_st_hash_len_fid; +static jfieldID lock_stat_st_regsize_fid; +static jfieldID log_stat_st_magic_fid; +static jfieldID log_stat_st_version_fid; +static jfieldID log_stat_st_mode_fid; +static jfieldID log_stat_st_lg_bsize_fid; +static jfieldID log_stat_st_lg_size_fid; +static jfieldID log_stat_st_wc_bytes_fid; +static jfieldID log_stat_st_wc_mbytes_fid; +static jfieldID log_stat_st_record_fid; +static jfieldID log_stat_st_w_bytes_fid; +static jfieldID log_stat_st_w_mbytes_fid; +static jfieldID log_stat_st_wcount_fid; +static jfieldID log_stat_st_wcount_fill_fid; +static jfieldID log_stat_st_rcount_fid; +static jfieldID log_stat_st_scount_fid; +static jfieldID log_stat_st_region_wait_fid; +static jfieldID log_stat_st_region_nowait_fid; +static jfieldID log_stat_st_cur_file_fid; +static jfieldID log_stat_st_cur_offset_fid; +static jfieldID log_stat_st_disk_file_fid; +static jfieldID log_stat_st_disk_offset_fid; +static jfieldID log_stat_st_maxcommitperflush_fid; +static jfieldID log_stat_st_mincommitperflush_fid; +static jfieldID log_stat_st_regsize_fid; +static jfieldID mpool_fstat_file_name_fid; +static jfieldID mpool_fstat_st_pagesize_fid; +static jfieldID mpool_fstat_st_map_fid; +static jfieldID mpool_fstat_st_cache_hit_fid; +static jfieldID mpool_fstat_st_cache_miss_fid; +static jfieldID mpool_fstat_st_page_create_fid; +static jfieldID mpool_fstat_st_page_in_fid; +static jfieldID mpool_fstat_st_page_out_fid; +static jfieldID mpool_stat_st_gbytes_fid; +static jfieldID mpool_stat_st_bytes_fid; +static jfieldID mpool_stat_st_ncache_fid; +static jfieldID mpool_stat_st_max_ncache_fid; +static jfieldID mpool_stat_st_mmapsize_fid; +static jfieldID mpool_stat_st_maxopenfd_fid; +static jfieldID mpool_stat_st_maxwrite_fid; +static jfieldID mpool_stat_st_maxwrite_sleep_fid; +static jfieldID mpool_stat_st_pages_fid; +static jfieldID mpool_stat_st_map_fid; +static jfieldID mpool_stat_st_cache_hit_fid; +static jfieldID mpool_stat_st_cache_miss_fid; +static jfieldID mpool_stat_st_page_create_fid; +static jfieldID mpool_stat_st_page_in_fid; +static jfieldID mpool_stat_st_page_out_fid; +static jfieldID mpool_stat_st_ro_evict_fid; +static jfieldID mpool_stat_st_rw_evict_fid; +static jfieldID mpool_stat_st_page_trickle_fid; +static jfieldID mpool_stat_st_page_clean_fid; +static jfieldID mpool_stat_st_page_dirty_fid; +static jfieldID mpool_stat_st_hash_buckets_fid; +static jfieldID mpool_stat_st_pagesize_fid; +static jfieldID mpool_stat_st_hash_searches_fid; +static jfieldID mpool_stat_st_hash_longest_fid; +static jfieldID mpool_stat_st_hash_examined_fid; +static jfieldID mpool_stat_st_hash_nowait_fid; +static jfieldID mpool_stat_st_hash_wait_fid; +static jfieldID mpool_stat_st_hash_max_nowait_fid; +static jfieldID mpool_stat_st_hash_max_wait_fid; +static jfieldID mpool_stat_st_region_nowait_fid; +static jfieldID mpool_stat_st_region_wait_fid; +static jfieldID mpool_stat_st_mvcc_frozen_fid; +static jfieldID mpool_stat_st_mvcc_thawed_fid; +static jfieldID mpool_stat_st_mvcc_freed_fid; +static jfieldID mpool_stat_st_alloc_fid; +static jfieldID mpool_stat_st_alloc_buckets_fid; +static jfieldID mpool_stat_st_alloc_max_buckets_fid; +static jfieldID mpool_stat_st_alloc_pages_fid; +static jfieldID mpool_stat_st_alloc_max_pages_fid; +static jfieldID mpool_stat_st_io_wait_fid; +static jfieldID mpool_stat_st_sync_interrupted_fid; +static jfieldID mpool_stat_st_regsize_fid; +static jfieldID mutex_stat_st_mutex_align_fid; +static jfieldID mutex_stat_st_mutex_tas_spins_fid; +static jfieldID mutex_stat_st_mutex_cnt_fid; +static jfieldID mutex_stat_st_mutex_free_fid; +static jfieldID mutex_stat_st_mutex_inuse_fid; +static jfieldID mutex_stat_st_mutex_inuse_max_fid; +static jfieldID mutex_stat_st_region_wait_fid; +static jfieldID mutex_stat_st_region_nowait_fid; +static jfieldID mutex_stat_st_regsize_fid; +static jfieldID qam_stat_qs_magic_fid; +static jfieldID qam_stat_qs_version_fid; +static jfieldID qam_stat_qs_metaflags_fid; +static jfieldID qam_stat_qs_nkeys_fid; +static jfieldID qam_stat_qs_ndata_fid; +static jfieldID qam_stat_qs_pagesize_fid; +static jfieldID qam_stat_qs_extentsize_fid; +static jfieldID qam_stat_qs_pages_fid; +static jfieldID qam_stat_qs_re_len_fid; +static jfieldID qam_stat_qs_re_pad_fid; +static jfieldID qam_stat_qs_pgfree_fid; +static jfieldID qam_stat_qs_first_recno_fid; +static jfieldID qam_stat_qs_cur_recno_fid; +static jfieldID rep_stat_st_log_queued_fid; +static jfieldID rep_stat_st_startup_complete_fid; +static jfieldID rep_stat_st_status_fid; +static jfieldID rep_stat_st_next_lsn_fid; +static jfieldID rep_stat_st_waiting_lsn_fid; +static jfieldID rep_stat_st_max_perm_lsn_fid; +static jfieldID rep_stat_st_next_pg_fid; +static jfieldID rep_stat_st_waiting_pg_fid; +static jfieldID rep_stat_st_dupmasters_fid; +static jfieldID rep_stat_st_env_id_fid; +static jfieldID rep_stat_st_env_priority_fid; +static jfieldID rep_stat_st_bulk_fills_fid; +static jfieldID rep_stat_st_bulk_overflows_fid; +static jfieldID rep_stat_st_bulk_records_fid; +static jfieldID rep_stat_st_bulk_transfers_fid; +static jfieldID rep_stat_st_client_rerequests_fid; +static jfieldID rep_stat_st_client_svc_req_fid; +static jfieldID rep_stat_st_client_svc_miss_fid; +static jfieldID rep_stat_st_gen_fid; +static jfieldID rep_stat_st_egen_fid; +static jfieldID rep_stat_st_log_duplicated_fid; +static jfieldID rep_stat_st_log_queued_max_fid; +static jfieldID rep_stat_st_log_queued_total_fid; +static jfieldID rep_stat_st_log_records_fid; +static jfieldID rep_stat_st_log_requested_fid; +static jfieldID rep_stat_st_master_fid; +static jfieldID rep_stat_st_master_changes_fid; +static jfieldID rep_stat_st_msgs_badgen_fid; +static jfieldID rep_stat_st_msgs_processed_fid; +static jfieldID rep_stat_st_msgs_recover_fid; +static jfieldID rep_stat_st_msgs_send_failures_fid; +static jfieldID rep_stat_st_msgs_sent_fid; +static jfieldID rep_stat_st_newsites_fid; +static jfieldID rep_stat_st_nsites_fid; +static jfieldID rep_stat_st_nthrottles_fid; +static jfieldID rep_stat_st_outdated_fid; +static jfieldID rep_stat_st_pg_duplicated_fid; +static jfieldID rep_stat_st_pg_records_fid; +static jfieldID rep_stat_st_pg_requested_fid; +static jfieldID rep_stat_st_txns_applied_fid; +static jfieldID rep_stat_st_startsync_delayed_fid; +static jfieldID rep_stat_st_elections_fid; +static jfieldID rep_stat_st_elections_won_fid; +static jfieldID rep_stat_st_election_cur_winner_fid; +static jfieldID rep_stat_st_election_gen_fid; +static jfieldID rep_stat_st_election_lsn_fid; +static jfieldID rep_stat_st_election_nsites_fid; +static jfieldID rep_stat_st_election_nvotes_fid; +static jfieldID rep_stat_st_election_priority_fid; +static jfieldID rep_stat_st_election_status_fid; +static jfieldID rep_stat_st_election_tiebreaker_fid; +static jfieldID rep_stat_st_election_votes_fid; +static jfieldID rep_stat_st_election_sec_fid; +static jfieldID rep_stat_st_election_usec_fid; +static jfieldID rep_stat_st_max_lease_sec_fid; +static jfieldID rep_stat_st_max_lease_usec_fid; +static jfieldID repmgr_stat_st_perm_failed_fid; +static jfieldID repmgr_stat_st_msgs_queued_fid; +static jfieldID repmgr_stat_st_msgs_dropped_fid; +static jfieldID repmgr_stat_st_connection_drop_fid; +static jfieldID repmgr_stat_st_connect_fail_fid; +static jfieldID seq_stat_st_wait_fid; +static jfieldID seq_stat_st_nowait_fid; +static jfieldID seq_stat_st_current_fid; +static jfieldID seq_stat_st_value_fid; +static jfieldID seq_stat_st_last_value_fid; +static jfieldID seq_stat_st_min_fid; +static jfieldID seq_stat_st_max_fid; +static jfieldID seq_stat_st_cache_size_fid; +static jfieldID seq_stat_st_flags_fid; +static jfieldID txn_stat_st_nrestores_fid; +static jfieldID txn_stat_st_last_ckp_fid; +static jfieldID txn_stat_st_time_ckp_fid; +static jfieldID txn_stat_st_last_txnid_fid; +static jfieldID txn_stat_st_maxtxns_fid; +static jfieldID txn_stat_st_naborts_fid; +static jfieldID txn_stat_st_nbegins_fid; +static jfieldID txn_stat_st_ncommits_fid; +static jfieldID txn_stat_st_nactive_fid; +static jfieldID txn_stat_st_nsnapshot_fid; +static jfieldID txn_stat_st_maxnactive_fid; +static jfieldID txn_stat_st_maxnsnapshot_fid; +static jfieldID txn_stat_st_txnarray_fid; +static jfieldID txn_stat_st_region_wait_fid; +static jfieldID txn_stat_st_region_nowait_fid; +static jfieldID txn_stat_st_regsize_fid; +static jfieldID txn_active_txnid_fid; +static jfieldID txn_active_parentid_fid; +static jfieldID txn_active_pid_fid; +static jfieldID txn_active_lsn_fid; +static jfieldID txn_active_read_lsn_fid; +static jfieldID txn_active_mvcc_ref_fid; +static jfieldID txn_active_status_fid; +static jfieldID txn_active_gid_fid; +static jfieldID txn_active_name_fid; +/* END-STAT-FIELD-DECLS */ + +static jmethodID dbenv_construct, dbt_construct, dblsn_construct; +static jmethodID dbpreplist_construct, dbtxn_construct; +static jmethodID bt_stat_construct, get_err_msg_method, h_stat_construct; +static jmethodID lock_stat_construct, log_stat_construct; +static jmethodID mpool_stat_construct, mpool_fstat_construct; +static jmethodID mutex_stat_construct, qam_stat_construct; +static jmethodID rep_stat_construct, repmgr_stat_construct, seq_stat_construct; +static jmethodID txn_stat_construct, txn_active_construct; +static jmethodID dbex_construct, deadex_construct, lockex_construct; +static jmethodID memex_construct, memex_update_method; +static jmethodID repdupmasterex_construct, rephandledeadex_construct; +static jmethodID repholdelectionex_construct, repjoinfailex_construct; +static jmethodID repmgr_siteinfo_construct, rephost_construct, repleaseexpiredex_construct; +static jmethodID repleasetimeoutex_construct, replockoutex_construct; +static jmethodID repunavailex_construct; +static jmethodID runrecex_construct, versionex_construct; +static jmethodID filenotfoundex_construct, illegalargex_construct; +static jmethodID outofmemerr_construct; +static jmethodID lock_construct; + +static jmethodID app_dispatch_method, errcall_method, env_feedback_method; +static jmethodID msgcall_method, paniccall_method, rep_transport_method; +static jmethodID panic_event_notify_method, rep_client_event_notify_method; +static jmethodID rep_elected_event_notify_method; +static jmethodID rep_master_event_notify_method; +static jmethodID rep_new_master_event_notify_method; +static jmethodID rep_perm_failed_event_notify_method; +static jmethodID rep_startup_done_event_notify_method; +static jmethodID write_failed_event_notify_method; + +static jmethodID append_recno_method, bt_compare_method, bt_compress_method; +static jmethodID bt_decompress_method, bt_prefix_method; +static jmethodID db_feedback_method, dup_compare_method; +static jmethodID foreignkey_nullify_method, h_compare_method, h_hash_method; +static jmethodID partition_method, seckey_create_method; + +static jmethodID outputstream_write_method; + +const struct { + jclass *cl; + const char *name; +} all_classes[] = { + { &dbenv_class, DB_PKG "internal/DbEnv" }, + { &db_class, DB_PKG "internal/Db" }, + { &dbc_class, DB_PKG "internal/Dbc" }, + { &dbt_class, DB_PKG "DatabaseEntry" }, + { &dblsn_class, DB_PKG "LogSequenceNumber" }, + { &dbpreplist_class, DB_PKG "PreparedTransaction" }, + { &dbtxn_class, DB_PKG "internal/DbTxn" }, + + { &bt_stat_class, DB_PKG "BtreeStats" }, + { &compact_class, DB_PKG "CompactStats" }, + { &h_stat_class, DB_PKG "HashStats" }, + { &lock_stat_class, DB_PKG "LockStats" }, + { &log_stat_class, DB_PKG "LogStats" }, + { &mpool_fstat_class, DB_PKG "CacheFileStats" }, + { &mpool_stat_class, DB_PKG "CacheStats" }, + { &mutex_stat_class, DB_PKG "MutexStats" }, + { &qam_stat_class, DB_PKG "QueueStats" }, + { &rep_stat_class, DB_PKG "ReplicationStats" }, + { &repmgr_stat_class, DB_PKG "ReplicationManagerStats" }, + { &seq_stat_class, DB_PKG "SequenceStats" }, + { &txn_stat_class, DB_PKG "TransactionStats" }, + { &txn_active_class, DB_PKG "TransactionStats$Active" }, + + { &keyrange_class, DB_PKG "KeyRange" }, + { &lock_class, DB_PKG "internal/DbLock" }, + { &lockreq_class, DB_PKG "LockRequest" }, + + { &dbex_class, DB_PKG "DatabaseException" }, + { &deadex_class, DB_PKG "DeadlockException" }, + { &lockex_class, DB_PKG "LockNotGrantedException" }, + { &memex_class, DB_PKG "MemoryException" }, + { &repdupmasterex_class, DB_PKG "ReplicationDuplicateMasterException" }, + { &rephandledeadex_class, DB_PKG "ReplicationHandleDeadException" }, + { &repholdelectionex_class, DB_PKG "ReplicationHoldElectionException" }, + { &rephost_class, DB_PKG "ReplicationHostAddress" }, + { &repmgr_siteinfo_class, DB_PKG "ReplicationManagerSiteInfo" }, + { &repjoinfailex_class, DB_PKG "ReplicationJoinFailureException" }, + { &repleaseexpiredex_class, DB_PKG "ReplicationLeaseExpiredException" }, + { &repleasetimeoutex_class, DB_PKG "ReplicationLeaseTimeoutException" }, + { &replockoutex_class, DB_PKG "ReplicationLockoutException" }, + { &repunavailex_class, DB_PKG "ReplicationSiteUnavailableException" }, + { &runrecex_class, DB_PKG "RunRecoveryException" }, + { &versionex_class, DB_PKG "VersionMismatchException" }, + { &filenotfoundex_class, "java/io/FileNotFoundException" }, + { &illegalargex_class, "java/lang/IllegalArgumentException" }, + { &outofmemerr_class, "java/lang/OutOfMemoryError" }, + + { &bytearray_class, "[B" }, + { &string_class, "java/lang/String" }, + { &outputstream_class, "java/io/OutputStream" } +}; + +const struct { + jfieldID *fid; + jclass *cl; + const char *name; + const char *sig; +} all_fields[] = { + { &dbc_cptr_fid, &dbc_class, "swigCPtr", "J" }, + + { &dblsn_file_fid, &dblsn_class, "file", "I" }, + { &dblsn_offset_fid, &dblsn_class, "offset", "I" }, + + { &dbt_data_fid, &dbt_class, "data", "[B" }, + { &dbt_data_nio_fid, &dbt_class, "data_nio", "Ljava/nio/ByteBuffer;" }, + { &dbt_size_fid, &dbt_class, "size", "I" }, + { &dbt_ulen_fid, &dbt_class, "ulen", "I" }, + { &dbt_dlen_fid, &dbt_class, "dlen", "I" }, + { &dbt_doff_fid, &dbt_class, "doff", "I" }, + { &dbt_flags_fid, &dbt_class, "flags", "I" }, + { &dbt_offset_fid, &dbt_class, "offset", "I" }, + + { &kr_less_fid, &keyrange_class, "less", "D" }, + { &kr_equal_fid, &keyrange_class, "equal", "D" }, + { &kr_greater_fid, &keyrange_class, "greater", "D" }, + + { &lock_cptr_fid, &lock_class, "swigCPtr", "J" }, + + { &lockreq_op_fid, &lockreq_class, "op", "I" }, + { &lockreq_modeflag_fid, &lockreq_class, "modeFlag", "I" }, + { &lockreq_timeout_fid, &lockreq_class, "timeout", "I" }, + { &lockreq_obj_fid, &lockreq_class, "obj", + "L" DB_PKG "DatabaseEntry;" }, + { &lockreq_lock_fid, &lockreq_class, "lock", + "L" DB_PKG "internal/DbLock;" }, + +/* BEGIN-STAT-FIELDS */ + { &bt_stat_bt_magic_fid, &bt_stat_class, "bt_magic", "I" }, + { &bt_stat_bt_version_fid, &bt_stat_class, "bt_version", "I" }, + { &bt_stat_bt_metaflags_fid, &bt_stat_class, "bt_metaflags", "I" }, + { &bt_stat_bt_nkeys_fid, &bt_stat_class, "bt_nkeys", "I" }, + { &bt_stat_bt_ndata_fid, &bt_stat_class, "bt_ndata", "I" }, + { &bt_stat_bt_pagecnt_fid, &bt_stat_class, "bt_pagecnt", "I" }, + { &bt_stat_bt_pagesize_fid, &bt_stat_class, "bt_pagesize", "I" }, + { &bt_stat_bt_minkey_fid, &bt_stat_class, "bt_minkey", "I" }, + { &bt_stat_bt_re_len_fid, &bt_stat_class, "bt_re_len", "I" }, + { &bt_stat_bt_re_pad_fid, &bt_stat_class, "bt_re_pad", "I" }, + { &bt_stat_bt_levels_fid, &bt_stat_class, "bt_levels", "I" }, + { &bt_stat_bt_int_pg_fid, &bt_stat_class, "bt_int_pg", "I" }, + { &bt_stat_bt_leaf_pg_fid, &bt_stat_class, "bt_leaf_pg", "I" }, + { &bt_stat_bt_dup_pg_fid, &bt_stat_class, "bt_dup_pg", "I" }, + { &bt_stat_bt_over_pg_fid, &bt_stat_class, "bt_over_pg", "I" }, + { &bt_stat_bt_empty_pg_fid, &bt_stat_class, "bt_empty_pg", "I" }, + { &bt_stat_bt_free_fid, &bt_stat_class, "bt_free", "I" }, + { &bt_stat_bt_int_pgfree_fid, &bt_stat_class, "bt_int_pgfree", "J" }, + { &bt_stat_bt_leaf_pgfree_fid, &bt_stat_class, "bt_leaf_pgfree", "J" }, + { &bt_stat_bt_dup_pgfree_fid, &bt_stat_class, "bt_dup_pgfree", "J" }, + { &bt_stat_bt_over_pgfree_fid, &bt_stat_class, "bt_over_pgfree", "J" }, + { &compact_compact_fillpercent_fid, &compact_class, "compact_fillpercent", "I" }, + { &compact_compact_timeout_fid, &compact_class, "compact_timeout", "I" }, + { &compact_compact_pages_fid, &compact_class, "compact_pages", "I" }, + { &compact_compact_pages_free_fid, &compact_class, "compact_pages_free", "I" }, + { &compact_compact_pages_examine_fid, &compact_class, "compact_pages_examine", "I" }, + { &compact_compact_levels_fid, &compact_class, "compact_levels", "I" }, + { &compact_compact_deadlock_fid, &compact_class, "compact_deadlock", "I" }, + { &compact_compact_pages_truncated_fid, &compact_class, "compact_pages_truncated", "I" }, + { &compact_compact_truncate_fid, &compact_class, "compact_truncate", "I" }, + { &h_stat_hash_magic_fid, &h_stat_class, "hash_magic", "I" }, + { &h_stat_hash_version_fid, &h_stat_class, "hash_version", "I" }, + { &h_stat_hash_metaflags_fid, &h_stat_class, "hash_metaflags", "I" }, + { &h_stat_hash_nkeys_fid, &h_stat_class, "hash_nkeys", "I" }, + { &h_stat_hash_ndata_fid, &h_stat_class, "hash_ndata", "I" }, + { &h_stat_hash_pagecnt_fid, &h_stat_class, "hash_pagecnt", "I" }, + { &h_stat_hash_pagesize_fid, &h_stat_class, "hash_pagesize", "I" }, + { &h_stat_hash_ffactor_fid, &h_stat_class, "hash_ffactor", "I" }, + { &h_stat_hash_buckets_fid, &h_stat_class, "hash_buckets", "I" }, + { &h_stat_hash_free_fid, &h_stat_class, "hash_free", "I" }, + { &h_stat_hash_bfree_fid, &h_stat_class, "hash_bfree", "J" }, + { &h_stat_hash_bigpages_fid, &h_stat_class, "hash_bigpages", "I" }, + { &h_stat_hash_big_bfree_fid, &h_stat_class, "hash_big_bfree", "J" }, + { &h_stat_hash_overflows_fid, &h_stat_class, "hash_overflows", "I" }, + { &h_stat_hash_ovfl_free_fid, &h_stat_class, "hash_ovfl_free", "J" }, + { &h_stat_hash_dup_fid, &h_stat_class, "hash_dup", "I" }, + { &h_stat_hash_dup_free_fid, &h_stat_class, "hash_dup_free", "J" }, + { &lock_stat_st_id_fid, &lock_stat_class, "st_id", "I" }, + { &lock_stat_st_cur_maxid_fid, &lock_stat_class, "st_cur_maxid", "I" }, + { &lock_stat_st_maxlocks_fid, &lock_stat_class, "st_maxlocks", "I" }, + { &lock_stat_st_maxlockers_fid, &lock_stat_class, "st_maxlockers", "I" }, + { &lock_stat_st_maxobjects_fid, &lock_stat_class, "st_maxobjects", "I" }, + { &lock_stat_st_partitions_fid, &lock_stat_class, "st_partitions", "I" }, + { &lock_stat_st_nmodes_fid, &lock_stat_class, "st_nmodes", "I" }, + { &lock_stat_st_nlockers_fid, &lock_stat_class, "st_nlockers", "I" }, + { &lock_stat_st_nlocks_fid, &lock_stat_class, "st_nlocks", "I" }, + { &lock_stat_st_maxnlocks_fid, &lock_stat_class, "st_maxnlocks", "I" }, + { &lock_stat_st_maxhlocks_fid, &lock_stat_class, "st_maxhlocks", "I" }, + { &lock_stat_st_locksteals_fid, &lock_stat_class, "st_locksteals", "J" }, + { &lock_stat_st_maxlsteals_fid, &lock_stat_class, "st_maxlsteals", "J" }, + { &lock_stat_st_maxnlockers_fid, &lock_stat_class, "st_maxnlockers", "I" }, + { &lock_stat_st_nobjects_fid, &lock_stat_class, "st_nobjects", "I" }, + { &lock_stat_st_maxnobjects_fid, &lock_stat_class, "st_maxnobjects", "I" }, + { &lock_stat_st_maxhobjects_fid, &lock_stat_class, "st_maxhobjects", "I" }, + { &lock_stat_st_objectsteals_fid, &lock_stat_class, "st_objectsteals", "J" }, + { &lock_stat_st_maxosteals_fid, &lock_stat_class, "st_maxosteals", "J" }, + { &lock_stat_st_nrequests_fid, &lock_stat_class, "st_nrequests", "J" }, + { &lock_stat_st_nreleases_fid, &lock_stat_class, "st_nreleases", "J" }, + { &lock_stat_st_nupgrade_fid, &lock_stat_class, "st_nupgrade", "J" }, + { &lock_stat_st_ndowngrade_fid, &lock_stat_class, "st_ndowngrade", "J" }, + { &lock_stat_st_lock_wait_fid, &lock_stat_class, "st_lock_wait", "J" }, + { &lock_stat_st_lock_nowait_fid, &lock_stat_class, "st_lock_nowait", "J" }, + { &lock_stat_st_ndeadlocks_fid, &lock_stat_class, "st_ndeadlocks", "J" }, + { &lock_stat_st_locktimeout_fid, &lock_stat_class, "st_locktimeout", "I" }, + { &lock_stat_st_nlocktimeouts_fid, &lock_stat_class, "st_nlocktimeouts", "J" }, + { &lock_stat_st_txntimeout_fid, &lock_stat_class, "st_txntimeout", "I" }, + { &lock_stat_st_ntxntimeouts_fid, &lock_stat_class, "st_ntxntimeouts", "J" }, + { &lock_stat_st_part_wait_fid, &lock_stat_class, "st_part_wait", "J" }, + { &lock_stat_st_part_nowait_fid, &lock_stat_class, "st_part_nowait", "J" }, + { &lock_stat_st_part_max_wait_fid, &lock_stat_class, "st_part_max_wait", "J" }, + { &lock_stat_st_part_max_nowait_fid, &lock_stat_class, "st_part_max_nowait", "J" }, + { &lock_stat_st_objs_wait_fid, &lock_stat_class, "st_objs_wait", "J" }, + { &lock_stat_st_objs_nowait_fid, &lock_stat_class, "st_objs_nowait", "J" }, + { &lock_stat_st_lockers_wait_fid, &lock_stat_class, "st_lockers_wait", "J" }, + { &lock_stat_st_lockers_nowait_fid, &lock_stat_class, "st_lockers_nowait", "J" }, + { &lock_stat_st_region_wait_fid, &lock_stat_class, "st_region_wait", "J" }, + { &lock_stat_st_region_nowait_fid, &lock_stat_class, "st_region_nowait", "J" }, + { &lock_stat_st_hash_len_fid, &lock_stat_class, "st_hash_len", "I" }, + { &lock_stat_st_regsize_fid, &lock_stat_class, "st_regsize", "I" }, + { &log_stat_st_magic_fid, &log_stat_class, "st_magic", "I" }, + { &log_stat_st_version_fid, &log_stat_class, "st_version", "I" }, + { &log_stat_st_mode_fid, &log_stat_class, "st_mode", "I" }, + { &log_stat_st_lg_bsize_fid, &log_stat_class, "st_lg_bsize", "I" }, + { &log_stat_st_lg_size_fid, &log_stat_class, "st_lg_size", "I" }, + { &log_stat_st_wc_bytes_fid, &log_stat_class, "st_wc_bytes", "I" }, + { &log_stat_st_wc_mbytes_fid, &log_stat_class, "st_wc_mbytes", "I" }, + { &log_stat_st_record_fid, &log_stat_class, "st_record", "J" }, + { &log_stat_st_w_bytes_fid, &log_stat_class, "st_w_bytes", "I" }, + { &log_stat_st_w_mbytes_fid, &log_stat_class, "st_w_mbytes", "I" }, + { &log_stat_st_wcount_fid, &log_stat_class, "st_wcount", "J" }, + { &log_stat_st_wcount_fill_fid, &log_stat_class, "st_wcount_fill", "J" }, + { &log_stat_st_rcount_fid, &log_stat_class, "st_rcount", "J" }, + { &log_stat_st_scount_fid, &log_stat_class, "st_scount", "J" }, + { &log_stat_st_region_wait_fid, &log_stat_class, "st_region_wait", "J" }, + { &log_stat_st_region_nowait_fid, &log_stat_class, "st_region_nowait", "J" }, + { &log_stat_st_cur_file_fid, &log_stat_class, "st_cur_file", "I" }, + { &log_stat_st_cur_offset_fid, &log_stat_class, "st_cur_offset", "I" }, + { &log_stat_st_disk_file_fid, &log_stat_class, "st_disk_file", "I" }, + { &log_stat_st_disk_offset_fid, &log_stat_class, "st_disk_offset", "I" }, + { &log_stat_st_maxcommitperflush_fid, &log_stat_class, "st_maxcommitperflush", "I" }, + { &log_stat_st_mincommitperflush_fid, &log_stat_class, "st_mincommitperflush", "I" }, + { &log_stat_st_regsize_fid, &log_stat_class, "st_regsize", "I" }, + { &mpool_fstat_file_name_fid, &mpool_fstat_class, "file_name", "Ljava/lang/String;" }, + { &mpool_fstat_st_pagesize_fid, &mpool_fstat_class, "st_pagesize", "I" }, + { &mpool_fstat_st_map_fid, &mpool_fstat_class, "st_map", "I" }, + { &mpool_fstat_st_cache_hit_fid, &mpool_fstat_class, "st_cache_hit", "J" }, + { &mpool_fstat_st_cache_miss_fid, &mpool_fstat_class, "st_cache_miss", "J" }, + { &mpool_fstat_st_page_create_fid, &mpool_fstat_class, "st_page_create", "J" }, + { &mpool_fstat_st_page_in_fid, &mpool_fstat_class, "st_page_in", "J" }, + { &mpool_fstat_st_page_out_fid, &mpool_fstat_class, "st_page_out", "J" }, + { &mpool_stat_st_gbytes_fid, &mpool_stat_class, "st_gbytes", "I" }, + { &mpool_stat_st_bytes_fid, &mpool_stat_class, "st_bytes", "I" }, + { &mpool_stat_st_ncache_fid, &mpool_stat_class, "st_ncache", "I" }, + { &mpool_stat_st_max_ncache_fid, &mpool_stat_class, "st_max_ncache", "I" }, + { &mpool_stat_st_mmapsize_fid, &mpool_stat_class, "st_mmapsize", "I" }, + { &mpool_stat_st_maxopenfd_fid, &mpool_stat_class, "st_maxopenfd", "I" }, + { &mpool_stat_st_maxwrite_fid, &mpool_stat_class, "st_maxwrite", "I" }, + { &mpool_stat_st_maxwrite_sleep_fid, &mpool_stat_class, "st_maxwrite_sleep", "I" }, + { &mpool_stat_st_pages_fid, &mpool_stat_class, "st_pages", "I" }, + { &mpool_stat_st_map_fid, &mpool_stat_class, "st_map", "I" }, + { &mpool_stat_st_cache_hit_fid, &mpool_stat_class, "st_cache_hit", "J" }, + { &mpool_stat_st_cache_miss_fid, &mpool_stat_class, "st_cache_miss", "J" }, + { &mpool_stat_st_page_create_fid, &mpool_stat_class, "st_page_create", "J" }, + { &mpool_stat_st_page_in_fid, &mpool_stat_class, "st_page_in", "J" }, + { &mpool_stat_st_page_out_fid, &mpool_stat_class, "st_page_out", "J" }, + { &mpool_stat_st_ro_evict_fid, &mpool_stat_class, "st_ro_evict", "J" }, + { &mpool_stat_st_rw_evict_fid, &mpool_stat_class, "st_rw_evict", "J" }, + { &mpool_stat_st_page_trickle_fid, &mpool_stat_class, "st_page_trickle", "J" }, + { &mpool_stat_st_page_clean_fid, &mpool_stat_class, "st_page_clean", "I" }, + { &mpool_stat_st_page_dirty_fid, &mpool_stat_class, "st_page_dirty", "I" }, + { &mpool_stat_st_hash_buckets_fid, &mpool_stat_class, "st_hash_buckets", "I" }, + { &mpool_stat_st_pagesize_fid, &mpool_stat_class, "st_pagesize", "I" }, + { &mpool_stat_st_hash_searches_fid, &mpool_stat_class, "st_hash_searches", "I" }, + { &mpool_stat_st_hash_longest_fid, &mpool_stat_class, "st_hash_longest", "I" }, + { &mpool_stat_st_hash_examined_fid, &mpool_stat_class, "st_hash_examined", "J" }, + { &mpool_stat_st_hash_nowait_fid, &mpool_stat_class, "st_hash_nowait", "J" }, + { &mpool_stat_st_hash_wait_fid, &mpool_stat_class, "st_hash_wait", "J" }, + { &mpool_stat_st_hash_max_nowait_fid, &mpool_stat_class, "st_hash_max_nowait", "J" }, + { &mpool_stat_st_hash_max_wait_fid, &mpool_stat_class, "st_hash_max_wait", "J" }, + { &mpool_stat_st_region_nowait_fid, &mpool_stat_class, "st_region_nowait", "J" }, + { &mpool_stat_st_region_wait_fid, &mpool_stat_class, "st_region_wait", "J" }, + { &mpool_stat_st_mvcc_frozen_fid, &mpool_stat_class, "st_mvcc_frozen", "J" }, + { &mpool_stat_st_mvcc_thawed_fid, &mpool_stat_class, "st_mvcc_thawed", "J" }, + { &mpool_stat_st_mvcc_freed_fid, &mpool_stat_class, "st_mvcc_freed", "J" }, + { &mpool_stat_st_alloc_fid, &mpool_stat_class, "st_alloc", "J" }, + { &mpool_stat_st_alloc_buckets_fid, &mpool_stat_class, "st_alloc_buckets", "J" }, + { &mpool_stat_st_alloc_max_buckets_fid, &mpool_stat_class, "st_alloc_max_buckets", "J" }, + { &mpool_stat_st_alloc_pages_fid, &mpool_stat_class, "st_alloc_pages", "J" }, + { &mpool_stat_st_alloc_max_pages_fid, &mpool_stat_class, "st_alloc_max_pages", "J" }, + { &mpool_stat_st_io_wait_fid, &mpool_stat_class, "st_io_wait", "J" }, + { &mpool_stat_st_sync_interrupted_fid, &mpool_stat_class, "st_sync_interrupted", "J" }, + { &mpool_stat_st_regsize_fid, &mpool_stat_class, "st_regsize", "I" }, + { &mutex_stat_st_mutex_align_fid, &mutex_stat_class, "st_mutex_align", "I" }, + { &mutex_stat_st_mutex_tas_spins_fid, &mutex_stat_class, "st_mutex_tas_spins", "I" }, + { &mutex_stat_st_mutex_cnt_fid, &mutex_stat_class, "st_mutex_cnt", "I" }, + { &mutex_stat_st_mutex_free_fid, &mutex_stat_class, "st_mutex_free", "I" }, + { &mutex_stat_st_mutex_inuse_fid, &mutex_stat_class, "st_mutex_inuse", "I" }, + { &mutex_stat_st_mutex_inuse_max_fid, &mutex_stat_class, "st_mutex_inuse_max", "I" }, + { &mutex_stat_st_region_wait_fid, &mutex_stat_class, "st_region_wait", "J" }, + { &mutex_stat_st_region_nowait_fid, &mutex_stat_class, "st_region_nowait", "J" }, + { &mutex_stat_st_regsize_fid, &mutex_stat_class, "st_regsize", "I" }, + { &qam_stat_qs_magic_fid, &qam_stat_class, "qs_magic", "I" }, + { &qam_stat_qs_version_fid, &qam_stat_class, "qs_version", "I" }, + { &qam_stat_qs_metaflags_fid, &qam_stat_class, "qs_metaflags", "I" }, + { &qam_stat_qs_nkeys_fid, &qam_stat_class, "qs_nkeys", "I" }, + { &qam_stat_qs_ndata_fid, &qam_stat_class, "qs_ndata", "I" }, + { &qam_stat_qs_pagesize_fid, &qam_stat_class, "qs_pagesize", "I" }, + { &qam_stat_qs_extentsize_fid, &qam_stat_class, "qs_extentsize", "I" }, + { &qam_stat_qs_pages_fid, &qam_stat_class, "qs_pages", "I" }, + { &qam_stat_qs_re_len_fid, &qam_stat_class, "qs_re_len", "I" }, + { &qam_stat_qs_re_pad_fid, &qam_stat_class, "qs_re_pad", "I" }, + { &qam_stat_qs_pgfree_fid, &qam_stat_class, "qs_pgfree", "I" }, + { &qam_stat_qs_first_recno_fid, &qam_stat_class, "qs_first_recno", "I" }, + { &qam_stat_qs_cur_recno_fid, &qam_stat_class, "qs_cur_recno", "I" }, + { &rep_stat_st_log_queued_fid, &rep_stat_class, "st_log_queued", "J" }, + { &rep_stat_st_startup_complete_fid, &rep_stat_class, "st_startup_complete", "I" }, + { &rep_stat_st_status_fid, &rep_stat_class, "st_status", "I" }, + { &rep_stat_st_next_lsn_fid, &rep_stat_class, "st_next_lsn", "L" DB_PKG "LogSequenceNumber;" }, + { &rep_stat_st_waiting_lsn_fid, &rep_stat_class, "st_waiting_lsn", "L" DB_PKG "LogSequenceNumber;" }, + { &rep_stat_st_max_perm_lsn_fid, &rep_stat_class, "st_max_perm_lsn", "L" DB_PKG "LogSequenceNumber;" }, + { &rep_stat_st_next_pg_fid, &rep_stat_class, "st_next_pg", "I" }, + { &rep_stat_st_waiting_pg_fid, &rep_stat_class, "st_waiting_pg", "I" }, + { &rep_stat_st_dupmasters_fid, &rep_stat_class, "st_dupmasters", "I" }, + { &rep_stat_st_env_id_fid, &rep_stat_class, "st_env_id", "I" }, + { &rep_stat_st_env_priority_fid, &rep_stat_class, "st_env_priority", "I" }, + { &rep_stat_st_bulk_fills_fid, &rep_stat_class, "st_bulk_fills", "J" }, + { &rep_stat_st_bulk_overflows_fid, &rep_stat_class, "st_bulk_overflows", "J" }, + { &rep_stat_st_bulk_records_fid, &rep_stat_class, "st_bulk_records", "J" }, + { &rep_stat_st_bulk_transfers_fid, &rep_stat_class, "st_bulk_transfers", "J" }, + { &rep_stat_st_client_rerequests_fid, &rep_stat_class, "st_client_rerequests", "J" }, + { &rep_stat_st_client_svc_req_fid, &rep_stat_class, "st_client_svc_req", "J" }, + { &rep_stat_st_client_svc_miss_fid, &rep_stat_class, "st_client_svc_miss", "J" }, + { &rep_stat_st_gen_fid, &rep_stat_class, "st_gen", "I" }, + { &rep_stat_st_egen_fid, &rep_stat_class, "st_egen", "I" }, + { &rep_stat_st_log_duplicated_fid, &rep_stat_class, "st_log_duplicated", "J" }, + { &rep_stat_st_log_queued_max_fid, &rep_stat_class, "st_log_queued_max", "J" }, + { &rep_stat_st_log_queued_total_fid, &rep_stat_class, "st_log_queued_total", "J" }, + { &rep_stat_st_log_records_fid, &rep_stat_class, "st_log_records", "J" }, + { &rep_stat_st_log_requested_fid, &rep_stat_class, "st_log_requested", "J" }, + { &rep_stat_st_master_fid, &rep_stat_class, "st_master", "I" }, + { &rep_stat_st_master_changes_fid, &rep_stat_class, "st_master_changes", "J" }, + { &rep_stat_st_msgs_badgen_fid, &rep_stat_class, "st_msgs_badgen", "J" }, + { &rep_stat_st_msgs_processed_fid, &rep_stat_class, "st_msgs_processed", "J" }, + { &rep_stat_st_msgs_recover_fid, &rep_stat_class, "st_msgs_recover", "J" }, + { &rep_stat_st_msgs_send_failures_fid, &rep_stat_class, "st_msgs_send_failures", "J" }, + { &rep_stat_st_msgs_sent_fid, &rep_stat_class, "st_msgs_sent", "J" }, + { &rep_stat_st_newsites_fid, &rep_stat_class, "st_newsites", "J" }, + { &rep_stat_st_nsites_fid, &rep_stat_class, "st_nsites", "I" }, + { &rep_stat_st_nthrottles_fid, &rep_stat_class, "st_nthrottles", "J" }, + { &rep_stat_st_outdated_fid, &rep_stat_class, "st_outdated", "J" }, + { &rep_stat_st_pg_duplicated_fid, &rep_stat_class, "st_pg_duplicated", "J" }, + { &rep_stat_st_pg_records_fid, &rep_stat_class, "st_pg_records", "J" }, + { &rep_stat_st_pg_requested_fid, &rep_stat_class, "st_pg_requested", "J" }, + { &rep_stat_st_txns_applied_fid, &rep_stat_class, "st_txns_applied", "J" }, + { &rep_stat_st_startsync_delayed_fid, &rep_stat_class, "st_startsync_delayed", "J" }, + { &rep_stat_st_elections_fid, &rep_stat_class, "st_elections", "J" }, + { &rep_stat_st_elections_won_fid, &rep_stat_class, "st_elections_won", "J" }, + { &rep_stat_st_election_cur_winner_fid, &rep_stat_class, "st_election_cur_winner", "I" }, + { &rep_stat_st_election_gen_fid, &rep_stat_class, "st_election_gen", "I" }, + { &rep_stat_st_election_lsn_fid, &rep_stat_class, "st_election_lsn", "L" DB_PKG "LogSequenceNumber;" }, + { &rep_stat_st_election_nsites_fid, &rep_stat_class, "st_election_nsites", "I" }, + { &rep_stat_st_election_nvotes_fid, &rep_stat_class, "st_election_nvotes", "I" }, + { &rep_stat_st_election_priority_fid, &rep_stat_class, "st_election_priority", "I" }, + { &rep_stat_st_election_status_fid, &rep_stat_class, "st_election_status", "I" }, + { &rep_stat_st_election_tiebreaker_fid, &rep_stat_class, "st_election_tiebreaker", "I" }, + { &rep_stat_st_election_votes_fid, &rep_stat_class, "st_election_votes", "I" }, + { &rep_stat_st_election_sec_fid, &rep_stat_class, "st_election_sec", "I" }, + { &rep_stat_st_election_usec_fid, &rep_stat_class, "st_election_usec", "I" }, + { &rep_stat_st_max_lease_sec_fid, &rep_stat_class, "st_max_lease_sec", "I" }, + { &rep_stat_st_max_lease_usec_fid, &rep_stat_class, "st_max_lease_usec", "I" }, + { &repmgr_stat_st_perm_failed_fid, &repmgr_stat_class, "st_perm_failed", "J" }, + { &repmgr_stat_st_msgs_queued_fid, &repmgr_stat_class, "st_msgs_queued", "J" }, + { &repmgr_stat_st_msgs_dropped_fid, &repmgr_stat_class, "st_msgs_dropped", "J" }, + { &repmgr_stat_st_connection_drop_fid, &repmgr_stat_class, "st_connection_drop", "J" }, + { &repmgr_stat_st_connect_fail_fid, &repmgr_stat_class, "st_connect_fail", "J" }, + { &seq_stat_st_wait_fid, &seq_stat_class, "st_wait", "J" }, + { &seq_stat_st_nowait_fid, &seq_stat_class, "st_nowait", "J" }, + { &seq_stat_st_current_fid, &seq_stat_class, "st_current", "J" }, + { &seq_stat_st_value_fid, &seq_stat_class, "st_value", "J" }, + { &seq_stat_st_last_value_fid, &seq_stat_class, "st_last_value", "J" }, + { &seq_stat_st_min_fid, &seq_stat_class, "st_min", "J" }, + { &seq_stat_st_max_fid, &seq_stat_class, "st_max", "J" }, + { &seq_stat_st_cache_size_fid, &seq_stat_class, "st_cache_size", "I" }, + { &seq_stat_st_flags_fid, &seq_stat_class, "st_flags", "I" }, + { &txn_stat_st_nrestores_fid, &txn_stat_class, "st_nrestores", "I" }, + { &txn_stat_st_last_ckp_fid, &txn_stat_class, "st_last_ckp", "L" DB_PKG "LogSequenceNumber;" }, + { &txn_stat_st_time_ckp_fid, &txn_stat_class, "st_time_ckp", "J" }, + { &txn_stat_st_last_txnid_fid, &txn_stat_class, "st_last_txnid", "I" }, + { &txn_stat_st_maxtxns_fid, &txn_stat_class, "st_maxtxns", "I" }, + { &txn_stat_st_naborts_fid, &txn_stat_class, "st_naborts", "J" }, + { &txn_stat_st_nbegins_fid, &txn_stat_class, "st_nbegins", "J" }, + { &txn_stat_st_ncommits_fid, &txn_stat_class, "st_ncommits", "J" }, + { &txn_stat_st_nactive_fid, &txn_stat_class, "st_nactive", "I" }, + { &txn_stat_st_nsnapshot_fid, &txn_stat_class, "st_nsnapshot", "I" }, + { &txn_stat_st_maxnactive_fid, &txn_stat_class, "st_maxnactive", "I" }, + { &txn_stat_st_maxnsnapshot_fid, &txn_stat_class, "st_maxnsnapshot", "I" }, + { &txn_stat_st_txnarray_fid, &txn_stat_class, "st_txnarray", "[L" DB_PKG "TransactionStats$Active;" }, + { &txn_stat_st_region_wait_fid, &txn_stat_class, "st_region_wait", "J" }, + { &txn_stat_st_region_nowait_fid, &txn_stat_class, "st_region_nowait", "J" }, + { &txn_stat_st_regsize_fid, &txn_stat_class, "st_regsize", "I" }, + { &txn_active_txnid_fid, &txn_active_class, "txnid", "I" }, + { &txn_active_parentid_fid, &txn_active_class, "parentid", "I" }, + { &txn_active_pid_fid, &txn_active_class, "pid", "I" }, + { &txn_active_lsn_fid, &txn_active_class, "lsn", "L" DB_PKG "LogSequenceNumber;" }, + { &txn_active_read_lsn_fid, &txn_active_class, "read_lsn", "L" DB_PKG "LogSequenceNumber;" }, + { &txn_active_mvcc_ref_fid, &txn_active_class, "mvcc_ref", "I" }, + { &txn_active_status_fid, &txn_active_class, "status", "I" }, + { &txn_active_gid_fid, &txn_active_class, "gid", "[B" }, + { &txn_active_name_fid, &txn_active_class, "name", "Ljava/lang/String;" }, +/* END-STAT-FIELDS */ + + { &repmgr_siteinfo_status_fid, &repmgr_siteinfo_class, "status", "I" } +}; + +const struct { + jmethodID *mid; + jclass *cl; + const char *name; + const char *sig; +} all_methods[] = { + { &dbenv_construct, &dbenv_class, "<init>", "(JZ)V" }, + { &dbt_construct, &dbt_class, "<init>", "()V" }, + { &dblsn_construct, &dblsn_class, "<init>", "(II)V" }, + { &dbpreplist_construct, &dbpreplist_class, "<init>", + "(L" DB_PKG "internal/DbTxn;[B)V" }, + { &dbtxn_construct, &dbtxn_class, "<init>", "(JZ)V" }, + + { &bt_stat_construct, &bt_stat_class, "<init>", "()V" }, + { &get_err_msg_method, &dbenv_class, "get_err_msg", + "(Ljava/lang/String;)Ljava/lang/String;" }, + { &h_stat_construct, &h_stat_class, "<init>", "()V" }, + { &lock_stat_construct, &lock_stat_class, "<init>", "()V" }, + { &log_stat_construct, &log_stat_class, "<init>", "()V" }, + { &mpool_stat_construct, &mpool_stat_class, "<init>", "()V" }, + { &mpool_fstat_construct, &mpool_fstat_class, "<init>", "()V" }, + { &mutex_stat_construct, &mutex_stat_class, "<init>", "()V" }, + { &qam_stat_construct, &qam_stat_class, "<init>", "()V" }, + { &rep_stat_construct, &rep_stat_class, "<init>", "()V" }, + { &repmgr_stat_construct, &repmgr_stat_class, "<init>", "()V" }, + { &seq_stat_construct, &seq_stat_class, "<init>", "()V" }, + { &txn_stat_construct, &txn_stat_class, "<init>", "()V" }, + { &txn_active_construct, &txn_active_class, "<init>", "()V" }, + { &rephost_construct, &rephost_class, "<init>", "(Ljava/lang/String;I)V" }, + { &repmgr_siteinfo_construct, &repmgr_siteinfo_class, "<init>", + "(L" DB_PKG "ReplicationHostAddress;I)V" }, + + { &dbex_construct, &dbex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &deadex_construct, &deadex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &lockex_construct, &lockex_class, "<init>", + "(Ljava/lang/String;IIL" DB_PKG "DatabaseEntry;L" + DB_PKG "internal/DbLock;IL" DB_PKG "internal/DbEnv;)V" }, + { &memex_construct, &memex_class, "<init>", + "(Ljava/lang/String;L" DB_PKG "DatabaseEntry;IL" + DB_PKG "internal/DbEnv;)V" }, + { &memex_update_method, &memex_class, "updateDatabaseEntry", + "(L" DB_PKG "DatabaseEntry;)V" }, + { &repdupmasterex_construct, &repdupmasterex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &rephandledeadex_construct, &rephandledeadex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &repholdelectionex_construct, &repholdelectionex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &repjoinfailex_construct, &repjoinfailex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &repleaseexpiredex_construct, &repleaseexpiredex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &repleasetimeoutex_construct, &repleasetimeoutex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &replockoutex_construct, &replockoutex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &repunavailex_construct, &repunavailex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &runrecex_construct, &runrecex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &versionex_construct, &versionex_class, "<init>", + "(Ljava/lang/String;IL" DB_PKG "internal/DbEnv;)V" }, + { &filenotfoundex_construct, &filenotfoundex_class, "<init>", + "(Ljava/lang/String;)V" }, + { &illegalargex_construct, &illegalargex_class, "<init>", + "(Ljava/lang/String;)V" }, + { &outofmemerr_construct, &outofmemerr_class, "<init>", + "(Ljava/lang/String;)V" }, + + { &lock_construct, &lock_class, "<init>", "(JZ)V" }, + + { &app_dispatch_method, &dbenv_class, "handle_app_dispatch", + "(L" DB_PKG "DatabaseEntry;L" DB_PKG "LogSequenceNumber;I)I" }, + { &panic_event_notify_method, &dbenv_class, "handle_panic_event_notify", + "()V" }, + { &rep_client_event_notify_method, &dbenv_class, + "handle_rep_client_event_notify", "()V" }, + { &rep_elected_event_notify_method, &dbenv_class, + "handle_rep_elected_event_notify" ,"()V" }, + { &rep_master_event_notify_method, &dbenv_class, + "handle_rep_master_event_notify", "()V" }, + { &rep_new_master_event_notify_method, &dbenv_class, + "handle_rep_new_master_event_notify", "(I)V" }, + { &rep_perm_failed_event_notify_method, &dbenv_class, + "handle_rep_perm_failed_event_notify", "()V" }, + { &rep_startup_done_event_notify_method, &dbenv_class, + "handle_rep_startup_done_event_notify", "()V" }, + { &write_failed_event_notify_method, &dbenv_class, + "handle_write_failed_event_notify", "(I)V" }, + { &env_feedback_method, &dbenv_class, "handle_env_feedback", "(II)V" }, + { &errcall_method, &dbenv_class, "handle_error", + "(Ljava/lang/String;)V" }, + { &msgcall_method, &dbenv_class, "handle_message", + "(Ljava/lang/String;)V" }, + { &paniccall_method, &dbenv_class, "handle_panic", + "(L" DB_PKG "DatabaseException;)V" }, + { &rep_transport_method, &dbenv_class, "handle_rep_transport", + "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" + DB_PKG "LogSequenceNumber;II)I" }, + + { &append_recno_method, &db_class, "handle_append_recno", + "(L" DB_PKG "DatabaseEntry;I)V" }, + { &bt_compare_method, &db_class, "handle_bt_compare", + "([B[B)I" }, + { &bt_compress_method, &db_class, "handle_bt_compress", + "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" DB_PKG + "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" DB_PKG + "DatabaseEntry;)I" }, + { &bt_decompress_method, &db_class, "handle_bt_decompress", + "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" DB_PKG + "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" DB_PKG + "DatabaseEntry;)I" }, + { &bt_prefix_method, &db_class, "handle_bt_prefix", + "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;)I" }, + { &db_feedback_method, &db_class, "handle_db_feedback", "(II)V" }, + { &dup_compare_method, &db_class, "handle_dup_compare", + "([B[B)I" }, + { &foreignkey_nullify_method, &db_class, "handle_foreignkey_nullify", + "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;L" DB_PKG + "DatabaseEntry;)Z" }, + { &h_compare_method, &db_class, "handle_h_compare", + "([B[B)I" }, + { &h_hash_method, &db_class, "handle_h_hash", "([BI)I" }, + { &partition_method, &db_class, "handle_partition", + "(L" DB_PKG "DatabaseEntry;)I" }, + { &seckey_create_method, &db_class, "handle_seckey_create", + "(L" DB_PKG "DatabaseEntry;L" DB_PKG "DatabaseEntry;)[L" + DB_PKG "DatabaseEntry;" }, + + { &outputstream_write_method, &outputstream_class, "write", "([BII)V" } +}; + +#define NELEM(x) (sizeof (x) / sizeof (x[0])) + +SWIGEXPORT void JNICALL Java_com_sleepycat_db_internal_db_1javaJNI_initialize( + JNIEnv *jenv, jclass clazz) +{ + jclass cl; + unsigned int i, j; + + COMPQUIET(clazz, NULL); + + if ((*jenv)->GetJavaVM(jenv, &javavm) != 0) { + __db_errx(NULL, "Cannot get Java VM"); + return; + } + + for (i = 0; i < NELEM(all_classes); i++) { + cl = (*jenv)->FindClass(jenv, all_classes[i].name); + if (cl == NULL) { + fprintf(stderr, + "Failed to load class %s - check CLASSPATH\n", + all_classes[i].name); + return; + } + + /* + * Wrap classes in GlobalRefs so we keep the reference between + * calls. + */ + *all_classes[i].cl = (jclass)(*jenv)->NewGlobalRef(jenv, cl); + + if (*all_classes[i].cl == NULL) { + fprintf(stderr, + "Failed to create a global reference for %s\n", + all_classes[i].name); + return; + } + } + + /* Get field IDs */ + for (i = 0; i < NELEM(all_fields); i++) { + *all_fields[i].fid = (*jenv)->GetFieldID(jenv, + *all_fields[i].cl, all_fields[i].name, all_fields[i].sig); + + if (*all_fields[i].fid == NULL) { + fprintf(stderr, + "Failed to look up field %s with sig %s\n", + all_fields[i].name, all_fields[i].sig); + return; + } + } + + /* Get method IDs */ + for (i = 0; i < NELEM(all_methods); i++) { + *all_methods[i].mid = (*jenv)->GetMethodID(jenv, + *all_methods[i].cl, all_methods[i].name, + all_methods[i].sig); + + if (*all_methods[i].mid == NULL) { + for (j = 0; j < NELEM(all_classes); j++) + if (all_methods[i].cl == all_classes[j].cl) + break; + fprintf(stderr, + "Failed to look up method %s.%s with sig %s\n", + all_classes[j].name, all_methods[i].name, + all_methods[i].sig); + return; + } + } +} + +static JNIEnv *__dbj_get_jnienv(int *needDetach) +{ + /* + * Note: Different versions of the JNI disagree on the signature for + * AttachCurrentThreadAsDaemon. The most recent documentation seems to + * say that (JNIEnv **) is correct, but newer JNIs seem to use + * (void **), oddly enough. + */ +#ifdef JNI_VERSION_1_2 + void *jenv = 0; +#else + JNIEnv *jenv = 0; +#endif + + *needDetach = 0; + if ((*javavm)->GetEnv(javavm, &jenv, JNI_VERSION_1_2) == JNI_OK) + return ((JNIEnv *)jenv); + + /* + * This should always succeed, as we are called via some Java activity. + * I think therefore I am (a thread). + */ + if ((*javavm)->AttachCurrentThread(javavm, &jenv, 0) != 0) + return (0); + + *needDetach = 1; + return ((JNIEnv *)jenv); +} + +static void __dbj_detach() +{ + (void)(*javavm)->DetachCurrentThread(javavm); +} + +static jobject __dbj_wrap_DB_LSN(JNIEnv *jenv, DB_LSN *lsn) +{ + return (*jenv)->NewObject(jenv, dblsn_class, dblsn_construct, + lsn->file, lsn->offset); +} +%} |