term.h

Go to the documentation of this file.

#ifndef VOLK_TERM_H
#define VOLK_TERM_H
 
//#include <assert.h>
 
#include "volksdata/buffer.h"
#include "volksdata/namespace.h"

 
#define UUID4_URN_SIZE UUIDSTR_SIZE + 10
 
// Some common RDF term values.
#define VOLK_RDF_TYPE       "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
#define VOLK_RDF_TYPE_NS    "rdf:type"
#define DEFAULT_DTYPE       "http://www.w3.org/2001/XMLSchema#string"
#define DEFAULT_DTYPE_NS    "xsd:string"
 
/*
 * Data types.
 */

typedef char VOLK_LangTag[8];

typedef enum {
    VOLK_TERM_UNDEFINED = 0,
    VOLK_TERM_IRIREF,       
    VOLK_TERM_LITERAL,      
    VOLK_TERM_LT_LITERAL,   
    VOLK_TERM_BNODE,        
} VOLK_TermType;

typedef struct match_coord_t {
    unsigned int        offset;     
    unsigned int        size;       
} MatchCoord;

typedef struct iri_info_t {
    MatchCoord          prefix;     
    MatchCoord          scheme;     
    MatchCoord          auth;       
    MatchCoord          path;       
    MatchCoord          query;      
    MatchCoord          frag;       
} VOLK_IRIInfo;

typedef struct link_map_iter VOLK_LinkMapIterator;

typedef struct term_t {
    char              * data;       
    union {
        struct term_t * datatype;   
        VOLK_LangTag    lang;       
        VOLK_Key        bnode_id;   
        void          * metadata;   
    };
    VOLK_TermType       type;       
} VOLK_Term;
 

#define VOLK_IS_LITERAL(term) \
    ((term)->type == VOLK_TERM_LITERAL || (term)->type == VOLK_TERM_LT_LITERAL)
 

typedef struct triple_t {
    VOLK_Term *s;                   
    VOLK_Term *p;                   
    VOLK_Term *o;                   
} VOLK_Triple;
 

typedef enum {
    VOLK_LINK_INBOUND,              
    VOLK_LINK_OUTBOUND,             
    VOLK_LINK_EDGE,                 
} VOLK_LinkType;
 

typedef struct link_map VOLK_LinkMap;
 

typedef struct hashmap VOLK_TermSet;
 
 
/*
 * External variables.
 */

extern uint32_t VOLK_default_dtype_key;

extern VOLK_Term *VOLK_default_datatype;

extern VOLK_TermSet *VOLK_term_cache;

extern VOLK_Term *VOLK_default_ctx;
 
 
/*
 * API functions.
 */

VOLK_Term *
VOLK_term_new (VOLK_TermType type, const char *data, void *metadata);
 

#define TERM_DUMMY VOLK_term_new (VOLK_TERM_UNDEFINED, NULL, NULL)
 

inline VOLK_Term *
VOLK_iriref_new (const char *data)
{ return VOLK_term_new (VOLK_TERM_IRIREF, data, NULL); }
 

inline VOLK_Term *
VOLK_iriref_new_ns (const char *data)
{
    char *fquri;
    RCNL (VOLK_nsmap_normalize_uri (data, &fquri));
 
    VOLK_Term *t = VOLK_term_new (VOLK_TERM_IRIREF, fquri, NULL);
    free (fquri);
 
    return t;
}
 

VOLK_Term *
VOLK_iriref_new_abs (const VOLK_Term *root, const VOLK_Term *iri);
 

VOLK_Term *
VOLK_iriref_new_rel (const VOLK_Term *root, const VOLK_Term *iri);
 

inline VOLK_Term *
VOLK_literal_new (const char *data, VOLK_Term *datatype)
{ return VOLK_term_new (VOLK_TERM_LITERAL, data, datatype); }
 

VOLK_rc
VOLK_parse_iri (char *iri_str, VOLK_IRIInfo *iri_info);
 

inline VOLK_Term *
VOLK_lt_literal_new (const char *data, char *lang)
{ return VOLK_term_new (VOLK_TERM_LT_LITERAL, data, lang); }
 

