resourceserver.h

Go to the documentation of this file.

#pragma once
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#include <functional>
#include "core/refcounted.h"
#include "ids/id.h"
#include "core/singleton.h"
#include "resourceid.h"
#include "resourceloader.h"
#include "resourceloaderthread.h"
#include "io/urn.h"
#include "io/path.h"
#include "io/assignregistry.h"
#include "db/dbfactory.h"
#include "db/database.h"
 
namespace Resources
{
class ResourceServer : public Core::RefCounted
{
    __DeclareClass(ResourceServer);
    __DeclareInterfaceSingleton(ResourceServer);
public:
    ResourceServer();
    virtual ~ResourceServer();

    void Open();
    void Close();

    void Update(IndexT frameIndex);

    Resources::ResourceId CreateResource(const ResourceName& res, std::function<void(const Resources::ResourceId)> success = nullptr, std::function<void(const Resources::ResourceId)> failed = nullptr, bool immediate = false, bool stream = true);
    Resources::ResourceId CreateResource(const ResourceName& res, const Util::StringAtom& tag, std::function<void(const Resources::ResourceId)> success = nullptr, std::function<void(const Resources::ResourceId)> failed = nullptr, bool immediate = false, bool stream = true);
    template<class METADATA> Resources::ResourceId CreateResource(const ResourceName& res, const METADATA& metaData, std::function<void(const Resources::ResourceId)> success = nullptr, std::function<void(const Resources::ResourceId)> failed = nullptr, bool immediate = false, bool stream = true);
    template<class METADATA> Resources::ResourceId CreateResource(const ResourceName& res, const METADATA& metaData, const Util::StringAtom& tag, std::function<void(const Resources::ResourceId)> success = nullptr, std::function<void(const Resources::ResourceId)> failed = nullptr, bool immediate = false, bool stream = true);

    Resources::ResourceId CreateResource(const IO::Path& res, std::function<void(const Resources::ResourceId)> success = nullptr, std::function<void(const Resources::ResourceId)> failed = nullptr, bool immediate = false, bool stream = true);
    Resources::ResourceId CreateResource(const IO::Path& res, const Util::StringAtom& tag, std::function<void(const Resources::ResourceId)> success = nullptr, std::function<void(const Resources::ResourceId)> failed = nullptr, bool immediate = false, bool stream = true);
    template<class METADATA> Resources::ResourceId CreateResource(const IO::Path& res, const METADATA& metaData, std::function<void(const Resources::ResourceId)> success = nullptr, std::function<void(const Resources::ResourceId)> failed = nullptr, bool immediate = false, bool stream = true);
    template<class METADATA> Resources::ResourceId CreateResource(const IO::Path& res, const METADATA& metaData, const Util::StringAtom& tag, std::function<void(const Resources::ResourceId)> success = nullptr, std::function<void(const Resources::ResourceId)> failed = nullptr, bool immediate = false, bool stream = true);

    void DiscardResource(const Resources::ResourceId res);
    void DiscardResources(const Util::StringAtom& tag);
    bool HasPendingResources();
    void ReloadResource(const ResourceName& res, std::function<void(const Resources::ResourceId)> success = nullptr, std::function<void(const Resources::ResourceId)> failed = nullptr);
    void SetMinLod(const ResourceId& id, float lod, bool immediate);
    void CreateResourceListener(const ResourceId& id, std::function<void(const Resources::ResourceId)> success, std::function<void(const Resources::ResourceId)> failed = nullptr);

    Core::Rtti* GetType(const Resources::ResourceId id);

    const Resources::ResourceName GetName(const Resources::ResourceId id) const;
    const Util::StringAtom GetTag(const Resources::ResourceId id) const;
    const Resource::State GetState(const Resources::ResourceId id) const;
    const SizeT GetUsage(const Resources::ResourceId id) const;
    bool HasResource(const Resources::ResourceId id) const;
    const Resources::ResourceId GetId(const Resources::ResourceName& name) const;

    void RegisterStreamLoader(const Util::StringAtom& ext, const Ptr<ResourceLoader>& loader);
    void DeregisterStreamLoader(const Util::StringAtom& ext, const Ptr<ResourceLoader>& loader);
    template <class POOL_TYPE> POOL_TYPE* GetStreamLoader() const;
    bool HasStreamLoader(const Util::StringAtom& ext) const;
    bool HasStreamLoader(const IO::URN& urn) const;
    bool HasStreamLoader(const IO::Path& path) const;

