variant_pool
This template class allows instances of multiple derived types to be constructed from a common store.
C++03
It may support up to 16 types and MAX_SIZE instances.
template <const size_t MAX_SIZE,
typename T1, typename T2 = void, typename T3 = void, typename T4 = void,
typename T5 = void, typename T6 = void, typename T7 = void, typename T8 = void,
typename T9 = void, typename T10 = void, typename T11 = void, typename T12 = void,
typename T13 = void, typename T14 = void, typename T15 = void, typename T16 = void>C++11 and above
It supports a variable number of types and MAX_SIZE instances.
template <size_t MAX_SIZE_, typename... Ts>
class variant_pooltemplate <typename... Ts>
class variant_pool_ext : public etl::generic_pool_ext<etl::largest<Ts...>::size, etl::largest<Ts...>::alignment>Note: The caller of the pools’s create becomes the owner of the instance. It must call destroy.
Constants
MAX_SIZE
The maximum number of instances that may be created.
Member functions
template <typename T>
T* create()C++03
template <typename T, typename TP1>
T* create(const TP1& p1)
template <typename T, typename TP1, typename TP2>
T* create(const TP1& p1, const TP2& p2)
template <typename T, typename TP1, typename TP2, typename TP3>
T* create(const TP1& p1, const TP2& p2, const TP3& p3)
template <typename T, typename TP1, typename TP2, typename TP3, typename TP4>
T* create(const TP1& p1, const TP2& p2, const TP3& p3, const TP4& p4)Creates an instance of T with zero to four constructor parameters. The parameters are forwarded to T’s constructor.
Returns a pointer to the constructed instance or nullptr.
If T if not one of those declared in the template parameter list then a compile time error will occur.
If T cannot be created due to there being no spare capacity then an etl::pool_element_size is emitted. If exceptions are not configured to be thrown then the function returns nullptr.
C++11 and above
template <typename T, typename… Args>
T* create(Args&&… args)
Description
Creates an instance of T with the supplied parameters. The parameters are forwarded to T’s constructor.
Returns a pointer to the constructed instance or nullptr.
If T if not one of those declared in the template parameter list then a compile time error will occur.
If T cannot be created due to there being no spare capacity then an etl::pool_element_size is emitted. If exceptions are not configured to be thrown then the function returns nullptr.
bool destroy(const T* const p)Description
Destroys the instance pointed to by p.
Compile time error if T is not one of, or not a base of, one the supported types.
If the pool is empty or p does not belong to it then an etl::pool_object_not_in_pool is emitted.
If exceptions are not configured to be thrown then the function returns true for success and false for failure.
size_t max_size() constDescription
Returns the maximum number of items in the pool.
size_t available() constDescription
Returns the number of free items in the pool.
size_t size() constDescription
Returns the number of allocated items in the pool.
bool empty() constDescription
Checks to see if there are no allocated items in the pool.
bool full() constDescription
Checks to see if there are no free items in the pool.
Example
//***********************************
struct Base
{
virtual ~Base()
{
}
};
//***********************************
struct Derived1 : public Base
{
enum
{
ID = 1
};
};
//***********************************
struct Derived2 : public Base
{
enum
{
ID = 2
};
Derived2(int a_)
: a(a_)
{
}
int a;
};
//***********************************
struct Derived3 : public Base
{
enum
{
ID = 3
};
Derived3(int a_, double b_)
: a(a_),
b(b_)
{
}
int a;
double b;
}
//***********************************
struct Derived4 : public Base
{
enum
{
ID = 4
};
};
// A pool that can create up to three instances of Derived1, Derived2, Derived3.
// Notice that the types can be declared in any order.
typedef etl::variant_pool<3, Derived1, Derived3, Derived2> VariantPool;
VariantPool pool;
// Create an instance of Derived1.
Derived1* pb1 = pool.create<Derived1>();
// Create an instance of Derived2 from its id, with constructor parameter 3.
Derived2* pb2 = pool.create<Derived2>(3);
// Create an instance of Derived3 with constructor parameters 4 and 1.2.
Derived3* pb3 = pool.create<Derived3>(4, 1.2);
// Create an instance of Derived4.
Derived4* pb4 = pool.create<Derived4>(); // Compile time error.
// Destroy the instances.
pool.destroy(pb2);
pool.destroy(pb1);
pool.destroy(pb3);