CreatureLib/CInterface/Library/BaseLibrary.cpp

#include "../Core.hpp"

#define BASELIBRARY(simpleName, fullname, returnType)                                                                  \
    export uint8_t simpleName##_Insert(fullname* p, const char* name, returnType* t) {                                 \
        Try(p->Insert(Arbutils::CaseInsensitiveConstString::GetHash(name), t);)                                        \
    }                                                                                                                  \
                                                                                                                       \
    export uint8_t simpleName##_InsertWithHash(fullname* p, uint32_t hashedKey, returnType* t) {                       \
        Try(p->Insert(hashedKey, t);)                                                                                  \
    }                                                                                                                  \
                                                                                                                       \
    export uint8_t simpleName##_Delete(fullname* p, const char* name) {                                                \
        Try(p->Delete(Arbutils::CaseInsensitiveConstString::GetHash(name));)                                           \
    }                                                                                                                  \
                                                                                                                       \
    export uint8_t simpleName##_DeleteWithHash(fullname* p, uint32_t hashedKey) { Try(p->Delete(hashedKey);) }         \
                                                                                                                       \
    export bool simpleName##_TryGet(fullname* p, const char* name, const returnType*& out) {                           \
        borrowed_ptr<const returnType> o;                                                                              \
        auto v = p->TryGet(Arbutils::CaseInsensitiveConstString::GetHash(name), o);                                    \
        out = o.operator->();                                                                                          \
        return v;                                                                                                      \
    }                                                                                                                  \
                                                                                                                       \
    export bool simpleName##_TryGetWithHash(fullname* p, uint32_t hashedKey, const returnType*& out) {                 \
        borrowed_ptr<const returnType> o;                                                                              \
        auto v = p->TryGet(hashedKey, o);                                                                              \
        out = o.operator->();                                                                                          \
        return v;                                                                                                      \
    }                                                                                                                  \
                                                                                                                       \
    export uint8_t simpleName##_Get(fullname* p, const char* name, const returnType*& out) {                           \
        Try(out = p->Get(Arbutils::CaseInsensitiveConstString::GetHash(name)).operator->();)                           \
    }                                                                                                                  \
                                                                                                                       \
    export uint8_t simpleName##_GetWithHash(fullname* p, uint32_t hashedKey, const returnType*& out) {                 \
        Try(out = p->Get(hashedKey).operator->();)                                                                     \
    }                                                                                                                  \
                                                                                                                       \
    export size_t simpleName##_GetCount(fullname* p) { return p->GetCount(); }