ResourceMap.h

#pragma once
 
#include "ResourcePolicies.h"
 
namespace Cogs
{
  template<typename HandleType, typename ResourceType, typename StoragePolicy, typename LockingPolicy, typename VerificationPolicy>
  class ResourceMapBase
  {
  public:
    StoragePolicy resources;
    LockingPolicy m;
    using Lock = std::lock_guard<LockingPolicy>;
 
    ResourceMapBase() = default;
 
    ResourceMapBase(size_t capacity, size_t pageSize, Memory::Allocator * allocator) : resources(capacity, pageSize, allocator) {}
 
    ~ResourceMapBase()
    {
      Lock lock(m);
 
      resources.clear(true);
    }
 
    HandleType addResource(const ResourceType& resource, bool persistent = false)
    {
      Lock lock(m);
 
      return resources.allocate(resource, persistent);
    }
 
    HandleType addResource(ResourceType&& resource, bool persistent = false)
    {
      Lock lock(m);
 
      return resources.allocate(std::move(resource), persistent);
    }
 
    void removeResource(HandleType handle)
    {
      Lock lock(m);
 
      VerificationPolicy::verify(handle, resources);
 
      resources.deallocate(handle);
    }
 
    bool hasResource(HandleType handle)
    {
      Lock lock(m);
 
      return resources.hasResource(handle);
    }
 
    size_t size() const
    {
      return this->resources.size();
    }
 
    typename StoragePolicy::iterator begin() { return resources.begin(); }
 
    typename StoragePolicy::iterator end() { return resources.end(); }
 
    void clear()
    {
      Lock lock(m);
 
      resources.clear();
    }
 
    const ResourceType & operator[](const HandleType handle) const
    {
      if (StoragePolicy::SafeDereference()) {
        VerificationPolicy::verify(handle, resources);
 
        return resources[handle];
      } else {
        std::lock_guard<LockingPolicy> lock(m);
 
        VerificationPolicy::verify(handle, resources);
 
        return resources[handle];
      }
    }
 
    ResourceType & operator[](const HandleType handle)
    {
      if (StoragePolicy::SafeDereference()) {
        VerificationPolicy::verify(handle, resources);
 
        return resources[handle];
      } else {
        std::lock_guard<LockingPolicy> lock(m);
 
        VerificationPolicy::verify(handle, resources);
 
        return resources[handle];
      }
    }
 
    HandleType getHandle(const ResourceType & r) { return resources.getHandle(r); }
 
    void pin(const HandleType handle)
    {
      VerificationPolicy::verify(handle, resources);
 
      resources.pin(handle);
    }
 
    bool pinned(const HandleType & handle) const { return resources.pinned(handle); }
  };
 
  template<class HandleType, class ResourceType>
  using ResourceMap = ResourceMapBase<HandleType, ResourceType, PoolStoragePolicy<HandleType, ResourceType>, DefaultLockingPolicy, DefaultVerificationPolicy>;
 
  template<typename HandleType, typename ResourceType>
  using SafeResourceMap = ResourceMapBase<HandleType, ResourceType, PoolStoragePolicy<HandleType, ResourceType>, MutexLockingPolicy, DefaultVerificationPolicy>;
}