codec.h

Go to the documentation of this file.

 
#ifndef VOLK_CODEC_H
#define VOLK_CODEC_H
 
// Add new codec implementations to this include list.
#include "volksdata/codec/codec_nt.h"
#include "volksdata/codec/codec_ttl.h"
#include "volksdata/codec/codec_trig.h"
 
/*
 * 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 )     \
    ENTRY(  TRIG,           trig,   trig_codec )    \
 

 
#define ENTRY(a, b, c) VOLK_CODEC_FMT_##a,
typedef enum {
    CODEC_TBL
} VOLK_CodecFormat;
#undef ENTRY
 

typedef struct codec_iter_wrapper_t {
    void *it;
    const VOLK_Codec *codec;
} VOLK_CodecIterator;
 

#define ENTRY(a, b, c) case VOLK_CODEC_FMT_##a: return &c;
static inline const VOLK_Codec *
VOLK_codec_get (const VOLK_CodecFormat fmt)
{
    switch (fmt) {
        CODEC_TBL
        default:
            log_warn ("No codec found for format `%s`.", fmt);
            return NULL;
    }
}
#undef ENTRY
 
 
/*
 * Codec operations.
 */
 

static inline VOLK_rc
VOLK_codec_encode_term (const VOLK_Term *term, char **out, VOLK_CodecFormat fmt)
{
    const VOLK_Codec *codec = VOLK_codec_get (fmt);
    if (UNLIKELY (!(codec->features & VOLK_CODEC_FEAT_ENCODE_TERM)))
        return VOLK_NOT_IMPL_ERR;
 
    return codec->encode_term (term, out);
}
 

static inline VOLK_CodecIterator *
VOLK_codec_encode_gr_init (
        const VOLK_Graph *gr, void *udata, VOLK_CodecFormat fmt)
{
    const VOLK_Codec *codec = VOLK_codec_get (fmt);
    if (UNLIKELY (!(codec->features & VOLK_CODEC_FEAT_ENCODE_GR))) {
        log_error ("Graph encoding is not supported by this codec.");
        return NULL;
    }
    VOLK_CodecIterator *itw = malloc (sizeof *itw);
    NLNL (itw);
    itw->codec = codec;
    itw->it = codec->encode_graph_init (gr, udata);
 
    return itw;
}
 

static inline VOLK_rc
VOLK_codec_encode_gr_iter (VOLK_CodecIterator *itw, char **res)
{ return itw->codec->encode_graph_iter (itw->it, res); }
 

static inline void
VOLK_codec_encode_gr_done (VOLK_CodecIterator *itw)
{
    itw->codec->encode_graph_done (itw->it);
    free (itw);
}
 
 

static inline VOLK_CodecIterator *
VOLK_codec_encode_dset_init (const VOLK_Graph **dset, VOLK_CodecFormat fmt)
{
    const VOLK_Codec *codec = VOLK_codec_get (fmt);
    if (UNLIKELY (!(codec->features & VOLK_CODEC_FEAT_ENCODE_DS))) {
        log_error ("Dataset encoding is not supported by this codec.");
        return NULL;
    }
 
    VOLK_CodecIterator *itw = malloc (sizeof *itw);
    NLNL (itw);
    itw->codec = codec;
    itw->it = codec->encode_dset_init (dset);
 
    return itw;
}
 

static inline VOLK_rc
VOLK_codec_encode_dset_iter (
        VOLK_CodecIterator *itw, const VOLK_Graph *gr, char **res)
{ return itw->codec->encode_dset_iter (itw->it, gr, res); }
 
 

static inline void
VOLK_codec_encode_dset_done (VOLK_CodecIterator *itw)
{
    itw->codec->encode_dset_done (itw->it);
    free (itw);
}
 

