ssdtree.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <cx/container/sarray.h>
#include <cx/ssdtree/node/ssdnode.h>
#include <cx/string/strbase.h>
 
 
_Ret_valid_ SSDNode* _ssdCreateRoot(int crtype, _In_opt_ SSDTree* tree, uint32 flags);
 
#define ssdCreateHashtable(...) _ssdCreateRoot(SSD_Create_Hashtable, NULL, opt_flags(__VA_ARGS__))
 
#define ssdCreateArray(...) _ssdCreateRoot(SSD_Create_Array, NULL, opt_flags(__VA_ARGS__))
 
#define ssdCreateSingle(...) _ssdCreateRoot(SSD_Create_Single, NULL, opt_flags(__VA_ARGS__))
 
#define ssdCreateCustom(crtype, tree) _ssdCreateRoot(crtype, tree, 0)
 
 
 
_Ret_opt_valid_ SSDNode* _ssdClone(_In_ SSDNode* root, _In_opt_ SSDTree* desttree,
                                   _Inout_opt_ SSDLockState* lstate);
 
#define ssdClone(root, desttree) _ssdClone(root, desttree, (SSDLockState*)_ssdCurrentLockState)
 
_Ret_opt_valid_ SSDNode* _ssdSubtree(_In_ SSDNode* root, _In_opt_ strref path, SSDCreateType create,
                                     _Inout_opt_ SSDLockState* lstate);
 
#define ssdSubtree(root, path, create) \
    _ssdSubtree(root, path, create, (SSDLockState*)_ssdCurrentLockState)
 
_Ret_opt_valid_ SSDNode* _ssdSubtreeB(_In_ SSDNode* root, _In_opt_ strref path,
                                      _Inout_opt_ SSDLockState* lstate);
 
#define ssdSubtreeB(root, path) \
    _ssdSubtreeB(root, path, (SSDLockState*)&_ssdCurrentLockState->_is_SSDLockState)
 
 
 
 
_Success_(return) bool _ssdGet(_In_ SSDNode* root, _In_opt_ strref path, _Out_ stvar* out,
                        _Inout_opt_ SSDLockState* lstate);
 
#define ssdGet(root, path, out) _ssdGet(root, path, out, (SSDLockState*)_ssdCurrentLockState)
 
_Success_(return) _meta_inline bool _ssdGetD(_In_ SSDNode* root, _In_opt_ strref path, _Out_ stvar* out,
                                      stvar def, _Inout_opt_ SSDLockState* lstate)
{
    if (_ssdGet(root, path, out, lstate))
        return true;
 
    stvarCopy(out, def);
    return false;
}
 
#define ssdGetD(root, path, out, def) \
    _ssdGetD(root, path, out, def, (SSDLockState*)_ssdCurrentLockState)
 
_Success_(return) bool _ssdCopyOut(_In_ SSDNode* root, _In_opt_ strref path, stype valtype,
                            _stCopyDest_Anno_(valtype) stgeneric* val,
                            _Inout_opt_ SSDLockState* lstate);
 
#define ssdCopyOut(root, path, vtype, val_copy_out)   \
    _ssdCopyOut(root,                                 \
                path,                                 \
                stCheckedPtrArg(vtype, val_copy_out), \
                (SSDLockState*)_ssdCurrentLockState)
 
_Success_(return) bool _ssdCopyOutD(_In_ SSDNode* root, _In_opt_ strref path, stype valtype,
                             _stCopyDest_Anno_(valtype) stgeneric* val, stgeneric def,
                             _Inout_opt_ SSDLockState* lstate);
 
#define ssdCopyOutD(root, path, vtype, val_copy_out, def) \
    _ssdCopyOutD(root,                                    \
                 path,                                    \
                 stCheckedPtrArg(vtype, val_copy_out),    \
                 stArg(vtype, def),                       \
                 (SSDLockState*)_ssdCurrentLockState)
 
#define ssdval_spec(type)                                                                \
    _meta_inline stTypeDef(type)                                                         \
        _ssdVal_##type(_In_ SSDNode* root,                                               \
                       _In_opt_ strref path,                                             \
                       stTypeDef(type) def,                                              \
                       _Inout_opt_ SSDLockState* lstate)                                 \
    {                                                                                    \
        stTypeDef(type) out;                                                             \
        _ssdCopyOutD(root, path, stCheckedPtrArg(type, &out), stArg(type, def), lstate); \
        return out;                                                                      \
    }
 
// clang-format off
ssdval_spec(bool)
ssdval_spec(int8)
ssdval_spec(int16)
ssdval_spec(int32)
ssdval_spec(int64)
ssdval_spec(uint8)
ssdval_spec(uint16)
ssdval_spec(uint32)
ssdval_spec(uint64)
ssdval_spec(float32)
ssdval_spec(float64)
// clang-format on
 
#define ssdVal(type, root, path, def) \
    _ssdVal_##type(root, path, def, (SSDLockState*)_ssdCurrentLockState)
 
            _meta_inline bool _ssdStringOut(_In_ SSDNode* root, _In_opt_ strref path,
                                            _Inout_ string* out, _Inout_opt_ SSDLockState* lstate)
{
    strDestroy(out);
    return _ssdCopyOut(root, path, stCheckedPtrArg(string, out), lstate);
}
 
#define ssdStringOut(root, path, out) \
    _ssdStringOut(root, path, out, (SSDLockState*)_ssdCurrentLockState)
 
_meta_inline bool _ssdStringOutD(_In_ SSDNode* root, _In_opt_ strref path, _Inout_ string* out,
                                 _In_opt_ strref def, _Inout_opt_ SSDLockState* lstate)
{
    strDestroy(out);
    return _ssdCopyOutD(root, path, stCheckedPtrArg(string, out), stArg(strref, def), lstate);
}
 
