writer_trig.c

Go to the documentation of this file.

#include "volksdata/codec/writer_trig.h"
 
 
// Position of a cursor.
typedef enum {
    TRIG_POS_START,         
    TRIG_POS_START_BODY,    
    TRIG_POS_GRAPH,         
    TRIG_POS_END_GR,        
    TRIG_POS_END,           
} TRIGPos;

struct trig_encode_iter_t {
    VOLK_rc             rc;         
    VOLK_DataSet *      dset;       
    VOLK_Graph *        gr;         
    TTLEncodeIterator * gr_it;      
    TRIGPos             pos;        
    void *              txn;        
};
 
 
/* * * Codec functions. * * */

static VOLK_rc
trig_build_prolog (TRIGEncodeIterator *it, char **res_p)
{
    char *res = fmt_header ("# ");
 
    const char ***nsm = VOLK_nsmap_dump ();
    char *ns_tpl = "@prefix %s: <%s> .\n";
 
    // Prefix map.
    for (size_t i = 0; nsm[i]; i++) {
        const char **ns = nsm[i];
        size_t old_len = strlen (res);
        size_t ns_len = strlen (ns[0]) + strlen (ns[1]) + strlen (ns_tpl);
        char *tmp = realloc (res, old_len + ns_len + 1);
        if (UNLIKELY (!tmp)) return VOLK_MEM_ERR;
        res = tmp;
 
        sprintf (res + old_len, ns_tpl, ns[0], ns[1]);
        free (ns);
    }
    free (nsm);
 
    *res_p = res;
    it->pos = TRIG_POS_START_BODY;
    it->rc = VOLK_OK;
 
    return VOLK_OK;
}
 
 
void *
trig_encode_dset_init (VOLK_DataSet *ds)
{
    NLNL (ds);
    TRIGEncodeIterator *it = calloc (1, sizeof (*it));
    NLNL (it);
 
    it->dset = ds;
    it->pos = TRIG_POS_START;
    it->rc = VOLK_NORESULT;
    RCNL (VOLK_store_begin (it->dset->store, VOLK_STORE_TXN_RO, &it->txn));
 
    return it;
}
 
 
VOLK_rc
trig_encode_dset_iter (void *h, char **res_p)
{
    TRIGEncodeIterator *it = h;
 
    // End of overall encoding process.
    // If at the start of the body and the data set is empty before
    // starting popping graphs, quit right away.
    if (it->pos == TRIG_POS_END || (
        it->pos == TRIG_POS_START_BODY &&
        VOLK_term_set_size (it->dset->gr) == 0
    )) return VOLK_END;
 
    // Beginning of overall encoding process: write prolog.
    if (it->pos == TRIG_POS_START) return trig_build_prolog (it, res_p);
    else if (it->pos == TRIG_POS_END_GR) {
        // End of graph encoding loop: finalize graph codec iterator.
        ttl_encode_graph_done (it->gr_it);
        it->gr_it = NULL;
    }
    char *gr_uri_trig = NULL;
 
    // Preallocate closing brace + newline in any case: cheap and simpler.
    size_t out_size = 3;
 
    // After writing prolog: populate first graph.
    // Or: a graph just finished encoding, try to get the next one.
    // Allocate the boundary symbols.
reload_graph:
    if (it->pos == TRIG_POS_START_BODY || it->pos == TRIG_POS_END_GR) {
        VOLK_Term *gr_uri = VOLK_term_set_pop (it->dset->gr);
        if (gr_uri) {
            log_trace ("New graph to encode: %s", gr_uri->data);
            // The default context URI is the default graph.
            if (VOLK_term_equals (gr_uri,  VOLK_default_ctx)) {
                log_trace ("Encoding default context.");
                gr_uri_trig = NULL;
                it->gr = VOLK_graph_new (
                        it->dset->store, VOLK_default_ctx->data);
                out_size += 3;
            } else {
                ttl_encode_term (gr_uri, &gr_uri_trig);
                it->gr = VOLK_graph_new (
                        it->dset->store, gr_uri->data);
                out_size += strlen (gr_uri_trig) + 4;
            }
            log_trace ("%zu triples to encode.", VOLK_graph_size (it->gr));
            VOLK_term_free (gr_uri);
            TTLEncodeOptions opt = {
                .flags = VOLK_CODEC_NO_PROLOG | VOLK_CODEC_INDENT,
                .txn = it->txn,
            };
            it->gr_it = ttl_encode_graph_init (it->gr, &opt);
        } else {
            log_debug ("End of dataset encoding.");
            it->pos = TRIG_POS_END;
        }
    }
    char *res = realloc (*res_p, out_size);
    NLRCCK (res, VOLK_MEM_ERR);
    *res_p = res;
 
    if (it->pos == TRIG_POS_GRAPH) {
        log_trace ("In graph encoding loop.");
        VOLK_rc gr_rc = ttl_encode_graph_iter (it->gr_it, res_p);
        if (gr_rc == VOLK_END || gr_rc == VOLK_NORESULT) {
            ttl_encode_graph_done (it->gr_it);
            VOLK_graph_free (it->gr);
            it->pos = TRIG_POS_END_GR;
            goto reload_graph;
        }
    } else {
        log_trace ("At graph boundary.");
        // Write closing and/or opening braces. This uses up the iteration.
        size_t offset;  // Where in the out string to start writing graph name.
        if (it->pos == TRIG_POS_END_GR || it->pos == TRIG_POS_END) {
            sprintf (res, "}\n");
            offset = 2;
        } else offset = 0;
        if (it->pos == TRIG_POS_START_BODY || it->pos == TRIG_POS_END_GR) {
            log_trace ("Begin writing graph body.");
            if (!gr_uri_trig) sprintf (res + offset, "\n{\n");
            else {
                sprintf (res + offset, "\n%s {\n", gr_uri_trig);
                free (gr_uri_trig);
            }
            it->pos = TRIG_POS_GRAPH;
            it->rc = VOLK_OK;
        }
    }
 
    return it->rc;
}
 
 
void
trig_encode_dset_done (void *h)
{
    if (!h) return;
    TRIGEncodeIterator *it = h;
 
    VOLK_store_abort (it->dset->store, it->txn);
    VOLK_data_set_free (it->dset);
    free (it);
}