serwriter.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <cx/container/hashtable.h>
#include <cx/serialize/sertype.h>
 
CX_C_BEGIN
 
 
typedef struct SerWriter SerWriter;
 
typedef struct SerWriterOps {
    bool (*writeNull)(_Inout_ SerWriter* w);
    bool (*writeBool)(_Inout_ SerWriter* w, bool v);
    bool (*writeInt)(_Inout_ SerWriter* w, int64 v, stype declared);
    bool (*writeUint)(_Inout_ SerWriter* w, uint64 v, stype declared);
    bool (*writeReal)(_Inout_ SerWriter* w, float64 v, stype declared);
    bool (*writeStr)(_Inout_ SerWriter* w, _In_opt_ strref v);
    bool (*writeBytes)(_Inout_ SerWriter* w, _In_reads_bytes_(n) const void* p, size_t n);
 
    bool (*arrBegin)(_Inout_ SerWriter* w, int32 count);
    bool (*arrEnd)(_Inout_ SerWriter* w);
    bool (*mapBegin)(_Inout_ SerWriter* w, int32 count);
    bool (*mapKey)(_Inout_ SerWriter* w, _In_opt_ strref key);
    bool (*mapKeyTyped)(_Inout_ SerWriter* w, _In_ const STypeInfoExt* kt, stgeneric key);
    bool (*mapEnd)(_Inout_ SerWriter* w);
 
    bool (*typeTag)(_Inout_ SerWriter* w, _In_ const STypeInfoExt* st);
 
    bool (*refDef)(_Inout_ SerWriter* w, uint32 id);
    bool (*refUse)(_Inout_ SerWriter* w, uint32 id);
 
    bool (*finish)(_Inout_ SerWriter* w);   
    void (*destroy)(_Inout_ _Post_invalid_ SerWriter* w);   
} SerWriterOps;
 
typedef struct SerWriter {
    const SerWriterOps* ops;
    flags_t caps;        
    flags_t flags;       
    bool finished;        // serWriterFinish has run
    SerError err;
    SerTraverseState traverse;   // path stack and error list; managed internally
 
    sa_ptr inprogress;    // objects currently being written; cycle guard, unused with SER_Refs
 
    hashtable refids;     // object -> assigned reference id, once SER_Refs is in use
    uint32 nextrefid;     // next reference id to hand out
    // backend private data follows
} SerWriter;
 
_Ret_notnull_ SerWriter* _serWriterAlloc(size_t size, _In_ const SerWriterOps* ops, flags_t caps,
                                         flags_t flags);
 
bool serWriterFinish(_Inout_ SerWriter* w);
 
void serWriterDestroy(_Inout_ SerWriter** w);
 
#define serWriterCaps(w) ((w)->caps)
 
#define serWriterCan(w, capname) (((w)->caps & SER_Cap_##capname) != 0)
 
// Thin wrappers around the vtable, used by the traverser and by custom serialize hooks.
_meta_inline bool serWriteNull(_Inout_ SerWriter* w) { return w->ops->writeNull(w); }
_meta_inline bool serWriteBool(_Inout_ SerWriter* w, bool v) { return w->ops->writeBool(w, v); }
_meta_inline bool serWriteInt(_Inout_ SerWriter* w, int64 v, stype declared)
{
    return w->ops->writeInt(w, v, declared);
}
_meta_inline bool serWriteUint(_Inout_ SerWriter* w, uint64 v, stype declared)
{
    return w->ops->writeUint(w, v, declared);
}
_meta_inline bool serWriteReal(_Inout_ SerWriter* w, float64 v, stype declared)
{
    return w->ops->writeReal(w, v, declared);
}
_meta_inline bool serWriteStr(_Inout_ SerWriter* w, _In_opt_ strref v)
{
    return w->ops->writeStr(w, v);
}
_meta_inline bool serWriteBytes(_Inout_ SerWriter* w, _In_reads_bytes_(n) const void* p, size_t n)
{
    return w->ops->writeBytes(w, p, n);
}
_meta_inline bool serArrBegin(_Inout_ SerWriter* w, int32 count)
{
    return w->ops->arrBegin(w, count);
}
_meta_inline bool serArrEnd(_Inout_ SerWriter* w) { return w->ops->arrEnd(w); }
_meta_inline bool serMapBegin(_Inout_ SerWriter* w, int32 count)
{
    return w->ops->mapBegin(w, count);
}
_meta_inline bool serMapKey(_Inout_ SerWriter* w, _In_opt_ strref key)
{
    return w->ops->mapKey(w, key);
}
_meta_inline bool serMapEnd(_Inout_ SerWriter* w) { return w->ops->mapEnd(w); }
 
// Prefer the serWrite() 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 value's runtime type is `schema->type`.
bool _serWrite(_Inout_ SerWriter* w, _In_ const STypeInfoExt* schema, stgeneric val);
 
#define serWrite(w, type, val) _serWrite(w, stExt(type), stArg(type, val))
 
bool serWriterFail(_Inout_ SerWriter* w, int32 code, _In_opt_ strref msg);
 
 
CX_C_END