sertype.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <cx/container/sarray.h>
#include <cx/string.h>
#include <cx/struct/struct.h>
#include <cx/stype/stype.h>
 
CX_C_BEGIN
 
 
typedef struct ObjClassInfo ObjClassInfo;
 
typedef enum SerNodeKindEnum {
    SER_Invalid = 0,   
    SER_EOF,           
 
    SER_Null,          
    SER_Bool,          
    SER_Int,           
    SER_Uint,          
    SER_Real,          
    SER_Str,           
    SER_Bytes,         
 
    SER_ArrayBegin,    
    SER_ArrayEnd,
    SER_MapBegin,      
    SER_MapKey,        
    SER_MapEnd,
 
    SER_TypeTag,   
    SER_RefDef,    
    SER_RefUse,    
} SerNodeKind;
 
typedef struct SerResolved {
    stype type;                     
    const StructInfo* structinfo;   
    ObjClassInfo* clsinfo;          
} SerResolved;
 
typedef bool (*SerTypeResolver)(_Out_ SerResolved* out, _In_opt_ strref name,
                                _Inout_opt_ void* user);
 
typedef struct SerResolverEnt {
    SerTypeResolver fn;
    void* user;
} SerResolverEnt;
saDeclare(SerResolverEnt);
 
// The wire-name table for cx's own structural types, defined in sertype.c. It names types on
// the way out and resolves them on the way back in, so the two directions cannot disagree.
// Reached through serReaderResolve(), which consults it after the reader's own resolvers.
_Ret_maybenull_ strref _serBuiltinName(uint32 stypeid);
bool _serResolveBuiltin(_Out_ SerResolved* out, _In_opt_ strref name);
 
bool serStructSetResolver(_Out_ SerResolved* out, _In_opt_ strref name, _Inout_opt_ void* user);
 
bool serClassSetResolver(_Out_ SerResolved* out, _In_opt_ strref name, _Inout_opt_ void* user);
 
bool serObjClassResolver(_Out_ SerResolved* out, _In_opt_ strref name, _Inout_opt_ void* user);
 
 
 
enum SerCapabilitiesEnum {
    SER_Cap_NonStringKeys = (1 << 0),   
    SER_Cap_Bytes         = (1 << 1),   
    SER_Cap_TypeTags      = (1 << 2),   
    SER_Cap_Refs          = (1 << 3),   
    SER_Cap_ExactInt      = (1 << 4),   
    SER_Cap_Skip          = (1 << 5),   
    SER_Cap_Sizes         = (1 << 6),   
};
 
enum SerFlagsEnum {
    // JSON
    SER_JSON_Pretty  = 0x00000001,   
    SER_JSON_Compact = 0x00000002,   
 
    // binary
    SER_Bin_Compact       = 0x00000100,   
    SER_Bin_NoStringDedup = 0x00000200,   
 
    // general
    SER_EmitDefaults = 0x01000000,   
    SER_Refs         = 0x02000000,   
    SER_Strict       = 0x10000000,   
 
    SER_Collect = 0x20000000,
};
 
enum SerErrorCodeEnum {
    SER_Err_None = 0,
    SER_Err_Backend,       
    SER_Err_Type,          
    SER_Err_Schema,        
    SER_Err_Data,          
    SER_Err_Unsupported,   
    SER_Err_Overflow,      
};
 
typedef struct SerError {
    int32 code;    
    string msg;    
    string path;   
} SerError;
saDeclare(SerError);
 
void serErrorDestroy(_Inout_ SerError* err);
 
typedef struct SerPathFrame {
    strref name;   
    int32 idx;     
} SerPathFrame;
saDeclare(SerPathFrame);
 
typedef struct SerTraverseState {
    sa_SerPathFrame path;    
    sa_SerError collected;   
} SerTraverseState;
 
void _serTraverseStateDestroy(_Inout_ SerTraverseState* ws);
 
void serPathString(_Inout_ string* out, _In_ const SerTraverseState* ws);
 
 
CX_C_END