#define ssdStringOutD(root, path, out, def) \
    _ssdStringOutD(root, path, out, def, (SSDLockState*)_ssdCurrentLockState)
 
 
 
bool _ssdSet(_Inout_ SSDNode* root, _In_opt_ strref path, bool createpath, stvar val,
             _Inout_opt_ SSDLockState* lstate);
 
#define ssdSet(root, path, createpath, val) \
    _ssdSet(root, path, createpath, val, (SSDLockState*)_ssdCurrentLockState)
 
bool _ssdSetC(_Inout_ SSDNode* root, _In_opt_ strref path, bool createpath,
              _Pre_notnull_ _Post_invalid_ stvar* val, _Inout_opt_ SSDLockState* lstate);
 
#define ssdSetC(root, path, createpath, val) \
    _ssdSetC(root, path, createpath, val, (SSDLockState*)_ssdCurrentLockState)
 
bool _ssdRemove(_Inout_ SSDNode* root, _In_opt_ strref path, _Inout_opt_ SSDLockState* lstate);
 
#define ssdRemove(root, path) _ssdRemove(root, path, (SSDLockState*)_ssdCurrentLockState)
 
 
 
stvar* _ssdPtr(_In_ SSDNode* root, _In_opt_ strref path, _Inout_ SSDLockState* lstate);
 
#define ssdPtr(root, path) \
    _ssdPtr(root, path, (SSDLockState*)&_ssdCurrentLockState->_is_SSDLockState)
 
_Ret_opt_valid_ _meta_inline strref
_ssdStrRef(_In_ SSDNode* root, _In_opt_ strref path, _Inout_ SSDLockState* lstate)
{
    stvar* temp = _ssdPtr(root, path, lstate);
    return stvarIs(temp, string) ? temp->data.st_string : NULL;
}
 
#define ssdStrRef(root, path) \
    _ssdStrRef(root, path, (SSDLockState*)&_ssdCurrentLockState->_is_SSDLockState)
 
_Must_inspect_result_ _Ret_opt_valid_ _meta_inline ObjInst*
_ssdObjInstPtr(_In_ SSDNode* root, _In_opt_ strref path, _Inout_ SSDLockState* lstate)
{
    stvar* temp = _ssdPtr(root, path, lstate);
    return stvarIs(temp, object) ? temp->data.st_object : NULL;
}
 
#define ssdObjInstPtr(root, path) \
    _ssdObjInstPtr(root, path, (SSDLockState*)&_ssdCurrentLockState->_is_SSDLockState)
 
#define ssdObjPtr(root, path, clsname) objDynCast(clsname, ssdObjInstPtr(root, path))
 
 
 
bool _ssdExportArray(_In_ SSDNode* root, _In_opt_ strref path, _Inout_ sa_stvar* out,
                     _Inout_opt_ SSDLockState* lstate);
 
#define ssdExportArray(root, path, out) \
    _ssdExportArray(root, path, out, (SSDLockState*)_ssdCurrentLockState)
 
bool _ssdImportArray(_Inout_ SSDNode* root, _In_opt_ strref path, _In_ sa_stvar arr,
                     _Inout_opt_ SSDLockState* lstate);
 
#define ssdImportArray(root, path, arr) \
    _ssdImportArray(root, path, arr, (SSDLockState*)_ssdCurrentLockState)
 
bool _ssdExportTypedArray(_In_ SSDNode* root, _In_opt_ strref path, stype elemtype,
                          _Inout_ sahandle out, bool strict, _Inout_opt_ SSDLockState* lstate);
bool _ssdImportTypedArray(_Inout_ SSDNode* root, _In_opt_ strref path, stype elemtype,
                          _In_ sa_ref arr, _Inout_opt_ SSDLockState* lstate);
 
#define ssdExportTypedArray(root, path, type, out, strict) \
    _ssdExportTypedArray(root,                             \
                         path,                             \
                         stType(type),                     \
                         SAHANDLE(out),                    \
                         strict,                           \
                         (SSDLockState*)_ssdCurrentLockState)
 
#define ssdImportTypedArray(root, path, type, arr) \
    _ssdImportTypedArray(root, path, stType(type), SAREF(arr), (SSDLockState*)_ssdCurrentLockState)
 
int32 _ssdCount(_In_ SSDNode* root, _In_opt_ strref path, bool arrayonly,
                _Inout_opt_ SSDLockState* lstate);
 
#define ssdCount(root, path, arrayonly) \
    _ssdCount(root, path, arrayonly, (SSDLockState*)_ssdCurrentLockState)
 
_Ret_opt_valid_ stvar* _ssdIndex(_In_ SSDNode* root, _In_opt_ strref path, int32 idx,
                                 _Inout_ SSDLockState* lstate);
 
#define ssdIndex(root, path, idx) \
    _ssdIndex(root, path, idx, (SSDLockState*)&_ssdCurrentLockState->_is_SSDLockState)
 
bool _ssdAppend(_Inout_ SSDNode* root, _In_opt_ strref path, bool createpath, stvar val,
                _Inout_opt_ SSDLockState* lstate);
 
#define ssdAppend(root, path, createpath, val) \
    _ssdAppend(root, path, createpath, val, (SSDLockState*)_ssdCurrentLockState)
 
 
 
bool _ssdGraft(_Inout_ SSDNode* dest, _In_opt_ strref destpath,
               _Inout_opt_ SSDLockState* dest_lstate, _In_ SSDNode* src, _In_opt_ strref srcpath,
               _Inout_opt_ SSDLockState* src_lstate);
 
#define ssdGraft(dest, destpath, src, srcpath) \
    _ssdGraft(dest, destpath, (SSDLockState*)_ssdCurrentLockState, src, srcpath, NULL)