model_support.h File Reference

#include <stdbool.h>
#include <stddef.h>
#include <stdlib.h>
#include <sys/time.h>
#include <string.h>
#include <json-c/json.h>
#include "externs.h"
#include "model_collections.h"
#include "types.h"
#include <unistd.h>

Go to the source code of this file.

Data Structures
struct	field_meta
struct	type_meta
struct	tag

Macros
#define	MODEL_API
	set of macros to help generate struct and function for our model;
#define	MODEL_JSON_COMPACT   0x1
#define	none(t)   t
#define	ptr(t)   t*
#define	array(t)   t##_array
#define	map(t)   model_map
#define	list(t)   model_list
#define	FIELD_DECL(name, type, mod, path, _)   mod(type) name;
#define	DECLARE_MODEL(type, model)
#define	DECLARE_MODEL_FUNCS(T)
#define	gen_field_meta(n, memtype, modifier, p, partype)
#define	IMPL_MODEL(type, model)
#define	IMPL_MODEL_FUNCS(T)
#define	MODEL_PARSE_INVALID   (-2)
#define	MODEL_PARSE_PARTIAL   (-3)
#define	mk_enum2(v, t)   t##_##v
#define	mk_enum3(v, n, t)   t##_##v
#define	enum_f2(v, t)   const t v
#define	enum_f3(v, n, t)   const t v
#define	get_ovrd(_1, _2, _3, NAME, ...)   NAME
#define	mk_enum(...)   get_ovrd(__VA_ARGS__, mk_enum3, mk_enum2)(__VA_ARGS__),
#define	enum_field(...)   get_ovrd(__VA_ARGS__, enum_f3, enum_f2)(__VA_ARGS__);
#define	DECLARE_ENUM(Enum, Values)
#define	get_value_of_ovrd(_1, _2, _3, _4, _5, NAME, ...)   NAME
#define	enum_value_of4(v, t, str, len)   if(strncmp(str,#v,len) == 0){return (t)t##s.v;}
#define	enum_value_of5(n, v, t, str, len)   if(strncmp(str,v,len) == 0){return (t)t##s.n;}
#define	enum_value_of(...)   get_value_of_ovrd(__VA_ARGS__, enum_value_of5, enum_value_of4)(__VA_ARGS__)
#define	enum_c2(v, t)   case t##_##v: return #v
#define	enum_c3(n, v, t)   case t##_##n: return v
#define	enum_case(...)   get_ovrd(__VA_ARGS__, enum_c3, enum_c2)(__VA_ARGS__);
#define	enum_field_v2(v, t)   .v = t##_##v
#define	enum_field_v3(n, v, t)   .n = t##_##n
#define	enum_field_val(...)   get_ovrd(__VA_ARGS__, enum_field_v3, enum_field_v2)(__VA_ARGS__),
#define	IMPL_ENUM(Enum, Values)

Typedefs
typedef const char *	model_string
typedef model_string *	model_string_array
typedef int64_t	model_number
typedef model_number **	model_number_array
typedef bool	model_bool
typedef model_bool **	model_bool_array
typedef char *	json
typedef int(*	_parse_f) (void *obj, const char *json, void *tok)
typedef int(*	_to_json_f) (const void *obj, void *buf, int indent, int flags)
typedef void(*	_free_f) (void *obj)
typedef int(*	_cmp_f) (const void *lh, const void *rh)
typedef int(*	from_json_func) (void *obj, struct json_object *json, const struct type_meta *meta)
typedef struct json_object *(*	to_json_func) (const void *obj)
typedef struct timeval	timestamp

Enumerations
enum	_field_mod {   none_mod , ptr_mod , array_mod , map_mod ,   list_mod }
enum	tag_type { tag_null , tag_bool , tag_number , tag_string }

