idallocator.h

Go to the documentation of this file.

#pragma once
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#include "id.h"
#include "idpool.h"
#include "util/array.h"
#include "threading/criticalsection.h"
#include <tuple>
#include <utility>
#include "util/tupleutility.h"
#include "util/arrayallocator.h"
#include "util/arrayallocatorsafe.h"
#include "idgenerationpool.h"
 
namespace Ids
{
 
template<class ... TYPES>
class IdAllocator : public Util::ArrayAllocator<TYPES...>
{
public:
    IdAllocator(uint32_t maxid = 0xFFFFFFFF) : maxId(maxid) {};
    
    Ids::Id32 Alloc()
    {
        Ids::Id32 id;
        if (this->pool.Allocate(id))
        {
            Util::ArrayAllocator<TYPES...>::Alloc();
            n_assert2(this->maxId > Ids::Index(id), "max amount of allocations exceeded!\n");
        }
 
        return id;
    }
 
    void Dealloc(Ids::Id32 id)
    {
        // TODO: We could possibly get better performance when defragging if we insert it in reverse order (high to low)
        this->pool.Deallocate(id);
    }
 
    template<int MEMBER>
    inline void Set(const Ids::Id32 id, const Util::tuple_array_t<MEMBER, TYPES...>& type)
    {
        Util::ArrayAllocator<TYPES...>::template Set<MEMBER>(Ids::Index(id), type);
    }
 
    inline void Set(const Ids::Id32 id, TYPES... values)
    {
        Util::ArrayAllocator<TYPES...>::Set(Ids::Index(id), values...);
    }
 
    template<int MEMBER>
    inline Util::tuple_array_t<MEMBER, TYPES...>& Get(const Ids::Id32 id)
    {
        return Util::ArrayAllocator<TYPES...>::template Get<MEMBER>(Ids::Index(id));
    }
 
    template<int MEMBER>
    inline const Util::tuple_array_t<MEMBER, TYPES...>& ConstGet(const Ids::Id32 id) const
    {
        return Util::ArrayAllocator<TYPES...>::template ConstGet<MEMBER>(Ids::Index(id));
    }
 
    inline Util::Queue<Id32>& FreeIds()
    {
        return this->pool.FreeIds();
    }
 
    const uint32_t Size() const
    {
        return this->size;
    }
 
private:
    uint32_t maxId = 0xFFFFFFFF;
    Ids::IdGenerationPool pool;
};
 
#define _DECL_ACQUIRE_RELEASE(ty) \
    bool ty##Acquire(const ty id); \
    void ty##Release(const ty id); \
    struct ty##Lock \
    { \
        ty##Lock(const ty element) : element(element) { this->didAcquire = ty##Acquire(this->element); } \
        ~ty##Lock() { if (this->didAcquire) ty##Release(this->element); } \
    private: \
        bool didAcquire; \
        ty element; \
    };
 
#define _IMPL_ACQUIRE_RELEASE(ty, allocator) \
    bool ty##Acquire(const ty id) { return allocator.Acquire(id.id); } \
    void ty##Release(const ty id) { allocator.Release(id.id); }
 
template<int MAX_ALLOCS, class... TYPES>
class IdAllocatorSafe : public Util::ArrayAllocatorSafe<MAX_ALLOCS, TYPES...>
{
public:
    IdAllocatorSafe()
    {
    };
 
    Ids::Id32 Alloc()
    {
        this->allocationLock.Lock();
        Ids::Id32 id;
        if (this->pool.Allocate(id))
        {
            alloc_for_each_in_tuple(this->objects);
            this->owners.Append(Threading::Thread::GetMyThreadId());
            n_assert2(MAX_ALLOCS > Ids::Index(id), "max amount of allocations exceeded!\n");
        }
        else
        {
            this->owners[Ids::Index(id)] = Threading::Thread::GetMyThreadId();
        }
        this->allocationLock.Unlock();
 
        return id;
    }
 
    template<int MEMBER>
    inline void Set(const Ids::Id32 id, const Util::tuple_array_t<MEMBER, TYPES...>& type)
    {
        Util::ArrayAllocatorSafe<MAX_ALLOCS, TYPES...>::template Set<MEMBER>(Ids::Index(id), type);
    }
 
    inline void Set(const Ids::Id32 id, TYPES... values)
    {
        Util::ArrayAllocatorSafe<MAX_ALLOCS, TYPES...>::Set(Ids::Index(id), values...);
    }
 
    template<int MEMBER>
    inline Util::tuple_array_t<MEMBER, TYPES...>& Get(const Ids::Id32 id)
    {
        return Util::ArrayAllocatorSafe<MAX_ALLOCS, TYPES...>::template Get<MEMBER>(Ids::Index(id));
    }
 
    template<int MEMBER>
    inline const Util::tuple_array_t<MEMBER, TYPES...>& ConstGet(const Ids::Id32 id) const
    {
        return Util::ArrayAllocatorSafe<MAX_ALLOCS, TYPES...>::template ConstGet<MEMBER>(Ids::Index(id));
    }
 
    inline Util::Queue<Id32>& FreeIds()
    {
        return this->pool.FreeIds();
    }
 
    void TryAcquire(const Ids::Id32 id)
    {
        Util::ArrayAllocatorSafe<MAX_ALLOCS, TYPES...>::TryAcquire(Ids::Index(id));
    }
    bool Acquire(const Ids::Id32 id)
    {
        return Util::ArrayAllocatorSafe<MAX_ALLOCS, TYPES...>::Acquire(Ids::Index(id));
    }
    void Release(const Ids::Id32 id)
    {
        Util::ArrayAllocatorSafe<MAX_ALLOCS, TYPES...>::Release(Ids::Index(id));
    }
 
    void Dealloc(Ids::Id32 id)
    {
        // TODO: We could possibly get better performance when defragging if we insert it in reverse order (high to low)
        this->allocationLock.Lock();
        this->pool.Deallocate(id);
        this->allocationLock.Unlock();
    }
 
private:
    Ids::IdGenerationPool pool;
};
 
} // namespace Ids