contact | forum | legal | impressum | privacy

Home · About · Download · Documentation · Licensing · Store

Overview API Tutorial Samples FAQ

hamsterdb API Documentation

 

hamsterdb.hpp

Go to the documentation of this file.

#ifndef HAM_HAMSTERDB_HPP__
#define HAM_HAMSTERDB_HPP__

#include <ham/hamsterdb_int.h>
#include <cstring>
#include <vector>

namespace ham {

/*
 * forward declarations
 */
class txn;
class db;
class env;

class error {
public:
    error(ham_status_t st) : m_errno(st) {
    };

    ham_status_t get_errno() const {
        return (m_errno);
    }

    const char *get_string() const {
        return (ham_strerror(m_errno));
    }

private:
    ham_status_t m_errno;
};

class key {
public:
    key(void *data=0, ham_size_t size=0, ham_u32_t flags=0) {
        memset(&m_key, 0, sizeof(m_key));
        m_key.data=data;
        m_key.size=size;
        m_key.flags=flags;
    }

    key(const key &other) : m_key(other.m_key) {
    }

    key &operator=(const key &other) {
        m_key=other.m_key;
        return (*this);
    }

    void *get_data() const {
        return (m_key.data);
    }

    void set_data(void *data) {
        m_key.data=data;
    }

    ham_size_t get_size() const {
        return (m_key.size);
    }

    void set_size(ham_size_t size) {
        m_key.size=size;
    }

    ham_u32_t get_flags() const {
        return (m_key.flags);
    }

    void set_flags(ham_u32_t flags) {
        m_key.flags=flags;
    }

    ham_key_t *get_handle() {
        return (&m_key);
    }

private:
    ham_key_t m_key;
};

class record {
public:
    record(void *data=0, ham_size_t size=0, ham_u32_t flags=0) {
        memset(&m_rec, 0, sizeof(m_rec));
        m_rec.data=data;
        m_rec.size=size;
        m_rec.flags=flags;
    }

    record(const record &other) : m_rec(other.m_rec) {
    }

    record &operator=(const record &other) {
        m_rec=other.m_rec;
        return (*this);
    }

    void *get_data() const {
        return (m_rec.data);
    }

    void set_data(void *data) {
        m_rec.data=data;
    }

    ham_size_t get_size() const {
        return (m_rec.size);
    }

    void set_size(ham_size_t size) {
        m_rec.size=size;
    }

    ham_u32_t get_flags() const {
        return (m_rec.flags);
    }

    void set_flags(ham_u32_t flags) {
        m_rec.flags=flags;
    }

    ham_record_t *get_handle() {
        return (&m_rec);
    }

protected:
    ham_record_t m_rec;
};


class txn {
public:
    txn(ham_txn_t *t=0) : m_txn(t) {
    }

    void abort() {
        ham_status_t st;
        st=ham_txn_abort(m_txn, 0);
        if (st)
            throw error(st);
    }

    void commit() {
        ham_status_t st;
        st=ham_txn_commit(m_txn, 0);
        if (st)
            throw error(st);
    }

    ham_txn_t *get_handle() {
        return (m_txn);
    }

protected:
    ham_txn_t *m_txn;
    db *m_db;
};


class db
{
public:
    static void set_errhandler(ham_errhandler_fun f) {
        ham_set_errhandler(f);
    }

    static void get_version(ham_u32_t *major, ham_u32_t *minor,
                    ham_u32_t *revision) {
        ham_get_version(major, minor, revision);
    }

    static void get_license(const char **licensee, const char **product) {
        ham_get_license(licensee, product);
    }

    db() : m_db(0) {
    }

    ~db() {
        close();
    }

    db &operator=(const db &other) {
                db &rhs=(db &)other;
        if (this==&other)
            return (*this);
        close();
        m_db=rhs.m_db;
        rhs.m_db=0; 
        return (*this);
    }

    void create(const char *filename, ham_u32_t flags=0,
            ham_u32_t mode=0644, ham_parameter_t *param=0) {
        ham_status_t st;
        if (!m_db) {
            st=ham_new(&m_db);
            if (st)
                throw error(st);
        }
        if ((st=ham_create_ex(m_db, filename, flags, mode, param)))
            throw error(st);
    }

    void open(const char *filename, ham_u32_t flags=0,
            ham_parameter_t *param=0) {
        ham_status_t st;
        if (!m_db) {
            st=ham_new(&m_db);
            if (st)
                throw error(st);
        }
        if ((st=ham_open_ex(m_db, filename, flags, param)))
            throw error(st);
    }

