Use C++11 features with containers

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

diff --git a/source/resources/resourcemanager.cpp b/source/resources/resourcemanager.cpp
index 30f75013252fe2397819cb5cb5a49330e54347de..4bac0aec841aa1552f3062a42a93f57ea2b7fb31 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>
@@ -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);
                }
 
@@ -219,8 +218,8 @@ void ResourceManager::dispatch_work()
 
        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;
                }
 }
 
@@ -253,13 +252,13 @@ void ResourceManager::unload_by_size()
        {
                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)
+               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 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());
 }
@@ -415,7 +414,7 @@ void ResourceManager::LoadingThread::main()
        }
 }
 
-ResourceManager::ManagedResource *ResourceManager::LoadingThread::front(LoadQueue &que)
+ResourceManager::ManagedResource *ResourceManager::LoadingThread::front(list<ManagedResource *> &que)
 {
        MutexLock lock(queue_mutex);
        if(que.empty())
@@ -459,10 +458,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);