Initial commit

engine/app/src/DataModel/CacheableContentProvider.hpp

@@ -0,0 +1,98 @@
+#pragma once
+
+#include <vector>
+
+#include "Tree/Service.hpp"
+#include "DataModel/ContentProvider.hpp"
+#include "Utility/ContentProviderJob.hpp"
+#include "Utility/ControlledLRUCache.hpp"
+#include <boost/unordered_map.hpp>
+#include <boost/unordered_set.hpp>
+
+typedef boost::unordered_set<std::string> Set;
+
+namespace Aya
+{
+
+extern const char* const sCacheableContentProvider;
+class CacheableContentProvider
+    : public DescribedNonCreatable<CacheableContentProvider, Instance, sCacheableContentProvider, Aya::Reflection::ClassDescriptor::RUNTIME_LOCAL>
+    , public Service
+    , public HeartbeatInstance
+{
+    typedef DescribedNonCreatable<CacheableContentProvider, Instance, sCacheableContentProvider, Aya::Reflection::ClassDescriptor::RUNTIME_LOCAL>
+        Super;
+
+protected:
+    class CachedItem
+    {
+    public:
+        AsyncHttpQueue::RequestResult requestResult;
+        shared_ptr<void> data;
+
+    public:
+        CachedItem(shared_ptr<void> data = shared_ptr<void>(), AsyncHttpQueue::RequestResult result = AsyncHttpQueue::Waiting)
+            : data(data)
+            , requestResult(result)
+        {
+        }
+        ~CachedItem()
+        {
+            data.reset();
+        }
+        friend class CacheableContentProvider;
+    };
+
+    shared_ptr<ContentProviderJob> contentJob;
+    Aya::atomic<int> pendingRequests;
+    bool immediateMode;
+
+    boost::scoped_ptr<ConcurrentControlledLRUCache<std::string, boost::shared_ptr<CachedItem>>> lruCache;
+
+    boost::mutex failedCacheMutex;
+    Set failedCache;
+
+public:
+    CacheableContentProvider(CacheSizeEnforceMethod enforceMethod, unsigned long size);
+    virtual ~CacheableContentProvider();
+
+    void setCacheSize(int size);
+    void setImmediateMode();
+    bool isRequestQueueEmpty()
+    {
+        return pendingRequests == 0;
+    }
+
+    bool clearContent();
+
+    bool hasContent(const ContentId& id);
+    boost::shared_ptr<void> requestContent(const ContentId& id, float priority, bool markUsed, AsyncHttpQueue::RequestResult& result);
+    boost::shared_ptr<void> blockingRequestContent(const ContentId& id, bool markUsed);
+    boost::shared_ptr<void> fetchContent(const ContentId& id);
+
+    bool isAssetFailed(const ContentId& id);
+
+    // HeartbeatInstance
+    /*override*/ void onHeartbeat(const Heartbeat& event);
+    /*override*/ void onServiceProvider(ServiceProvider* oldProvider, ServiceProvider* newProvider);
+
+protected:
+    static void LoadContentCallbackHelper(boost::weak_ptr<CacheableContentProvider> cacheableContentProvider, AsyncHttpQueue::RequestResult result,
+        std::istream* filestream, shared_ptr<const std::string> data, std::string id);
+    void LoadContentCallback(AsyncHttpQueue::RequestResult result, std::istream* filestream, shared_ptr<const std::string> data, std::string id);
+
+    static TaskScheduler::StepResult ProcessTaskHelper(
+        boost::weak_ptr<CacheableContentProvider> weakCcp, const std::string& id, shared_ptr<const std::string> data);
+    virtual TaskScheduler::StepResult ProcessTask(const std::string& id, shared_ptr<const std::string> data) = 0;
+
+    static void ErrorTaskHelper(boost::weak_ptr<CacheableContentProvider> weakCcp, const std::string& id);
+    virtual void ErrorTask(const std::string& id);
+
+    bool isAssetContent(ContentId id);
+    void markContentFailed(const std::string& id);
+    AsyncHttpQueue::RequestResult getContentStatus(const std::string& id);
+
+    virtual void updateContent(const std::string& id, boost::shared_ptr<CachedItem> cachedItem);
+};
+
+} // namespace Aya