static inline VOLK_CodecIterator *
VOLK_codec_encode_store_init (VOLK_Store *store, VOLK_CodecFormat fmt)
{
    const VOLK_Codec *codec = VOLK_codec_get (fmt);
    if (UNLIKELY (!(codec->features & VOLK_CODEC_FEAT_ENCODE_STORE))) {
        log_error ("Store encoding is not supported by this codec.");
        return NULL;
    }
 
    VOLK_CodecIterator *itw = malloc (sizeof *itw);
    NLNL (itw);
    itw->codec = codec;
    itw->it = codec->encode_store_init (store);
 
    return itw;
}
 

static inline VOLK_rc
VOLK_codec_encode_store_iter (VOLK_CodecIterator *itw , char **res)
{ return itw->codec->encode_store_iter (itw->it, res); }
 

static inline void
VOLK_codec_encode_store_done (VOLK_CodecIterator *itw)
{
    itw->codec->encode_store_done (itw->it);
    free (itw);
}
 
 
/*
 * Decode functions.
 */
 
static inline VOLK_rc
VOLK_codec_decode_term (
        const char *data, VOLK_Term **out, VOLK_CodecFormat fmt)
{
    const VOLK_Codec *codec = VOLK_codec_get (fmt);
    if (UNLIKELY (!(codec->features & VOLK_CODEC_FEAT_DECODE_TERM)))
        return VOLK_NOT_IMPL_ERR;
    return codec->decode_term (data, out);
}
 

static inline VOLK_rc
VOLK_codec_decode_gr (
        FILE *fh, const char *data, VOLK_Graph *gr, VOLK_CodecFormat fmt,
        size_t *ct, char **err)
{
    const VOLK_Codec *codec = VOLK_codec_get (fmt);
    if (UNLIKELY (!(codec->features & VOLK_CODEC_FEAT_DECODE_GR)))
        return VOLK_NOT_IMPL_ERR;
 
    return codec->decode_graph (fh, data, gr, ct, err);
}
 

static inline VOLK_rc
VOLK_codec_decode_dset (
        FILE *fh, const char *data, VOLK_Store *store, void *txn,
        VOLK_CodecFormat fmt, size_t *ct, char **err)
{
    const VOLK_Codec *codec = VOLK_codec_get (fmt);
    if (UNLIKELY (!(codec->features & VOLK_CODEC_FEAT_DECODE_DS))) {
        log_error ("Store decoding is not supported by this codec.");
        return VOLK_NOT_IMPL_ERR;
    }
 
    return codec->decode_dset (fh, data, store, txn, ct, err);
}
 
 
/*
static inline VOLK_rc
VOLK_codec_decode_dset_iter (
    VOLK_CodecIterator *itw, VOLK_Graph **gr,
    size_t *ct, char **err
)
{ return itw->codec->decode_dset_iter (itw->it, gr, ct, err); }
 
 
static inline void
VOLK_codec_decode_dset_done (VOLK_CodecIterator *itw)
{
    itw->codec->decode_dset_done (itw->it);
    free (itw);
}
*/
 
 
/* TODO
static inline VOLK_rc
VOLK_codec_decode_dset (
        FILE *fh, const char *data, VOLK_Graph **out, VOLK_CodecFormat fmt)
{
    const VOLK_Codec *codec = VOLK_codec_get (fmt);
    if (UNLIKELY (!(codec->features & VOLK_CODEC_FEAT_DECODE_DS)))
        return VOLK_NOT_IMPL_ERR;
 
    void *it = codec->decode_dset_init (fh, data);
}
*/
 
/* TODO probably not needed.
static inline VOLK_rc
VOLK_codec_decode_store (
        const VOLK_Store *store, char**res, VOLK_CodecFormat fmt)
{
    const VOLK_Codec *codec = VOLK_codec_get (fmt);
    if (UNLIKELY (!(codec->features & VOLK_CODEC_FEAT_DECODE_STORE)))
        return VOLK_NOT_IMPL_ERR;
 
    void *it = codec->decode_store_init (store);
}
*/

 
#endif  // VOLK_CODEC_H