@ -1,4 +1,6 @@
# ifdef ULE_CONFIG_OPTION_SERIALIZATION
# include <fast_float/fast_float.h>
# include "types.h"
@ -7,52 +9,52 @@
# include "print.h"
static inline const char * getFormatStringOut ( u8 v ) { TYPES_H_FTAG ; return " %hu \n " ; }
static inline const char * getFormatStringOut ( u16 v ) { TYPES_H_FTAG ; return " %hu \n " ; }
static inline const char * getFormatStringOut ( u32 v ) { TYPES_H_FTAG ; return " %u \n " ; }
static inline const char * getFormatStringOut ( u64 v ) { TYPES_H_FTAG ; return " %llu \n " ; }
static inline const char * getFormatStringOut ( u8 v ) { ULE_ TYPES_H_FTAG; return " %hu \n " ; }
static inline const char * getFormatStringOut ( u16 v ) { ULE_ TYPES_H_FTAG; return " %hu \n " ; }
static inline const char * getFormatStringOut ( u32 v ) { ULE_ TYPES_H_FTAG; return " %u \n " ; }
static inline const char * getFormatStringOut ( u64 v ) { ULE_ TYPES_H_FTAG; return " %llu \n " ; }
static inline const char * getFormatStringOut ( s8 v ) { TYPES_H_FTAG ; return " %hd \n " ; }
static inline const char * getFormatStringOut ( s16 v ) { TYPES_H_FTAG ; return " %hd \n " ; }
static inline const char * getFormatStringOut ( s32 v ) { TYPES_H_FTAG ; return " %d \n " ; }
static inline const char * getFormatStringOut ( s64 v ) { TYPES_H_FTAG ; return " %lld \n " ; }
static inline const char * getFormatStringOut ( s8 v ) { ULE_ TYPES_H_FTAG; return " %hd \n " ; }
static inline const char * getFormatStringOut ( s16 v ) { ULE_ TYPES_H_FTAG; return " %hd \n " ; }
static inline const char * getFormatStringOut ( s32 v ) { ULE_ TYPES_H_FTAG; return " %d \n " ; }
static inline const char * getFormatStringOut ( s64 v ) { ULE_ TYPES_H_FTAG; return " %lld \n " ; }
static inline const char * getFormatStringOut ( float v ) { TYPES_H_FTAG ; return " %f \n " ; }
static inline const char * getFormatStringOut ( double v ) { TYPES_H_FTAG ; return " %f \n " ; }
static inline const char * getFormatStringOut ( float v ) { ULE_ TYPES_H_FTAG; return " %f \n " ; }
static inline const char * getFormatStringOut ( double v ) { ULE_ TYPES_H_FTAG; return " %f \n " ; }
// important constraint - strings need to be wrapped in double-quotes.
// the sentinel value 'null' without quotations is used to denote null values, which means
// if strings were not wrapped in double quotes, you would not be able to distinguish null
// values from the literal string "null".
static inline const char * getFormatStringOut ( char * v ) { TYPES_H_FTAG ; return " \" %s \" \n " ; }
static inline const char * getFormatStringOut ( const char * v ) { TYPES_H_FTAG ; return " \" %s \" \n " ; }
static inline const char * getFormatStringOut ( char * v ) { ULE_ TYPES_H_FTAG; return " \" %s \" \n " ; }
static inline const char * getFormatStringOut ( const char * v ) { ULE_ TYPES_H_FTAG; return " \" %s \" \n " ; }
# ifdef _USING_GLM_TYPES__
static inline const char * getFormatStringOut ( glm : : vec < 2 , float , ( glm : : qualifier ) 3 > v ) { TYPES_H_FTAG ; return " %f %f \n " ; }
static inline const char * getFormatStringOut ( glm : : vec < 3 , float , ( glm : : qualifier ) 3 > v ) { TYPES_H_FTAG ; return " %f %f %f \n " ; }
static inline const char * getFormatStringOut ( glm : : vec < 4 , float , ( glm : : qualifier ) 3 > v ) { TYPES_H_FTAG ; return " %f %f %f %f \n " ; }
static inline const char * getFormatStringOut ( glm : : vec < 2 , float , ( glm : : qualifier ) 3 > v ) { ULE_ TYPES_H_FTAG; return " %f %f \n " ; }
static inline const char * getFormatStringOut ( glm : : vec < 3 , float , ( glm : : qualifier ) 3 > v ) { ULE_ TYPES_H_FTAG; return " %f %f %f \n " ; }
static inline const char * getFormatStringOut ( glm : : vec < 4 , float , ( glm : : qualifier ) 3 > v ) { ULE_ TYPES_H_FTAG; return " %f %f %f %f \n " ; }
static inline const char * getFormatStringOut ( glm : : mat < 2 , 2 , float , ( glm : : qualifier ) 3 > v ) { TYPES_H_FTAG ; return " %f %f %f %f \n " ; }
static inline const char * getFormatStringOut ( glm : : mat < 3 , 3 , float , ( glm : : qualifier ) 3 > v ) { TYPES_H_FTAG ; return " %f %f %f %f %f %f %f %f %f \n " ; }
static inline const char * getFormatStringOut ( glm : : mat < 4 , 4 , float , ( glm : : qualifier ) 3 > v ) { TYPES_H_FTAG ; return " %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f \n " ; }
static inline const char * getFormatStringOut ( glm : : mat < 2 , 2 , float , ( glm : : qualifier ) 3 > v ) { ULE_ TYPES_H_FTAG; return " %f %f %f %f \n " ; }
static inline const char * getFormatStringOut ( glm : : mat < 3 , 3 , float , ( glm : : qualifier ) 3 > v ) { ULE_ TYPES_H_FTAG; return " %f %f %f %f %f %f %f %f %f \n " ; }
static inline const char * getFormatStringOut ( glm : : mat < 4 , 4 , float , ( glm : : qualifier ) 3 > v ) { ULE_ TYPES_H_FTAG; return " %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f \n " ; }
# endif
# define SERIALIZE_H_FUNC_BODY str->appendf(getFormatStringOut(v), v);
void serialize ( String * str , u8 v ) { TYPES_H_FTAG ; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , u16 v ) { TYPES_H_FTAG ; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , u32 v ) { TYPES_H_FTAG ; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , u64 v ) { TYPES_H_FTAG ; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , s8 v ) { TYPES_H_FTAG ; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , s16 v ) { TYPES_H_FTAG ; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , s32 v ) { TYPES_H_FTAG ; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , s64 v ) { TYPES_H_FTAG ; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , float v ) { TYPES_H_FTAG ; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , double v ) { TYPES_H_FTAG ; SERIALIZE_H_FUNC_BODY }
template < typename T > // do I really need a template for this?
void serialize ( String * str , u8 v ) { ULE_ TYPES_H_FTAG; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , u16 v ) { ULE_ TYPES_H_FTAG; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , u32 v ) { ULE_ TYPES_H_FTAG; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , u64 v ) { ULE_ TYPES_H_FTAG; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , s8 v ) { ULE_ TYPES_H_FTAG; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , s16 v ) { ULE_ TYPES_H_FTAG; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , s32 v ) { ULE_ TYPES_H_FTAG; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , s64 v ) { ULE_ TYPES_H_FTAG; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , float v ) { ULE_ TYPES_H_FTAG; SERIALIZE_H_FUNC_BODY }
void serialize ( String * str , double v ) { ULE_ TYPES_H_FTAG; SERIALIZE_H_FUNC_BODY }
extern template < typename T > // @TODO do not use a template for this.
static inline void deserializeInteger ( char * * buffer , T * v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
char * _buffer = * buffer ;
T value = 0 ;
@ -107,7 +109,7 @@ static const u32 BINARY32_MAX_CHARS = 14;
static const u32 BINARY64_MAX_CHARS = 24 ;
void deserialize ( char * * buffer , float * v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
char * _buffer = * buffer ;
while ( String : : isAsciiWhitespace ( * _buffer ) ) _buffer + + ;
fast_float : : from_chars_result result = fast_float : : from_chars ( _buffer , _buffer + BINARY32_MAX_CHARS , * v ) ;
@ -115,7 +117,7 @@ void deserialize(char** buffer, float* v) {
* buffer = ( char * ) result . ptr ;
}
void deserialize ( char * * buffer , double * v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
char * _buffer = * buffer ;
while ( String : : isAsciiWhitespace ( * _buffer ) ) _buffer + + ;
fast_float : : from_chars_result result = fast_float : : from_chars ( _buffer , _buffer + BINARY64_MAX_CHARS , * v ) ;
@ -125,19 +127,19 @@ void deserialize(char** buffer, double* v) {
# ifndef _WIN32
// win32 doesn't treat size_t as different than a u64, which causes ambiguous function calls
static inline const char * getFormatStringOut ( size_t v ) { TYPES_H_FTAG ; return " %lu \n " ; }
static inline const char * getFormatStringOut ( size_t v ) { ULE_ TYPES_H_FTAG; return " %lu \n " ; }
void serialize ( String * str , size_t v ) { SERIALIZE_H_FUNC_BODY }
void deserialize ( char * * buffer , size_t * v ) { SERIALIZE_H_DESERIALIZE_FUNC_BODY }
# endif
// STRING STUFF
void serialize ( String * str , char * v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
SERIALIZE_HANDLE_NULL ( str , v ) ;
SERIALIZE_H_FUNC_BODY ;
}
void serialize ( String * str , const char * v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
SERIALIZE_HANDLE_NULL ( str , v ) ;
SERIALIZE_H_FUNC_BODY ;
}
@ -160,7 +162,7 @@ void serialize(String* str, const char* v) {
static char SERIALIZE_SCRATCH_BUFFER [ SERIALIZE_SCRATCH_BUFFER_SIZE ] ;
static s32 deserializeString ( char * * buffer , char * v , s32 vSize ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
char * _buffer = * buffer ;
while ( String : : isAsciiWhitespace ( * _buffer ) ) _buffer + + ;
@ -181,7 +183,7 @@ static s32 deserializeString(char** buffer, char* v, s32 vSize) {
return i ;
}
static s32 deserializeString ( char * * buffer , char * v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
char * _buffer = * buffer ;
while ( String : : isAsciiWhitespace ( * _buffer ) ) _buffer + + ;
massert ( _buffer [ 0 ] = = ' " ' , " expecting to deserialize a string, but found something other than a double quote " ) ;
@ -199,15 +201,15 @@ static s32 deserializeString(char** buffer, char* v) {
return i ;
}
void deserialize ( char * * buffer , char * v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
deserializeString ( buffer , v ) ;
}
void deserialize ( char * * buffer , const char * v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
deserializeString ( buffer , ( char * ) v ) ;
}
void deserialize ( char * * buffer , char * * v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
DESERIALIZE_HANDLE_NULL ( buffer , v ) ;
@ -216,7 +218,7 @@ void deserialize(char** buffer, char** v) {
* v = String : : cpy ( SERIALIZE_SCRATCH_BUFFER , ( u32 ) i ) ;
}
void deserialize ( char * * buffer , const char * * v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
DESERIALIZE_HANDLE_NULL ( buffer , ( char * ) v ) ; // error: readonly variable is not assignable
@ -231,33 +233,33 @@ void deserialize(char** buffer, const char** v) {
// have that template parameter == 3, so everything below becomes unresolved symbols if
// I don't do the nasty template garbage here
void serialize ( String * str , glm : : vec < 2 , float , ( glm : : qualifier ) ( glm : : qualifier ) 3 > v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
str - > appendf ( getFormatStringOut ( v ) , v [ 0 ] , v [ 1 ] ) ;
}
void serialize ( String * str , glm : : vec < 3 , float , ( glm : : qualifier ) ( glm : : qualifier ) 3 > v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
str - > appendf ( getFormatStringOut ( v ) , v [ 0 ] , v [ 1 ] , v [ 2 ] ) ;
}
void serialize ( String * str , glm : : vec < 4 , float , ( glm : : qualifier ) 3 > v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
str - > appendf ( getFormatStringOut ( v ) , v [ 0 ] , v [ 1 ] , v [ 2 ] , v [ 3 ] ) ;
}
void serialize ( String * str , glm : : mat < 2 , 2 , float , ( glm : : qualifier ) 3 > v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
str - > appendf ( getFormatStringOut ( v )
, v [ 0 ] [ 0 ] , v [ 0 ] [ 1 ]
, v [ 1 ] [ 0 ] , v [ 1 ] [ 1 ] ) ;
}
void serialize ( String * str , glm : : mat < 3 , 3 , float , ( glm : : qualifier ) 3 > v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
str - > appendf ( getFormatStringOut ( v )
, v [ 0 ] [ 0 ] , v [ 0 ] [ 1 ] , v [ 0 ] [ 2 ]
, v [ 1 ] [ 0 ] , v [ 1 ] [ 1 ] , v [ 1 ] [ 2 ]
, v [ 2 ] [ 0 ] , v [ 2 ] [ 1 ] , v [ 2 ] [ 2 ] ) ;
}
void serialize ( String * str , glm : : mat < 4 , 4 , float , ( glm : : qualifier ) 3 > v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
str - > appendf ( getFormatStringOut ( v )
, v [ 0 ] [ 0 ] , v [ 0 ] [ 1 ] , v [ 0 ] [ 2 ] , v [ 0 ] [ 3 ]
, v [ 1 ] [ 0 ] , v [ 1 ] [ 1 ] , v [ 1 ] [ 2 ] , v [ 1 ] [ 3 ]
@ -266,21 +268,21 @@ void serialize(String* str, glm::mat<4, 4, float, (glm::qualifier) 3> v) {
}
void deserialize ( char * * buffer , glm : : vec < 2 , float , ( glm : : qualifier ) 3 > * v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
float * _v = ( float * ) v ;
for ( u32 i = 0 ; i < 2 ; i + + ) {
deserialize ( buffer , _v + i ) ;
}
}
void deserialize ( char * * buffer , glm : : vec < 3 , float , ( glm : : qualifier ) 3 > * v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
float * _v = ( float * ) v ;
for ( u32 i = 0 ; i < 3 ; i + + ) {
deserialize ( buffer , _v + i ) ;
}
}
void deserialize ( char * * buffer , glm : : vec < 4 , float , ( glm : : qualifier ) 3 > * v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
float * _v = ( float * ) v ;
for ( u32 i = 0 ; i < 4 ; i + + ) {
deserialize ( buffer , _v + i ) ;
@ -288,21 +290,21 @@ void deserialize(char** buffer, glm::vec<4, float, (glm::qualifier) 3>* v) {
}
void deserialize ( char * * buffer , glm : : mat < 2 , 2 , float , ( glm : : qualifier ) 3 > * v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
float * m = ( float * ) v ;
for ( u32 i = 0 ; i < 4 ; i + + ) {
deserialize ( buffer , m + i ) ;
}
}
void deserialize ( char * * buffer , glm : : mat < 3 , 3 , float , ( glm : : qualifier ) 3 > * v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
float * m = ( float * ) v ;
for ( u32 i = 0 ; i < 9 ; i + + ) {
deserialize ( buffer , m + i ) ;
}
}
void deserialize ( char * * buffer , glm : : mat < 4 , 4 , float , ( glm : : qualifier ) 3 > * v ) {
TYPES_H_FTAG ;
ULE_ TYPES_H_FTAG;
float * m = ( float * ) v ;
for ( u32 i = 0 ; i < 16 ; i + + ) {
deserialize ( buffer , m + i ) ;
@ -313,4 +315,5 @@ void deserialize(char** buffer, glm::mat<4, 4, float, (glm::qualifier) 3>* v) {
# undef SERIALIZE_H_DESERIALIZE_FUNC_BODY
# endif
# endif