factory.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Vicente Mataix Ferrandiz
//
 
#if !defined(KRATOS_FACTORY_H_INCLUDED )
#define  KRATOS_FACTORY_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "includes/kratos_parameters.h"
#include "includes/kratos_components.h"
 
namespace Kratos
{
 
 
class FactoryBase
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(FactoryBase);
 
 
    explicit FactoryBase(){}
 
    virtual ~FactoryBase(){}
 
 
    virtual bool Has(const std::string& rClassName) const
    {
        KRATOS_ERROR << "Methods must be implemented in the derived class" << std::endl;
        return false;
    }
 
 
    virtual std::string Info() const
    {
        return "FactoryBase";
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const
    {
        rOStream << this->Info() << std::endl;
    }
 
    virtual void PrintData(std::ostream& rOStream) const
    {
    }
};
 
template<typename TClass>
class Factory
    : public FactoryBase
{
public:
 
    typedef TClass ClassType;
 
    KRATOS_CLASS_POINTER_DEFINITION(Factory);
 
 
    explicit Factory(){}
 
    virtual ~Factory() = default;
 
 
 
    bool Has(const std::string& rClassName) const override
    {
        return KratosComponents<ClassType>::Has( rClassName );
    }
 
    template<typename... TArgumentsType >
    typename ClassType::Pointer Create(TArgumentsType&&... Arguments) const
    {
        std::tuple<TArgumentsType...> args(Arguments...);
        constexpr std::size_t args_size = std::tuple_size<std::tuple<TArgumentsType...>>::value;
        Kratos::Parameters Settings = std::get<args_size - 1>(args);
        const std::string& r_name = Settings["name"].GetString();
        KRATOS_ERROR_IF_NOT(Has( r_name )) << "Trying to construct a class with type name= " << r_name << "\n" <<
                                            "Which does not exist. The list of available options (for currently loaded applications) are: \n" <<
                                            KratosComponents<ClassType>() << std::endl;
        const ClassType& aux = KratosComponents<ClassType>::Get( r_name );
        return aux.Create(std::forward<TArgumentsType>(Arguments)...);
    }
 
 
 
 
    std::string Info() const override
    {
        return "Factory";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << this->Info() << std::endl;
        const auto factory_components = KratosComponents<ClassType>::GetComponents();
        for (const auto& r_comp : factory_components) {
            rOStream << "\t" << r_comp.first << std::endl;
        }
    }
 
    virtual void PrintData(std::ostream& rOStream) const override
    {
    }
 
};
 
namespace Internals
{
    template <typename TBaseCategoryType>
    class RegisteredPrototypeBase {
        public:
        RegisteredPrototypeBase() = default;
    };
 
    template <typename TClassType, typename TBaseCategoryType>
    class RegisteredPrototype : public  RegisteredPrototypeBase<TBaseCategoryType> {
        public:
        explicit RegisteredPrototype(const std::string& rName, const TClassType& rPrototype)
        {
            KratosComponents<TBaseCategoryType>::Add(rName, rPrototype);
        }
    };
 
}
 
 
 
template<class TClass>
inline std::ostream& operator << (std::ostream& rOStream,
                                  const Factory<TClass>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif // KRATOS_FACTORY_H_INCLUDED  defined