ResourceManagerBase.h

#pragma once
 
#include "ResourceLoadInfo.h"
#include "ResourceHandle.h"
 
namespace Cogs
{
  namespace Core
  {
    class Context;
 
    struct ResourceManagerBaseStorage;
 
    class COGSCORE_DLL_API ResourceManagerBase : public IResourceManager
    {
    public:
      ResourceManagerBase(Context * context);
      ~ResourceManagerBase() override;
 
      void initialize() override;
      void clear() override;
 
      void reportLeaks(std::string_view typeName);
 
      std::string getReport();
 
      bool checkPreloaded(ResourceLoadInfoBase * loadInfo);
 
      ResourceHandleBase releaseInternal(ResourceId resourceId);
      
      ResourceHandleBase loadResourceInternal(ResourceLoadInfoBase * loadInfo);
 
      void processLoading() final;
 
      void setProcessed(ResourceLoadInfoBase * loadInfo, bool swapping = false);
 
      void activateResources() final;
 
      virtual void processDeletion() override;
 
      void fillDeletionQueue(std::vector<ResourceBase *> & deletion);
 
      void destroyLocked(ResourceBase * resource);
      void safeDestroy(ResourceBase * resource);
 
      ResourceId getNextResourceId() override;
 
      void resourceChanged(ResourceBase * resource) override;
      void resourceDeleted(ResourceBase * resource) override;
 
      void setResourceId(ResourceBase * resource, ResourceId id) override;
 
      void queueResource(ResourceLoadInfoBase * loadInfo);
 
      virtual void handleLoadInternal(ResourceLoadInfoBase * loadInfo) = 0;
      virtual ActivationResult handleActivationInternal(ResourceHandleBase r, ResourceBase * resource) = 0;
      virtual void handleDeletionInternal(ResourceBase * resource) = 0;
      virtual void handleFailedLoadInternal(ResourceLoadInfoBase * loadInfo) = 0;
      virtual void destroyLoadInfoInternal(ResourceLoadInfoBase * loadInfo) = 0;
      virtual bool shouldAutoReload() const;
      virtual bool shouldMergeBySource() const { return true; }
      virtual void handleReload(ResourceHandleBase /*handle*/) {}
 
      std::vector<ResourceBase *> getAllocatedResources() const;
 
      ResourceHandleBase getOrCreate(ResourceId id);
 
      ResourceHandleBase getByName(std::string_view name) const;
      ResourceHandleBase getBySource(std::string_view source) const;
      
      ResourceHandleBase createResource();
 
      virtual ResourceBase * createInternal() = 0;
      virtual void destroyInternal(ResourceBase * resource) = 0;
      virtual void destroyInternalLocked(ResourceBase * resource) = 0;
 
      ResourceHandleBase generateHandle(ResourceBase * resource);
 
      void clearUpdated();
 
      virtual int getUpdateQuota() const;
 
      // For debug purposes
      size_t updatedResourceCount();
 
      // For debug purposes
      size_t orphanedResourceCount();
 
      // For debug purposes
      size_t allocatedResourceCount();
 
    protected:
      [[nodiscard]] ResourceHandleBase getResourceHandle(ResourceId id) const;
 
      [[nodiscard]] bool isValidResource(ResourceId id) const;
 
      virtual void postProcessLoading() {}
 
    protected:
      std::unique_ptr<ResourceManagerBaseStorage> storage;
 
      Context * context = nullptr;
      ResourceTypes resourceType = ResourceTypes::Unknown;
 
    private:
      ResourceHandleBase createResourceInternal();
      ResourceHandleBase getOrCreateInternal(ResourceId id);
 
      void destroy(ResourceBase * resource);
    };
  }
}