writer_ttl.c

Go to the documentation of this file.

#include "volksdata/codec/writer_ttl.h"
 

struct ttl_encode_iter_t {
    VOLK_CodecFlags     flags;      
    const VOLK_Graph *  gr;         
    void *              txn;        
    VOLK_TermSet *      subjects;   
    size_t              s_cur;      
    VOLK_rc             rc;         
    char *              s_str;      
    char *              p_str;      
    char *              o_str;      
};
 
 
/* * * Codec functions. * * */
 
VOLK_rc
ttl_encode_term (const VOLK_Term *term, char **out_p)
{
    VOLK_rc rc;
    char
        *tmp = NULL,
        *out = NULL,
        *metadata = NULL;
    size_t buf_len;
 
    VOLK_rc md_rc = VOLK_NORESULT;
    switch (term->type) {
        case VOLK_TERM_IRIREF:
            if (strlen (term->data) == 0) {
                // Empty URI.
                NLRCCK (out = realloc (*out_p, 3), VOLK_MEM_ERR);
                sprintf (out, "<>");
            } else if (strcmp (term->data, VOLK_RDF_TYPE) == 0) {
                // Shorten RDF type
                buf_len = 2;
                NLRCCK (out = realloc (*out_p, 2), VOLK_MEM_ERR);
                out[0] = 'a';
                out[1] = '\0';
            } else {
                md_rc = VOLK_nsmap_denormalize_uri (term->data, &tmp);
                PRCCK (md_rc);
                if (md_rc == VOLK_NORESULT) {
                    // If URI counld not be shortened, add `<>`
                    // and copy term from the original.
                    out = realloc (*out_p, strlen (term->data) + 3);
                    if (UNLIKELY (!out)) return VOLK_MEM_ERR;
                    sprintf (out, "<%s>", term->data);
                } else {
                    // If URI was shortened, write it out without `<>` and
                    // use previously allocated data from denormalization.
                    // Free previous output pointer
                    free (*out_p);
                    out = tmp;
                }
            }
            rc = VOLK_OK;
            break;
 
        case VOLK_TERM_LITERAL:
            // Calculate string length.
            RCCK (escape_lit (term->data, &tmp));
            buf_len = strlen (tmp) + 3; // Room for "" and terminator
 
            // Data type.
            bool shorten = false;
            if (term->datatype && term->datatype != VOLK_default_datatype) {
#define XSD "http://www.w3.org/2001/XMLSchema#"
                // Shorten numeric and boolean types.
                if (strcmp ( term->datatype->data, XSD "integer") == 0) {
                    // TODO check for valid format.
                    shorten = true;
                } else if (strcmp ( term->datatype->data, XSD "double") == 0) {
                    // TODO check for valid format.
                    shorten = true;
                } else if (strcmp ( term->datatype->data, XSD "decimal") == 0) {
                    // TODO check for valid format.
                    shorten = true;
                } else if (strcmp ( term->datatype->data, XSD "boolean") == 0) {
                    // TODO check for valid format.
                    shorten = true;
                } else {
                    md_rc = VOLK_nsmap_denormalize_uri (
                            term->datatype->data, &metadata);
                    PRCCK (md_rc);
                    // Room for `^^<>` for FQURI, `^^` for NS URI
                    if (md_rc == VOLK_NORESULT) {
                        buf_len += 4;
                        metadata = term->datatype->data;
                    } else {
                        buf_len += 2;
                    }
                    buf_len += strlen (metadata);
                }
#undef XSD
            }
 
            out = realloc (*out_p, buf_len);
            NLRCCK (out, VOLK_MEM_ERR);
 
            if (shorten) strcpy (out, tmp);
            else if (metadata) {
                char *fmt = (
                        md_rc == VOLK_NORESULT ? "\"%s\"^^<%s>"
                        : "\"%s\"^^%s");
                sprintf (out, fmt, tmp, metadata);
            }
            else sprintf (out, "\"%s\"", tmp);
 
            free (tmp);
 
            rc = VOLK_OK;
 
            break;
 
        case VOLK_TERM_LT_LITERAL:
            // Calculate string length.
            if (escape_lit (term->data, &tmp) != VOLK_OK)
                return VOLK_ERROR;
            buf_len = strlen (tmp) + 3; // Room for "" and terminator
 
            if (term->lang[0] != '\0') {
                metadata = strndup (term->lang, sizeof (VOLK_LangTag));
                buf_len += strlen (metadata) + 1; // Room for @
            }
 
            out = realloc (*out_p, buf_len);
            if (UNLIKELY (!out)) return VOLK_MEM_ERR;
 
            sprintf (out, "\"%s\"", tmp);
            free (tmp);
 
            // 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.
            log_error ("Invalid term type: %d", term->type);
            rc = VOLK_PARSE_ERR;
    }
    if (metadata) free (metadata);
 
    *out_p = out;
    return rc;
}
 
 
void *
ttl_encode_graph_init (const VOLK_Graph *gr, VOLK_CodecFlags flags)
{
    TTLEncodeIterator *it;
    CALLOC_GUARD (it, NULL);
 
    it->flags = flags;
    it->gr = gr;
    it->subjects = VOLK_graph_unique_terms (gr, TRP_POS_S);
    // Sets the condition to build the prolog on 1st iteration.
    it->rc = VOLK_NORESULT;
    if (it->flags & VOLK_CODEC_TXN) {
        VOLK_Store *store = VOLK_graph_store (gr);
        if (VOLK_store_features (store) & VOLK_STORE_TXN)
            VOLK_store_begin (store, VOLK_STORE_TXN_RO, &it->txn);
    }
 
    return it;
}
 

