ResourcePool.h

浏览该文件的文档.

#pragma once
 
#include "ResourceRef.h"
 
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace z8 {
 
template <typename ResourceTy>
class ResourcePool {
private:
  std::vector<std::unique_ptr<ResourceTy>> Slots;
  std::unordered_map<std::string, ResourceRef<ResourceTy>> AssetIndex;
 
public:
  ResourceRef<ResourceTy> Add(std::string assetId,
                              std::unique_ptr<ResourceTy> resource) {
    if (!resource || assetId.empty() ||
        AssetIndex.find(assetId) != AssetIndex.end())
      return {};
 
    const auto index = static_cast<uint32_t>(Slots.size());
    Slots.push_back(std::move(resource));
    const ResourceRef<ResourceTy> reference(index);
    AssetIndex.emplace(std::move(assetId), reference);
    return reference;
  }
 
  ResourceRef<ResourceTy> Find(const std::string &assetId) const {
    const auto iterator = AssetIndex.find(assetId);
    return iterator == AssetIndex.end() ? ResourceRef<ResourceTy>{}
                                        : iterator->second;
  }
 
  size_t Size() const { return AssetIndex.size(); }
 
  ResourceTy *TryGet(ResourceRef<ResourceTy> reference) {
    return const_cast<ResourceTy *>(std::as_const(*this).TryGet(reference));
  }
 
  const ResourceTy *TryGet(ResourceRef<ResourceTy> reference) const {
    if (!reference.IsResolved() || reference.Index >= Slots.size())
      return nullptr;
    return Slots[reference.Index].get();
  }
 
  template <typename VisitorTy>
  void Visit(VisitorTy &&visitor) const {
    for (uint32_t index = 0; index < Slots.size(); ++index) {
      const auto &resource = Slots[index];
      if (resource)
        visitor(ResourceRef<ResourceTy>(index), *resource);
    }
  }
};
 
} // namespace z8