writer_nt.c

Go to the documentation of this file.

#include "volksdata/codec/writer_nt.h"
 
 
struct nt_encode_iter_t {
    VOLK_GraphIterator *gr_it;      
    const VOLK_Term *   gr_uri;     
    size_t              cur;        
    VOLK_rc             rc;         
    char *              str_s,      
         *              str_p,      
         *              str_o;      
};
 
 
 
/* * * Codec functions. * * */
 
VOLK_rc
nt_encode_term (const VOLK_Term *term, char **out_p)
{
    VOLK_rc rc;
    char *out = NULL, *escaped;
    const char *metadata = NULL;
    size_t buf_len;
 
    char *data = term->data;
    switch (term->type) {
        case VOLK_TERM_IRIREF:
            out = realloc (*out_p, strlen (data) + 3);
            if (UNLIKELY (!out)) return VOLK_MEM_ERR;
 
            sprintf (out, "<%s>", data);
 
            if (data != term->data) free (data);
            rc = VOLK_OK;
            break;
 
        case VOLK_TERM_LITERAL:
            // Calculate string length.
            if (escape_lit (term->data, &escaped) != VOLK_OK)
                return VOLK_ERROR;
            buf_len = strlen (escaped) + 3; // Room for "" and terminator
 
            if (
                term->datatype != 0
                && term->datatype != VOLK_default_datatype
            ) {
                metadata = term->datatype->data;
                buf_len += strlen (metadata) + 4; // Room for ^^<>
            }
 
            out = realloc (*out_p, buf_len);
            if (UNLIKELY (!out)) return VOLK_MEM_ERR;
 
            sprintf (out, "\"%s\"", escaped);
            free (escaped);
 
            // Add datatype.
            if (metadata)
                out = strcat (strcat (strcat (out, "^^<"), metadata), ">");
 
            rc = VOLK_OK;
 
            break;
 
        case VOLK_TERM_LT_LITERAL:
            // Calculate string length.
            if (escape_lit (term->data, &escaped) != VOLK_OK)
                return VOLK_ERROR;
            buf_len = strlen (escaped) + 3; // Room for "" and terminator
 
            if (term->lang[0] != '\0') {
                metadata = term->lang;
                buf_len += strlen (metadata) + 1; // Room for @
            }
 
            out = realloc (*out_p, buf_len);
            if (UNLIKELY (!out)) return VOLK_MEM_ERR;
 
            sprintf (out, "\"%s\"", escaped);
            free (escaped);
 
            // Add lang.
            if (metadata) out = strcat (strcat (out, "@"), metadata);
 
            rc = VOLK_OK;
 
            break;
 
        case VOLK_TERM_BNODE:
            out = realloc (*out_p, strlen (term->data) + 3);
            if (UNLIKELY (!out)) return VOLK_MEM_ERR;
 
            sprintf (out, "_:%s", term->data);
            rc = VOLK_OK;
 
            break;
 
        default:
            out = *out_p;  // This is considered garbage.
            rc = VOLK_PARSE_ERR;
    }
 
    *out_p = out;
    return rc;
}
 
 
void *
nt_encode_graph_init (const VOLK_Graph *gr, VOLK_CodecFlags _unused)
{
    (void) _unused;
 
    NTEncodeIterator *it;
    CALLOC_GUARD (it, NULL);
 
    it->gr_it = VOLK_graph_lookup(gr, NULL, NULL, NULL, &it->cur);
    it->gr_uri = VOLK_graph_uri (gr);
 
    return it;
}
 
 
VOLK_rc
nt_encode_graph_iter (void *h, char **res)
{
    NTEncodeIterator *it = h;
    VOLK_Triple *spo = NULL;
 
    VOLK_rc rc = VOLK_graph_iter_next (it->gr_it, &spo);
    if (rc != VOLK_OK) goto finally;
 
    // If IRIRefs are relative to the graph URI, make them absolute.
    VOLK_Term *abs_s, *abs_o;
    if (spo->s->type == VOLK_TERM_IRIREF)
        abs_s = VOLK_iriref_new_abs (it->gr_uri, spo->s);
    else abs_s = spo->s;
    if (spo->o->type == VOLK_TERM_IRIREF)
        abs_o = VOLK_iriref_new_abs (it->gr_uri, spo->o);
    else abs_o = spo->o;
 
    nt_encode_term (abs_s, &it->str_s);
    nt_encode_term (spo->p, &it->str_p);
    nt_encode_term (abs_o, &it->str_o);
 
    if (abs_s != spo->s) VOLK_term_free (abs_s);
    if (abs_o != spo->o) VOLK_term_free (abs_o);
    VOLK_triple_free (spo);
 
    // 3 term separators + dot + newline + terminal = 6
    char *tmp = realloc (
            *res, strlen (it->str_s) + strlen (it->str_p)
            + strlen (it->str_o) + 6);
    if (UNLIKELY (!tmp)) {
        *res = NULL;
        rc = VOLK_MEM_ERR;
        goto finally;
    }
 
    sprintf (tmp, "%s %s %s .\n", it->str_s, it->str_p, it->str_o);
    *res = tmp;
 
    it->cur++;
 
finally:
    return rc;
}
 
 
void
nt_encode_graph_done (void *h)
{
    NTEncodeIterator *it = h;
    VOLK_graph_iter_free (it->gr_it);
    free (it->str_s);
    free (it->str_p);
    free (it->str_o);
    free (it);
}