Functions
void *	model_alloc (const type_meta *meta)
void	model_free (void *obj, const type_meta *meta)
void	model_free_array (void ***ap, const type_meta *meta)
int	model_cmp (const void *lh, const void *rh, const type_meta *meta)
int	model_parse (void *obj, const char *json, size_t len, const type_meta *meta)
int	model_from_json (void *obj, struct json_object *json, const type_meta *meta)
int	model_list_from_json (model_list *l, struct json_object *json, const type_meta *meta)
int	model_array_from_json (void ***obj, struct json_object *json, const type_meta *meta)
int	model_parse_array (void ***arp, const char *json, size_t len, const type_meta *meta)
int	model_parse_list (model_list *list, const char *json, size_t len, const type_meta *meta)
char *	model_to_json (const void *obj, const type_meta *meta, int flags, size_t *len)
ssize_t	model_to_json_r (const void *obj, const type_meta *meta, int flags, char *outbuf, size_t max)
const type_meta *	get_model_bool_meta ()
const type_meta *	get_model_number_meta ()
const type_meta *	get_model_string_meta ()
const type_meta *	get_timestamp_meta ()
const type_meta *	get_json_meta ()
const type_meta *	get_duration_meta ()
int	model_map_compare (const model_map *lh, const model_map *rh, const type_meta *m)
const type_meta *	get_tag_meta ()
int	enum_from_json (void *ptr, struct json_object *j, const void *enum_type)
int	json_enum (const void *ptr, void *buf, int indent, int flags, const void *enum_type)
struct json_object *	enum_to_json (const void *ptr, const void *enum_type)

Macro Definition Documentation

array

#define array

(

t

)

t##_array

DECLARE_ENUM

#define DECLARE_ENUM	(		Enum,
			Values
	)

Value:

enum Enum {                        \
Enum##_Unknown = 0,                \
Values(mk_enum, Enum)              \
};                                 \
typedef enum Enum Enum;            \
typedef Enum **Enum##_array;       \
struct Enum##_s {                  \
const char* (*name)(int v);                       \
Enum (*value_of)(const char* n);                  \
Enum (*value_ofn)(const char* s, size_t n);       \
Values(enum_field, Enum)                          \
};                                 \
MODEL_API const type_meta* get_##Enum##_meta();\
extern const struct Enum##_s Enum##s;

DECLARE_MODEL

#define DECLARE_MODEL	(		type,
			model
	)

Value:

typedef struct type##_s {\
model(FIELD_DECL, type) \
} type;\
DECLARE_MODEL_FUNCS(type)

DECLARE_MODEL_FUNCS

#define DECLARE_MODEL_FUNCS

(

T

)

Value:

typedef T ** T##_array; \
MODEL_API const type_meta* get_##T##_meta();\
static inline ptr(T) alloc_##T(){ return (ptr(T))model_alloc(get_##T##_meta()); }\
static inline void free_##T(ptr(T) v) { model_free(v, get_##T##_meta()); }     \
static inline void free_##T##_ptr(ptr(T) v) { model_free(v, get_##T##_meta()); free(v); }; \
static inline int cmp_##T(const ptr(T) lh, const ptr(T) rh) { return model_cmp(lh, rh, get_##T##_meta()); } \
MODEL_API void free_##T##_array(array(T) *ap);\
MODEL_API int parse_##T(ptr(T) v, const char* json, size_t len);\
MODEL_API int parse_##T##_ptr(ptr(T) *p, const char* json, size_t len);\
MODEL_API int parse_##T##_array(array(T) *a, const char* json, size_t len); \
MODEL_API int parse_##T##_list(list(T) *l, const char* json, size_t len); \
static inline ssize_t T##_to_json_r(const ptr(T) v, int flags, char *outbuf, size_t max) { return model_to_json_r(v, get_##T##_meta(), flags, outbuf, max); } \
static inline char* T##_to_json(const ptr(T) v, int flags, size_t *len) { return model_to_json(v, get_##T##_meta(), flags, len); }   \
static inline int T##_from_json(ptr(T) v, struct json_object *j) { return model_from_json(v, j, get_##T##_meta()); } \
static inline int T##_ptr_from_json(ptr(T) *v, struct json_object *j) {      \
    if (j == NULL || json_object_get_type(j) == json_type_null) { *v = NULL; return 0; }  \
    *v = alloc_##T();          \
    int rc = model_from_json(*v, j, get_##T##_meta());                              \
    if (rc != 0) { free_##T##_ptr(*v); *v = NULL;}          \
    return rc;\
} \
static inline int T##_list_from_json(list(T) *l, struct json_object *j) { return model_list_from_json(l, j, get_##T##_meta()); } \
static inline int T##_array_from_json(array(T) *a, struct json_object *j) { return model_array_from_json((void***)a, j, get_##T##_meta()); }

enum_c2

#define enum_c2	(		v,
			t
	)		case t##_##v: return #v

enum_c3

#define enum_c3	(		n,
			v,
			t
	)		case t##_##n: return v

enum_case

#define enum_case

