-#include <algorithm>
+#include <msp/core/algorithm.h>
#include <typeinfo>
#include <msp/debug/demangle.h>
#include <msp/strings/format.h>
async_loads = a;
}
-void ResourceManager::set_size_limit(UInt64 s)
+void ResourceManager::set_size_limit(uint64_t s)
{
size_limit = s;
}
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
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);
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);
}
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;
}
{
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;
}
}
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;
}
}
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
{
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)
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());
}
}
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
}
}
-ResourceManager::ManagedResource *ResourceManager::LoadingThread::front(LoadQueue &que)
+ResourceManager::ManagedResource *ResourceManager::LoadingThread::front(deque<ManagedResource *> &que)
{
MutexLock lock(queue_mutex);
if(que.empty())
{
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);
{
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();
}
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;
}