Teuchos_AbstractFactoryStd.hpp

// @HEADER
// *****************************************************************************
//                    Teuchos: Common Tools Package
//
// Copyright 2004 NTESS and the Teuchos contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef TEUCHOS_ABSTRACT_FACTORY_STD_HPP
#define TEUCHOS_ABSTRACT_FACTORY_STD_HPP
 
#include "Teuchos_AbstractFactory.hpp"
 
namespace Teuchos {
 
template<class T_impl>
class PostModNothing {
public:
  void initialize(T_impl* /* p */) const {} // required!
};
 
template<class T_impl>
class AllocatorNew {
public:
  typedef Teuchos::RCP<T_impl>  ptr_t;                         // required!
  const ptr_t allocate() const { return Teuchos::rcp(new T_impl()); }  // required!
};
 
template<class T_itfc, class T_impl
         ,class T_PostMod = PostModNothing<T_impl>
         ,class T_Allocator = AllocatorNew<T_impl>
        >
class AbstractFactoryStd : public AbstractFactory<T_itfc> {
public:
 
  typedef typename Teuchos::AbstractFactory<T_itfc>::obj_ptr_t   obj_ptr_t;  // RAB: 20030916: G++ 3.2 complains without this
 
  AbstractFactoryStd( const T_PostMod& post_mod = T_PostMod(), const T_Allocator& alloc = T_Allocator() );
 
  obj_ptr_t create() const;
 
private:
  T_PostMod    post_mod_;
  T_Allocator  alloc_;
 
};
 
 
template<class T_itfc, class T_impl>
RCP<const AbstractFactory<T_itfc> >
abstractFactoryStd()
{
  return rcp(
    new AbstractFactoryStd<T_itfc,T_impl,PostModNothing<T_impl>,AllocatorNew<T_impl> >()
    );
}
 
 
template<class T_itfc, class T_impl, class T_Allocator>
RCP<const AbstractFactory<T_itfc> >
abstractFactoryStd( const T_Allocator& alloc = T_Allocator() )
{
  return rcp(
    new AbstractFactoryStd<T_itfc,T_impl,PostModNothing<T_impl>,T_Allocator>(
      PostModNothing<T_impl>(), alloc
      )
    );
}
 
 
// ///////////////////////////////////////////////////////
// Template member definitions
 
template<class T_itfc, class T_impl, class T_PostMod, class T_Allocator>
inline
AbstractFactoryStd<T_itfc,T_impl,T_PostMod,T_Allocator>::AbstractFactoryStd(
  const T_PostMod& post_mod, const T_Allocator& alloc
  )
  :post_mod_(post_mod)
  ,alloc_(alloc)
{}
 
template<class T_itfc, class T_impl, class T_PostMod, class T_Allocator>
inline
typename AbstractFactoryStd<T_itfc,T_impl,T_PostMod,T_Allocator>::obj_ptr_t
AbstractFactoryStd<T_itfc,T_impl,T_PostMod,T_Allocator>::create() const
{
  typename T_Allocator::ptr_t
    ptr = alloc_.allocate();
  post_mod_.initialize(ptr.get());
  return ptr;
}
 
} // end Teuchos
 
#endif // TEUCHOS_ABSTRACT_FACTORY_STD_HPP