    ham_status_t get_error() {
        return (ham_get_error(m_db));
    }

    txn begin() {
        ham_txn_t *h;
        ham_status_t st=ham_txn_begin(&h, get_handle(), 0);
        if (st)
            throw error(st);
        return (txn(h));
    }

    void set_prefix_compare_func(ham_prefix_compare_func_t foo) {
        ham_status_t st=ham_set_prefix_compare_func(m_db, foo);
        if (st)
            throw error(st);
    }

    void set_compare_func(ham_compare_func_t foo) {
        ham_status_t st=ham_set_compare_func(m_db, foo);
        if (st)
            throw error(st);
    }

    void enable_compression(ham_u32_t level, ham_u32_t flags=0) {
        ham_status_t st=ham_enable_compression(m_db, level, flags);
        if (st)
            throw error(st);
    }

    record find(txn *t, key *k, ham_u32_t flags=0) {
        record r;
        ham_status_t st=ham_find(m_db, 
                t ? t->get_handle() : 0, 
                k ? k->get_handle() : 0,
                r.get_handle(), flags);
        if (st)
            throw error(st);
        return (r);
    }

    record find(key *k, ham_u32_t flags=0) {
        return (find(0, k, flags));
    }

    void insert(txn *t, key *k, record *r, ham_u32_t flags=0) {
        ham_status_t st=ham_insert(m_db, 
                t ? t->get_handle() : 0, 
                k ? k->get_handle() : 0, 
                r ? r->get_handle() : 0, flags);
        if (st)
            throw error(st);
    }

    void insert(key *k, record *r, ham_u32_t flags=0) {
        insert(0, k, r, flags);
    }

    void erase(key *k, ham_u32_t flags=0) {
        erase(0, k, flags);
    }

    void erase(txn *t, key *k, ham_u32_t flags=0) {
        ham_status_t st=ham_erase(m_db, 
                t ? t->get_handle() : 0, 
                k ? k->get_handle() : 0, flags);
        if (st)
            throw error(st);
    }

    void flush(ham_u32_t flags=0) {
        ham_status_t st=ham_flush(m_db, flags);
        if (st)
            throw error(st);
    }

    void close(ham_u32_t flags=0) {
        if (!m_db)
            return;
        ham_status_t st=ham_close(m_db, flags);
        if (st)
            throw error(st);
        st=ham_delete(m_db);
        if (st)
            throw error(st);
        m_db=0;
    }

    ham_db_t *get_handle() {
        return (m_db);
    }

protected:
    friend class env;

    /* Copy Constructor. Is protected and should not be used. */
    db(ham_db_t *db) : m_db(db) {
    }

private:
    ham_db_t *m_db;
};


class cursor
{
public:
    cursor(db *db=0, txn *t=0, ham_u32_t flags=0)
    :   m_cursor(0) {
        create(db, t, flags);
    }

    cursor(txn *t, db *db=0, ham_u32_t flags=0)
    :   m_cursor(0) {
        create(db, t, flags);
    }

    ~cursor() {
        close();
    }

    void create(db *db, txn *t=0, ham_u32_t flags=0) {
        if (m_cursor)
            close();
        if (db) {
            ham_status_t st=ham_cursor_create(db->get_handle(), 
                    t ? t->get_handle() : 0, 
                    flags, &m_cursor);
            if (st)
                throw error(st);
        }
    }

    cursor clone() {
        ham_cursor_t *dest;
        ham_status_t st=ham_cursor_clone(m_cursor, &dest);
        if (st)
            throw error(st);
        return (cursor(dest));
    }

    void move(key *k, record *r, ham_u32_t flags=0) {
        ham_status_t st=ham_cursor_move(m_cursor, k ? k->get_handle() : 0,
                        r ? r->get_handle() : 0, flags);
        if (st)
            throw error(st);
    }

    void move_first(key *k=0, record *r=0) {
        move(k, r, HAM_CURSOR_FIRST);
    }

    void move_last(key *k=0, record *r=0) {
        move(k, r, HAM_CURSOR_LAST);
    }

    void move_next(key *k=0, record *r=0) {
        move(k, r, HAM_CURSOR_NEXT);
    }

    void move_previous(key *k=0, record *r=0) {
        move(k, r, HAM_CURSOR_PREVIOUS);
    }

    void overwrite(record *r, ham_u32_t flags=0) {
        ham_status_t st=ham_cursor_overwrite(m_cursor, 
                        r ? r->get_handle() : 0, flags);
        if (st)
            throw error(st);
    }

