stvar.h

Go to the documentation of this file.

#pragma once
 
 
#include <cx/cx.h>
#include <cx/stype/stype.h>
 
CX_C_BEGIN
 
 
 
#ifndef __cplusplus
#define stvarInit(typen, val) { .data = { .st_##typen = val }, ._type = stType(typen) }
 
#define stvar(typen, val) ((stvar) { .data = stArg(typen, val), ._type = stType(typen) })
 
#define stvNone ((stvar) { ._type = stType(none) })
 
#define stvark(key, typen, val) \
    ((stvar) { .data = stArg(typen, val), ._type = stType(typen), ._key = #key })
 
#define stvarkn(name, typen, val) \
    ((stvar) { .data = stArg(typen, val), ._type = stType(typen), ._key = (name) })
#else
_meta_inline stvar _stvar(stype st, stgeneric val)
{
    stvar ret;
    ret.data  = val;
    ret._type = st;
    ret._key  = NULL;
    return ret;
}
#define stvar(typen, val)         _stvar(stType(typen), stArg(typen, val))
 
_meta_inline stvar _stvark(const char* nm, stype st, stgeneric val)
{
    stvar ret = _stvar(st, val);
    ret._key  = nm;
    return ret;
}
#define stvark(key, typen, val)   _stvark(#key, stType(typen), stArg(typen, val))
#define stvarkn(name, typen, val) _stvark((name), stType(typen), stArg(typen, val))
 
#define stvNone _stvar(stType(none), _cxStGenZero())
#endif
 
 
 
typedef struct stvp {
    stype type;        
    stgeneric* ptr;    
    const char* key;   
} stvp;
 
#ifndef __cplusplus
#define stvp(typen, pval) ((stvp) { stCheckedPtrArg(typen, pval), NULL })
 
#define stvpk(key, typen, pval) ((stvp) { stCheckedPtrArg(typen, pval), #key })
 
#define stvpNone ((stvp) { NULL, NULL, NULL })
#else
_meta_inline stvp _stvp(const char* nm, stype st, stgeneric* p)
{
    stvp ret;
    ret.type = st;
    ret.ptr  = p;
    ret.key  = nm;
    return ret;
}
#define stvp(typen, pval)       _stvp(NULL, stCheckedPtrArg(typen, pval))
#define stvpk(key, typen, pval) _stvp(#key, stCheckedPtrArg(typen, pval))
#define stvpNone                _stvp(NULL, NULL, NULL)
#endif
 
 
 
// Core lifecycle helpers. These manage storage in a standardized manner so that oversized (PassPtr)
// values - suid, opaque, struct — are deep-copied into a heap allocation the variant owns, rather
// than left as dangling pointers to a caller's temporary.
 
// Initialize *stv (assumed uninitialized) from a type + value. Overwrite/init semantics:
// does NOT destroy any prior contents. For PassPtr types, allocates and deep-copies.
// Does not touch the key name.
void _stvarInit(stvar* stv, stype type, stgeneric val);
 
// As _stvarInit, but also sets the key name (pointer-copied, never duplicated).
void _stvarInitK(stvar* stv, stype type, stgeneric val, const char* vk);
 
// Destroy the contents of *stv, free any owned heap allocation, clear any key name, and
// reset to none.
void _stvarClear(stvar* stv, flags_t flags);
 
// Replace semantics: destroy existing contents, then initialize from type + value.
// Clears any existing key name.
void _stvarSet(stvar* stv, stype type, stgeneric val);
 
// Replace semantics preserving/replacing the key name.
void _stvarSetK(stvar* stv, stype type, stgeneric val, const char* vk);
 
// Prepare *stv -- which may hold a live value -- to receive a value of `type` written
// directly into the returned storage. For PassPtr types the variant allocates and owns the
// block; otherwise the storage is the variant's own inline `data`. Either way the variant is
// left holding a zero-filled value of that type, so _stvarClear can always undo it.
_Ret_notnull_ void* _stvarPrepare(stvar* stv, stype type);
 
#define stvarSet(stv, type, val) _stvarSet(stv, stCheckedArg(type, val))
 
#define stvarSetK(stv, key, type, val) _stvarSetK(stv, stCheckedArg(type, val), #key)
 
_meta_inline void stvarDestroy(stvar* stv)
{
    _stvarClear(stv, 0);
}
 
_meta_inline void stvarCopy(stvar* dvar, stvar svar)
{
    _stvarInitK(dvar, stvarType(&svar), svar.data, svar._key);
}
 
 
 
#define stvarIs(svar, type) _stvarIs(svar, stType(type))
_meta_inline bool _stvarIs(stvar* svar, stype styp)
{
    return svar && stEq(stvarType(svar), styp);
}
 
_meta_inline string stvarString(stvar* svar)
{
    if (stvarIs(svar, string))
        return svar->data.st_string;
    return NULL;
}
 
_meta_inline string* stvarStringPtr(stvar* svar)
{
    if (stvarIs(svar, string))
        return &svar->data.st_string;
    return NULL;
}
 
_meta_inline ObjInst* stvarObjInst(stvar* svar)
{
    if (stvarIs(svar, object))
        return svar->data.st_object;
    return NULL;
}
 
_meta_inline ObjInst** stvarObjInstPtr(stvar* svar)
{
    if (stvarIs(svar, object))
        return &svar->data.st_object;
    return NULL;
}
 
#define stvarObj(class, svar) (objDynCast(class, stvarObjInst(svar)))
 
 
 
typedef struct stvlist {
    int count;     
    int cursor;    
    stvar* vars;   
} stvlist;
 
void stvlInit(stvlist* list, int count, stvar* vars);
 
#define stvlInitSA(list, vararray) _stvlInitSA(list, (vararray).a)
void _stvlInitSA(stvlist* list, stvar* vara);
 
#define stvlNext(list, type, pvar) _stvlNext(list, stCheckedPtrArg(type, pvar))
bool _stvlNext(stvlist* list, stype type, stgeneric* out);
 
#define stvlNextPtr(list) _stvlNextPtr(list, stType(ptr))
void* _stvlNextPtr(stvlist* list, stype type);
 
#define stvlNextObj(list, class) objDynCast(class, (ObjInst*)_stvlNextPtr(list, stType(object)))
 
void stvlRewind(stvlist* list);
 
stgeneric _stvlAt(_In_ stvlist* list, int idx, stype type);
 
#define stvlAt(list, idx, type) (_stvlAt((list), (idx), stType(type)).st_##type)
 
#define stvlAtPtr(list, idx) (_stvlAt((list), (idx), stType(ptr)).st_ptr)
 
#define stvlAtObj(list, idx, class) \
    objDynCast(class, (ObjInst*)_stvlAt((list), (idx), stType(object)).st_object)
 
 
 
#define stvlFind(list, key, type, pvar) _stvlFind(list, #key, stCheckedPtrArg(type, pvar))
bool _stvlFind(_In_ stvlist* list, const char* key, stype type, stgeneric* out);
 
#define stvlFindPtr(list, key) _stvlFindPtr(list, #key, stType(ptr))
void* _stvlFindPtr(_In_ stvlist* list, const char* key, stype type);
 
#define stvlFindObj(list, key, class) \
    objDynCast(class, (ObjInst*)_stvlFindPtr(list, #key, stType(object)))
 
stgeneric _stvlFindVal(_In_ stvlist* list, const char* key, stype type);
 
#define stvlFindVal(list, key, type) (_stvlFindVal(list, #key, stType(type)).st_##type)
 
#define stvlHasKey(list, key) _stvlHasKey(list, #key)
bool _stvlHasKey(_In_ stvlist* list, const char* key);
 
 
CX_C_END