These templates implement an Abstract Factory that allows creation of a class "factory" that can be used to create "concrete" instance that are descended from a abstract base class

Given an abstract class A with a descendant concrete class B, the concrete class is registered by instantiating the PFactory template as follows:

  PFactory<A>::Worker<B> aFactory("B");

To instantiate an object of type B, use the following:

  A * b = PFactory<A>::CreateInstance("B");

A vector containing the names of all of the concrete classes for an abstract type can be obtained as follows:

  PFactory<A>::KeyList_T list = PFactory<A>::GetKeyList()

Note that these example assumes that the "key" type for the factory registration is of the default type PString. If a different key type is needed, then it is necessary to specify the key type:

  PFactory<C, unsigned>::Worker<D> aFactory(42);
  C * d = PFactory<C, unsigned>::CreateInstance(42);
  PFactory<C, unsigned>::KeyList_T list = PFactory<C, unsigned>::GetKeyList()

The factory functions also allow the creation of "singleton" factories that return a single instance for all calls to CreateInstance. This can be done by passing a "true" as a second paramater to the factory registration as shown below, which will cause a single instance to be minted upon the first call to CreateInstance, and then returned for all subsequent calls.

 PFactory<A>::Worker<E> eFactory("E", true);

It is also possible to manually set the instance in cases where the object needs to be created non-trivially.

A version that can construct factory concrete classes that take an argument is also available.

  PParamFactory<C, double, unsigned>::Worker<D> aFactory(42);
  C * d = PParamFactory<C, double, unsigned>::CreateInstance(42, 3.14159);

The argument can, of course, be a class/struct to allow multiple parameters during construction.

The following types are defined as part of the PFactory template class:

KeyList_T    a vector<> of the key type (usually std::string)
Worker       an abstract factory for a specified concrete type
WorkerMap_T  a map<> that converts from the key type to the Worker instance
             for each concrete type registered for a specific abstract type

As a side issue, note that the factory lists are all thread safe for addition, creation, and obtaining the key lists.