environment.c

Go to the documentation of this file.

#include "volksdata/environment.h"
#include "volksdata/data/bootstrap.h"
 

 
typedef struct store_reg_entry {
    char *id;
    void *env;
} StoreRegEntry;
 

static int nsmap_comp_fn (const void *a, const void *b, void *_unused)
{
    (void) _unused;
 
    const NSEntry *nsa = a;
    const NSEntry *nsb = b;
 
    return strncmp (nsa->pfx, nsb->pfx, PFX_LEN);
}
 
static uint64_t nsmap_hash_fn (
        const void *item, uint64_t seed0, uint64_t _unused)
{
    (void) _unused;
    const NSEntry *nse = item;
 
    return (uint64_t) VOLK_HASH64 (nse->pfx, strlen (nse->pfx), seed0);
}
 
static void nsmap_free_fn (void *item)
{ free (((NSEntry *) item)->ns); }
 
 
static int store_reg_comp_fn (const void *a, const void *b, void *_unused)
{
    (void) _unused;
    const StoreRegEntry *ela = a;
    const StoreRegEntry *elb = b;
 
    return strcmp (ela->id, elb->id);
}
 
static uint64_t store_reg_hash_fn (
        const void *item, uint64_t seed0, uint64_t _unused)
{
    (void) _unused;
 
    const StoreRegEntry *el = item;
    return (uint64_t) VOLK_HASH64 (el->id, strlen (el->id), seed0);
}
 
 
/*
 * API
 */
 
VOLK_rc
VOLK_init (void)
{
    if (VOLK_env_is_init) {
        LOG_RC (VOLK_NOACTION);
        return VOLK_NOACTION;
    }
 
#ifdef DEBUG
    // In debug mode, always use max logging.
    int loglevel = LOG_TRACE;
#else
    char *_loglevel = getenv ("VOLK_LOGLEVEL");
    int loglevel = (_loglevel == NULL) ? LOG_INFO : atoi (_loglevel);
#endif
    log_set_level (loglevel);
 
    // Default namespace map.
    VOLK_default_nsm = hashmap_new (
            sizeof (NSEntry), 0, VOLK_HASH_SEED, 0,
            nsmap_hash_fn, nsmap_comp_fn, nsmap_free_fn, NULL);
    if (hashmap_oom (VOLK_default_nsm)) return VOLK_MEM_ERR;
 
 
    if (UNLIKELY (!VOLK_default_nsm)) return VOLK_ERROR;
    for (int i = 0; init_nsmap[i][0] != NULL; i++)
        VOLK_nsmap_add (init_nsmap[i][0], init_nsmap[i][1]);
 
    // Default context URI.
    const char *default_ctx_str = getenv ("VOLK_DEFAULT_CTX");
    if (!default_ctx_str) default_ctx_str = DEFAULT_CTX_LABEL;
    VOLK_default_ctx = VOLK_iriref_new (default_ctx_str);
    if (UNLIKELY (!VOLK_default_ctx)) return VOLK_ERROR;
    VOLK_default_ctx_buf = VOLK_term_serialize (VOLK_default_ctx);
    if (UNLIKELY (!VOLK_default_ctx_buf)) return VOLK_ERROR;
 
    // Initialize term cache.
    VOLK_term_cache = VOLK_term_set_new();
    if (UNLIKELY (!VOLK_term_cache)) return VOLK_MEM_ERR;
 
    // Create and cache default literal datatype key.
    // This will be done only once in the program, so no need to check for
    // duplicates.
    VOLK_default_datatype = VOLK_iriref_new (DEFAULT_DTYPE);
    VOLK_rc rc = VOLK_term_set_add (
            VOLK_term_cache, VOLK_default_datatype, NULL);
    PRCCK (rc);
 
    // Create hashmap for store registry.
    VOLK_store_reg = hashmap_new (
            sizeof (StoreRegEntry), 1, VOLK_HASH_SEED, 0,
            store_reg_hash_fn, store_reg_comp_fn, NULL, NULL);
    if (hashmap_oom (VOLK_store_reg)) return VOLK_MEM_ERR;
 
    VOLK_env_is_init = true;
    log_info ("Volksdata environment initialized.");
 
    // Set automatic teardown TODO Is this a good idea?
    atexit (VOLK_done);
 
    return VOLK_OK;
}
 
 
void
VOLK_done (void)
{
    if (!VOLK_env_is_init) return;
 
    // Free default NS map and context.
    VOLK_buffer_free (VOLK_default_ctx_buf);
    VOLK_term_free (VOLK_default_ctx);
    hashmap_free (VOLK_default_nsm);
 
    // Free ID cache, including default literal datatype.
    hashmap_free (VOLK_term_cache);
    VOLK_default_datatype = NULL;
    VOLK_env_is_init = false;
 
    log_info ("Volksdata environment torn down.");
}
 
 
/*
 * Externals.
 */
 
struct hashmap *VOLK_store_reg = NULL;