codec.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
 
 
/*
 * Define supported codecs.
 *
 * Add new codec implementations to this table.
 */
#define CODEC_TBL                                   \
/*          #enum suffix    #fmt    #codec if  */   \
    ENTRY(  NT,             nt,     nt_codec  )     \
    ENTRY(  TTL,            ttl,    ttl_codec )     \
 

typedef enum codec_type {
#define ENTRY(a, b, c) \
    VOLK_CODEC_##a,
CODEC_TBL
#undef ENTRY
} VOLK_CodecType;
typedef struct codec_t VOLK_Codec;
 

typedef struct ttl_parser_state {
    VOLK_GraphIterator *    it;     
    VOLK_Term *             base;   
    VOLK_Term *             lms;    
    size_t                  ct;     
    VOLK_rc                 rc;     
} VOLK_TTLParserState;

/* 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;
*/
 
 
/*
 * 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);

 

 
/*
inline const VOLK_Codec *
codec_by_fmt (const char *fmt)
{
#define ENTRY(a, b, c) \
    if str
CODEC_TBL
#undef ENTRY
}
*/
 
/*
 * Interface prototypes.
 */

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

typedef void * (*gr_encode_init_fn_t)(const VOLK_Graph *gr);
 

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

typedef void (*gr_encode_done_fn_t)(void *it);
 

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

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

struct codec_t {
    char                name[16];           
    char                mimetype[32]; 
    char                extension[8];       
 
    // Encoding.
    term_enc_fn_t       encode_term;        
 
    gr_encode_init_fn_t encode_graph_init;  
    gr_encode_iter_fn_t encode_graph_iter;  
    gr_encode_done_fn_t encode_graph_done;  
 
    // Decoding.
    term_decode_fn_t    decode_term;        
    gr_decode_fn_t      decode_graph;       
};

 
#endif  // VOLK_CODEC_BASE_H