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 getSharedInstance(KeyType key);
    void removeSharedInstance(KeyType key);
    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>::getSharedInstance(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;
        }
    });
    return instance;
}
 
template<typename KeyType, typename InstanceType>
void VuoKeyedPool<KeyType,InstanceType>::removeSharedInstance(KeyType key)
{
//  VLog("%s key=%d",instanceTypeString.c_str(),key);
    dispatch_sync(queue, ^{
        pool.erase(key);
    });
}
 
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;
}