codec_interface.h

Go to the documentation of this file.

 
#ifndef VOLK_CODEC_BASE_H
#define VOLK_CODEC_BASE_H
 
#include "volksdata/graph.h"



#ifdef VOLK_RDF_STREAM_CHUNK_SIZE
#define CHUNK_SIZE VOLK_RDF_STREAM_CHUNK_SIZE
#else
#define CHUNK_SIZE 4096
#endif

/* TODO A plain string will suffice for now.
typedef struct parse_error_t {
    unsigned int        line;       // Line number where the error occurred.
    unsigned int        linec;      // Position in line of the offending token.
    char *              token;      // String representation of the token.
} VOLK_ParseError;
*/

typedef enum codec_flags_t {
    VOLK_CODEC_NO_PROLOG    = 1<<0, 
    CODEC_EXT_TXN           = 1<<1, 
    VOLK_CODEC_INDENT       = 1<<2, 
} VOLK_CodecFlags;

typedef enum codec_feat_t {
    VOLK_CODEC_FEAT_ENCODE_TERM   = 1<<0, 
    VOLK_CODEC_FEAT_DECODE_TERM   = 1<<1, 
 
    VOLK_CODEC_FEAT_ENCODE_GR     = 1<<2, 
    VOLK_CODEC_FEAT_DECODE_GR     = 1<<3, 
 
    VOLK_CODEC_FEAT_ENCODE_DS     = 1<<4, 
    VOLK_CODEC_FEAT_DECODE_DS     = 1<<5, 
 
    VOLK_CODEC_FEAT_ENCODE_STORE  = 1<<6, 
    VOLK_CODEC_FEAT_DECODE_STORE  = 1<<7, 
} VOLK_CodecFeatures;
 
/*
 * Common utility functions.
 */

inline uint8_t
*uint8_dup (const uint8_t *str)
{ return (uint8_t *) strdup ((char *) str); }
 

inline uint8_t
*uint8_ndup (const uint8_t *str, size_t size)
{ return (uint8_t *) strndup ((char *) str, size); }
 

VOLK_rc
escape_lit (const char *in, char **out);
 

static inline char
escape_char (const char c) {
    switch (c) {
        case '\t': return 't';
        case '\b': return 'b';
        case '\n': return 'n';
        case '\r': return 'r';
        case '\f': return 'f';
        default: return c;
    }
}
 

inline char
unescape_char (const char c)
{
    switch (c) {
        case 't': return '\t';
        case 'b': return '\b';
        case 'n': return '\n';
        case 'r': return '\r';
        case 'f': return '\f';
        default: return c;
    }
}
 

uint8_t *unescape_unicode (const uint8_t *esc_str, size_t size);
 

char *fmt_header (char *pfx);
 
 
/*
 * Interface prototypes.
 */
 
 
/*
 * Decoding functions.
 */

typedef VOLK_rc (*encode_term_fn_t)(const VOLK_Term *term, char **rep);
 

typedef void * (*encode_gr_init_fn_t)(const VOLK_Graph *gr, void *udata);
 

typedef VOLK_rc (*encode_gr_iter_fn_t)(void *it, char **res);
 

typedef void (*encode_gr_done_fn_t)(void *it);
 

typedef void * (*encode_ds_init_fn_t)(const VOLK_Graph **dset);
 

typedef VOLK_rc (*encode_ds_iter_fn_t)(
        void *it, const VOLK_Graph *gr, char **res);
 

typedef void (*encode_ds_done_fn_t)(void *it);
 

typedef void * (*encode_store_init_fn_t)(VOLK_Store *store);
 

typedef VOLK_rc (*encode_store_iter_fn_t)(void *it, char **res);
 

typedef void (*encode_store_done_fn_t)(void *it);
 
 
/*
 * Decoding functions.
 */
 

typedef VOLK_rc (*decode_term_fn_t)(const char *rep, VOLK_Term **term);
 

typedef VOLK_rc (*decode_gr_fn_t)(
        FILE *fh, const char *sh, VOLK_Graph *gr, size_t *ct, char **err);
 

typedef VOLK_rc (*decode_ds_fn_t)(
        FILE *fh, const char *sh, VOLK_Store *store, void *udata,
        size_t *ct, char **err_p);
 

//typedef void * (*decode_ds_init_fn_t)(FILE *fh, const char *sh);
 

//typedef VOLK_rc (*decode_ds_iter_fn_t)(
//        void *it, VOLK_Graph **gr, size_t *ct, char **err);
 

//typedef void (*decode_ds_done_fn_t)(void *it);
 

typedef struct codec_t {
    char                name[16];           
    char                mimetype[32]; 
    char                extension[8];       
    VOLK_CodecFeatures  features;           
 
    // Encoding.
    encode_term_fn_t    encode_term;        
 
    encode_gr_init_fn_t encode_graph_init;  
    encode_gr_iter_fn_t encode_graph_iter;  
    encode_gr_done_fn_t encode_graph_done;  
 
    encode_ds_init_fn_t encode_dset_init;   
    encode_ds_iter_fn_t encode_dset_iter;   
    encode_ds_done_fn_t encode_dset_done;   
 
    encode_store_init_fn_t encode_store_init;   
    encode_store_iter_fn_t encode_store_iter;   
    encode_store_done_fn_t encode_store_done;   
 
    // Decoding.
    decode_term_fn_t    decode_term;        
 
    decode_gr_fn_t      decode_graph;       
 
    decode_ds_fn_t      decode_dset;        
} VOLK_Codec;

 
#endif  // VOLK_CODEC_BASE_H