ResourceManager.hpp

#pragma once
#ifndef __H__OCULAR_RESOURCES_RESOURCE_MANAGER__H__
#define __H__OCULAR_RESOURCES_RESOURCE_MANAGER__H__

#include <memory>
#include <list>
#include <string>
#include <unordered_map>

#include "ResourceDetails.hpp"
#include "ResourceMemoryDetails.hpp"
#include "ResourcePriorityBehaviour.hpp"
#include "ResourceExplorer.hpp"
#include "ResourceLoader.hpp"
#include "ResourceLoaderManager.hpp"
#include "ResourceSaver.hpp"
#include "ResourceSaverManager.hpp"
#include "ResourceDefaults.hpp"

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Core
    {
        class ResourceManager 
        {
        public:

            ResourceManager();
            ~ResourceManager();

            //----------------------------------------

            void initialize();

            void unloadAllResources();

            void forceSourceRefresh();
            
            bool forceLoadResource(std::string const& path);

            bool forceUnloadResource(std::string const& path);

            bool addResource(std::string const& name, File const& sourceFile, Resource* resource, ResourceType type);

            ResourceMemoryDetails getMemoryUsage();

            Resource* getResource(std::string const& path);

            template<class T> T* getResource(std::string const& path) { return dynamic_cast<T*>(getResource(path)); };

            Resource* getEmptyResource(ResourceType type);

            Resource* getMissingResource(ResourceType type);

            File getResourceFile(std::string const& path) const;

            std::string getResourceMappingName(File const& file) const;

            bool isInMemory(std::string const& path);

            bool doesExist(std::string const& path);

            Resource* loadUnmanagedFile(File const& file);

            bool saveResource(Resource* resource, File const& file);

            void setMemoryLimit(uint64_t maxMemory);

            void setPriorityBehaviour(ResourcePriorityBehaviour behaviour);

            void setSourceBlacklist(std::list<std::string> const& blacklist);

            void setSourceDirectory(std::string const& directory);

            std::string const& getSourceDirectory() const;
            
            void registerResourceLoader(std::shared_ptr<AResourceLoader> loader);
            
            void registerResourceSaver(std::shared_ptr<AResourceSaver> loader);

            unsigned getNumberOfResources() const;

            unsigned getNumberOfResourceLoaders() const;

            unsigned getNumberOfResourceSavers() const;

            void isFileTypeSupported(std::string const& extension, bool& canLoad, bool& canSave) const;

            void getResourcesOfType(ResourceType type, std::vector<std::string>& resources);

        protected:

            void freeMemorySpace();

            ResourceDetails* findLeastFrequentlyUsed();

            ResourceDetails* findLeastRecentlyUsed();

            ResourceDetails* findSizeAscending();

            ResourceDetails* findSizeDescending();

        private:
            
            std::unordered_map<std::string, std::shared_ptr<ResourceDetails>> m_ResourceMap;
            std::unordered_map<std::string, File> m_FileMap;

            ResourceExplorer      m_ResourceExplorer;
            ResourceLoaderManager m_ResourceLoaderManager;
            ResourceSaverManager  m_ResourceSaverManager;
            ResourceMemoryDetails m_MemoryDetails;
            ResourceDefaults      m_ResourceDefaults;

            ResourcePriorityBehaviour m_PriorityBehaviour;

            uint64_t m_MemoryLimit;

        };
    }
}
//------------------------------------------------------------------------------------------

#endif