pfactory.h File Reference

#include <ptlib.h>
#include <string>
#include <map>
#include <vector>

Go to the source code of this file.

Classes
class	PFactoryBase
class	PFactoryBase::FactoryMap
class	PFactory< _Abstract_T, _Key_T >
class	PFactory< _Abstract_T, _Key_T >::WorkerBase
class	PFactory< _Abstract_T, _Key_T >::Worker< _Concrete_T >
Defines
#define	PLOAD_FACTORY(AbstractType, KeyType)
#define	PINSTANTIATE_FACTORY(AbstractType, KeyType)   namespace PWLibFactoryLoader { int AbstractType##_##KeyType##_loader; }
Typedefs
typedef std::string	PDefaultPFactoryKey

---

Define Documentation

#define PINSTANTIATE_FACTORY	(	AbstractType,
		KeyType		)	namespace PWLibFactoryLoader { int AbstractType##_##KeyType##_loader; }

#define PLOAD_FACTORY	(	AbstractType,
		KeyType		)

Value:

namespace PWLibFactoryLoader { \
    extern int AbstractType##_##KeyType##_loader; \
    static int AbstractType##_##KeyType##_loader_instance = AbstractType##_##KeyType##_loader; \
  };

---

Typedef Documentation

typedef std::string PDefaultPFactoryKey

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.

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 KeyMap_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.

---