static VOLK_rc
ttl_build_prolog (TTLEncodeIterator *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);
 
    // Base.
    char *base_uri_str = VOLK_graph_uri (it->gr)->data;
    char *base_stmt_tpl = "\n@base <%s> .\n\n";
    char *base_stmt = malloc (
            strlen (base_stmt_tpl) + strlen (base_uri_str) + 1);
    if (!UNLIKELY (base_stmt)) return VOLK_MEM_ERR;
    sprintf (base_stmt, base_stmt_tpl, base_uri_str);
    res = realloc (res, strlen (res) + strlen (base_stmt) + 1);
    if (!UNLIKELY (res)) return VOLK_MEM_ERR;
    res = strcat (res, base_stmt);
    free (base_stmt);
 
    *res_p = res;
    it->rc = VOLK_OK;
 
    return VOLK_OK;
}
 
 
VOLK_rc
ttl_encode_graph_iter (void *h, char **res_p)
{
    TTLEncodeIterator *it = h;
 
    if (!(it->flags & VOLK_CODEC_NO_PROLOG) && it->rc == VOLK_NORESULT)
        return ttl_build_prolog (it, res_p);
 
    VOLK_Term *s = NULL;
    char *res = *res_p;  // Result string will be reallocated.
    VOLK_rc rc = VOLK_term_set_next (it->subjects, &it->s_cur, &s);
    if (rc == VOLK_END) return rc;  // Return without logging error.
    RCCK (rc);  // Log error or warning for anything else.
 
    ttl_encode_term (s, &res);
 
    VOLK_LinkMap *lmap = VOLK_graph_connections (
            it->gr, s, VOLK_LINK_OUTBOUND);
 
    VOLK_LinkMapIterator *lmit = VOLK_link_map_iter_new (lmap);
    VOLK_Term *p = NULL;
    VOLK_TermSet *o_ts = NULL;
    char *p_join = "\n    ";  // Newline & indent after subject.
    // Begin predicate loop.
    while (VOLK_link_map_next (lmit, &p, &o_ts) != VOLK_END) {
        // Add predicate representation.
        RCCK (ttl_encode_term (p, &it->p_str));
        char *tmp = realloc (
                res, strlen (res) + strlen (it->p_str) + strlen (p_join) + 1);
        if (UNLIKELY (!tmp)) goto memfail;
        res = strcat (strcat (tmp, p_join), it->p_str);
 
        p_join = " ;\n    ";
 
        // Add objects for predicate.
        size_t i = 0;
        VOLK_Term *o = NULL;
        char *o_join = " ";
        while (VOLK_term_set_next (o_ts, &i, &o) != VOLK_END) {
            it->rc = ttl_encode_term (o, &it->o_str);
            RCCK (it->rc);
            char *tmp = realloc (
                    res, strlen (res) + strlen (it->o_str) + strlen (o_join) + 1);
            if (UNLIKELY (!tmp)) goto memfail;
            res = strcat (strcat (tmp, o_join), it->o_str);
            o_join = " ,\n        ";  // Double indent for objects.
        }
    }
 
    char *s_sep = "\n.\n\n";  // Period goes on its own line for visibility.
    char *tmp = realloc (res, strlen (res) + strlen (s_sep) + 1);
    if (UNLIKELY (!tmp)) goto memfail;
 
    *res_p = strcat (tmp, s_sep);
 
    VOLK_link_map_iter_free (lmit);
    VOLK_link_map_free (lmap);
 
    return it->rc;
 
memfail:
    free (res);
    *res_p = NULL;
    return VOLK_MEM_ERR;
}
 
 
void
ttl_encode_graph_done (void *h)
{
    if (!h) return;
    TTLEncodeIterator *it = h;
    if (it->txn) VOLK_store_abort (VOLK_graph_store (it->gr), it->txn);
    VOLK_term_set_free (it->subjects);
    free (it->s_str);
    free (it->p_str);
    free (it->o_str);
    free (it);
}