BerkeleyDBXML-0.4: Database/Berkeley/db_helper.cpp

#include "db_helper.h"

#include <string.h>
#include <stdlib.h>

int _dbenv_create__(DbEnv** dbenv, u_int32_t flags) {
    *dbenv = new DbEnv(flags);
    return 0;
}

int _dbenv_get_lk_max_lockers(DbEnv *dbenv, u_int32_t *lk_maxp) {
    try {
        return dbenv->get_lk_max_lockers(lk_maxp);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbenv_set_lk_max_lockers(DbEnv *dbenv, u_int32_t max) {
    try {
        return dbenv->set_lk_max_lockers(max);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbenv_get_lk_max_locks(DbEnv *dbenv, u_int32_t *lk_maxp) {
    try {
        return dbenv->get_lk_max_locks(lk_maxp);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbenv_set_lk_max_locks(DbEnv *dbenv, u_int32_t max) {
    try {
        return dbenv->set_lk_max_locks(max);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbenv_get_lk_max_objects(DbEnv *dbenv, u_int32_t *lk_maxp) {
    try {
        return dbenv->get_lk_max_objects(lk_maxp);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbenv_set_lk_max_objects(DbEnv *dbenv, u_int32_t max) {
    try {
        return dbenv->set_lk_max_objects(max);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbenv_get_tx_max(DbEnv *dbenv, u_int32_t *lk_maxp) {
    try {
        return dbenv->get_tx_max(lk_maxp);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbenv_set_tx_max(DbEnv *dbenv, u_int32_t max) {
    try {
        return dbenv->set_tx_max(max);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbenv_get_cachesize(DbEnv *dbenv, u_int32_t *gbytesp, u_int32_t *bytesp, int *ncachep) {
    try {
        return dbenv->get_cachesize(gbytesp, bytesp, ncachep);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbenv_set_cachesize(DbEnv *dbenv, u_int32_t gbytes, u_int32_t bytes, int ncache) {
    try {
        return dbenv->set_cachesize(gbytes, bytes, ncache);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbenv_get_lg_regionmax(DbEnv *dbenv, u_int32_t *lk_maxp) {
    try {
        return dbenv->get_lg_regionmax(lk_maxp);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbenv_set_lg_regionmax(DbEnv *dbenv, u_int32_t max) {
    try {
        return dbenv->set_lg_regionmax(max);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbenv_open(DbEnv *dbenv, char *db_home, u_int32_t flags, int mode) {
    try {
        return dbenv->open(db_home, flags, mode);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _db_create(DbEnv* dbenv, u_int32_t flags, Db** db)
{
    try {
        *db = new Db(dbenv, flags);
        return 0;
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

void _db_delete(Db* db)
{
    delete db;
}

int _db_set_pagesize(Db* db, u_int32_t pagesize)
{
    try {
        return db->set_pagesize(pagesize);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _db_open(Db* db, DbTxn* txn, const char* file, const char* database,
    int type, u_int32_t flags, int mode)
{
    try {
        return db->open(txn, file, database, (DBTYPE) type, flags, mode);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbenv_txn_begin(DbEnv* dbenv, DbTxn* parent, DbTxn** txn, u_int32_t flags)
{
    try {
        return dbenv->txn_begin(parent, txn, flags);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbenv_txn_checkpoint(DbEnv* dbenv, u_int32_t kbyte, u_int32_t min, u_int32_t flags)
{
    try {
        return dbenv->txn_checkpoint(kbyte, min, flags);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbtxn_abort(DbTxn* dbtxn)
{
    try {
        return dbtxn->abort();
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbtxn_commit(DbTxn* dbtxn, u_int32_t flags)
{
    try {
        return dbtxn->commit(flags);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

void _dbtxn_delete(DbTxn* dbtxn)
{
    // dbtxn_abort or dbtxn_commit actually do the delete.
    // To do: Make it so memory leaks aren't possible.
}

u_int32_t _dbtxn_id(DbTxn* dbtxn)
{
    return dbtxn->id();
}

void _dblock_delete(DbLock* dblock)
{
    delete dblock;
}

int _dbenv_lock_get(DbEnv* dbenv, u_int32_t lockerID, u_int32_t flags,
    const char* object, u_int32_t object_len, u_int32_t lockmode, DbLock** dblock)
{
    Dbt dbt;
    memset(&dbt, 0, sizeof(dbt));
    dbt.set_data((void*)object);
    dbt.set_size(object_len);
    *dblock = new DbLock;
    try {
        int ret = dbenv->lock_get(lockerID, flags, &dbt, (db_lockmode_t)lockmode, *dblock);
        if (ret != 0) {
            delete *dblock;
            *dblock = NULL;
        }
        return ret;
    }
    catch (DbException& exc) {
        delete *dblock;
        *dblock = NULL;
        return exc.get_errno();
    }
}

int _dbenv_lock_put(DbEnv* dbenv, DbLock* dblock)
{
    try {
        dbenv->lock_put(dblock);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

void _deleteString(char* str)
{
    delete[] str;
}

void _freeString(char* str)
{
    free(str);
}

int _db_get(Db* db, DbTxn* dbtxn, const char* key, u_int32_t key_len, char** value, u_int32_t* value_len, u_int32_t flags)
{
    Dbt keyDbt((void*)key, key_len);
    Dbt valueDbt;
    valueDbt.set_flags(DB_DBT_MALLOC);
    *value = NULL;
    *value_len = 0;
    try {
        int ret = db->get(dbtxn, &keyDbt, &valueDbt, flags);
        if (ret == 0) {
            *value = (char*)valueDbt.get_data();
            *value_len = valueDbt.get_size();
        }
        return ret;
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _db_put(Db* db, DbTxn* dbtxn, const char* key, u_int32_t key_len, char* value, u_int32_t value_len, u_int32_t flags)
{
    Dbt keyDbt((void*)key, key_len);
    Dbt valueDbt((void*)value, value_len);
    try {
        return db->put(dbtxn, &keyDbt, &valueDbt, flags);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _db_del(Db* db, DbTxn* dbtxn, const char* key, u_int32_t key_len, u_int32_t flags)
{
    Dbt keyDbt((void*)key, key_len);
    try {
        return db->del(dbtxn, &keyDbt, flags);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _db_close(Db* db, u_int32_t flags)
{
    try {
        return db->close(flags);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbenv_close(DbEnv* dbEnv, u_int32_t flags)
{
    try {
        int ret = dbEnv->close(flags);
        delete dbEnv;
        return ret;
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}

int _dbenv_set_lk_detect(DbEnv* dbEnv, u_int32_t flag)
{
    try {
        return dbEnv->set_lk_detect(flag);
    }
    catch (DbException& exc) {
        return exc.get_errno();
    }
}