sarray.h

Go to the documentation of this file.

#pragma once
 
 
#include <cx/cx.h>
#include <cx/debug/assert.h>
#include <cx/debug/dbgtypes.h>
#include <cx/utils/macros/unused.h>
 
CX_C_BEGIN
 
#define sarrayref(typ) sa_##typ
#define sarrayhdl(typ) sa_##typ*
 
 
#define saDeclareType(name, typ) \
    typedef union sa_##name {    \
        _nv_sarray* _debug;      \
        void* _is_sarray;        \
        void* _is_sarray_##name; \
        typ* a;                  \
    } sa_##name
 
#define saDeclare(name) saDeclareType(name, name)
 
#define saDeclarePtr(name) saDeclareType(name, name*)
 
#define saInitNone { .a = 0 }
 
// Pre-declared common sarray types
typedef sa_ref sa_opaque;
saDeclare(int8);
saDeclare(int16);
saDeclare(int32);
saDeclare(int64);
saDeclare(intptr);
saDeclare(uint8);
saDeclare(uint16);
saDeclare(uint32);
saDeclare(uint64);
saDeclare(uintptr);
saDeclare(bool);
saDeclareType(size, size_t);
saDeclare(float32);
saDeclare(float64);
saDeclareType(ptr, void*);
saDeclare(string);
// strref doesn't make sense in an sarray
saDeclareType(object, ObjInst*);
saDeclareType(suid, SUID);
saDeclare(stvar);
saDeclareType(sarray, sa_ref);
saDeclare(hashtable);
saDeclare(closure);
 
// SArray header structure
//
// Internal structure containing array metadata. Access through helper macros.
typedef struct SArrayHeader {
    // sarray header begins here
    stype elemtype;
    int32 count;
    int32 capacity;
    uint32 flags;   // high 8 bits = growth
    void* data[1];
} SArrayHeader;
 
enum SARRAY_CREATE_FLAGS_ENUM {
    SA_Ref    = 0x0010,   
    SA_Sorted = 0x0020,   
    SA_AutoShrink = 0x0040,   
};
 
// Growth rate strategies for array expansion
enum SARRAY_GROW_ENUM {
    SA_GROW_Auto,
 
    // Dynamic growth rates (transition from high to lower growth as size increases)
    SA_GROW_Normal,
    SA_GROW_Aggressive,
    SA_GROW_Slow,
 
    // Fixed growth rates
    SA_GROW_100,
    SA_GROW_50,
    SA_GROW_25,
 
    SA_GROW_Minimal,
};
 
enum SARRAY_FUNC_FLAGS_ENUM {
    SA_Unique = 0x00010000,
 
    SA_Fast = 0x00020000,
 
    SA_Inexact = 0x00100000,
 
    // Internal use only - do not use directly
    SAINT_Consume = 0x10000000,
};
 
#define SA_GROW_MASK (0xff000000)
 
#define SA_Grow(rate) (((uint32)SA_GROW_##rate) << 24)
 
// Internal macro - extracts growth settings from flags
#define SA_GET_GROW(flags) ((flags) >> 24)
 
#define SARRAY_HDRSIZE  (offsetof(SArrayHeader, data))
#define SARRAY_HDR(ref) ((SArrayHeader*)(((uintptr)((ref).a)) - SARRAY_HDRSIZE))
#define SAREF(r)        (unused_noeval(&((r)._is_sarray)), *(sa_ref*)(&(r)))
#define SAHANDLE(h)     ((sahandle)(unused_noeval((h != NULL) && &((h)->_is_sarray)), (h)))
 
_Ret_notnull_ _meta_inline SArrayHeader* _saHdr(_In_ sa_ref ref)
{
    return SARRAY_HDR(ref);
}
 
#define saSize(ref) ((ref)._is_sarray ? _saHdr(SAREF(ref))->count : 0)
 
#define saCapacity(ref) ((ref)._is_sarray ? _saHdr(SAREF(ref))->capacity : 0)
 
#define saElemSize(ref) ((ref)._is_sarray ? stGetSize(_saHdr(SAREF(ref))->elemtype) : 0)
 
#define saElemType(ref) ((ref)._is_sarray ? _saHdr(SAREF(ref))->elemtype : 0)
 
#define saValid(ref) ((ref).a)
 
 
 
_Success_(!canfail || return) _When_(canfail, _Check_return_) _At_(out->a, _Post_notnull_) bool
_saInit(_Out_ sahandle out, stype elemtype, int32 capacity, bool canfail, flags_t flags);
 