inline VOLK_Term *
VOLK_bnode_new (const char *data)
{ return VOLK_term_new (VOLK_TERM_BNODE, data, NULL); }
 

VOLK_Term *
VOLK_term_copy (const VOLK_Term *src);
 

VOLK_Term *
VOLK_term_new_from_buffer (const VOLK_Buffer *sterm);
 

VOLK_Buffer *
VOLK_term_serialize (const VOLK_Term *term);
 

VOLK_Key
VOLK_term_hash (const VOLK_Term *term);
 

inline bool VOLK_term_equals (const VOLK_Term *term1, const VOLK_Term *term2)
{ return term1 == term2 || VOLK_term_hash (term1) == VOLK_term_hash (term2); }
 
 
void
VOLK_term_free (VOLK_Term *term);
 

char *
VOLK_iriref_prefix (const VOLK_Term *iri);
 

char *
VOLK_iriref_path (const VOLK_Term *iri);
 

char *
VOLK_iriref_frag (const VOLK_Term *iri);
 
/*
 * TRIPLES
 */

VOLK_Triple *
VOLK_triple_new(VOLK_Term *s, VOLK_Term *p, VOLK_Term *o);
 

#define TRP_DUMMY VOLK_triple_new (NULL, NULL, NULL)
 
 
VOLK_Triple *
VOLK_triple_new_from_btriple (const VOLK_BufferTriple *sspo);
 
 
VOLK_BufferTriple *
VOLK_triple_serialize (const VOLK_Triple *spo);
 

VOLK_rc
VOLK_triple_init (VOLK_Triple *spo, VOLK_Term *s, VOLK_Term *p, VOLK_Term *o);
 

void
VOLK_triple_done (VOLK_Triple *spo);
 

void
VOLK_triple_free (VOLK_Triple *spo);
 

inline VOLK_Term *
VOLK_triple_pos (const VOLK_Triple *trp, const VOLK_TriplePos n)
{
    if (n == TRP_POS_S) return trp->s;
    if (n == TRP_POS_P) return trp->p;
    if (n == TRP_POS_O) return trp->o;
    return NULL;
}
 

inline VOLK_Key
VOLK_triple_hash (const VOLK_Triple *trp)
{
    VOLK_BufferTriple *strp = VOLK_triple_serialize (trp);
    VOLK_Key hash = VOLK_btriple_hash (strp);
    VOLK_btriple_free (strp);
 
    return hash;
}
 

VOLK_TermSet *
VOLK_term_set_new (void);
 

void
VOLK_term_set_free (VOLK_TermSet *ts);
 

VOLK_rc
VOLK_term_set_add (VOLK_TermSet *ts, VOLK_Term *term, VOLK_Term **existing);
 

const VOLK_Term *
VOLK_term_set_get (VOLK_TermSet *ts, VOLK_Key key);
 

VOLK_rc
VOLK_term_set_next (VOLK_TermSet *ts, size_t *i, VOLK_Term **term);
 

size_t
VOLK_term_set_size (VOLK_TermSet *ts);
 

VOLK_LinkMap *
VOLK_link_map_new (const VOLK_Term *linked_term, VOLK_LinkType type);
 

void
VOLK_link_map_free (VOLK_LinkMap *lm);
 

VOLK_LinkType
VOLK_link_map_type (const VOLK_LinkMap *map);
 

VOLK_rc
VOLK_link_map_add (
        VOLK_LinkMap *lmap, VOLK_Term *term, VOLK_TermSet *tset);
 

VOLK_LinkMapIterator *
VOLK_link_map_iter_new (const VOLK_LinkMap *lmap);
 

VOLK_rc
VOLK_link_map_next (
        VOLK_LinkMapIterator *it, VOLK_Term **lt, VOLK_TermSet **ts);
 

void
VOLK_link_map_iter_free (VOLK_LinkMapIterator *it);
 

VOLK_rc
VOLK_link_map_triples (VOLK_LinkMapIterator *it, VOLK_Triple *spo);

 
#endif // VOLK_TERM_H