Use standard fixed-size integer types

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

diff --git a/source/resources/resourcemanager.cpp b/source/resources/resourcemanager.cpp
index 30f75013252fe2397819cb5cb5a49330e54347de..5358183f24bc5a39d156b6f9bcab1c87136bac31 100644 (file)
--- a/source/resources/resourcemanager.cpp
+++ b/source/resources/resourcemanager.cpp
@@ -1,4 +1,4 @@
-#include <algorithm>
+#include <msp/core/algorithm.h>
 #include <typeinfo>
 #include <msp/debug/demangle.h>
 #include <msp/strings/format.h>
@@ -50,7 +50,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;
 }
@@ -118,8 +118,7 @@ void ResourceManager::load_resource(Resource &r)
        if(async_loads)
        {
                managed.state = ManagedResource::LOAD_QUEUED;
-               LoadQueue::iterator i;
-               for(i=queue.begin(); (i!=queue.end() && (*i)->load_priority>=managed.load_priority); ++i) ;
+               auto i = find_if(queue, [&managed](ManagedResource *q){ return q->load_priority>managed.load_priority; });
                queue.insert(i, &managed);
        }
        else
@@ -156,15 +155,15 @@ void ResourceManager::remove_resource(Resource &r)
        ManagedResource::State state = managed.state;
        if(state==ManagedResource::LOAD_QUEUED)
        {
-               LoadQueue::iterator i = find(queue.begin(), queue.end(), &managed);
+               auto i = find(queue, &managed);
                if(i!=queue.end())
                        queue.erase(i);
        }
        else if(state>ManagedResource::LOAD_QUEUED && state<ManagedResource::LOADED)
                thread.remove_resource(managed);
 
-       for(vector<ResourceObserver *>::const_iterator i=managed.observers.begin(); i!=managed.observers.end(); ++i)
-               (*i)->resource_removed(r);
+       for(ResourceObserver *o: managed.observers)
+               o->resource_removed(r);
 
        MutexLock lock(map_mutex);
        remove_existing(resources, &r);
@@ -202,9 +201,9 @@ void ResourceManager::tick()
                        unload_by_age();
 
                        next_unload = frame;
-                       for(ResourceMap::iterator i=resources.begin(); i!=resources.end(); ++i)
-                               if(i->second.state==ManagedResource::LOADED)
-                                       next_unload = min(next_unload, i->second.last_used);
+                       for(const auto &kvp: resources)
+                               if(kvp.second.state==ManagedResource::LOADED)
+                                       next_unload = min(next_unload, kvp.second.last_used);
                        next_unload = (next_unload<frame ? next_unload+max_retain_frames : 0);
                }
 
@@ -215,12 +214,12 @@ void ResourceManager::tick()
 
 void ResourceManager::dispatch_work()
 {
-       queue.sort(age_order);
+       sort(queue, age_order);
 
        if(queue.front()->last_used+min_retain_frames<frame)
        {
-               for(LoadQueue::iterator i=queue.begin(); i!=queue.end(); ++i)
-                       (*i)->state = ManagedResource::NOT_LOADED;
+               for(ManagedResource *r: queue)
+                       r->state = ManagedResource::NOT_LOADED;
                queue.clear();
                return;
        }
@@ -237,11 +236,11 @@ void ResourceManager::unload_by_age()
 {
        unsigned unload_limit = frame-max_retain_frames;
 
-       for(ResourceMap::iterator i=resources.begin(); i!=resources.end(); ++i)
-               if(i->second.state==ManagedResource::LOADED && i->second.last_used<unload_limit)
+       for(auto &kvp: resources)
+               if(kvp.second.state==ManagedResource::LOADED && kvp.second.last_used<unload_limit)
                {
-                       i->second.unload();
-                       total_data_size -= i->second.data_size;
+                       kvp.second.unload();
+                       total_data_size -= kvp.second.data_size;
                }
 }
 
@@ -252,14 +251,14 @@ void ResourceManager::unload_by_size()
        while(total_data_size>size_limit)
        {
                ManagedResource *best = 0;
-               UInt64 best_impact = 0;
-               for(ResourceMap::iterator i=resources.begin(); i!=resources.end(); ++i)
-                       if(i->second.state==ManagedResource::LOADED && i->second.last_used<unload_limit)
+               uint64_t best_impact = 0;
+               for(auto &kvp: resources)
+                       if(kvp.second.state==ManagedResource::LOADED && kvp.second.last_used<unload_limit)
                        {
-                               UInt64 impact = i->second.data_size*(frame-i->second.last_used);
+                               uint64_t impact = kvp.second.data_size*(frame-kvp.second.last_used);
                                if(!best || impact>best_impact)
                                {
-                                       best = &i->second;
+                                       best = &kvp.second;
                                        best_impact = impact;
                                }
                        }
@@ -336,8 +335,8 @@ void ResourceManager::ManagedResource::finish_loading(bool successful)
                state = LOADED;
                data_size = resource->get_data_size();
 
-               for(vector<ResourceObserver *>::const_iterator i=observers.begin(); i!=observers.end(); ++i)
-                       (*i)->resource_loaded(*resource);
+               for(ResourceObserver *o: observers)
+                       o->resource_loaded(*resource);
        }
        else
        {
@@ -356,8 +355,8 @@ void ResourceManager::ManagedResource::unload()
        resource->unload();
        state = NOT_LOADED;
 
-       for(vector<ResourceObserver *>::const_iterator i=observers.begin(); i!=observers.end(); ++i)
-               (*i)->resource_unloaded(*resource);
+       for(ResourceObserver *o: observers)
+               o->resource_unloaded(*resource);
 }
 
 void ResourceManager::ManagedResource::add_observer(ResourceObserver &w)
@@ -368,7 +367,7 @@ void ResourceManager::ManagedResource::add_observer(ResourceObserver &w)
 
 void ResourceManager::ManagedResource::remove_observer(ResourceObserver &w)
 {
-       vector<ResourceObserver *>::iterator end = remove(observers.begin(), observers.end(), &w);
+       auto end = remove(observers.begin(), observers.end(), &w);
        if(end!=observers.end())
                observers.erase(end, observers.end());
 }
@@ -407,7 +406,8 @@ void ResourceManager::LoadingThread::main()
                        }
 
                        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
@@ -415,7 +415,7 @@ void ResourceManager::LoadingThread::main()
        }
 }
 
-ResourceManager::ManagedResource *ResourceManager::LoadingThread::front(LoadQueue &que)
+ResourceManager::ManagedResource *ResourceManager::LoadingThread::front(deque<ManagedResource *> &que)
 {
        MutexLock lock(queue_mutex);
        if(que.empty())
@@ -459,10 +459,10 @@ bool ResourceManager::LoadingThread::try_remove_resource(ManagedResource &r)
 {
        MutexLock lock(queue_mutex);
 
-       LoadQueue::iterator i = find(async_queue.begin(), async_queue.end(), &r);
+       auto i = find(async_queue, &r);
        if(i==async_queue.end())
        {
-               i = find(sync_queue.begin(), sync_queue.end(), &r);
+               i = find(sync_queue, &r);
                if(i!=sync_queue.end())
                {
                        sync_queue.erase(i);
@@ -520,7 +520,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();
                }
@@ -529,10 +530,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;
 }