jsonCache.h

Go to the documentation of this file.

#ifndef CACHE_H
#define CACHE_H

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <pthread.h>

/*
        TYPES 
*/

typedef enum json_type_e
{
        JSON_NULL,
        JSON_BOOL,
        JSON_STRING,
        JSON_INT,
        JSON_REAL,
        JSON_OBJECT,
        JSON_ARRAY,
        JSON_SOMETHING_ELSE
} json_type;

/*
        MAIN Json type definition
*/

typedef struct json_t_s
{
        json_type type;
        size_t refcounter;

        pthread_spinlock_t lock;
        volatile char locked;
}json_t;

static inline void json_lock( json_t *json )
{
        if( !json )
                return;

        pthread_spin_lock( &json->lock );
        json->locked = 1;
}

static inline void json_unlock( json_t *json )
{
        if( !json )
                return;

        pthread_spin_unlock( &json->lock );
        json->locked = 0;
}

static inline int json_locked( json_t *json )
{
        return json->locked;
}

void json_incref( json_t *json );
void json_decref( json_t *json );

/* INTERNALS ------------------------ */
json_t * __json_t_init( json_type type );
void __json_t_release( json_t *json );
/* ---------------------------------- */

static inline void json_incref_lf( json_t *json )
{
        if( !json )
                return;

        json->refcounter++;
}


static inline int json_decref_lf( json_t *json )
{
        if( !json )
                return 0;

        json->refcounter--;

        if( json->refcounter == 0 )
        {
                __json_t_release( json );
                return 0;
        }

        return 1;
}



/*
        BASIC Types
*/

typedef struct json_null_s
{
        json_t ___;
} json_null_t;

json_t * json_null();
void json_null_destroy(json_t * json);

typedef struct json_bool_s
{
        json_t ___;
        char value;
} json_bool_t;

json_t * json_bool( int thruth );

/* INTERNALS ------------------------ */
void json_bool_destroy(json_t * json);
/* ---------------------------------- */

/*
        C Types
*/

typedef struct json_string_s
{
        json_t ___;
        char *value;
} json_string_t;

json_t * json_string( char * string );
json_t * json_string_l( char *string , int len );

/* INTERNALS ------------------------ */
void json_string_destroy(json_t * json);
/* ---------------------------------- */

typedef struct json_int_s
{
        json_t ___;
        int64_t value;
} json_int_t;

json_t * json_int( int64_t value );

/* INTERNALS ------------------------ */
void json_int_destroy(json_t * json);
/* ---------------------------------- */

typedef struct json_real_s
{
        json_t ___;
        double value;
} json_real_t;

json_t * json_real( double value );

/* INTERNALS ------------------------ */
void json_real_destroy(json_t * json);
/* ---------------------------------- */

/*
        CONTAINERS Types
*/

struct ObjectHT_entry
{
        char *key;
        json_t * elem;

        struct ObjectHT_entry * prev;
};

struct ObjectHT
{
        struct ObjectHT_entry ** entries;
        size_t size;
        int pow2_size;
};


void ObjectHT_init( struct ObjectHT *ht, int pow2_size );
void ObjectHT_release( struct ObjectHT *ht );

void ObjectHT_set( struct ObjectHT *ht, char *key, json_t * elem );
struct ObjectHT_entry * ObjectHT_get( struct ObjectHT *ht, char *key );
void ObjectHT_delete( struct ObjectHT *ht, char *key );


typedef struct json_object_s
{
        json_t ___;
        struct ObjectHT ht;
} json_object_t;

json_t * json_object();

json_t * json_object_set( json_t * json, char *key, json_t * elem );
json_t * json_object_get( json_t * json, char *key );
json_t * json_object_delete( json_t * json, char *key );


/* INTERNALS ------------------------ */
void json_object_destroy(json_t * json);
/* ---------------------------------- */

typedef struct json_array_s
{
        json_t ___;

        json_t **content;
        size_t size;
} json_array_t;

json_t * json_array();

json_t * json_array_push(json_t *json, json_t * elem);
json_t * json_array_push_at(json_t *json, unsigned int offset, json_t * elem);
json_t * json_array_get( json_t *json, unsigned int offset );
json_t * json_array_set( json_t *json, unsigned int offset , json_t * elem);
json_t * json_array_del( json_t *json, unsigned int offset );

