store.c

Go to the documentation of this file.

#include "volksdata/store.h"
 
 
#define ENTRY(a, b) case VOLK_STORE_##a: return &b;
const VOLK_StoreInt *
VOLK_store_int (VOLK_StoreType type) {
    switch (type) {
        BACKEND_TBL
        default: return NULL;
    }
}
#undef ENTRY
 
 
const char *
VOLK_store_type_label (VOLK_StoreType type)
{
#define ENTRY(a, b) case VOLK_STORE_##a: return "STORE_" #a;
    switch (type) {
        BACKEND_TBL
        default: return "";
    }
#undef ENTRY
}
 
 
VOLK_Store *
VOLK_store_new (
        const VOLK_StoreType store_type, const char *store_id, size_t size,
        bool clear)
{
    if (UNLIKELY (!VOLK_env_is_init)) {
        log_error (
                "Environment is not initialized. Did you call VOLK_init()?");
        return NULL;
    }
    const VOLK_StoreInt *sif = VOLK_store_int (store_type);
    if (UNLIKELY (!sif)) {
        log_error ("Not a valid store type: %d", store_type);
        return NULL;
    }
 
    VOLK_Store *store;
    MALLOC_GUARD (store, NULL);
 
    store->type = store_type;
    store->sif = sif;
 
    if (store->sif->setup_fn)
        PCHECK (store->sif->setup_fn (store_id, clear), fail);
 
    // TODO implement custom default context.
    store->data = store->sif->new_fn (store_id, size);
    NLCHECK (store->data, fail);
 
    if (store->sif->id_fn) store->id = store->sif->id_fn (store->data);
    else store->id = store_id ? strdup (store_id) : NULL;
 
    return store;
 
fail:
    free (store);
 
    return NULL;
}
 
 
void
VOLK_store_free (VOLK_Store *store)
{
    if (UNLIKELY (!store)) return;
    log_debug ("Freeing store @%p", store);
 
    store->sif->free_fn (store->data);
    if (store->id) free (store->id);
    free (store);
}
 
 
size_t
VOLK_store_size (const VOLK_Store *store)
{ return store->sif->size_fn (store->data); }
 
 
VOLK_StoreFeature
VOLK_store_features (const VOLK_Store *store)
{ return store->sif->features; }
 
 
char *
VOLK_store_id (const VOLK_Store *store)
{ return store->sif->id_fn (store->data); }
 
 
VOLK_rc
VOLK_store_begin (VOLK_Store *store, VOLK_StoreFlags flags, void **txn) {
    if (UNLIKELY (!(store->sif->features & VOLK_STORE_TXN)))
        return VOLK_NOT_IMPL_ERR;
 
    return store->sif->txn_begin_fn (store->data, flags, txn);
}
 
 
VOLK_rc
VOLK_store_commit (VOLK_Store *store, void *txn)
{
    if (UNLIKELY (!(store->sif->features & VOLK_STORE_TXN)))
        return VOLK_NOT_IMPL_ERR;
 
    return store->sif->txn_commit_fn (txn);
}
 
 
void
VOLK_store_abort (VOLK_Store *store, void *txn)
{
    if (UNLIKELY (!(store->sif->features & VOLK_STORE_TXN))) return;
 
    store->sif->txn_abort_fn (txn);
}
 
 
VOLK_rc
VOLK_store_update_ctx_txn (
        VOLK_Store *store, void *txn, const VOLK_Buffer *old_c,
        const VOLK_Buffer *new_c)
{
    if (UNLIKELY (!(store->sif->features & VOLK_STORE_CTX)))
        return VOLK_NOT_IMPL_ERR;
 
    return store->sif->update_ctx_fn (store->data, old_c, new_c, txn);
}
 
 
void *
VOLK_store_add_init_txn (
        VOLK_Store *store, void *txn, const VOLK_Buffer *sc)
{ return store->sif->add_init_fn (store->data, sc, txn); }
 
 
VOLK_rc
VOLK_store_add_iter (
        VOLK_Store *store, void *it, const VOLK_BufferTriple *sspo)
{ return store->sif->add_iter_fn (it, sspo); }
 
 
void
VOLK_store_add_abort (VOLK_Store *store, void *it)
{
    if (
        UNLIKELY (!(store->sif->features & VOLK_STORE_TXN)) ||
        UNLIKELY (!store->sif->add_abort_fn)
    ) return;
 
    store->sif->add_abort_fn (it);
}
 
 
VOLK_rc
VOLK_store_add_done (VOLK_Store *store, void *it)
{ return store->sif->add_done_fn (it); }
 
 
VOLK_rc
VOLK_store_add_term_txn (VOLK_Store *store, void *txn, VOLK_Buffer *sterm)
{ return store->sif->add_term_fn (store->data, sterm, txn); }
 
 
void *
VOLK_store_lookup_txn (
        const VOLK_Store *store, void *txn,
        const VOLK_Buffer *ss, const VOLK_Buffer *sp, const VOLK_Buffer *so,
        const VOLK_Buffer *sc, size_t *ct)
{
    if (UNLIKELY (!(store->sif->features & VOLK_STORE_CTX)) && sc) {
        log_warn (
                "Store does not support contexts. Ignoring passed context.");
        sc = NULL;
    }
 
    return store->sif->lookup_fn (store->data, ss, sp, so, sc, txn, ct); }
 
 
VOLK_rc VOLK_store_iter_next (
        VOLK_Store *store, void *it, VOLK_BufferTriple *sspo,
        VOLK_Buffer **ctx)
{
    if (UNLIKELY (!(store->sif->features & VOLK_STORE_CTX)) && ctx) {
        log_warn (
                "Store does not support contexts. Ignoring passed context.");
        ctx = NULL;
    }
 
    return store->sif->lu_next_fn (it, sspo, ctx);
}
 
 
void
VOLK_store_iter_free (VOLK_Store *store, void *it)
{ store->sif->lu_free_fn (it); }
 
 
void *
VOLK_store_iter_txn (const VOLK_Store *store, void *it)
{
    if (UNLIKELY (!(store->sif->features & VOLK_STORE_TXN))) {
        log_warn ("Store does not support transactions.");
        return NULL;
    }
 
    return store->sif->iter_txn_fn (it);
}
 
 
VOLK_rc
VOLK_store_remove_txn (
        VOLK_Store *store, void *txn,
        const VOLK_Buffer *ss, const VOLK_Buffer *sp, const VOLK_Buffer *so,
        const VOLK_Buffer *sc, size_t *ct)
{ return store->sif->remove_fn (store->data, ss, sp, so, sc, txn, ct); }
 
 
VOLK_Buffer **
VOLK_store_ctx_list_txn (VOLK_Store *store, void *txn)
{
    if (UNLIKELY (!(store->sif->features & VOLK_STORE_CTX))) {
        log_error ("Store does not support contexts.");
        return NULL;
    }
 
    return store->sif->ctx_list_fn (store->data, txn);
}