Use emplace_back when a new object is being constructed

[libs/gl.git] / source / resources / resourcemanager.cpp

diff --git a/source/resources/resourcemanager.cpp b/source/resources/resourcemanager.cpp
index 4bac0aec841aa1552f3062a42a93f57ea2b7fb31..91b374244090f78397b9cbfe78db63c36c97026b 100644 (file)
--- a/source/resources/resourcemanager.cpp
+++ b/source/resources/resourcemanager.cpp
@@ -3,6 +3,7 @@
 #include <msp/debug/demangle.h>
 #include <msp/strings/format.h>
 #include <msp/time/utils.h>
+#include "error.h"
 #include "resourcemanager.h"
 #include "resources.h"
 #include "resourceobserver.h"
@@ -21,17 +22,6 @@ resource_load_error::resource_load_error(const string &name, const exception &ex
 { }
 
 
-ResourceManager::ResourceManager():
-       policy(LOAD_ON_DEMAND),
-       async_loads(true),
-       total_data_size(0),
-       size_limit(0),
-       frame(0),
-       min_retain_frames(30),
-       max_retain_frames(0),
-       next_unload(0)
-{ }
-
 ResourceManager::~ResourceManager()
 {
        thread.terminate();
@@ -50,7 +40,7 @@ void ResourceManager::set_async_loads(bool a)
        async_loads = a;
 }
 
-void ResourceManager::set_size_limit(UInt64 s)
+void ResourceManager::set_size_limit(uint64_t s)
 {
        size_limit = s;
 }
@@ -67,10 +57,22 @@ void ResourceManager::set_max_retain_frames(unsigned f)
 
 void ResourceManager::add_resource(Resource &r)
 {
+       if(r.get_manager()!=this)
+               throw invalid_operation("ResourceManager::add_resource");
        MutexLock lock(map_mutex);
        insert_unique(resources, &r, ManagedResource(r));
 }
 
+void ResourceManager::move_resource(Resource &from, Resource &to)
+{
+       if(to.get_manager()!=this || from.get_manager_data()!=to.get_manager_data())
+               throw invalid_operation("ResourceManager::move_resource");
+       ManagedResource *managed = reinterpret_cast<ManagedResource *>(to.get_manager_data());
+       MutexLock lock(map_mutex);
+       insert_unique(resources, &to, *managed);
+       resources.erase(&from);
+}
+
 const ResourceManager::ManagedResource &ResourceManager::get_managed_resource(const Resource &r) const
 {
        MutexLock lock(map_mutex);
@@ -214,7 +216,7 @@ void ResourceManager::tick()
 
 void ResourceManager::dispatch_work()
 {
-       queue.sort(age_order);
+       sort(queue, age_order);
 
        if(queue.front()->last_used+min_retain_frames<frame)
        {
@@ -251,11 +253,11 @@ void ResourceManager::unload_by_size()
        while(total_data_size>size_limit)
        {
                ManagedResource *best = 0;
-               UInt64 best_impact = 0;
+               uint64_t best_impact = 0;
                for(auto &kvp: resources)
                        if(kvp.second.state==ManagedResource::LOADED && kvp.second.last_used<unload_limit)
                        {
-                               UInt64 impact = kvp.second.data_size*(frame-kvp.second.last_used);
+                               uint64_t impact = kvp.second.data_size*(frame-kvp.second.last_used);
                                if(!best || impact>best_impact)
                                {
                                        best = &kvp.second;
@@ -401,12 +403,13 @@ void ResourceManager::LoadingThread::main()
                        catch(const exception &e)
                        {
                                MutexLock lock(queue_mutex);
-                               error_queue.push_back(resource_load_error(managed->location.name, e));
+                               error_queue.emplace_back(managed->location.name, e);
                                managed->state = ManagedResource::LOAD_ERROR;
                        }
 
                        MutexLock lock(queue_mutex);
-                       sync_queue.splice(sync_queue.end(), async_queue, async_queue.begin());
+                       sync_queue.push_back(async_queue.front());
+                       async_queue.pop_front();
                        wait_for_work = async_queue.empty();
                }
                else
@@ -414,7 +417,7 @@ void ResourceManager::LoadingThread::main()
        }
 }
 
-ResourceManager::ManagedResource *ResourceManager::LoadingThread::front(list<ManagedResource *> &que)
+ResourceManager::ManagedResource *ResourceManager::LoadingThread::front(deque<ManagedResource *> &que)
 {
        MutexLock lock(queue_mutex);
        if(que.empty())
@@ -519,7 +522,8 @@ bool ResourceManager::LoadingThread::sync()
                {
                        MutexLock lock(queue_mutex);
                        bool was_empty = async_queue.empty();
-                       async_queue.splice(async_queue.end(), sync_queue, sync_queue.begin());
+                       async_queue.push_back(sync_queue.front());
+                       sync_queue.pop_front();
                        if(was_empty)
                                sem.signal();
                }
@@ -528,10 +532,10 @@ bool ResourceManager::LoadingThread::sync()
        return any_finished;
 }
 
-UInt64 ResourceManager::LoadingThread::get_and_reset_loaded_data_size()
+uint64_t ResourceManager::LoadingThread::get_and_reset_loaded_data_size()
 {
        MutexLock lock(data_size_mutex);
-       UInt64 result = loaded_data_size;
+       uint64_t result = loaded_data_size;
        loaded_data_size = 0;
        return result;
 }