serreader.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <cx/buffer/buffer.h>
#include <cx/container/hashtable.h>
#include <cx/serialize/sertype.h>
 
CX_C_BEGIN
 
 
typedef struct SerReader SerReader;
 
typedef struct SerReaderOps {
    SerNodeKind (*peek)(_Inout_ SerReader* r);
 
    bool (*readNull)(_Inout_ SerReader* r);
    bool (*readBool)(_Inout_ SerReader* r, _Out_ bool* out);
 
    bool (*readInt)(_Inout_ SerReader* r, _Out_ int64* out, stype declared);
    bool (*readUint)(_Inout_ SerReader* r, _Out_ uint64* out, stype declared);   
    bool (*readReal)(_Inout_ SerReader* r, _Out_ float64* out, stype declared);  
    bool (*readStr)(_Inout_ SerReader* r, _Inout_ string* out);
    bool (*readBytes)(_Inout_ SerReader* r, _Inout_ Buffer* out);
 
    bool (*arrBegin)(_Inout_ SerReader* r, _Out_ int32* count);
    bool (*arrNext)(_Inout_ SerReader* r);   
    bool (*arrEnd)(_Inout_ SerReader* r);
    bool (*mapBegin)(_Inout_ SerReader* r, _Out_ int32* count);
    bool (*mapNext)(_Inout_ SerReader* r, _Inout_ string* key);   
    bool (*mapEnd)(_Inout_ SerReader* r);
 
    bool (*readTypeTag)(_Inout_ SerReader* r, _Inout_ string* name);
    bool (*readRef)(_Inout_ SerReader* r, _Out_ uint32* id);
    bool (*skip)(_Inout_ SerReader* r);
 
    void (*destroy)(_Inout_ _Post_invalid_ SerReader* r);   
} SerReaderOps;
 
typedef struct SerReader {
    const SerReaderOps* ops;
    flags_t caps;     
    flags_t flags;    
    SerError err;
    SerTraverseState traverse;
    sa_SerResolverEnt resolvers;
 
    hashtable refs;
    // backend private data follows
} SerReader;
 
_Ret_notnull_ SerReader* _serReaderAlloc(size_t size, _In_ const SerReaderOps* ops, flags_t caps,
                                         flags_t flags);
 
void serReaderDestroy(_Inout_ SerReader** r);
 
void serReaderAddResolver(_Inout_ SerReader* r, SerTypeResolver fn, _Inout_opt_ void* user);
 
bool serReaderResolve(_Out_ SerResolved* out, _Inout_ SerReader* r, _In_opt_ strref name);
 
#define serReaderCaps(r) ((r)->caps)
 
#define serReaderCan(r, capname) (((r)->caps & SER_Cap_##capname) != 0)
 
// Node consumers, mirroring the emitters in serwriter.h.
_meta_inline SerNodeKind serPeek(_Inout_ SerReader* r) { return r->ops->peek(r); }
_meta_inline bool serReadNull(_Inout_ SerReader* r) { return r->ops->readNull(r); }
_meta_inline bool serReadBool(_Inout_ SerReader* r, _Out_ bool* out)
{
    return r->ops->readBool(r, out);
}
_meta_inline bool serReadInt(_Inout_ SerReader* r, _Out_ int64* out, stype declared)
{
    return r->ops->readInt(r, out, declared);
}
_meta_inline bool serReadUint(_Inout_ SerReader* r, _Out_ uint64* out, stype declared)
{
    return r->ops->readUint(r, out, declared);
}
_meta_inline bool serReadReal(_Inout_ SerReader* r, _Out_ float64* out, stype declared)
{
    return r->ops->readReal(r, out, declared);
}
_meta_inline bool serReadStr(_Inout_ SerReader* r, _Inout_ string* out)
{
    return r->ops->readStr(r, out);
}
_meta_inline bool serReadBytes(_Inout_ SerReader* r, _Inout_ Buffer* out)
{
    return r->ops->readBytes(r, out);
}
_meta_inline bool serArrBeginR(_Inout_ SerReader* r, _Out_ int32* count)
{
    return r->ops->arrBegin(r, count);
}
_meta_inline bool serArrNext(_Inout_ SerReader* r) { return r->ops->arrNext(r); }
_meta_inline bool serArrEndR(_Inout_ SerReader* r) { return r->ops->arrEnd(r); }
_meta_inline bool serMapBeginR(_Inout_ SerReader* r, _Out_ int32* count)
{
    return r->ops->mapBegin(r, count);
}
_meta_inline bool serMapNext(_Inout_ SerReader* r, _Inout_ string* key)
{
    return r->ops->mapNext(r, key);
}
_meta_inline bool serMapEndR(_Inout_ SerReader* r) { return r->ops->mapEnd(r); }
_meta_inline bool serSkip(_Inout_ SerReader* r) { return r->ops->skip(r); }
 
// Prefer the serRead() macro. This takes the schema as a descriptor rather than a type name,
// for the cases the macro cannot spell: a generated member descriptor (`memberdesc->schema`), a
// hand-built container descriptor, or a slot whose schema and value type come from different
// names -- a `structp` in a `structset` slot, for instance. The schema is never NULL; a dynamic
// slot uses a leaf descriptor such as `stExt(stvar)`. The type to produce is `schema->type`.
bool _serRead(_Inout_ SerReader* r, _In_ const STypeInfoExt* schema, _Inout_ stgeneric* val);
 
#define serRead(r, type, pval) _serRead(r, stExt(type), stArgPtr(type, pval))
 
bool serReaderFail(_Inout_ SerReader* r, int32 code, _In_opt_ strref msg);
 
 
CX_C_END