Teuchos::AbstractFactoryStd< T_itfc, T_impl, T_PostMod, T_Allocator > Class Template Reference

Simple, templated concrete subclass of universal "Abstract Factory" interface for the creation of objects. More...

#include <Teuchos_AbstractFactoryStd.hpp>

Inheritance diagram for Teuchos::AbstractFactoryStd< T_itfc, T_impl, T_PostMod, T_Allocator >:

Inheritance graph
[legend]

List of all members.

Public Types

typedef
Teuchos::AbstractFactory
< T_itfc >::obj_ptr_t 
obj_ptr_t

Public Member Functions

 AbstractFactoryStd (const T_PostMod &post_mod=T_PostMod(), const T_Allocator &alloc=T_Allocator())
 

Private Attributes

T_PostMod post_mod_
T_Allocator alloc_

Related Functions

(Note that these are not member functions.)

template<class T_itfc , class T_impl >
RCP< const AbstractFactory
< T_itfc > > 
abstractFactoryStd ()
 Nonmember constructor for an standar abstract factory object.
template<class T_itfc , class T_impl , class T_Allocator >
RCP< const AbstractFactory
< T_itfc > > 
abstractFactoryStd (const T_Allocator &alloc=T_Allocator())
 Nonmember constructor for an standar abstract factory object.

Overriden from AbstractFactory



obj_ptr_t create () const
 


Detailed Description

template<class T_itfc, class T_impl, class T_PostMod = PostModNothing<T_impl>, class T_Allocator = AllocatorNew<T_impl>>
class Teuchos::AbstractFactoryStd< T_itfc, T_impl, T_PostMod, T_Allocator >

Simple, templated concrete subclass of universal "Abstract Factory" interface for the creation of objects.

This concrete subclass represents a general AbstractFactory subclass that can be modified through policy template parameters. This class is templated on the interface type T_itfc that is exposed by the AbstractFactory<T_itfc> base interface and by a (concrete) implementation type T_impl. The most typical use of this subclass is to use a concrete, default-constructable subclass for T_impl and then to simply instantiate a concrete abstract factory for that class using:


 Teuchos::AbstractFactoryStd<T_itfc,T_impl>  abstractFactory;
 

For this default usage, The only requirements for the derived classes type T_impl is that it allow the default constructor T_impl::T_impl() (i.e. dont make T_impl::T_impl() private) and that it allow T_impl::new() and T_impl::delete (i.e. don't make them private functions, see Meyers, More Effective C++, Item 27).

However, this subclass is also templated on two other policy types that allow a modification on how objects are created and destroyed. The first templated policy type, T_PostMod, defines how an object is modified after it is initially created. The second templated policy type, T_Allocator, defines exactly how an object is created (and therefore also how it is destroyed). These type two policy classes are described in more detail below.

The type T_PostMod is responsible for performing any post modifications on a dynamically allocated object before returning it from create(). The requirements for the type T_PostMod are that it has a default constructor, a copy constructor and a method T_PostMod::initialize(T_itfc2*) const that will perform any required post modifications (initializations). The type T_itfc2 argument for this function must be a base class of T_impl of course. The default type for T_PostMod is PostModNothing<T_impl> which does nothing.

The type T_Allocator allows for specialized memory allocation and cleanup. This type must allow the default constructor and copy constructor and have a method Teuchos::RCP<T_impl> T_Allocator::allocate() const which creates a smart reference-counted pointer to the allocated object. Also, in returning a RCP<> object, the client can set a deallocatioin policy object that can specialize the deallocation of the object (see RCP). In defining a specialized T_Allocator class, the client can all initialize the object using more than just the default constructor. Therefore, if the client provides a specialized T_Allocator class, there are no restrictions on the class T_impl (i.e. does not have to have a default constructor or allow new or delete). The default class for T_Allocator is AllocatorNew<T_impl> who's allocate() function just returns rcp(new T_impl()).

Since the T_Allocator class can specialize both the memory management and can initialize the object using more that the default constructor, the class T_PostMod may seem unecessary. However, it is more likely that the client will want to define an initialization for a set of classes through an abstract interface and can not for a particular concrete subclass. Also the initialization for an object can be orthogonal to how it is created and destroyed, thus the two classes T_PostMod and T_Allocator are both needed for a more general implementation.

Definition at line 129 of file Teuchos_AbstractFactoryStd.hpp.


Member Typedef Documentation

template<class T_itfc, class T_impl, class T_PostMod = PostModNothing<T_impl>, class T_Allocator = AllocatorNew<T_impl>>
typedef Teuchos::AbstractFactory<T_itfc>::obj_ptr_t Teuchos::AbstractFactoryStd< T_itfc, T_impl, T_PostMod, T_Allocator >::obj_ptr_t

Definition at line 132 of file Teuchos_AbstractFactoryStd.hpp.


Constructor & Destructor Documentation

template<class T_itfc , class T_impl , class T_PostMod, class T_Allocator>
Teuchos::AbstractFactoryStd< T_itfc, T_impl, T_PostMod, T_Allocator >::AbstractFactoryStd ( const T_PostMod &  post_mod = T_PostMod(),
const T_Allocator &  alloc = T_Allocator() 
) [inline]

Definition at line 185 of file Teuchos_AbstractFactoryStd.hpp.


Member Function Documentation

template<class T_itfc , class T_impl , class T_PostMod , class T_Allocator >
AbstractFactoryStd< T_itfc, T_impl, T_PostMod, T_Allocator >::obj_ptr_t Teuchos::AbstractFactoryStd< T_itfc, T_impl, T_PostMod, T_Allocator >::create (  )  const [inline, virtual]


Friends And Related Function Documentation

template<class T_itfc , class T_impl >
RCP< const AbstractFactory< T_itfc > > abstractFactoryStd (  )  [related]

Nonmember constructor for an standar abstract factory object.

Definition at line 156 of file Teuchos_AbstractFactoryStd.hpp.

template<class T_itfc , class T_impl , class T_Allocator >
RCP< const AbstractFactory< T_itfc > > abstractFactoryStd ( const T_Allocator &  alloc = T_Allocator()  )  [related]

Nonmember constructor for an standar abstract factory object.

Definition at line 170 of file Teuchos_AbstractFactoryStd.hpp.


Member Data Documentation

template<class T_itfc, class T_impl, class T_PostMod = PostModNothing<T_impl>, class T_Allocator = AllocatorNew<T_impl>>
T_PostMod Teuchos::AbstractFactoryStd< T_itfc, T_impl, T_PostMod, T_Allocator >::post_mod_ [private]

Definition at line 144 of file Teuchos_AbstractFactoryStd.hpp.

template<class T_itfc, class T_impl, class T_PostMod = PostModNothing<T_impl>, class T_Allocator = AllocatorNew<T_impl>>
T_Allocator Teuchos::AbstractFactoryStd< T_itfc, T_impl, T_PostMod, T_Allocator >::alloc_ [private]

Definition at line 145 of file Teuchos_AbstractFactoryStd.hpp.


The documentation for this class was generated from the following file:

Generated on Wed Jul 22 13:00:04 2009 for Teuchos Package Browser (Single Doxygen Collection) by doxygen 1.5.8