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 >:

Public Member Functions
	AbstractFactoryStd (const T_PostMod &post_mod=T_PostMod(), const T_Allocator &alloc=T_Allocator())
Overriden from AbstractFactory
obj_ptr_t	create () const
Public Member Functions inherited from Teuchos::AbstractFactory< T_itfc >
virtual	~AbstractFactory ()

Related Functions
(Note that these are not member functions.)
template<class T_itfc , class T_impl , class T_Allocator >
	RCP< const AbstractFactory< T_itfc > >
	Nonmember constructor for an standar abstract factory object. More...
template<class T_itfc , class T_impl >
RCP< const AbstractFactory < T_itfc > >	abstractFactoryStd ()
	Nonmember constructor for an standar abstract factory object. More...

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 142 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 198 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

inlinevirtual

Implements Teuchos::AbstractFactory< T_itfc >.

Definition at line 208 of file Teuchos_AbstractFactoryStd.hpp.

Friends And Related Function Documentation

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

template<class T_itfc , class T_impl , class T_Allocator >

Teuchos::AbstractFactoryStd< T_itfc, T_impl, T_PostMod, T_Allocator >::RCP< const AbstractFactory< T_itfc > >

related

Initial value:

{
  return rcp(
    new AbstractFactoryStd<T_itfc,T_impl,PostModNothing<T_impl>,T_Allocator>(
      PostModNothing<T_impl>(), alloc
      )
    )

Nonmember constructor for an standar abstract factory object.

Definition at line 184 of file Teuchos_AbstractFactoryStd.hpp.

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 169 of file Teuchos_AbstractFactoryStd.hpp.

---

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

• Teuchos_AbstractFactoryStd.hpp