namespace.c

Go to the documentation of this file.

#include "volksdata/namespace.h"
 

struct dump_iter_t {
    size_t              i;          // Iterator counter.
    const char ***      data;       // Stored data.
};
 
 
// TODO expose in API as first-class iterator function.
static bool nsmap_dump_ns_iter_fn (const void *item, void *udata)
{
    const NSEntry *entry = item;
    struct dump_iter_t *cur = udata;
    //LOG_TRACE ("Dumping NS to string: %s %s", entry->pfx, entry->ns);
 
    cur->data[cur->i][0] = (const char *)entry->pfx;
    cur->data[cur->i++][1] = (const char *)entry->ns;
 
    return true;
}
 

 
/*
 * @note The internal functions to create and tear down this structure
 * are in the environment module, while all functions for regular operations
 * are in this module. This is because environment requires term, and term
 * requires some namespace functions. This split is a bit awkward but it
 * avoids circular dependencies; and anyways, nsm-related functions in the
 * environment module are not exposed.
 */
struct hashmap *VOLK_default_nsm = NULL;
 
 
VOLK_rc
VOLK_nsmap_add (const char *pfx, const char *nsstr)
{
    NSEntry entry_s = {};
 
    if (strlen(pfx) >= PFX_LEN)
        log_warn(
                "Prefix `%s` is longer than the maximum allowed size "
                "(%d characters). Truncating.", pfx, PFX_LEN - 1);
    strncpy (entry_s.pfx, pfx, PFX_LEN -1);
    entry_s.ns = strdup (nsstr);
 
    const NSEntry *ret = hashmap_delete (VOLK_default_nsm, &entry_s);
    if (!ret) LOG_DEBUG("Adding prefix '%s' to NS map.", entry_s.pfx);
    else {
        LOG_DEBUG(
                "Replacing NS '%s' with '%s' for prefix '%s'.",
                ret->ns, entry_s.ns, entry_s.pfx);
        // Free replaced NS string.
        free (ret->ns);
    }
    hashmap_set (VOLK_default_nsm, &entry_s);
    if (hashmap_oom (VOLK_default_nsm)) return VOLK_MEM_ERR;
 
    return VOLK_OK;
}
 
 
VOLK_rc
VOLK_nsmap_remove (const char *pfx)
{
    NSEntry entry_s = {};
    strncpy (entry_s.pfx, pfx, PFX_LEN - 1);
    const NSEntry *entry = hashmap_delete (VOLK_default_nsm, &entry_s);
 
    if (!entry) return VOLK_NOACTION;
 
    free (entry->ns);
 
    return VOLK_OK;
}
 
 
const char *
VOLK_nsmap_get_ns (const char *pfx)
{
    NSEntry entry_s = {};
    strncpy (entry_s.pfx, pfx, PFX_LEN - 1);
    const NSEntry *entry = hashmap_get (VOLK_default_nsm, &entry_s);
 
    return (entry) ? entry->ns : NULL;
}
 
 
const char *
VOLK_nsmap_get_pfx (const char *ns)
{
    const NSEntry *entry;
    size_t i = 0;
    while (hashmap_iter (VOLK_default_nsm, &i, (void **) &entry)) {
        if (strncmp (entry->ns, ns, strlen (ns)) == 0)
            return entry->pfx;
    }
 
    return NULL;
}
 
 
VOLK_rc
VOLK_nsmap_normalize_uri (const char *pfx_uri, char **fq_uri_p)
{
    if (!pfx_uri) {
        log_error ("Prefixed URI cannot be NULL.");
        return VOLK_VALUE_ERR;
    }
    VOLK_rc rc = VOLK_NORESULT;
    char *fq_uri = NULL;
 
    size_t pfx_len = strcspn (pfx_uri, ":");
    if (pfx_len >= PFX_LEN || pfx_len == strlen (pfx_uri)) {
        log_warn (
                "No prefix separator detected in URI `%s` within maximum "
                "prefix length (%d characters).", pfx_uri, PFX_LEN - 1);
        goto finally;
    }
 
    VOLK_ns_pfx pfx;
    strncpy (pfx, pfx_uri, pfx_len);
    pfx[pfx_len] = '\0';
 
    const char *ns = VOLK_nsmap_get_ns (pfx);
 
    if (ns) {
        // -1 for :, +1 for terminator.
        size_t fq_size = strlen (ns) + strlen (pfx_uri) - pfx_len;
        fq_uri = malloc (fq_size);
        if (UNLIKELY (! (fq_uri))) return VOLK_MEM_ERR;
 
        strcpy (fq_uri, ns);
        strcat (fq_uri, pfx_uri + pfx_len + 1);
 
        rc = VOLK_OK;
    } else log_warn ("No NS prefix found in map to normalize %s", pfx_uri);
 
finally:
    *fq_uri_p = fq_uri;
 
    return rc;
}
 
 
VOLK_rc
VOLK_nsmap_denormalize_uri (const char *fq_uri, char **pfx_uri_p)
{
    /*
     * This is different from VOLK_nsmap_get_ns, in that the URI being looked
     * at will unlikely match exactly the full namespace stored in the map.
     * This function has to count the characters left over from the match in
     * order to add the URI suffix.
     */
    VOLK_rc rc = VOLK_NORESULT;
    const NSEntry *entry;
    const char *pfx = NULL;
    char *pfx_uri = NULL;
 
    size_t i = 0, offset;
    while (hashmap_iter (VOLK_default_nsm, &i, (void **) &entry)) {
        offset = strlen (entry->ns);
        if (strncmp (entry->ns, fq_uri, offset) == 0) {
            pfx = entry->pfx;
            break;
        }
    }
    if (pfx) {
        // +2: one for terminating \x00, one for the colon.
        pfx_uri = malloc (strlen (pfx) + strlen (fq_uri) - offset + 2);
        if (UNLIKELY (! (pfx_uri))) return VOLK_MEM_ERR;
 
        sprintf (pfx_uri, "%s:%s", pfx, fq_uri + offset);
 
        rc = VOLK_OK;
    } else log_warn ("No NS prefix found in map to denormalize %s", fq_uri);
 
    *pfx_uri_p = pfx_uri;
 
    return rc;
}
 
 
const char ***
VOLK_nsmap_dump (void)
{
    size_t i = hashmap_count (VOLK_default_nsm);
 
    const char ***data = malloc (2 * (i + 1) * sizeof (char *));
    if (UNLIKELY (!data)) return NULL;
 
    for (size_t j = 0; j < i; j++) {
        data[j] = malloc (2 * sizeof (char *));
        if (UNLIKELY (!data[j])) return NULL;
    }
 
    struct dump_iter_t cur = {.i = 0, .data = data};
    hashmap_scan (VOLK_default_nsm, nsmap_dump_ns_iter_fn, &cur);
    data[i] = NULL; // Sentinel
 
    return data;
}