(

...

)

get_ovrd(__VA_ARGS__, enum_c3, enum_c2)(__VA_ARGS__);

enum_f2

#define enum_f2	(		v,
			t
	)		const t v

enum_f3

#define enum_f3	(		v,
			n,
			t
	)		const t v

enum_field

#define enum_field

(

...

)

get_ovrd(__VA_ARGS__, enum_f3, enum_f2)(__VA_ARGS__);

enum_field_v2

#define enum_field_v2	(		v,
			t
	)		.v = t##_##v

enum_field_v3

#define enum_field_v3	(		n,
			v,
			t
	)		.n = t##_##n

enum_field_val

#define enum_field_val

(

...

)

get_ovrd(__VA_ARGS__, enum_field_v3, enum_field_v2)(__VA_ARGS__),

enum_value_of

#define enum_value_of

(

...

)

get_value_of_ovrd(__VA_ARGS__, enum_value_of5, enum_value_of4)(__VA_ARGS__)

enum_value_of4

#define enum_value_of4	(		v,
			t,
			str,
			len
	)		if(strncmp(str,#v,len) == 0){return (t)t##s.v;}

enum_value_of5

#define enum_value_of5	(		n,
			v,
			t,
			str,
			len
	)		if(strncmp(str,v,len) == 0){return (t)t##s.n;}

FIELD_DECL

#define FIELD_DECL	(		name,
			type,
			mod,
			path,
			_
	)		mod(type) name;

gen_field_meta

#define gen_field_meta	(		n,
			memtype,
			modifier,
			p,
			partype
	)

Value:

{\
.name = #n, \
.path = #p, \
.offset = offsetof(partype,n), \
.mod = modifier##_mod, \
.meta = get_##memtype##_meta, \
},

get_ovrd

#define get_ovrd	(		_1,
			_2,
			_3,
			NAME,
			...
	)		NAME

get_value_of_ovrd

#define get_value_of_ovrd	(		_1,
			_2,
			_3,
			_4,
			_5,
			NAME,
			...
	)		NAME

IMPL_ENUM

#define IMPL_ENUM	(		Enum,
			Values
	)

IMPL_MODEL

#define IMPL_MODEL	(		type,
			model
	)

Value:

static field_meta type##_FIELDS[] =  {\
    model(gen_field_meta, type) \
    };                          \
static type_meta type##_META = { \
.name = #type, \
.size = sizeof(type),\
.field_count = sizeof(type##_FIELDS) / sizeof(field_meta),\
.fields = type##_FIELDS,\
};                              \
IMPL_MODEL_FUNCS(type)

IMPL_MODEL_FUNCS

#define IMPL_MODEL_FUNCS

(

T

)

Value:

const type_meta* get_##T##_meta() { return &T##_META; }\
int parse_##T(ptr(T) v, const char* json, size_t len) { return model_parse(v, json, len, get_##T##_meta()); } \
int parse_##T##_ptr(ptr(T) *p, const char* json, size_t len) {\
*p = (ptr(T))calloc(1, sizeof(T)); \
int rc = parse_##T(*p, json, len); \
if (rc < 0) { free_##T(*p); free(*p); *p = NULL; } \
return rc;\
}\
int parse_##T##_array(array(T) *a, const char *json, size_t len) { return model_parse_array((void***)a, json, len, get_##T##_meta()); }\
int parse_##T##_list(list(T) *l, const char *json, size_t len) { return model_parse_list(l, json, len, get_##T##_meta()); }\
void free_##T##_array(array(T) *ap) { model_free_array((void***)ap, get_##T##_meta()); }

list

#define list

(

t

)

model_list

map

#define map

(

t

)

model_map

mk_enum

#define mk_enum

(

...

)

get_ovrd(__VA_ARGS__, mk_enum3, mk_enum2)(__VA_ARGS__),

mk_enum2

#define mk_enum2	(		v,
			t
	)		t##_##v

mk_enum3

#define mk_enum3	(		v,
			n,
			t
	)		t##_##v

MODEL_API

#define MODEL_API

set of macros to help generate struct and function for our model;

• DECLARE_MODEL(type, model_def) : type name of the struct, model_def - marco defining fields for the model

  NOTE: matching IMPL_MODEL macro in model.c is used to generate function implementations

Fields are defined with name, type, type modifier, and path (for JSON mapping) type could be primitives (bool, int, string, timestamp - string in ISO8601 format) or other model types type modifier: none, ptr, array

