VuoPool.hh

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <map>
#include <dispatch/dispatch.h>
 
template<typename KeyType, typename InstanceType>
class VuoKeyedPool
{
public:
    typedef InstanceType (*AllocateFunctionType)(KeyType);
 
    VuoKeyedPool(std::string instanceTypeString, AllocateFunctionType allocate);
    InstanceType useSharedInstance(KeyType key);
    void disuseSharedInstance(InstanceType instance);
    void visit(void (^b)(KeyType,InstanceType));
    unsigned int size(void);
 
private:
    std::string instanceTypeString; 
    AllocateFunctionType allocate;  
    dispatch_queue_t queue;         
    typedef std::map<KeyType,InstanceType> PoolType;
    PoolType pool;
};
 
#define VUOKEYEDPOOL(keyType,instanceType) extern VuoKeyedPool<keyType, instanceType> * instanceType ## Pool
 
#define VUOKEYEDPOOL_DEFINE(keyType,instanceType,allocate) VuoKeyedPool<keyType, instanceType> * instanceType ## Pool = new VuoKeyedPool<keyType, instanceType>(#instanceType, allocate)
 
template<typename KeyType, typename InstanceType>
VuoKeyedPool<KeyType,InstanceType>::VuoKeyedPool(std::string instanceTypeString, AllocateFunctionType allocate)
{
//  VLog("%s",instanceTypeString.c_str());
    this->instanceTypeString = instanceTypeString;
    this->allocate = allocate;
    this->queue = dispatch_queue_create(instanceTypeString.c_str(), NULL);
}
 
template<typename KeyType, typename InstanceType>
InstanceType VuoKeyedPool<KeyType,InstanceType>::useSharedInstance(KeyType key)
{
//  VLog("%s key=%d",instanceTypeString.c_str(),key);
    __block InstanceType instance;
    dispatch_sync(queue, ^{
        typename PoolType::iterator it = pool.find(key);
        if (it != pool.end())
            instance = it->second;
        else
        {
            instance = allocate(key);
            pool[key] = instance;
        }
 
        VuoRetain(instance);
    });
    return instance;
}
 
template<typename KeyType, typename InstanceType>
void VuoKeyedPool<KeyType,InstanceType>::disuseSharedInstance(InstanceType instance)
{
    if (!instance)
        return;
 
//  VLog("%s key=%d",instanceTypeString.c_str(),key);
    dispatch_sync(queue, ^{
        for (auto it = pool.begin(); it != pool.end(); ++it)
            if (it->second == instance)
            {
                int referenceCount = VuoRelease(it->second);
                if (referenceCount == 0)
                {
                    pool.erase(it);
                    break;
                }
            }
    });
}
 
template<typename KeyType, typename InstanceType>
void VuoKeyedPool<KeyType,InstanceType>::visit(void (^b)(KeyType,InstanceType))
{
    dispatch_sync(queue, ^{
        for (typename PoolType::iterator i = pool.begin(); i != pool.end(); ++i)
            b(i->first, i->second);
    });
}
 
template<typename KeyType, typename InstanceType>
unsigned int VuoKeyedPool<KeyType,InstanceType>::size(void)
{
    __block unsigned int c;
    dispatch_sync(queue, ^{
        c = pool.size();
    });
    return c;
}