RawResourceCollection.h

Go to the documentation of this file.

#pragma once
 
#include "SDL/ISdlReferenceGroup.h"
#include "SDL/sdl_exceptions.h"
#include "Utility/utility.h"
 
#include <Common/assertion.h>
#include <Common/Container/TStdUnorderedStringMap.h>
 
#include <unordered_map>
#include <string>
#include <vector>
#include <type_traits>
#include <cstddef>
#include <utility>
 
namespace ph
{
 
class RawResourceCollection : public ISdlReferenceGroup
{
public:
    std::shared_ptr<ISdlResource> get(std::string_view resourceName) const override;
    bool has(std::string_view resourceName) const override;
 
    void add(
        std::shared_ptr<ISdlResource> resource,
        std::string_view resourceName);
 
    std::shared_ptr<ISdlResource> remove(std::string_view resourceName);
 
    std::string rename(std::string_view resourceName, std::string_view newResourceName);
 
    std::string makeResourceName(std::string_view intendedName);
 
    template<typename T>
    std::vector<std::shared_ptr<T>> getAllOfType(
        std::vector<std::string>* out_resourceNames = nullptr) const;
 
    std::vector<std::shared_ptr<ISdlResource>> getAll(
        std::vector<std::string>* out_resourceNames = nullptr) const;
 
    template<typename T>
    std::vector<const T*> listAllOfType(
        std::vector<std::string>* out_resourceNames = nullptr) const;
 
    std::vector<const ISdlResource*> listAll(
        std::vector<std::string>* out_resourceNames = nullptr) const;
 
private:
    using ResourceMapType = TStdUnorderedStringMap<std::shared_ptr<ISdlResource>>;
 
    ResourceMapType m_nameToResource;
};
 
inline std::shared_ptr<ISdlResource> RawResourceCollection::get(std::string_view resourceName) const
{
    const auto& iter = m_nameToResource.find(resourceName);
    return iter != m_nameToResource.end() ? iter->second : nullptr;
}
 
inline bool RawResourceCollection::has(std::string_view resourceName) const
{
    // Mostly the same as `get(1)`, while saving a copy of shared pointer.
 
    const auto& iter = m_nameToResource.find(resourceName);
    return iter != m_nameToResource.end();
}
 
template<typename T>
inline std::vector<std::shared_ptr<T>> RawResourceCollection::getAllOfType(
    std::vector<std::string>* const out_resourceNames) const
{
    static_assert(std::is_base_of_v<ISdlResource, T>,
        "T is not a SDL resource.");
 
    std::vector<std::shared_ptr<T>> resources;
    for(const auto& [name, resource] : m_nameToResource)
    {
        std::shared_ptr<T> castedResource = std::dynamic_pointer_cast<T>(resource);
        if(castedResource)
        {
            resources.push_back(std::move(castedResource));
 
            if(out_resourceNames)
            {
                out_resourceNames->push_back(name);
            }
        }
    }
    return resources;
}
 
template<typename T>
inline std::vector<const T*> RawResourceCollection::listAllOfType(
    std::vector<std::string>* const out_resourceNames) const
{
    static_assert(std::is_base_of_v<ISdlResource, T>,
        "T is not a SDL resource.");
    
    std::vector<const T*> resources;
    for(const auto& [name, resource] : m_nameToResource)
    {
        T* castedResource = dynamic_cast<T*>(resource.get());
        if(castedResource)
        {
            resources.push_back(castedResource);
 
            if(out_resourceNames)
            {
                out_resourceNames->push_back(name);
            }
        }
    }
    return resources;
}
 
}// end namespace ph