Code is written so that it supports buffered and streamed mode.
You just have to define structure and model for that structure. You can have any number of models for one structure.
Serializatiion reads directly from structure members. Deserialization writes directly to structure members.
It is possible to serialize/deserialize directly from and to buffer without callbacks.
Deserializer also supports simple validation.
Buffer must only be big enough to hold left or righ side of parameter plus some bytes for '": ' characters in JSON "left":"right"
Size of simple structure members such as 'int' 'float' 'double' is detected automaticaly.
Each member also supports simple validation.
Size of member is detected automaticaly. For example, there is no need to specify if unsigned is 8bit 16bit or 32bit.
SER_TYPE_UNSIGNED
SER_TYPE_SIGNED
SER_TYPE_FLOAT
SER_TYPE_STRING
SER_TYPE_BOOL
SER_TYPE_PASSWORD
SER_TYPE_TIME
SER_TYPE_DATE
SER_TYPE_DATETIME
SER_TYPE_TIMESPAN
SER_TYPE_EUI_48
SER_TYPE_EUI_64
SER_TYPE_HEX
SER_TYPE_RHEX reversed hex representation bytes are swaped
SER_TYPE_UNSIGNED_ARRAY
SER_TYPE_SIGNED_ARRAY
SER_TYPE_FLOAT_ARRAY
SER_TYPE_BOOL_ARRAY
SER_TYPE_HEX_ARRAY
SER_TYPE_RHEX_ARRAY
SER_TYPE_OBJECT
SER_TYPE_OBJECT_PTR serialization only
SER_TYPE_OBJECT_ARRRY
SER_TYPE_OBJECT_PTR_ARRAY serialization only
SER_TYPE_STRING_PTR
SER_TYPE_TOTAL_COUNT
Serializer works with user preconfigured SerializationInfo_t array of SerializationItem where member mapping is specified.
Struct members are mapped with following macros helpers _D is direction specification _DN is direction and custom json parameter name specification
SERIALIZATION_START(NAME, NAMESPACE, STRUCTTYPE)
SERIALIZATION_END()
GENERATE_SER_OBJECT_ARRAY(NAME, CLASSTYPE, SERINFO)
GENERATE_SER_OBJECT_PTR_ARRAY(NAME, CLASSTYPE, SERINFO)
GENERATE_SER_OBJECT(NAME, CLASSTYPE, SERINFO)
GENERATE_SER_OBJECT_PTR(NAME, CLASSTYPE, SERINFO)
GENERATE_SERIALIZABLE_STRING(NAME, CLASSTYPE)
GENERATE_SERIALIZABLE_STRING_D(NAME, CLASSTYPE,DIR)
GENERATE_SERIALIZABLE(NAME, TYPE, CLASSTYPE)
GENERATE_SERIALIZABLE_D(NAME, TYPE, CLASSTYPE,DIR)
GENERATE_SERIALIZABLE_DN(NAME, ALTNAME, TYPE, CLASSTYPE,DIR)
GENERATE_SERIALIZABLE_N(NAME, ALTNAME, TYPE, CLASSTYPE)
GENERATE_VALIDATE_SERIALIZABLE(NAME, TYPE, CLASSTYPE,VALIDATOR)
GENERATE_SERIALIZABLE_ARRAY(NAME, TYPE, CLASSTYPE)
GENERATE_SERIALIZABLE_ARRAY_D(NAME, TYPE, CLASSTYPE, DIR)
typedef struct{
float Float;
timespan_t Interval;
int Number;
}struct_t;
const SerializationInfo_t MODEL1_SERIALIZATION_INFO = {
SERIALIZATION_START("MODEL1","M", struct_t),
GENERATE_SERIALIZABLE(Float, SER_TYPE_FLOAT, struct_t)
GENERATE_SERIALIZABLE(Interval, SER_TYPE_TIMESPAN, struct_t)
GENERATE_SERIALIZABLE_D(Number, SER_TYPE_SIGNED, struct_t,SER_DIR_R)
SERIALIZATION_END()
};
const SerializationInfo_t MODEL2_SERIALIZATION_INFO = {
SERIALIZATION_START("MODEL2","M", struct_t),
GENERATE_SERIALIZABLE(Float, SER_TYPE_FLOAT, struct_t)
SERIALIZATION_END()
};
struct_t resobj;
void *arg;
uint8_t buff[255];
JsonConvertHandle hnd;
//parameter of 4 is data lenght filled in buffer for buffer preload in streaming(callback configured) or buffered operation
JsonInitHandle(&hnd, buff, 255, 0, 0);
JsonHandleRegisterCallback(&hnd, DeserializeCallback, arg)
JsonResType res = JsonDeserialize(hnd, &resobj, MODEL1_SERIALIZATION_INFO);
int DeserializeCallback(void*arg, char *buf,int len, int *bread){
//read any input
//arg is your optional state
}
JsonInitHandle(&hnd, buff, 255, 0, 0);
JsonHandleRegisterCallback(&hnd, SerializeCallback, arg)
JsonSerialize(obj, MODEL2_SERIALIZATION_INFO, &hnd);
int SerializeCallback(void*arg, char *buf,int len, int *bread){ //bread not used
//write to any output
//arg is your optional state
}
This software is distributed under MIT license, so feel free to integrate it in your commercial products.