factory.hpp

Go to the documentation of this file.

/* 
 * This file is part of PLaSK (https://plask.app) by Photonics Group at TUL
 * Copyright (c) 2022 Lodz University of Technology
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
#ifndef PLASK__FILTERS_FACTORY_H
#define PLASK__FILTERS_FACTORY_H
 
#include "filter.hpp"
 
#include <map>
#include <string>
#include <functional>
#include "../utils/xml/reader.hpp"
#include "../manager.hpp"
 
namespace plask {
 
struct PLASK_API FiltersFactory
{
 
    typedef std::function<shared_ptr<Solver>(XMLReader& reader, Manager& manager)> FilterCreator;
 
private:
    std::map<std::string, FilterCreator> filterCreators;
 
public:
 
    static FiltersFactory& getDefault();
 
    struct PLASK_API Register {
        Register(const std::string typeName, FilterCreator filterCreator) { getDefault().add(typeName, filterCreator); }
    };
 
    template <typename PropertyTag>
    struct RegisterStandard {
        RegisterStandard() { getDefault().addStandard<PropertyTag>(); }
    };
 
    template <typename PropertyTag>
    static shared_ptr<Solver> standard(XMLReader& reader, Manager& manager);
 
    shared_ptr<Solver> get(XMLReader& reader, Manager& manager);
 
    void add(const std::string typeName, FilterCreator filterCreator);
 
    template <typename PropertyTag>
    void addStandard() { add(type_name<PropertyTag>(), FiltersFactory::standard<PropertyTag>); }
 
};
 
template <typename PropertyTag>
inline shared_ptr<Solver> FiltersFactory::standard(XMLReader& reader, Manager& manager) {
    shared_ptr<GeometryObject> out = manager.requireGeometryObject(reader.requireAttribute("geometry"));
    reader.requireTagEnd();
 
    if (shared_ptr<Geometry3D> out_as_geom3D = dynamic_pointer_cast<Geometry3D>(out))
        return shared_ptr<Solver>(new Filter<PropertyTag, Geometry3D>(out_as_geom3D));
 
    if (shared_ptr<Geometry2DCartesian> out_as_geom2D = dynamic_pointer_cast<Geometry2DCartesian>(out))
        return shared_ptr<Solver>(new Filter<PropertyTag, Geometry2DCartesian>(out_as_geom2D));
 
    if (shared_ptr<Geometry2DCylindrical> out_as_geomCyl = dynamic_pointer_cast<Geometry2DCylindrical>(out))
        return shared_ptr<Solver>(new Filter<PropertyTag, Geometry2DCylindrical>(out_as_geomCyl));
 
    throw NotImplemented("standard filter (for given configuration), geometry must be of type: Geometry3D, Geometry2DCartesian or Geometry2DCylindrical");
}
 
}   // namespace plask
 
#endif // PLASK__FILTERS_FACTORY_H