#define saInit(out, type, capacity, ...) \
    _saInit(SAHANDLE(out), stType(type), capacity, false, opt_flags(__VA_ARGS__))
 
#define saTryInit(out, type, capacity, ...) \
    _saInit(SAHANDLE(out), stType(type), capacity, true, opt_flags(__VA_ARGS__))
 
_At_(handle->a, _Pre_maybenull_ _Post_null_) void _saDestroy(_Inout_ sahandle handle);
 
#define saDestroy(handle) _saDestroy(SAHANDLE(handle))
 
_When_(canfail, _Check_return_) _At_(handle->a, _Pre_notnull_ _Post_notnull_) bool _saReserve(_Inout_ sahandle handle, int32 capacity, bool canfail);
 
#define saReserve(handle, capacity) _saReserve(SAHANDLE(handle), capacity, true)
 
_At_(handle->a, _Pre_notnull_ _Post_notnull_) void _saShrink(_Inout_ sahandle handle, int32 capacity);
 
#define saShrink(handle, capacity) _saShrink(SAHANDLE(handle), capacity)
 
_At_(handle->a, _Pre_notnull_ _Post_notnull_) void _saSetSize(_Inout_ sahandle handle, int32 size);
 
#define saSetSize(handle, size) _saSetSize(SAHANDLE(handle), size)
 
_At_(handle->a, _Pre_maybenull_) void _saClear(_Inout_ sahandle handle);
 
#define saClear(handle) _saClear(SAHANDLE(handle))
 
 
 
#define _sa_Consume_Arg_                                       \
    _When_(flags& SAINT_Consume, _Pre_notnull_ _Post_invalid_) \
        _When_(!(flags & SAINT_Consume), _Inout_)
_At_(handle->a, _Pre_maybenull_ _Post_notnull_) int32 _saPush(_Inout_ sahandle handle, stype elemtype, _In_ stgeneric elem,
                         flags_t flags);
_At_(handle->a, _Pre_maybenull_ _Post_notnull_) int32 _saPushPtr(_Inout_ sahandle handle, stype elemtype,
                            _sa_Consume_Arg_ stgeneric* elem, flags_t flags);
 
#define saPush(handle, type, elem, ...) \
    _saPush(SAHANDLE(handle), stCheckedArg(type, elem), opt_flags(__VA_ARGS__))
 
#define saPushC(handle, type, elem, ...)    \
    _saPushPtr(SAHANDLE(handle),            \
               stCheckedPtrArg(type, elem), \
               opt_flags(__VA_ARGS__) | SAINT_Consume)
 
_Ret_opt_valid_ _At_(handle->a, _Pre_maybenull_) void* _saPopPtr(_Inout_ sahandle handle, int32 idx);
 
#define saPopPtr(handle) _saPopPtr(SAHANDLE(handle), -1)
 
#define saPopPtrI(handle, idx) _saPopPtr(SAHANDLE(handle), idx)
 
_At_(ref.a, _Pre_notnull_) int32 _saFind(_In_ sa_ref ref, _In_ stgeneric elem, flags_t flags);
_At_(ref.a, _Pre_maybenull_) _meta_inline int32
_saFindChecked(_In_ sa_ref ref, stype elemtype, _In_ stgeneric elem, flags_t flags)
{
    if (!ref.a)
        return -1;
    devAssert(stEq(saElemType(ref), elemtype));
    return _saFind(ref, elem, flags);
}
 
#define saFind(ref, type, elem, ...) \
    _saFindChecked(SAREF(ref), stCheckedArg(type, elem), opt_flags(__VA_ARGS__))
 
_At_(handle->a, _Pre_notnull_ _Post_notnull_) bool _saFindRemove(_Inout_ sahandle handle, _In_ stgeneric elem, flags_t flags);
_At_(handle->a, _Pre_maybenull_) _meta_inline bool
_saFindRemoveChecked(_Inout_ sahandle handle, stype elemtype, _In_ stgeneric elem, flags_t flags)
{
    if (!handle->a)
        return false;
    devAssert(stEq(saElemType(*handle), elemtype));
    return _saFindRemove(handle, elem, flags);
}
 
#define saFindRemove(handle, type, elem, ...) \
    _saFindRemoveChecked(SAHANDLE(handle), stCheckedArg(type, elem), opt_flags(__VA_ARGS__))
 
_At_(handle->a, _Pre_notnull_ _Post_notnull_) int32 _saInsert(_Inout_ sahandle handle, int32 idx, _In_ stgeneric elem);
_At_(handle->a, _Pre_notnull_ _Post_notnull_) _meta_inline int32
_saInsertChecked(_Inout_ sahandle handle, int32 idx, stype elemtype, _In_ stgeneric elem)
{
    devAssert(handle->_is_sarray);
    devAssert(stEq(saElemType(*handle), elemtype));
    return _saInsert(handle, idx, elem);
}
 
