ResourcePolicies.h

#pragma once
 
#include "Foundation/Collections/Pool.h"
 
#include <mutex>
 
#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable:4512)
#endif
 
namespace Cogs
{
  template<typename ResourceType>
  struct ResourceWrapper
  {
    ResourceWrapper * next = nullptr;
 
    ResourceWrapper * prev = nullptr;
 
    ResourceType resource;
 
#ifdef _DEBUG
    uint16_t debugFlags = 0;
#endif
 
    bool pinned = false;
  };
 
  template<typename ResourceType>
  struct PoolIterator
  {
    typedef ResourceWrapper<ResourceType> WrapperType;
 
    typedef std::forward_iterator_tag iterator_category;
 
    typedef ResourceType value_type;
 
    typedef size_t difference_type;
 
    typedef ResourceType * pointer;
 
    typedef ResourceType & reference;
 
    PoolIterator(WrapperType * current) : current(current) {}
 
    PoolIterator(const PoolIterator & other) : current(other.current) {}
 
    PoolIterator operator++() { PoolIterator t(current); current = current->next; return t; }
    PoolIterator & operator++(int) { current = current->next; return *this; }
 
    [[nodiscard]] constexpr bool operator==(const PoolIterator & other) const { return current == other.current; }
 
    reference operator*() { return current->resource; }
 
    reference operator*() const { return current->resource; }
 
    const pointer operator->() const { return &current->resource; }
    
    pointer operator->() { return &current->resource; }
 
  private:
    WrapperType * current;
  };
 
  template<typename HandleType, typename ResourceType>
  struct PoolStoragePolicy
  {
    typedef PoolIterator<ResourceType> iterator;
    typedef ResourceWrapper<ResourceType> WrapperType;
 
    constexpr static bool SafeDereference() { return true; }
 
    PoolStoragePolicy(MemBlockType memType = MemBlockType::Rendering) : pool(memType) {}
 
    PoolStoragePolicy(size_t capacity, size_t pageSize, Memory::Allocator * allocator, MemBlockType memType = MemBlockType::Rendering) :
      pool((Collections::ElementOffset)capacity, (Collections::ElementOffset)pageSize, allocator, memType)
    {}
 
    HandleType allocate(ResourceType && resource, bool persistent)
    {
      auto r = pool.create();
 
      ++count;
 
      r->resource = std::move(resource);
 
      // Insert at head of allocated list.
      r->next = allocatedHead;
      allocatedHead = r;
      if (r->next) r->next->prev = r;
 
#ifdef _DEBUG
      // Reset debug flag, we might be reusing a deallocated resource.
      r->debugFlags = 0;
#endif
 
      auto handle = getHandle(r->resource);
 
      if (persistent) pin(handle);
 
      return handle;
    }
 
    HandleType allocate(const ResourceType & resource, bool persistent)
    {
      auto r = pool.create();
 
      ++count;
 
      r->resource = resource;
 
      // Insert at head of allocated list.
      r->next = allocatedHead;
      allocatedHead = r;
      if (r->next) r->next->prev = r;
 
#ifdef _DEBUG
      // Reset debug flag, we might be reusing a deallocated resource.
      r->debugFlags = 0;
#endif
 
      auto handle = getHandle(r->resource);
 
      if (persistent) pin(handle);
 
      return handle;
    }
 
    void deallocate(const HandleType & handle)
    {
      auto r = reinterpret_cast<WrapperType *>(handle.handle);
 
#ifdef _DEBUG
      assert(r->debugFlags == 0 && "Resource already deallocated.");
      // Signal deallocation.
      r->debugFlags = 1;
#endif
 
      // Remove from allocated list.
      if (r->next) r->next->prev = r->prev;
      if (r->prev) r->prev->next = r->next;
      if (r == allocatedHead) allocatedHead = r->next;
 
      pool.destroy(r);
 
      --count;
    }
 
    bool hasResource(const HandleType & handle) const
    {
      return HandleIsValid(handle);
    }
 
    ResourceType & operator[](const HandleType & handle)
    {
      auto wrapper = reinterpret_cast<WrapperType *>(handle.handle);
 
      return wrapper->resource;
    }
 
    void clear(bool force = false)
    {
      auto next = allocatedHead;
      while (next) {
        auto current = next;
        next = next->next;
 
        if (!current->pinned || force) {
          deallocate(getHandle(current->resource));
        }
      }
    }
 
    void pin(const HandleType & handle)
    {
      auto wrapper = reinterpret_cast<ResourceWrapper<ResourceType>*>(handle.handle);
 
      wrapper->pinned = true;
    }
 
    bool pinned(const HandleType & handle) const { return reinterpret_cast<WrapperType *>(handle.handle)->pinned; }
 
    iterator begin() { return iterator(allocatedHead); }
    iterator end() { return iterator(nullptr); }
 
    size_t size() const { return count; }
 
    HandleType getHandle(const ResourceType & r) { return HandleType(reinterpret_cast<int64_t>(getWrapperPointer(r))); }
 
    static WrapperType * getWrapperPointer(const ResourceType & r) { return reinterpret_cast<WrapperType *>(reinterpret_cast<intptr_t>(&r) - sizeof(ResourceType *) * 2); }
 
  private:
    Collections::Pool<WrapperType> pool;
    WrapperType * allocatedHead = nullptr;
 
    size_t count = 0;
  };
 
  struct DefaultLockingPolicy
  {
    void lock() {}
    void unlock() {}
  };
 
  struct MutexLockingPolicy
  {
    void lock() { m.lock(); }
    void unlock() { m.unlock(); }
 
  private:
    std::mutex m;
  };
 
  struct DefaultVerificationPolicy
  {
#ifdef _DEBUG
    template<typename HandleType, typename StorageType>
    static void verify(const HandleType & handle, const StorageType & storage) { assert(storage.hasResource(handle) && "Resource handle does not exist."); }
#else
    template<typename HandleType, typename StorageType>
    static void verify(const HandleType &, const StorageType &) {}
#endif
  };
}
 
#ifdef _WIN32
#pragma warning(pop)
#endif