The following functions are generated:

• int parse_TYPE(TYPE*, json, len) – parses json into an allocated struct, returns 0 if successful, -1 otherwise
• void free_TYPE(TYPE *obj) – frees struct
• int dump_TYPE(TYPE *obj, int indent) – prints the struct to stdout, indent is used for printing nested model objects

MODEL_JSON_COMPACT

#define MODEL_JSON_COMPACT   0x1

MODEL_PARSE_INVALID

#define MODEL_PARSE_INVALID   (-2)

MODEL_PARSE_PARTIAL

#define MODEL_PARSE_PARTIAL   (-3)

none

#define none

(

t

)

t

ptr

#define ptr

(

t

)

t*

Typedef Documentation

_cmp_f

typedef int(* _cmp_f) (const void *lh, const void *rh)

_free_f

typedef void(* _free_f) (void *obj)

_parse_f

typedef int(* _parse_f) (void *obj, const char *json, void *tok)

_to_json_f

typedef int(* _to_json_f) (const void *obj, void *buf, int indent, int flags)

from_json_func

typedef int(* from_json_func) (void *obj, struct json_object *json, const struct type_meta *meta)

json

typedef char* json

model_bool

typedef bool model_bool

model_bool_array

typedef model_bool** model_bool_array

model_number

typedef int64_t model_number

model_number_array

typedef model_number** model_number_array

model_string

typedef const char* model_string

model_string_array

typedef model_string* model_string_array

timestamp

typedef struct timeval timestamp

to_json_func

typedef struct json_object *(* to_json_func) (const void *obj)

Enumeration Type Documentation

_field_mod

enum _field_mod

Enumerator
none_mod
ptr_mod
array_mod
map_mod
list_mod

tag_type

enum tag_type

Enumerator
tag_null
tag_bool
tag_number
tag_string

Function Documentation

enum_from_json()

int enum_from_json	(	void *	ptr,
		struct json_object *	j,
		const void *	enum_type
	)

enum_to_json()

struct json_object * enum_to_json	(	const void *	ptr,
		const void *	enum_type
	)

get_duration_meta()

const type_meta * get_duration_meta ( )

extern

get_json_meta()

const type_meta * get_json_meta ( )

extern

get_model_bool_meta()

const type_meta * get_model_bool_meta ( )

extern

get_model_number_meta()

const type_meta * get_model_number_meta ( )

extern

get_model_string_meta()

const type_meta * get_model_string_meta ( )

extern

get_tag_meta()

const type_meta * get_tag_meta

(

)

get_timestamp_meta()

const type_meta * get_timestamp_meta ( )

extern

json_enum()

int json_enum	(	const void *	ptr,
		void *	buf,
		int	indent,
		int	flags,
		const void *	enum_type
	)

model_alloc()

void * model_alloc

(

const type_meta *

meta

)

model_array_from_json()

int model_array_from_json	(	void ***	obj,
		struct json_object *	json,
		const type_meta *	meta
	)

model_cmp()

int model_cmp	(	const void *	lh,
		const void *	rh,
		const type_meta *	meta
	)

model_free()

void model_free	(	void *	obj,
		const type_meta *	meta
	)

model_free_array()

void model_free_array	(	void ***	ap,
		const type_meta *	meta
	)

model_from_json()

int model_from_json	(	void *	obj,
		struct json_object *	json,
		const type_meta *	meta
	)

model_list_from_json()

int model_list_from_json	(	model_list *	l,
		struct json_object *	json,
		const type_meta *	meta
	)

model_map_compare()

int model_map_compare	(	const model_map *	lh,
		const model_map *	rh,
		const type_meta *	m
	)

model_parse()

int model_parse	(	void *	obj,
		const char *	json,
		size_t	len,
		const type_meta *	meta
	)

model_parse_array()

int model_parse_array	(	void ***	arp,
		const char *	json,
		size_t	len,
		const type_meta *	meta
	)

model_parse_list()

int model_parse_list	(	model_list *	list,
		const char *	json,
		size_t	len,
		const type_meta *	meta
	)

model_to_json()

char * model_to_json	(	const void *	obj,
		const type_meta *	meta,
		int	flags,
		size_t *	len
	)

model_to_json_r()

ssize_t model_to_json_r	(	const void *	obj,
		const type_meta *	meta,
		int	flags,
		char *	outbuf,
		size_t	max
	)