    void find(key *k, ham_u32_t flags=0) {
        ham_status_t st=ham_cursor_find(m_cursor, k->get_handle(), flags);
        if (st)
            throw error(st);
    }

    void insert(key *k, record *r, ham_u32_t flags=0) {
        ham_status_t st=ham_cursor_insert(m_cursor, k ? k->get_handle() : 0,
                        r ? r->get_handle() : 0, flags);
        if (st)
            throw error(st);
    }

    void erase(ham_u32_t flags=0) {
        ham_status_t st=ham_cursor_erase(m_cursor, flags);
        if (st)
            throw error(st);
    }

    ham_u32_t get_duplicate_count(ham_u32_t flags=0) {
        ham_u32_t c;
        ham_status_t st=ham_cursor_get_duplicate_count(m_cursor, &c, flags);
        if (st)
            throw error(st);
        return (c);
    }

    void close() {
        if (!m_cursor)
            return;
        ham_status_t st=ham_cursor_close(m_cursor);
        if (st)
            throw error(st);
        m_cursor=0;
    }

protected:
    /* Copy Constructor. Is protected and should not be used. */
    cursor(ham_cursor_t *c) {
        m_cursor=c;
    }

private:
    ham_cursor_t *m_cursor;
};

class env
{
public:
    env() : m_env(0) {
    }

    ~env() {
        close();
    }

    void create(const char *filename, ham_u32_t flags=0,
            ham_u32_t mode=0644, ham_parameter_t *param=0) {
        ham_status_t st;
        if (!m_env) {
            st=ham_env_new(&m_env);
            if (st)
                throw error(st);
        }
        if ((st=ham_env_create_ex(m_env, filename, flags, mode, param)))
            throw error(st);
    }

    void open(const char *filename, ham_u32_t flags=0,
            ham_parameter_t *param=0) {
        ham_status_t st;
        if (!m_env) {
            st=ham_env_new(&m_env);
            if (st)
                throw error(st);
        }
        if ((st=ham_env_open_ex(m_env, filename, flags, param)))
            throw error(st);
    }

    db create_db(ham_u16_t name, ham_u32_t flags=0, ham_parameter_t *param=0) {
        ham_status_t st;
        ham_db_t *dbh;

        st=ham_new(&dbh);
        if (st)
            throw error(st);
        st=ham_env_create_db(m_env, dbh, name, flags, param);
        if (st) {
            ham_delete(dbh);
            throw error(st);
        }

                return (ham::db(dbh));
    }

    db open_db(ham_u16_t name, ham_u32_t flags=0, ham_parameter_t *param=0) {
        ham_status_t st;
        ham_db_t *dbh;

        st=ham_new(&dbh);
        if (st)
            throw error(st);
        st=ham_env_open_db(m_env, dbh, name, flags, param);
        if (st) {
            ham_delete(dbh);
            throw error(st);
        }

                return (ham::db(dbh));
    }

    void rename_db(ham_u16_t oldname, ham_u16_t newname, ham_u32_t flags=0) {
        ham_status_t st=ham_env_rename_db(m_env, oldname, newname, flags);
        if (st)
            throw error(st);
    }

    void erase_db(ham_u16_t name, ham_u32_t flags=0) {
        ham_status_t st=ham_env_erase_db(m_env, name, flags);
        if (st)
            throw error(st);
    }

    void close(void) {
        if (!m_env)
            return;
        ham_status_t st=ham_env_close(m_env, 0);
        if (st)
            throw error(st);
        st=ham_env_delete(m_env);
        if (st)
            throw error(st);
        m_env=0;
    }

    void enable_encryption(ham_u8_t key[16], ham_u32_t flags=0) {
        ham_status_t st=ham_env_enable_encryption(m_env, key, flags);
        if (st)
            throw error(st);
    }

    std::vector<ham_u16_t> get_database_names(void) {
        ham_size_t count=32;
        ham_status_t st;
        std::vector<ham_u16_t> v(count);

        do {
            st=ham_env_get_database_names(m_env, &v[0], &count);
            if (!st)
                break;
            if (st && st!=HAM_LIMITS_REACHED)
                throw error(st);
            count+=16;
            v.resize(count);
        } while (1);

        v.resize(count);
        return (v);
    }

private:
    ham_env_t *m_env;
};

}; // namespace ham

#endif // HAMSTERDB_HPP__

 

 

The hamsterdb API

• Main Page
• Data Structures
• Directories
• File List
• Data Fields
• Globals
• The C++ API

 

Help us!

Found an information that is missing on this page? Please send a mail.

 

Copyright © 2005-2008 Christoph Rupp