ObjectPool with external Instance Creation - c++

Question

I try to modify an existing object pool class so that I am able to pass an instance creator class as an argument to the object pool. Basically I want to be able to keep the actual object construction out of the memory pool so I have more freedom in what way I create instances to be pooled.
Here is the object pool definition:
template <
typename T,
typename InstanceCreator = DefaultInstanceFactory<T>
>
class ObjectPool : private noncopyable {
...
}
So I would create an ObjectPool like this
ObjectPool<int> intPool((DefaultInstanceFactory<int>()));
or
ObjectPool<IntClass, IntClass::InstanceFactory> intPool (IntClass::InstanceFactory (1));
The default Instance creator looks like this
template <typename T>
class DefaultInstanceFactory {
public:
T * operator ()() const {
return new T;
}
};
Inside that ObjectPool class is a nested class that stores the items
class PooledItem {
public:
char data[OBJECT_SIZE];
PooledItem * next;
bool initialized;
PooledItem()
: initialized(false) {}
~PooledItem() {
// --- call T destructor
if (initialized)
cast()->~T();
}
T * cast() {
return reinterpret_cast<T *>(data);
};
};
There is a borrowObject method to acquire an object and here is my actual problem:
T * borrowObject() {
PooledItem * item = getItem();
T * obj = item->cast();
if (! item->initialized) {
// old original line, call the defaut constructor of T
new (obj) T();
// how to integrate the external Instance Creator at this point?
//new (instCreator_ ()) T(1);
//instCreator_ ();
item->initialized = true;
}
if (obj == NULL) {
throw ObjectPoolException(
"Object is NULL!", __FILE__, __LINE__, __FUNCTION__);
}
return obj;
}
In above method I marked the actual problem lines. I have no idea how to replace the placement new new (obj) T() line with the external Instance creator, to just reuse that memory.
For completeness, the method for returning an object to the pool looks like this
void returnObject(T * obj) {
// --- Get containing PooledItem pointer
PooledItem * item = reinterpret_cast<PooledItem *>(obj);
// --- Make sure object came from this pool
if (item->next != reinterpret_cast<PooledItem *>(this)) {
// throw Exception
}
// --- Destroy object now if we want to reconstruct it later
if (destroyOnRelease) {
item->cast()->~T();
item->initialized = false;
}
Could anybody give me some help how to modify the methods so that the external Instance Creator gets integrated properly? I do not know up to now, if I need to change something in the returnObject method, up to now I think not.
Appreciate your help!

Answer 1

Sounds like you need to change InstanceFactory's signature to take a pointer
template <typename T>
class DefaultInstanceFactory {
public:
void operator ()(T* out) const {
return new(out) T;
}
};