#include "db_config.h"
#ifndef lint
static const char revid[] = "$Id: cxx_env.cpp,v 1.2 2004/03/30 01:21:24 jtownsen Exp $";
#endif
#include <errno.h>
#include <stdio.h> // needed for set_error_stream
#include <string.h>
#include "db_cxx.h"
#include "dbinc/cxx_int.h"
#include "db_int.h"
#include "dbinc_auto/common_ext.h"
#ifdef HAVE_CXX_STDHEADERS
using std::cerr;
#endif
#define DBENV_METHOD_ERR(_name, _argspec, _arglist, _on_err) \
int DbEnv::_name _argspec \
{ \
DB_ENV *dbenv = unwrap(this); \
int ret; \
\
if ((ret = dbenv->_name _arglist) != 0) { \
_on_err; \
} \
return (ret); \
}
#define DBENV_METHOD(_name, _argspec, _arglist) \
DBENV_METHOD_ERR(_name, _argspec, _arglist, \
DB_ERROR(this, "DbEnv::" # _name, ret, error_policy()))
#define DBENV_METHOD_QUIET(_name, _argspec, _arglist) \
int DbEnv::_name _argspec \
{ \
DB_ENV *dbenv = unwrap(this); \
\
return (dbenv->_name _arglist); \
}
#define DBENV_METHOD_VOID(_name, _argspec, _arglist) \
void DbEnv::_name _argspec \
{ \
DB_ENV *dbenv = unwrap(this); \
\
dbenv->_name _arglist; \
}
extern "C" {
typedef void (*db_errcall_fcn_type)
(const char *, char *);
};
static int last_known_error_policy = ON_ERROR_UNKNOWN;
__DB_OSTREAMCLASS *DbEnv::error_stream_ = 0;
extern "C"
void _feedback_intercept_c(DB_ENV *env, int opcode, int pct)
{
DbEnv::_feedback_intercept(env, opcode, pct);
}
extern "C"
void _paniccall_intercept_c(DB_ENV *env, int errval)
{
DbEnv::_paniccall_intercept(env, errval);
}
extern "C"
void _stream_error_function_c(const char *prefix, char *message)
{
DbEnv::_stream_error_function(prefix, message);
}
extern "C"
int _app_dispatch_intercept_c(DB_ENV *env, DBT *dbt,
DB_LSN *lsn, db_recops op)
{
return (DbEnv::_app_dispatch_intercept(env, dbt, lsn, op));
}
extern "C"
int _rep_send_intercept_c(DB_ENV *env, const DBT *cntrl,
const DBT *data, const DB_LSN *lsn, int id,
u_int32_t flags)
{
return (DbEnv::_rep_send_intercept(env,
cntrl, data, lsn, id, flags));
}
void DbEnv::_feedback_intercept(DB_ENV *env, int opcode, int pct)
{
if (env == 0) {
DB_ERROR(DbEnv::get_DbEnv(env),
"DbEnv::feedback_callback", EINVAL, ON_ERROR_UNKNOWN);
return;
}
DbEnv *cxxenv = (DbEnv *)env->api1_internal;
if (cxxenv == 0) {
DB_ERROR(DbEnv::get_DbEnv(env),
"DbEnv::feedback_callback", EINVAL, ON_ERROR_UNKNOWN);
return;
}
if (cxxenv->feedback_callback_ == 0) {
DB_ERROR(DbEnv::get_DbEnv(env),
"DbEnv::feedback_callback", EINVAL, cxxenv->error_policy());
return;
}
(*cxxenv->feedback_callback_)(cxxenv, opcode, pct);
}
void DbEnv::_paniccall_intercept(DB_ENV *env, int errval)
{
if (env == 0) {
DB_ERROR(DbEnv::get_DbEnv(env),
"DbEnv::paniccall_callback", EINVAL, ON_ERROR_UNKNOWN);
}
DbEnv *cxxenv = (DbEnv *)env->api1_internal;
if (cxxenv == 0) {
DB_ERROR(DbEnv::get_DbEnv(env),
"DbEnv::paniccall_callback", EINVAL, ON_ERROR_UNKNOWN);
}
if (cxxenv->paniccall_callback_ == 0) {
DB_ERROR(DbEnv::get_DbEnv(env),
"DbEnv::paniccall_callback", EINVAL,
cxxenv->error_policy());
}
(*cxxenv->paniccall_callback_)(cxxenv, errval);
}
int DbEnv::_app_dispatch_intercept(DB_ENV *env, DBT *dbt,
DB_LSN *lsn, db_recops op)
{
if (env == 0) {
DB_ERROR(DbEnv::get_DbEnv(env),
"DbEnv::app_dispatch_callback", EINVAL, ON_ERROR_UNKNOWN);
return (EINVAL);
}
DbEnv *cxxenv = (DbEnv *)env->api1_internal;
if (cxxenv == 0) {
DB_ERROR(DbEnv::get_DbEnv(env),
"DbEnv::app_dispatch_callback", EINVAL, ON_ERROR_UNKNOWN);
return (EINVAL);
}
if (cxxenv->app_dispatch_callback_ == 0) {
DB_ERROR(DbEnv::get_DbEnv(env),
"DbEnv::app_dispatch_callback", EINVAL,
cxxenv->error_policy());
return (EINVAL);
}
Dbt *cxxdbt = (Dbt *)dbt;
DbLsn *cxxlsn = (DbLsn *)lsn;
return ((*cxxenv->app_dispatch_callback_)(cxxenv, cxxdbt, cxxlsn, op));
}
int DbEnv::_rep_send_intercept(DB_ENV *env, const DBT *cntrl,
const DBT *data, const DB_LSN *lsn, int id, u_int32_t flags)
{
if (env == 0) {
DB_ERROR(DbEnv::get_DbEnv(env),
"DbEnv::rep_send_callback", EINVAL, ON_ERROR_UNKNOWN);
return (EINVAL);
}
DbEnv *cxxenv = (DbEnv *)env->api1_internal;
if (cxxenv == 0) {
DB_ERROR(DbEnv::get_DbEnv(env),
"DbEnv::rep_send_callback", EINVAL, ON_ERROR_UNKNOWN);
return (EINVAL);
}
const Dbt *cxxcntrl = (const Dbt *)cntrl;
const DbLsn *cxxlsn = (const DbLsn *)lsn;
Dbt *cxxdata = (Dbt *)data;
return ((*cxxenv->rep_send_callback_)(cxxenv,
cxxcntrl, cxxdata, cxxlsn, id, flags));
}
DbEnv::DbEnv(u_int32_t flags)
: imp_(0)
, construct_error_(0)
, construct_flags_(flags)
, app_dispatch_callback_(0)
, feedback_callback_(0)
, paniccall_callback_(0)
, pgin_callback_(0)
, pgout_callback_(0)
, rep_send_callback_(0)
{
if ((construct_error_ = initialize(0)) != 0)
DB_ERROR(this, "DbEnv::DbEnv", construct_error_,
error_policy());
}
DbEnv::DbEnv(DB_ENV *env, u_int32_t flags)
: imp_(0)
, construct_error_(0)
, construct_flags_(flags)
, app_dispatch_callback_(0)
, feedback_callback_(0)
, paniccall_callback_(0)
, pgin_callback_(0)
, pgout_callback_(0)
, rep_send_callback_(0)
{
if ((construct_error_ = initialize(env)) != 0)
DB_ERROR(this, "DbEnv::DbEnv", construct_error_,
error_policy());
}
DbEnv::~DbEnv()
{
DB_ENV *env = unwrap(this);
if (env != NULL) {
cleanup();
(void)env->close(env, 0);
}
}
void DbEnv::cleanup()
{
DB_ENV *env = unwrap(this);
if (env != NULL) {
env->api1_internal = 0;
imp_ = 0;
}
}
int DbEnv::close(u_int32_t flags)
{
int ret;
DB_ENV *env = unwrap(this);
cleanup();
if ((ret = env->close(env, flags)) != 0)
DB_ERROR(this, "DbEnv::close", ret, error_policy());
return (ret);
}
DBENV_METHOD(dbremove,
(DbTxn *txn, const char *name, const char *subdb, u_int32_t flags),
(dbenv, unwrap(txn), name, subdb, flags))
DBENV_METHOD(dbrename, (DbTxn *txn, const char *name, const char *subdb,
const char *newname, u_int32_t flags),
(dbenv, unwrap(txn), name, subdb, newname, flags))
void DbEnv::err(int error, const char *format, ...)
{
DB_ENV *env = unwrap(this);
DB_REAL_ERR(env, error, 1, 1, format);
}
int DbEnv::error_policy()
{
if ((construct_flags_ & DB_CXX_NO_EXCEPTIONS) != 0) {
return (ON_ERROR_RETURN);
}
else {
return (ON_ERROR_THROW);
}
}
void DbEnv::errx(const char *format, ...)
{
DB_ENV *env = unwrap(this);
DB_REAL_ERR(env, 0, 0, 1, format);
}
void *DbEnv::get_app_private() const
{
return unwrapConst(this)->app_private;
}
DBENV_METHOD(get_home, (const char **homep), (dbenv, homep))
DBENV_METHOD(get_open_flags, (u_int32_t *flagsp), (dbenv, flagsp))
DBENV_METHOD(get_data_dirs, (const char ***dirspp), (dbenv, dirspp))
int DbEnv::initialize(DB_ENV *env)
{
int ret;
last_known_error_policy = error_policy();
if (env == 0) {
if ((ret = ::db_env_create(&env,
construct_flags_ & ~DB_CXX_NO_EXCEPTIONS)) != 0)
return (ret);
}
imp_ = wrap(env);
env->api1_internal = this; return (0);
}
DBENV_METHOD(lock_detect, (u_int32_t flags, u_int32_t atype, int *aborted),
(dbenv, flags, atype, aborted))
DBENV_METHOD_ERR(lock_get,
(u_int32_t locker, u_int32_t flags, const Dbt *obj,
db_lockmode_t lock_mode, DbLock *lock),
(dbenv, locker, flags, obj, lock_mode, &lock->lock_),
DbEnv::runtime_error_lock_get(this, "DbEnv::lock_get", ret,
DB_LOCK_GET, lock_mode, obj, *lock,
-1, error_policy()))
DBENV_METHOD(lock_id, (u_int32_t *idp), (dbenv, idp))
DBENV_METHOD(lock_id_free, (u_int32_t id), (dbenv, id))
DBENV_METHOD(lock_put, (DbLock *lock), (dbenv, &lock->lock_))
DBENV_METHOD(lock_stat, (DB_LOCK_STAT **statp, u_int32_t flags),
(dbenv, statp, flags))
DBENV_METHOD_ERR(lock_vec,
(u_int32_t locker, u_int32_t flags, DB_LOCKREQ list[],
int nlist, DB_LOCKREQ **elist_returned),
(dbenv, locker, flags, list, nlist, elist_returned),
DbEnv::runtime_error_lock_get(this, "DbEnv::lock_vec", ret,
(*elist_returned)->op, (*elist_returned)->mode,
Dbt::get_Dbt((*elist_returned)->obj), DbLock((*elist_returned)->lock),
(*elist_returned) - list, error_policy()))
DBENV_METHOD(log_archive, (char **list[], u_int32_t flags),
(dbenv, list, flags))
int DbEnv::log_compare(const DbLsn *lsn0, const DbLsn *lsn1)
{
return (::log_compare(lsn0, lsn1));
}
DBENV_METHOD(log_cursor, (DbLogc **cursorp, u_int32_t flags),
(dbenv, (DB_LOGC **)cursorp, flags))
DBENV_METHOD(log_file, (DbLsn *lsn, char *namep, size_t len),
(dbenv, lsn, namep, len))
DBENV_METHOD(log_flush, (const DbLsn *lsn), (dbenv, lsn))
DBENV_METHOD(log_put, (DbLsn *lsn, const Dbt *data, u_int32_t flags),
(dbenv, lsn, data, flags))
DBENV_METHOD(log_stat, (DB_LOG_STAT **spp, u_int32_t flags),
(dbenv, spp, flags))
int DbEnv::memp_fcreate(DbMpoolFile **dbmfp, u_int32_t flags)
{
DB_ENV *env = unwrap(this);
int ret;
DB_MPOOLFILE *mpf;
if (env == NULL)
ret = EINVAL;
else
ret = env->memp_fcreate(env, &mpf, flags);
if (DB_RETOK_STD(ret)) {
*dbmfp = new DbMpoolFile();
(*dbmfp)->imp_ = wrap(mpf);
} else
DB_ERROR(this, "DbMpoolFile::f_create", ret, ON_ERROR_UNKNOWN);
return (ret);
}
DBENV_METHOD(memp_register,
(int ftype, pgin_fcn_type pgin_fcn, pgout_fcn_type pgout_fcn),
(dbenv, ftype, pgin_fcn, pgout_fcn))
DBENV_METHOD(memp_stat,
(DB_MPOOL_STAT **gsp, DB_MPOOL_FSTAT ***fsp, u_int32_t flags),
(dbenv, gsp, fsp, flags))
DBENV_METHOD(memp_sync, (DbLsn *sn), (dbenv, sn))
DBENV_METHOD(memp_trickle, (int pct, int *nwrotep), (dbenv, pct, nwrotep))
int DbEnv::open(const char *db_home, u_int32_t flags, int mode)
{
int ret;
DB_ENV *env = unwrap(this);
if (construct_error_ != 0)
ret = construct_error_;
else
ret = env->open(env, db_home, flags, mode);
if (!DB_RETOK_STD(ret))
DB_ERROR(this, "DbEnv::open", ret, error_policy());
return (ret);
}
int DbEnv::remove(const char *db_home, u_int32_t flags)
{
int ret;
DB_ENV *env = unwrap(this);
cleanup();
if ((ret = env->remove(env, db_home, flags)) != 0)
DB_ERROR(this, "DbEnv::remove", ret, error_policy());
return (ret);
}
void DbEnv::runtime_error(DbEnv *env,
const char *caller, int error, int error_policy)
{
if (error_policy == ON_ERROR_UNKNOWN)
error_policy = last_known_error_policy;
if (error_policy == ON_ERROR_THROW) {
switch (error) {
case DB_LOCK_DEADLOCK:
{
DbDeadlockException dl_except(caller);
dl_except.set_env(env);
throw dl_except;
}
break;
case DB_RUNRECOVERY:
{
DbRunRecoveryException rr_except(caller);
rr_except.set_env(env);
throw rr_except;
}
break;
case DB_LOCK_NOTGRANTED:
{
DbLockNotGrantedException lng_except(caller);
lng_except.set_env(env);
throw lng_except;
}
break;
default:
{
DbException except(caller, error);
except.set_env(env);
throw except;
}
break;
}
}
}
void DbEnv::runtime_error_dbt(DbEnv *env,
const char *caller, Dbt *dbt, int error_policy)
{
if (error_policy == ON_ERROR_UNKNOWN)
error_policy = last_known_error_policy;
if (error_policy == ON_ERROR_THROW) {
DbMemoryException except(caller, dbt);
except.set_env(env);
throw except;
}
}
void DbEnv::runtime_error_lock_get(DbEnv *env,
const char *caller, int error,
db_lockop_t op, db_lockmode_t mode, const Dbt *obj,
DbLock lock, int index, int error_policy)
{
if (error != DB_LOCK_NOTGRANTED) {
runtime_error(env, caller, error, error_policy);
return;
}
if (error_policy == ON_ERROR_UNKNOWN)
error_policy = last_known_error_policy;
if (error_policy == ON_ERROR_THROW) {
DbLockNotGrantedException except(caller, op, mode,
obj, lock, index);
except.set_env(env);
throw except;
}
}
char *DbEnv::strerror(int error)
{
return (db_strerror(error));
}
void DbEnv::_stream_error_function(const char *prefix, char *message)
{
if (error_stream_) {
if (prefix) {
(*error_stream_) << prefix << (const char *)": ";
}
if (message) {
(*error_stream_) << (const char *)message;
}
(*error_stream_) << (const char *)"\n";
}
}
DBENV_METHOD_VOID(get_errfile, (FILE **errfilep), (dbenv, errfilep))
DBENV_METHOD_VOID(set_errfile, (FILE *errfile), (dbenv, errfile))
DBENV_METHOD_VOID(get_errpfx, (const char **errpfxp), (dbenv, errpfxp))
DBENV_METHOD_VOID(set_errpfx, (const char *errpfx), (dbenv, errpfx))
DBENV_METHOD(set_data_dir, (const char *dir), (dbenv, dir))
DBENV_METHOD(get_encrypt_flags, (u_int32_t *flagsp),
(dbenv, flagsp))
DBENV_METHOD(set_encrypt, (const char *passwd, u_int32_t flags),
(dbenv, passwd, flags))
DBENV_METHOD(get_lg_bsize, (u_int32_t *bsizep), (dbenv, bsizep))
DBENV_METHOD(set_lg_bsize, (u_int32_t bsize), (dbenv, bsize))
DBENV_METHOD(get_lg_dir, (const char **dirp), (dbenv, dirp))
DBENV_METHOD(set_lg_dir, (const char *dir), (dbenv, dir))
DBENV_METHOD(get_lg_max, (u_int32_t *maxp), (dbenv, maxp))
DBENV_METHOD(set_lg_max, (u_int32_t max), (dbenv, max))
DBENV_METHOD(get_lg_regionmax, (u_int32_t *regionmaxp), (dbenv, regionmaxp))
DBENV_METHOD(set_lg_regionmax, (u_int32_t regionmax), (dbenv, regionmax))
DBENV_METHOD(get_lk_conflicts, (const u_int8_t **lk_conflictsp, int *lk_maxp),
(dbenv, lk_conflictsp, lk_maxp))
DBENV_METHOD(set_lk_conflicts, (u_int8_t *lk_conflicts, int lk_max),
(dbenv, lk_conflicts, lk_max))
DBENV_METHOD(get_lk_detect, (u_int32_t *detectp), (dbenv, detectp))
DBENV_METHOD(set_lk_detect, (u_int32_t detect), (dbenv, detect))
DBENV_METHOD(set_lk_max, (u_int32_t max), (dbenv, max))
DBENV_METHOD(get_lk_max_lockers, (u_int32_t *max_lockersp),
(dbenv, max_lockersp))
DBENV_METHOD(set_lk_max_lockers, (u_int32_t max_lockers), (dbenv, max_lockers))
DBENV_METHOD(get_lk_max_locks, (u_int32_t *max_locksp), (dbenv, max_locksp))
DBENV_METHOD(set_lk_max_locks, (u_int32_t max_locks), (dbenv, max_locks))
DBENV_METHOD(get_lk_max_objects, (u_int32_t *max_objectsp),
(dbenv, max_objectsp))
DBENV_METHOD(set_lk_max_objects, (u_int32_t max_objects), (dbenv, max_objects))
DBENV_METHOD(get_mp_mmapsize, (size_t *mmapsizep), (dbenv, mmapsizep))
DBENV_METHOD(set_mp_mmapsize, (size_t mmapsize), (dbenv, mmapsize))
DBENV_METHOD(get_tmp_dir, (const char **tmp_dirp), (dbenv, tmp_dirp))
DBENV_METHOD(set_tmp_dir, (const char *tmp_dir), (dbenv, tmp_dir))
DBENV_METHOD(get_tx_max, (u_int32_t *tx_maxp), (dbenv, tx_maxp))
DBENV_METHOD(set_tx_max, (u_int32_t tx_max), (dbenv, tx_max))
DBENV_METHOD_QUIET(set_alloc,
(db_malloc_fcn_type malloc_fcn, db_realloc_fcn_type realloc_fcn,
db_free_fcn_type free_fcn),
(dbenv, malloc_fcn, realloc_fcn, free_fcn))
void DbEnv::set_app_private(void *value)
{
unwrap(this)->app_private = value;
}
DBENV_METHOD(get_cachesize,
(u_int32_t *gbytesp, u_int32_t *bytesp, int *ncachep),
(dbenv, gbytesp, bytesp, ncachep))
DBENV_METHOD(set_cachesize,
(u_int32_t gbytes, u_int32_t bytes, int ncache),
(dbenv, gbytes, bytes, ncache))
void DbEnv::set_errcall(void (*arg)(const char *, char *))
{
DB_ENV *dbenv = unwrap(this);
(*(dbenv->set_errcall))(dbenv, (db_errcall_fcn_type)arg);
}
void DbEnv::set_error_stream(__DB_OSTREAMCLASS *stream)
{
DB_ENV *dbenv = unwrap(this);
error_stream_ = stream;
dbenv->set_errcall(dbenv, (stream == 0) ? 0 :
_stream_error_function_c);
}
int DbEnv::set_feedback(void (*arg)(DbEnv *, int, int))
{
DB_ENV *dbenv = unwrap(this);
feedback_callback_ = arg;
return ((*(dbenv->set_feedback))(dbenv, _feedback_intercept_c));
}
DBENV_METHOD(get_flags, (u_int32_t *flagsp), (dbenv, flagsp))
DBENV_METHOD(set_flags, (u_int32_t flags, int onoff), (dbenv, flags, onoff))
int DbEnv::set_paniccall(void (*arg)(DbEnv *, int))
{
DB_ENV *dbenv = unwrap(this);
paniccall_callback_ = arg;
return ((*(dbenv->set_paniccall))(dbenv, _paniccall_intercept_c));
}
DBENV_METHOD(set_rpc_server,
(void *cl, char *host, long tsec, long ssec, u_int32_t flags),
(dbenv, cl, host, tsec, ssec, flags))
DBENV_METHOD(get_shm_key, (long *shm_keyp), (dbenv, shm_keyp))
DBENV_METHOD(set_shm_key, (long shm_key), (dbenv, shm_key))
DBENV_METHOD(get_tas_spins, (u_int32_t *argp), (dbenv, argp))
DBENV_METHOD(set_tas_spins, (u_int32_t arg), (dbenv, arg))
int DbEnv::set_app_dispatch
(int (*arg)(DbEnv *, Dbt *, DbLsn *, db_recops))
{
DB_ENV *dbenv = unwrap(this);
int ret;
app_dispatch_callback_ = arg;
if ((ret = (*(dbenv->set_app_dispatch))(dbenv,
_app_dispatch_intercept_c)) != 0)
DB_ERROR(this, "DbEnv::set_app_dispatch", ret, error_policy());
return (ret);
}
DBENV_METHOD(get_tx_timestamp, (time_t *timestamp), (dbenv, timestamp))
DBENV_METHOD(set_tx_timestamp, (time_t *timestamp), (dbenv, timestamp))
DBENV_METHOD(get_verbose, (u_int32_t which, int *onoffp),
(dbenv, which, onoffp))
DBENV_METHOD(set_verbose, (u_int32_t which, int onoff), (dbenv, which, onoff))
int DbEnv::txn_begin(DbTxn *pid, DbTxn **tid, u_int32_t flags)
{
DB_ENV *env = unwrap(this);
DB_TXN *txn;
int ret;
ret = env->txn_begin(env, unwrap(pid), &txn, flags);
if (DB_RETOK_STD(ret))
*tid = new DbTxn(txn);
else
DB_ERROR(this, "DbEnv::txn_begin", ret, error_policy());
return (ret);
}
DBENV_METHOD(txn_checkpoint, (u_int32_t kbyte, u_int32_t min, u_int32_t flags),
(dbenv, kbyte, min, flags))
int DbEnv::txn_recover(DbPreplist *preplist, long count,
long *retp, u_int32_t flags)
{
DB_ENV *dbenv = unwrap(this);
DB_PREPLIST *c_preplist;
long i;
int ret;
if (count <= 0)
ret = EINVAL;
else
ret = __os_malloc(dbenv, sizeof(DB_PREPLIST) * count,
&c_preplist);
if (ret != 0) {
DB_ERROR(this, "DbEnv::txn_recover", ret, error_policy());
return (ret);
}
if ((ret =
dbenv->txn_recover(dbenv, c_preplist, count, retp, flags)) != 0) {
__os_free(dbenv, c_preplist);
DB_ERROR(this, "DbEnv::txn_recover", ret, error_policy());
return (ret);
}
for (i = 0; i < *retp; i++) {
preplist[i].txn = new DbTxn();
preplist[i].txn->imp_ = wrap(c_preplist[i].txn);
memcpy(preplist[i].gid, c_preplist[i].gid,
sizeof(preplist[i].gid));
}
__os_free(dbenv, c_preplist);
return (0);
}
DBENV_METHOD(txn_stat, (DB_TXN_STAT **statp, u_int32_t flags),
(dbenv, statp, flags))
int DbEnv::set_rep_transport(int myid,
int (*f_send)(DbEnv *, const Dbt *, const Dbt *, const DbLsn *, int,
u_int32_t))
{
DB_ENV *dbenv = unwrap(this);
int ret;
rep_send_callback_ = f_send;
if ((ret = dbenv->set_rep_transport(dbenv,
myid, _rep_send_intercept_c)) != 0)
DB_ERROR(this, "DbEnv::set_rep_transport", ret, error_policy());
return (ret);
}
DBENV_METHOD(rep_elect,
(int nsites, int pri, u_int32_t timeout, int *idp),
(dbenv, nsites, pri, timeout, idp))
int DbEnv::rep_process_message(Dbt *control,
Dbt *rec, int *idp, DbLsn *ret_lsnp)
{
DB_ENV *dbenv = unwrap(this);
int ret;
ret = dbenv->rep_process_message(dbenv, control, rec, idp, ret_lsnp);
if (!DB_RETOK_REPPMSG(ret))
DB_ERROR(this, "DbEnv::rep_process_message", ret,
error_policy());
return (ret);
}
DBENV_METHOD(rep_start,
(Dbt *cookie, u_int32_t flags),
(dbenv, (DBT *)cookie, flags))
DBENV_METHOD(rep_stat, (DB_REP_STAT **statp, u_int32_t flags),
(dbenv, statp, flags))
DBENV_METHOD(get_rep_limit, (u_int32_t *gbytesp, u_int32_t *bytesp),
(dbenv, gbytesp, bytesp))
DBENV_METHOD(set_rep_limit, (u_int32_t gbytes, u_int32_t bytes),
(dbenv, gbytes, bytes))
DBENV_METHOD(get_timeout,
(db_timeout_t *timeoutp, u_int32_t flags),
(dbenv, timeoutp, flags))
DBENV_METHOD(set_timeout,
(db_timeout_t timeout, u_int32_t flags),
(dbenv, timeout, flags))
char *DbEnv::version(int *major, int *minor, int *patch)
{
return (db_version(major, minor, patch));
}
DbEnv *DbEnv::wrap_DB_ENV(DB_ENV *dbenv)
{
DbEnv *wrapped_env = get_DbEnv(dbenv);
if (wrapped_env == NULL)
wrapped_env = new DbEnv(dbenv, 0);
return wrapped_env;
}