MatrixFactory.h

Go to the documentation of this file.

#ifndef MATRIX_FACTORY_H
#define MATRIX_FACTORY_H
 
#include <memory>
#include <stdexcept>
#include <string>
#include <valarray>
#include <vector>
 
#include "CoreEnums.h"
#include "CsrMatrix.h"
#include "DenseMatrix.h"
#include "GenericMatrix.h"
 
template <typename T>
class MatrixFactory
{
    private:
        MatrixType m_default_matrix_type;
 
        std::unique_ptr<GenericMatrix<T>> createSelectedTypeUnique(MatrixType type);
        std::shared_ptr<GenericMatrix<T>> createSelectedTypeShared(MatrixType type);
 
    public:
        MatrixFactory(MatrixType type);
        MatrixFactory(const std::string& type);
 
        std::unique_ptr<GenericMatrix<T>> createUnique();
        std::unique_ptr<GenericMatrix<T>> createUnique(MatrixType type);
 
        std::shared_ptr<GenericMatrix<T>> createShared();
        std::shared_ptr<GenericMatrix<T>> createShared(MatrixType type);
};
 
template <typename T>
MatrixFactory<T>::MatrixFactory(const std::string& type)
    : m_default_matrix_type{setMatrixType(type)}
{
}
 
template <typename T>
MatrixFactory<T>::MatrixFactory(MatrixType type) : m_default_matrix_type{type}
{
}
 
template <typename T>
std::unique_ptr<GenericMatrix<T>> MatrixFactory<T>::createSelectedTypeUnique(MatrixType type)
{
    switch (type)
    {
        case MatrixType::Dense:
            return std::make_unique<DenseMatrix<T>>();
        case MatrixType::Csr:
            return std::make_unique<CsrSparseMatrix<T>>();
        default:
            throw std::invalid_argument("Unknown MatrixType in _create_selected_type_unique");
    }
}
 
template <typename T>
std::shared_ptr<GenericMatrix<T>> MatrixFactory<T>::createSelectedTypeShared(MatrixType type)
{
    switch (type)
    {
        case MatrixType::Dense:
            return std::make_shared<DenseMatrix<T>>();
        case MatrixType::Csr:
            return std::make_shared<CsrSparseMatrix<T>>();
        default:
            throw std::invalid_argument("Unknown MatrixType in _create_selected_type_shared");
    }
}
 
template <typename T>
std::unique_ptr<GenericMatrix<T>> MatrixFactory<T>::createUnique()
{
    return createSelectedTypeUnique(m_default_matrix_type);
}
 
template <typename T>
std::unique_ptr<GenericMatrix<T>> MatrixFactory<T>::createUnique(MatrixType type)
{
    return createSelectedTypeUnique(type);
}
 
template <typename T>
std::shared_ptr<GenericMatrix<T>> MatrixFactory<T>::createShared()
{
    return createSelectedTypeShared(m_default_matrix_type);
}
 
template <typename T>
std::shared_ptr<GenericMatrix<T>> MatrixFactory<T>::createShared(MatrixType type)
{
    return createSelectedTypeShared(type);
}
 
#endif