#define saInsert(handle, idx, type, elem) \
    _saInsertChecked(SAHANDLE(handle), idx, stCheckedArg(type, elem))
 
_At_(handle->a, _Pre_notnull_ _Post_notnull_) bool _saExtract(_Inout_ sahandle handle, int32 idx, _Inout_opt_ stgeneric* elem,
                           flags_t flags);
 
_At_(handle->a, _Pre_maybenull_) _meta_inline bool
_saExtractChecked(_Inout_ sahandle handle, int32 idx, stype elemtype,
                  _stCopyDest_Anno_opt_(elemtype) stgeneric* elem, flags_t flags)
{
    if (!handle->a)
        return false;
    devAssert(elemtype == stType(none) || stEq(saElemType(*handle), elemtype));
    return _saExtract(handle, idx, elem, flags);
}
 
#define saExtract(handle, idx, type, elem_copy_out, ...)    \
    _saExtractChecked(SAHANDLE(handle),                     \
                      idx,                                  \
                      stCheckedPtrArg(type, elem_copy_out), \
                      opt_flags(__VA_ARGS__))
 
#define saRemove(handle, idx, ...) \
    _saExtractChecked(SAHANDLE(handle), idx, stType(none), NULL, opt_flags(__VA_ARGS__))
 
_At_(handle->a, _Pre_maybenull_) void _saSort(_Inout_ sahandle handle, bool keep);
 
#define saSort(handle, keep) _saSort(SAHANDLE(handle), keep)
 
typedef intptr (*saCmpFunc)(stype st,
                            _In_ stgeneric gen1,
                            _In_ stgeneric gen2,
                            flags_t flags,
                            _In_opt_ void* ctx);
 
_At_(handle->a, _Pre_maybenull_) void _saSortCustom(_Inout_ sahandle handle,
                                                    _In_ saCmpFunc cmp,
                                                    _In_opt_ void* ctx,
                                                    flags_t flags);
 
#define saSortCustom(handle, cmp, ctx, ...) \
    _saSortCustom(SAHANDLE(handle), cmp, ctx, opt_flags(__VA_ARGS__))
 
 
 
_At_(out->a, _When_(ref.a, _Post_notnull_) ) void _saSlice(_Out_ sahandle out, _In_ sa_ref ref, int32 start, int32 end);
 
#define saSlice(out, src, start, end) _saSlice(SAHANDLE(out), SAREF(src), start, end)
 
#define saClone(out, src) _saSlice(SAHANDLE(out), SAREF(src), 0, 0)
 
_At_(out->a, _Post_maybenull_) void _saMerge(_Out_ sahandle out, int n, _In_ sa_ref* refs, flags_t flags);
 
#define saMerge(out, ...)                                         \
    _saMerge(SAHANDLE(out),                                       \
             sizeof((sa_ref[]) { __VA_ARGS__ }) / sizeof(sa_ref), \
             (sa_ref[]) { __VA_ARGS__ },                          \
             0)
 
#define saMergeF(out, flags, ...)                                 \
    _saMerge(SAHANDLE(out),                                       \
             sizeof((sa_ref[]) { __VA_ARGS__ }) / sizeof(sa_ref), \
             (sa_ref[]) { __VA_ARGS__ },                          \
             flags)
 
 
CX_C_END
 
#ifdef __cplusplus
// C++ needs a different initializer syntax
#undef saInitNone
#define saInitNone \
    { }
 
// C++ replacements for the compound-literal-based saMerge/saMergeF.
//
// The C versions build a temporary sa_ref[] via an array compound literal, which
// C++ does not support. Instead, collect the source arrays into a local sa_ref[]
// through a variadic template.
template <typename... SAs> _meta_inline void _cxSaMerge(sahandle out, flags_t flags, SAs... arrs)
{
    static_assert(sizeof...(SAs) > 0, "saMerge requires at least one source array");
    sa_ref refs[] = { *(sa_ref*)&arrs... };
    _saMerge(out, (int)(sizeof...(SAs)), refs, flags);
}
#undef saMerge
#undef saMergeF
#define saMerge(out, ...)         _cxSaMerge(SAHANDLE(out), 0, __VA_ARGS__)
#define saMergeF(out, flags, ...) _cxSaMerge(SAHANDLE(out), flags, __VA_ARGS__)
#endif