buffer.h

Go to the documentation of this file.

#ifndef VOLK_BUFFER_H
#define VOLK_BUFFER_H
 
#include "volksdata/core.h"


#define NULL_KEY 0
 

typedef enum {
    TRP_POS_S = 0,
    TRP_POS_P = 1,
    TRP_POS_O = 2,
} VOLK_TriplePos;
 

typedef enum {
    VOLK_BUF_BORROWED = 1<<0,       
} VOLK_BufferFlag;
 

typedef struct VOLK_Buffer {
    /*@null@*/ unsigned char *addr;
    size_t size;
    VOLK_BufferFlag flags;
} VOLK_Buffer;
 

typedef struct buffer_triple_t {
    VOLK_Buffer *s;
    VOLK_Buffer *p;
    VOLK_Buffer *o;
} VOLK_BufferTriple;
 

extern VOLK_Buffer *VOLK_default_ctx_buf;
 
 
/*
 * Function prototypes.
 */

VOLK_rc
VOLK_buffer_init (
        VOLK_Buffer *buf, const size_t size, const unsigned char *data);
 

inline VOLK_Buffer *
VOLK_buffer_new (const unsigned char *data, const size_t size)
{
    VOLK_Buffer *buf;
    CALLOC_GUARD (buf, NULL);
 
    if (VOLK_buffer_init (buf, size, data) != VOLK_OK) {
        free (buf->addr);
        free (buf);
        return NULL;
    }
 
    return buf;
}
 

inline VOLK_Buffer *
VOLK_buffer_new_borrowed (unsigned char *data, const size_t size)
{
    VOLK_Buffer *buf;
    MALLOC_GUARD (buf, NULL);
 
    buf->addr = data;
    buf->size = size;
    buf->flags = VOLK_BUF_BORROWED;
 
    return buf;
}
 

#define BUF_DUMMY VOLK_buffer_new (NULL, 0)
 

void VOLK_buffer_done (VOLK_Buffer *buf);
 

void VOLK_buffer_free (VOLK_Buffer *buf);
 

inline VOLK_Key
VOLK_buffer_hash (const VOLK_Buffer *buf)
{
    return (buf == NULL) ? NULL_KEY :
        VOLK_HASH (buf->addr, buf->size, VOLK_HASH_SEED);
}
 

void VOLK_buffer_print (const VOLK_Buffer *buf);
 

char *
VOLK_buffer_as_str (const VOLK_Buffer *buf);
 

inline int VOLK_buffer_cmp (const VOLK_Buffer *buf1, const VOLK_Buffer *buf2)
{
    return memcmp (
            buf1->addr, buf2->addr,
            (buf1->size > buf2->size ? buf1->size : buf2->size));
}
 

inline bool VOLK_buffer_eq (const VOLK_Buffer *buf1, const VOLK_Buffer *buf2)
{
    if (buf1->size != buf2->size) return false;
 
    return (VOLK_buffer_cmp (buf1, buf2) == 0) ? true : false;
}
 
 
/*
 * Buffer triples.
 */

VOLK_BufferTriple *
VOLK_btriple_new(VOLK_Buffer *s, VOLK_Buffer *p, VOLK_Buffer *o);
 

VOLK_rc
VOLK_btriple_init (
        VOLK_BufferTriple *sspo,
        VOLK_Buffer *s, VOLK_Buffer *p, VOLK_Buffer *o);
 

void
VOLK_btriple_done (VOLK_BufferTriple *sspo);
 

void
VOLK_btriple_free (VOLK_BufferTriple *sspo);
 

inline VOLK_Buffer *
VOLK_btriple_pos (const VOLK_BufferTriple *btrp, VOLK_TriplePos n)
{
    if (n == TRP_POS_S) return btrp->s;
    if (n == TRP_POS_P) return btrp->p;
    if (n == TRP_POS_O) return btrp->o;
 
    return NULL;
}
 

inline VOLK_Key
VOLK_btriple_hash (const VOLK_BufferTriple *strp)
{
    return VOLK_HASH (
        strp->s->addr, strp->s->size,
        VOLK_HASH (
            strp->p->addr, strp->p->size,
            VOLK_HASH (strp->o->addr, strp->o->size, VOLK_HASH_SEED)
        )
    );
}
 

#define BTRP_DUMMY VOLK_btriple_new (BUF_DUMMY, BUF_DUMMY, BUF_DUMMY)

 
#endif  // VOLK_BUFFER_H