reflect.h

Go to the documentation of this file.

 
#ifndef CSILK_REFLECT_H
#define CSILK_REFLECT_H
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "cJSON.h"
 
typedef enum {
    CSILK_TYPE_INT8,   
    CSILK_TYPE_UINT8,  
    CSILK_TYPE_INT16,  
    CSILK_TYPE_UINT16, 
    CSILK_TYPE_INT32,  
    CSILK_TYPE_UINT32, 
    CSILK_TYPE_INT64,  
    CSILK_TYPE_UINT64, 
    CSILK_TYPE_FLOAT,  
    CSILK_TYPE_DOUBLE, 
    CSILK_TYPE_BOOL,   
    CSILK_TYPE_STRING, 
    CSILK_TYPE_STRUCT  
} csilk_field_type_t;
 
typedef struct csilk_field_desc_s csilk_field_desc_t;
 
struct csilk_field_desc_s {
    const char* json_key;         
    csilk_field_type_t type;      
    size_t offset;            
    size_t size;              
    size_t array_length;          
    bool is_pointer;          
    const char* nested_type_name; 
};
 
typedef struct {
    const char* name;         
    const csilk_field_desc_t* fields; 
    size_t count; 
} csilk_reflect_entry_t;
 
void csilk_reflect_init(void);
 
void csilk_reflect_register(const char* name, const csilk_field_desc_t* fields, size_t count);
 
const csilk_reflect_entry_t* csilk_reflect_find(const char* name);
 
typedef void (*csilk_reflect_foreach_cb)(const char* name,
                     const csilk_reflect_entry_t* entry,
                     void* user_data);
 
void csilk_reflect_foreach(csilk_reflect_foreach_cb cb, void* user_data);
 
char* csilk_json_marshal(const char* type_name, const void* ptr);
 
int csilk_json_unmarshal(const char* type_name, const char* json_str, void* ptr);
 
/* --- Automatic Type Dispatch (C11 _Generic) --- */
 
#ifndef CSILK_USER_TYPE_MAP
#define CSILK_USER_TYPE_MAP
#endif
 
#define csilk_type_name(x)                                                                         \
    _Generic((x),                                                                              \
        _Bool: "bool",                                                                         \
        signed char: "int8",                                                                   \
        unsigned char: "uint8",                                                                \
        short: "int16",                                                                        \
        unsigned short: "uint16",                                                              \
        int: "int32",                                                                          \
        unsigned int: "uint32",                                                                \
        long: "int64",                                                                         \
        unsigned long: "uint64",                                                               \
        long long: "int64",                                                                    \
        unsigned long long: "uint64",                                                          \
        float: "float",                                                                        \
        double: "double",                                                                      \
        char*: "string",                                                                       \
        const char*: "string" CSILK_USER_TYPE_MAP,                                             \
        default: "unknown")
 
#define csilk_marshal(ptr) csilk_json_marshal(csilk_type_name(*(ptr)), ptr)
 
#define csilk_unmarshal(json, ptr) csilk_json_unmarshal(csilk_type_name(*(ptr)), json, ptr)
 
/* --- Macro Magic for Automatic Registration --- */
 
#define CSILK_META_EXPAND(struct_type, field, type_enum, size, arr_len, is_ptr, nested_name)       \
    {#field, type_enum, offsetof(struct_type, field), size, arr_len, is_ptr, nested_name},
 
#define CSILK_REGISTER_REFLECT(struct_type, map_macro)                                             \
    static csilk_field_desc_t struct_type##_meta[] = {                                         \
        map_macro(CSILK_META_EXPAND){NULL, 0, 0, 0, 0, false, NULL}};                          \
    static void __attribute__((constructor)) auto_reg_##struct_type(void)                      \
    {                                                                                          \
        size_t count = (sizeof(struct_type##_meta) / sizeof(csilk_field_desc_t)) - 1;      \
        csilk_reflect_register(#struct_type, struct_type##_meta, count);                   \
    }
 
#endif