GridFactory.h

Go to the documentation of this file.

#ifndef GRID_FACTORY_H
#define GRID_FACTORY_H
 
#include <memory>
#include <stdexcept>
#include <string>
#include <valarray>
#include <vector>
 
#include "CoreEnums.h"
#include "GridBase.h"
#include "GridOneDim.h"
#include "ShapeBase.h"
#include "SimulationClassBase.h"
 
template <typename T>
class GridFactory
{
    private:
        Dimension m_dimension;
        std::shared_ptr<GridBase<T>> m_simulation_grid{};
        std::shared_ptr<ShapeBase<T>> m_simulation_shape{};
 
        void loadGrid()
        {
            std::cerr << "[GridFactory]: Not implemented currently.\n";
            throw std::runtime_error(
                static_cast<std::string>("[GridFactory]: Not implemented currently."));
        }
        void create(SimulationClassBase<T>* sim);
 
    public:
        GridFactory(SimulationClassBase<T>* sim, std::shared_ptr<ShapeBase<T>> m_simulation_shape,
                    const std::string& dimension);
 
        std::shared_ptr<GridBase<T>> getGridPtr() { return m_simulation_grid; }
};
 
template <typename T>
GridFactory<T>::GridFactory(SimulationClassBase<T>* sim,
                            std::shared_ptr<ShapeBase<T>> simulation_shape,
                            const std::string& dimension)
    : m_dimension(setDimension(dimension)), m_simulation_shape{simulation_shape}
{
    create(sim);
}
 
template <typename T>
void GridFactory<T>::create(SimulationClassBase<T>* sim)
{
    switch (m_dimension)
    {
        case Dimension::OneD:
            m_simulation_grid = std::make_shared<GridOneDim<T>>(sim, m_simulation_shape);
            break;
        // TwoD and ThreeD are not yet supported
        default:
            std::cerr << "[GridFactory]: Creation of 2D and 3D grids is not yet supported!\n";
            throw std::runtime_error(static_cast<std::string>(
                "[GridFactory]: Creation of 2D and 3D grids is not yet supported!"));
    }
}
 
#endif