    void WaitForLoaderThread();

    void LoadDefaultResources();
private:
    friend class ResourceLoader;
 
    bool open;
    Util::Dictionary<Util::StringAtom, IndexT> extensionMap;
    Util::Dictionary<Util::StringAtom, IndexT> loaderMap;
    Util::Dictionary<const Core::Rtti*, IndexT> typeMap;
    Util::Array<Ptr<ResourceLoader>> loaders;
};
 
//------------------------------------------------------------------------------
inline Resources::ResourceId
Resources::ResourceServer::CreateResource(
    const ResourceName& id
    , std::function<void(const Resources::ResourceId)> success
    , std::function<void(const Resources::ResourceId)> failed
    , bool immediate
    , bool stream
)
{
    return this->CreateResource(id, "", success, failed, immediate, stream);
}
 
//------------------------------------------------------------------------------
inline Resources::ResourceId
Resources::ResourceServer::CreateResource(
    const ResourceName& res
    , const Util::StringAtom& tag
    , std::function<void(const Resources::ResourceId)> success
    , std::function<void(const Resources::ResourceId)> failed
    , bool immediate
    , bool stream
)
{
    // get resource loader by extension
    Util::String ext = res.AsString().GetFileExtension();
    IndexT i = this->extensionMap.FindIndex(ext);
    n_warn_fmt(i != InvalidIndex, "No resource loader is associated with file extension '%s'", ext.AsCharPtr());
    if (i == InvalidIndex)
        return Resources::InvalidResourceId;
    const Ptr<ResourceLoader>& loader = this->loaders[this->extensionMap.ValueAtIndex(i)].downcast<ResourceLoader>();
 
    // create container and cast to actual resource type
    Resources::ResourceId id = loader->CreateResource(IO::URI(res.AsString()), nullptr, 0, tag, success, failed, immediate, stream);
    return id;
}
 
//------------------------------------------------------------------------------
inline Resources::ResourceId
ResourceServer::CreateResource(
    const IO::Path& res,
    std::function<void(const Resources::ResourceId)> success,
    std::function<void(const Resources::ResourceId)> failed,
    bool immediate,
    bool stream
)
{
    return CreateResource(res, "", success, failed, immediate, stream);
}
 
//------------------------------------------------------------------------------
inline Resources::ResourceId
ResourceServer::CreateResource(
    const IO::Path& res,
    const Util::StringAtom& tag,
    std::function<void(const Resources::ResourceId)> success,
    std::function<void(const Resources::ResourceId)> failed,
    bool immediate,
    bool stream
)
{
    // get resource loader by extension
    IndexT i = this->extensionMap.FindIndex(res.GetType());
    n_assert_fmt(i != InvalidIndex, "No resource loader is associated with URN namespace '%s'", res.GetType().AsCharPtr());
    const Ptr<ResourceLoader>& loader = this->loaders[this->extensionMap.ValueAtIndex(i)].downcast<ResourceLoader>();
 
    // create container and cast to actual resource type
    Resources::ResourceId id = loader->CreateResource(res, nullptr, 0, tag, success, failed, immediate, stream);
    return id;
}
 
//------------------------------------------------------------------------------
template<class METADATA>
inline Resources::ResourceId
ResourceServer::CreateResource(
    const ResourceName& res
    , const METADATA& metaData
    , std::function<void(const Resources::ResourceId)> success
    , std::function<void(const Resources::ResourceId)> failed
    , bool immediate
    , bool stream
)
{
    return this->CreateResource(res, metaData, "", success, failed, immediate, stream);
}
 
//------------------------------------------------------------------------------
template<class METADATA>
inline Resources::ResourceId
ResourceServer::CreateResource(
    const ResourceName& res
    , const METADATA& metaData
    , const Util::StringAtom& tag
    , std::function<void(const Resources::ResourceId)> success
    , std::function<void(const Resources::ResourceId)> failed
    , bool immediate
    , bool stream
)
{
    // get resource loader by extension
    Util::String ext = res.AsString().GetFileExtension();
    IndexT i = this->extensionMap.FindIndex(ext);
    n_warn_fmt(i != InvalidIndex, "No resource loader is associated with file extension '%s'", ext.AsCharPtr());
    if (i == InvalidIndex)
        return Resources::InvalidResourceId;
    const Ptr<ResourceLoader>& loader = this->loaders[this->extensionMap.ValueAtIndex(i)].downcast<ResourceLoader>();
 
    // create container and cast to actual resource type
    Resources::ResourceId id = loader->CreateResource(IO::URI(res.Value()), &metaData, sizeof(METADATA), tag, success, failed, immediate, stream);
    return id;
}
 
//------------------------------------------------------------------------------
inline void
ResourceServer::ReloadResource(const ResourceName& res, std::function<void(const Resources::ResourceId)> success, std::function<void(const Resources::ResourceId)> failed)
{
    // get resource loader by extension
    Util::String ext = res.AsString().GetFileExtension();
    IndexT i = this->extensionMap.FindIndex(ext);
    n_warn_fmt(i != InvalidIndex, "No resource loader is associated with file extension '%s'", ext.AsCharPtr());
    if (i == InvalidIndex)
        return;
    const Ptr<ResourceLoader>& loader = this->loaders[this->extensionMap.ValueAtIndex(i)].downcast<ResourceLoader>();
 
    // create container and cast to actual resource type
    loader->ReloadResource(res, success, failed);
}
 
//------------------------------------------------------------------------------
inline bool 
ResourceServer::HasStreamLoader(const Util::StringAtom& ext) const
{
    IndexT i = this->extensionMap.FindIndex(ext);
    return i != InvalidIndex;
}
 
//------------------------------------------------------------------------------
inline bool
ResourceServer::HasStreamLoader(const IO::URN& urn) const
{
    IndexT i = this->extensionMap.FindIndex(urn.GetNamespace());
    return i != InvalidIndex;
}
 
//------------------------------------------------------------------------------
inline bool
ResourceServer::HasStreamLoader(const IO::Path& path) const
{
    IndexT i = this->extensionMap.FindIndex(path.GetType());
    return i != InvalidIndex;
}
 
//------------------------------------------------------------------------------
inline void 
ResourceServer::SetMinLod(const ResourceId& id, float lod, bool immediate)
{
    // get id of loader
    const Ids::Id8 loaderid = id.loaderIndex;
 
    // get resource loader by extension
    n_assert(this->loaders.Size() > loaderid);
    const Ptr<ResourceLoader>& loader = this->loaders[loaderid].downcast<ResourceLoader>();
 
    // update LOD
    loader->SetMinLod(id, lod, immediate);
}
 
//------------------------------------------------------------------------------
inline void
ResourceServer::CreateResourceListener(
    const ResourceId& id,
    std::function<void(const Resources::ResourceId)> success,
    std::function<void(const Resources::ResourceId)> failed
)
{
    // get id of loader
    const Ids::Id8 loaderid = id.loaderIndex;
 
    // get resource loader by extension
    n_assert(this->loaders.Size() > loaderid);
    const Ptr<ResourceLoader>& loader = this->loaders[loaderid].downcast<ResourceLoader>();
 
    loader->CreateListener(id, success, failed);
}
 
//------------------------------------------------------------------------------
inline void
ResourceServer::DiscardResource(const Resources::ResourceId id)
{
    // get id of loader
    const Ids::Id8 loaderid = id.loaderIndex;
 
    // get resource loader by extension
    n_assert(this->loaders.Size() > loaderid);
    const Ptr<ResourceLoader>& loader = this->loaders[loaderid].downcast<ResourceLoader>();
 
    // discard container
    loader->DiscardResource(id);
}
 
//------------------------------------------------------------------------------
inline const Resources::ResourceName
ResourceServer::GetName(const Resources::ResourceId id) const
{
    // get resource loader by extension
    n_assert(this->loaders.Size() > id.loaderIndex);
    const Ptr<ResourceLoader>& loader = this->loaders[id.loaderIndex];
    return loader->GetName(id);
}
 
//------------------------------------------------------------------------------
inline const Util::StringAtom
ResourceServer::GetTag(const Resources::ResourceId id) const
{
    // get resource loader by extension
    n_assert(this->loaders.Size() > id.loaderIndex);
    const Ptr<ResourceLoader>& loader = this->loaders[id.loaderIndex];
    return loader->GetTag(id);
}
 
//------------------------------------------------------------------------------
inline const Resources::Resource::State
ResourceServer::GetState(const Resources::ResourceId id) const
{
    // get resource loader by extension
    n_assert(this->loaders.Size() > id.loaderIndex);
    const Ptr<ResourceLoader>& loader = this->loaders[id.loaderIndex];
    return loader->GetState(id);
}
 
//------------------------------------------------------------------------------
inline const SizeT
ResourceServer::GetUsage(const Resources::ResourceId id) const
{
    // get resource loader by extension
    n_assert(this->loaders.Size() > id.loaderIndex);
    const Ptr<ResourceLoader>& loader = this->loaders[id.loaderIndex];
    return loader->GetUsage(id);
}
 
//------------------------------------------------------------------------------
inline bool
ResourceServer::HasResource(const Resources::ResourceId id) const
{
    if (this->loaders.Size() <= id.loaderIndex) return false;
    {
        const Ptr<ResourceLoader>& loader = this->loaders[id.loaderIndex];
        if (loader->HasResource(id)) return true;
        return false;       
    }
}
 
//------------------------------------------------------------------------------
inline const Resources::ResourceId
ResourceServer::GetId(const Resources::ResourceName& name) const
{
    IndexT i;
    for (i = 0; i < this->loaders.Size(); i++)
    {
        Resources::ResourceId id = this->loaders[i]->GetId(name);
        if (id != Resources::ResourceId::Invalid()) return id;
    }
    return Resources::ResourceId::Invalid();
}
 
//------------------------------------------------------------------------------
template <class POOL_TYPE>
inline POOL_TYPE*
ResourceServer::GetStreamLoader() const
{
    static_assert(std::is_base_of<ResourceLoader, POOL_TYPE>::value, "Type requested is not a stream pool");
    IndexT i = this->typeMap.FindIndex(&POOL_TYPE::RTTI);
    if (i != InvalidIndex)
    {
        return static_cast<POOL_TYPE*>(this->loaders[this->typeMap.ValueAtIndex(i)].get());
    }
 
    n_error("No loader registered for this type");
    return nullptr;
}
 
//------------------------------------------------------------------------------
inline Resources::ResourceId
CreateResource(
    const ResourceName& res
    , const Util::StringAtom& tag
    , std::function<void(const Resources::ResourceId)> success = nullptr
    , std::function<void(const Resources::ResourceId)> failed = nullptr
    , bool immediate = false
    , bool stream = true
)
{
    return ResourceServer::Instance()->CreateResource(res, tag, success, failed, immediate, stream);
}
 
//------------------------------------------------------------------------------
template <class METADATA>
inline Resources::ResourceId
CreateResource(
    const ResourceName& res
    , const METADATA& metaData
    , const Util::StringAtom& tag
    , std::function<void(const Resources::ResourceId)> success = nullptr
    , std::function<void(const Resources::ResourceId)> failed = nullptr
    , bool immediate = false
    , bool stream = true
)
{
    return ResourceServer::Instance()->CreateResource(res, metaData, tag, success, failed, immediate, stream);
}
 
//------------------------------------------------------------------------------
inline Resources::ResourceId
CreateResource(
    const IO::Path& res,
    const Util::StringAtom& tag,
    std::function<void(const Resources::ResourceId)> success = nullptr,
    std::function<void(const Resources::ResourceId)> failed = nullptr,
    bool immediate = false,
    bool stream = true
)
{
    return ResourceServer::Instance()->CreateResource(res, tag, success, failed, immediate, stream);
}
 
//------------------------------------------------------------------------------
inline void
CreateResourceListener(
    const ResourceId& id
    , std::function<void(const Resources::ResourceId)> success
    , std::function<void(const Resources::ResourceId)> failed = nullptr
)
{
    return ResourceServer::Instance()->CreateResourceListener(id, success, failed);
}
 
//------------------------------------------------------------------------------
inline void
SetMinLod(const ResourceId& id, float lod, bool immediate)
{
    return ResourceServer::Instance()->SetMinLod(id, lod, immediate);
}
 
//------------------------------------------------------------------------------
inline void
DiscardResource(const Resources::ResourceId id)
{
    ResourceServer::Instance()->DiscardResource(id);
}
 
//------------------------------------------------------------------------------
inline void 
ReloadResource(const ResourceName& res)
{
    return ResourceServer::Instance()->ReloadResource(res);
}
 
//------------------------------------------------------------------------------
inline void
WaitForLoaderThread()
{
    ResourceServer::Instance()->WaitForLoaderThread();
}
 
//------------------------------------------------------------------------------
template <class POOL_TYPE>
inline POOL_TYPE*
GetStreamLoader()
{
    static_assert(std::is_base_of<ResourceLoader, POOL_TYPE>::value, "Template argument is not a ResourceCache type!");
    return ResourceServer::Instance()->GetStreamLoader<POOL_TYPE>();
}
 
} // namespace Resources