gko::AbstractFactory< AbstractProductType, ComponentsType > Class Template Reference

The AbstractFactory is a generic interface template that enables easy implementation of the abstract factory design pattern. More...

#include <ginkgo/core/base/abstract_factory.hpp>

Inheritance diagram for gko::AbstractFactory< AbstractProductType, ComponentsType >:

Collaboration diagram for gko::AbstractFactory< AbstractProductType, ComponentsType >:

Public Types
using	abstract_product_type = AbstractProductType
using	components_type = ComponentsType

Public Member Functions
template<typename... Args>
std::unique_ptr< abstract_product_type >	generate (Args &&... args) const
	Creates a new product from the given components. More...
Public Member Functions inherited from gko::PolymorphicObject
PolymorphicObject &	operator= (const PolymorphicObject &)
std::shared_ptr< const Executor >	get_executor () const noexcept
	Returns the Executor of the object. More...
Public Member Functions inherited from gko::log::EnableLogging< PolymorphicObject >
void	add_logger (std::shared_ptr< const Logger > logger) override
void	remove_logger (const Logger *logger) override
void	remove_logger (ptr_param< const Logger > logger)
const std::vector< std::shared_ptr< const Logger > > &	get_loggers () const override
void	clear_loggers () override
Public Member Functions inherited from gko::log::Loggable
void	remove_logger (ptr_param< const Logger > logger)

Detailed Description

template<typename AbstractProductType, typename ComponentsType>
class gko::AbstractFactory< AbstractProductType, ComponentsType >

The AbstractFactory is a generic interface template that enables easy implementation of the abstract factory design pattern.

The interface provides the AbstractFactory::generate() method that can produce products of type AbstractProductType using an object of ComponentsType (which can be constructed on the fly from parameters to its constructors). The generate() method is not declared as virtual, as this allows subclasses to hide the method with a variant that preserves the compile-time type of the objects. Instead, implementers should override the generate_impl() method, which is declared virtual.

Implementers of concrete factories should consider using the EnableDefaultFactory mixin to obtain default implementations of utility methods of PolymorphicObject and AbstractFactory.

Template Parameters

AbstractProductType	the type of products the factory produces
ComponentsType	the type of components the factory needs to produce the product

Member Function Documentation

generate()

template<typename AbstractProductType, typename ComponentsType>

template<typename... Args>

std::unique_ptr<abstract_product_type> gko::AbstractFactory< AbstractProductType, ComponentsType >::generate ( Args &&...  args ) const

inline

Creates a new product from the given components.

The method will create an ComponentsType object from the arguments of this method, and pass it to the generate_impl() function which will create a new AbstractProductType.

Template Parameters

Args	types of arguments passed to the constructor of ComponentsType

Parameters

args	arguments passed to the constructor of ComponentsType

Returns

an instance of AbstractProductType

---

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

• ginkgo/core/base/abstract_factory.hpp