ResourceStore.h

#pragma once
 
#include "Base.h"
#include "ResourceArchive.h"
 
#include "Foundation/Memory/MemoryBuffer.h"
#include "Foundation/Platform/Threads.h"
#include "Foundation/StringView.h"
 
#include <string_view>
#include <span>
 
namespace Cogs
{
  struct IIOHandler;
 
  namespace Core
  {
    class Context;
 
    struct ResourceBuffer
    {
      [[nodiscard]]
      uint8_t * data() { return static_cast<uint8_t *>(buffer->data()); }
 
      [[nodiscard]]
      const uint8_t * data() const { return static_cast<uint8_t *>(buffer->data()); }
 
      [[nodiscard]]
      size_t size() const { return buffer ? buffer->size() : 0; }
 
      [[nodiscard]]
      bool empty() const { return !buffer || size() == 0; }
 
      [[nodiscard]]
      std::string_view toStringView() const {
        return empty() ? std::string_view() : std::string_view(static_cast<const char*>(buffer->data()), size());
      }
 
      template<class T>
      [[nodiscard]]
      std::span<const T> toSpan(size_t offset = 0) const {
        if (offset >= size()) {
          return std::span<const T>();
        }
        else {
          const void* dataStart = static_cast<const uint8_t*>(buffer->data()) + offset;
          return std::span<const T>(static_cast<const T*>(dataStart), (size() - offset) / sizeof(T));
        }
      }
 
      std::shared_ptr<Memory::MemoryBuffer> buffer;
    };
 
    enum class ResourceStoreFlags
    {
      None = 0,
      NoCachedContent = 1 << 0,         
      QueryOnly = 1 << 1,
      PreferUncachedContent = 1 << 2    
    };
 
    enum class ResourceProtocol
    {
      None = 0,
      File = 1,
      Default = File,
      Cache = 2,
      Archive = 3,
      Http = 4,
      Other = 5,
    };
 
    struct ResourceQueryResult
    {
      std::string path;
      ResourceProtocol protocol = ResourceProtocol::None;
    };
 
    ENABLE_ENUM_FLAGS(ResourceStoreFlags);
 
    class COGSCORE_DLL_API ResourceStore
    {
      friend void resourceStoreInspector(Context * context, bool * show);
    public:
      explicit ResourceStore(class Context * context);
      ~ResourceStore();
 
      void preloadResources(const std::vector<std::string> & resourceNames);
 
      [[nodiscard]]
      bool hasResources(const std::vector<std::string> & resourceNames);
 
      [[nodiscard]]
      bool hasResource(const std::string & resourceName);
 
      void addResource(std::string_view resourceName, const std::string_view content);
 
      void addResource(std::string_view resourceName, const void* content_data, size_t content_size);
 
      void addResourceArchive(const std::string & archiveName, bool prepend = false);
 
      /*
        Get the actual path of a resource.
      */
      [[nodiscard]]
      std::string getResourcePath(std::string_view resourceName, ResourceStoreFlags flags = ResourceStoreFlags::None) const;
 
      [[nodiscard]]
      ResourceQueryResult getResourceLocation(std::string_view resourceName, ResourceStoreFlags flags = ResourceStoreFlags::None) const;
 
      [[nodiscard]]
      ResourceBuffer getResourceContents(std::string_view resourceName, ResourceStoreFlags flags = ResourceStoreFlags::None) const;
 
      [[nodiscard]]
      std::string getResourceContentString(std::string_view resourceName, ResourceStoreFlags flags = ResourceStoreFlags::None) const;
 
      void addSearchPath(const std::string & path, bool prepend = false);
 
      [[nodiscard]]
      const std::string& getDataDir() const;
 
      void purge(const std::string & resourceName);
 
      void clear();
 
      [[nodiscard]]
      IIOHandler * getIOHandler();
 
    private:
      std::unique_ptr<struct ResourceStoreStorage> data;
    };
  }
}