/* INTERNALS ------------------------ */
void json_array_destroy(json_t * json);
int json_array_guarantee( json_array_t  *a, unsigned int offset, int count );
/* ---------------------------------- */


/*
        json_t MUTATORS
*/

#define json_to_null( a ) ( (json_null_t *)( a ) )
#define json_to_bool( a ) ( (json_bool_t *)( a ) )
#define json_to_string( a ) ( (json_string_t *)( a ) )
#define json_to_int( a ) ( (json_int_t *)( a ) )
#define json_to_real( a ) ( (json_real_t *)( a ) )
#define json_to_object( a ) ( (json_object_t *)( a ) )
#define json_to_array( a ) ( (json_array_t *)( a ) )

/*
        OBJECT ITERATOR
*/


typedef struct json_object_iterator_s
{
        struct ObjectHT *ht;
        size_t current_bucket;
        struct ObjectHT_entry *current_elem;
}json_object_iterator;

static inline void json_object_iterator_init( json_object_iterator *it, json_t * json )
{
        if( json->type != JSON_OBJECT )
        {
                it->ht = NULL;
                it->current_bucket = -1;
                it->current_elem = NULL;
                return;
        }
        
        json_object_t *o = json_to_object( json );
        
        it->ht = &o->ht;
        it->current_bucket = 0;
        it->current_elem = NULL;
        
        
}

static inline int json_object_iterator_next( json_object_iterator *it )
{
        if( !it->ht )
                return 0;
        
        if( !it->current_elem )
        {
                it->current_elem = it->ht->entries[ it->current_bucket ];
        }
        else
        {
                it->current_elem = it->current_elem->prev;
        }
        
        if( !it->current_elem )
        {
                it->current_bucket++;
                
                if( it->ht->size <= it->current_bucket )
                {
                        return 0;
                }
                else
                {
                        return json_object_iterator_next( it );
                }
                
        }
        else
        {
                return 1;
        }
        
}

static inline char * json_object_iterator_key( json_object_iterator *it )
{
        
        if( it->current_elem )
        {
                return it->current_elem->key;
        }
        
        return NULL;
}
        
static inline json_t * json_object_iterator_elem( json_object_iterator *it )
{
        if( it->current_elem )
        {
                return it->current_elem->elem;
        }
        
        return NULL;
}


/*
        Dumping
*/

typedef enum
{
        JSON_COMPACT = 1,
        JSON_PRETTY = 2,
        JSON_NO_LOCK = 4
}json_format;


char * json_dump( json_t * json, json_format mode );
void json_dump_f(FILE * f, json_t * json, json_format mode );

static inline void json_print( json_t * json, json_format mode )
{
        json_dump_f( stdout , json, mode );
}

/*
  PARSING
*/

json_t * _json_parse( char ** buff );
json_t * json_parse( char * json );


/*
        CACHE Implementation
*/

struct jsonCache
{
        json_t *cache;
        
        void (*set_handler)( char *, json_t *, void *);
        void (*delete_handler)( char *, void *);
        void *ctx;
};


void jsonCache_init( struct jsonCache *cache, void (*set_handler)( char *, json_t *, void *ctx), void (*delete_handler)( char *, void *ctx), void *ctx );
void jsonCache_release( struct jsonCache *cache );
json_t * jsonCache_get( struct jsonCache *cache, char *key );

void jsonCache_commit( struct jsonCache *cache, char *key );
char * jsonCache_json( struct jsonCache *c, char *key, json_format mode );

void jsonCache_set_json( struct jsonCache *cache, char *key, char *json );
void jsonCache_set( struct jsonCache *cache, char *key, json_t * elem );

void jsonCache_set_json_nocommit( struct jsonCache *cache, char *key, char *json );
void jsonCache_set_nocommit( struct jsonCache *cache, char *key, json_t * elem );

void jsonCache_delete( struct jsonCache *cache, char *key );
void jsonCache_delete_nocommit( struct jsonCache *cache, char *key );

#endif /* CACHE_H */