kratos_components.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ \.
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//                   Riccardo Rossi
//
 
#pragma once
 
// System includes
#include <string>
#include <iostream>
#include <map>
#include <typeinfo>
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "includes/data_communicator.h"
#include "containers/flags.h"
#include "containers/variable.h"
#include "utilities/quaternion.h"
 
namespace Kratos
{
 
template<class TComponentType>
class KRATOS_API(KRATOS_CORE) KratosComponents
{
public:
 
 
    KRATOS_CLASS_POINTER_DEFINITION(KratosComponents);
 
    using ComponentsContainerType = std::map<std::string, const TComponentType*>;
 
    using ValueType = typename ComponentsContainerType::value_type;
 
 
    KratosComponents() = default;
 
    virtual ~KratosComponents() = default;
 
 
 
    static void Add(const std::string& rName, const TComponentType& rComponent)
    {
        // Check if a different object was already registered with this name, since this is undefined behavior
        auto it_comp =  msComponents.find(rName);
        KRATOS_ERROR_IF(it_comp != msComponents.end() && typeid(*(it_comp->second)) != typeid(rComponent)) << "An object of different type was already registered with name \"" << rName << "\"!" << std::endl;
        msComponents.insert(ValueType(rName , &rComponent));
    }
 
    static void Remove(const std::string& rName)
    {
        std::size_t num_erased = msComponents.erase(rName);
        KRATOS_ERROR_IF(num_erased == 0) << "Trying to remove inexistent component \"" << rName << "\"." << std::endl;
    }
 
    static const TComponentType& Get(const std::string& rName)
    {
        auto it_comp =  msComponents.find(rName);
        KRATOS_DEBUG_ERROR_IF(it_comp == msComponents.end()) << GetMessageUnregisteredComponent(rName) << std::endl;
        return *(it_comp->second);
    }
 
    static void Register()
    {
 
    }
 
 
    static ComponentsContainerType& GetComponents()
    {
        return msComponents;
    }
 
    static ComponentsContainerType* pGetComponents()
    {
        return &msComponents;
    }
 
 
    static bool Has(const std::string& rName)
    {
        return (msComponents.find(rName) != msComponents.end());
    }
 
 
    virtual std::string Info() const
    {
        return "Kratos components";
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const
    {
        rOStream << "Kratos components";
    }
 
    virtual void PrintData(std::ostream& rOStream) const
    {
        for (const auto& r_comp : msComponents) {
            rOStream << "    " << r_comp.first << std::endl;
        }
    }
 
 
private:
 
    static ComponentsContainerType msComponents; 
 
 
 
 
    static std::string GetMessageUnregisteredComponent(const std::string& rName)
    {
        std::stringstream msg;
        msg << "The component \"" << rName << "\" is not registered!\nMaybe you need to import the application where it is defined?\nThe following components of this type are registered:" << std::endl;
        KratosComponents instance; // creating an instance for using "PrintData"
        instance.PrintData(msg);
        return msg.str();
    }
 
 
 
 
    KratosComponents& operator=(const KratosComponents& rOther);
 
    KratosComponents(const KratosComponents& rOther);
 
 
}; // Class KratosComponents
 
 
template<>
class KRATOS_API(KRATOS_CORE) KratosComponents<VariableData>
{
public:
 
 
    KRATOS_CLASS_POINTER_DEFINITION(KratosComponents);
 
    using ComponentsContainerType = std::map<std::string, VariableData*>;
 
    using ValueType = ComponentsContainerType::value_type;
 
 
    KratosComponents() = default;
 
    virtual ~KratosComponents() = default;
 
 
 
    static void Add(const std::string& rName, VariableData& rComponent)
    {
        msComponents.insert(ValueType(rName, &rComponent));
    }
 
    static void Remove(const std::string& rName)
    {
        std::size_t num_erased = msComponents.erase(rName);
        KRATOS_ERROR_IF(num_erased == 0) << "Trying to remove inexistent component \"" << rName << "\"." << std::endl;
    }
 
    static std::size_t Size()
    {
        return msComponents.size();
    }
 
    static VariableData& Get(const std::string& rName)
    {
        auto it_comp =  msComponents.find(rName);
        KRATOS_DEBUG_ERROR_IF(it_comp == msComponents.end()) << GetMessageUnregisteredVariable(rName) << std::endl;
        return *(it_comp->second);
    }
 
    static VariableData* pGet(const std::string& rName)
    {
        auto it_comp =  msComponents.find(rName);
        KRATOS_DEBUG_ERROR_IF(it_comp == msComponents.end()) << GetMessageUnregisteredVariable(rName) << std::endl;
        return it_comp->second;
    }
 
    static void Register()
    {
 
    }
 
 
    static ComponentsContainerType& GetComponents()
    {
        return msComponents;
    }
 
    static ComponentsContainerType* pGetComponents()
    {
        return &msComponents;
    }
 
 
    static bool Has(const std::string& rName)
    {
        return (msComponents.find(rName) != msComponents.end());
    }
 
 
    virtual std::string Info() const
    {
        return "Kratos components <VariableData>";
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const
    {
        rOStream << "Kratos components <VariableData>";
    }
 
    virtual void PrintData(std::ostream& rOStream) const
    {
        for (const auto& r_comp : msComponents) {
            rOStream << "    " << r_comp.first << std::endl;
        }
    }
 
 
private:
 
 
    static ComponentsContainerType msComponents; 
 
 
 
 
    static std::string GetMessageUnregisteredVariable(const std::string& rName)
    {
        std::stringstream msg;
        msg << "The variable \"" << rName << "\" is not registered!\nMaybe you need to import the application where it is defined?\nThe following variables are registered:" << std::endl;
        KratosComponents instance; // creating an instance for using "PrintData"
        instance.PrintData(msg);
        return msg.str();
    }
 
 
 
 
    KratosComponents& operator=(const KratosComponents& rOther);
 
    KratosComponents(const KratosComponents& rOther);
 
 
}; // Class KratosComponents
 
template<class TComponentType>
typename KratosComponents<TComponentType>::ComponentsContainerType KratosComponents<TComponentType>::msComponents;
 
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<Variable<bool>>;
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<Variable<int>>;
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<Variable<unsigned int>>;
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<Variable<double>>;
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<Variable<array_1d<double, 3>>>;
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<Variable<array_1d<double, 4>>>;
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<Variable<array_1d<double, 6>>>;
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<Variable<array_1d<double, 9>>>;
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<Variable<Quaternion<double>>>;
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<Variable<Vector>>;
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<Variable<Matrix>>;
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<Variable<std::string>>;
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<Variable<Flags>>;
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<Flags>;
KRATOS_API_EXTERN template class KRATOS_API(KRATOS_CORE) KratosComponents<DataCommunicator>;
 
 
template<class TComponentType>
inline std::ostream& operator << (std::ostream& rOStream,
                                  const KratosComponents<TComponentType>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
void KRATOS_API(KRATOS_CORE) AddKratosComponent(const std::string& rName, const Variable<bool>& rComponent);
void KRATOS_API(KRATOS_CORE) AddKratosComponent(const std::string& rName, const Variable<int>& rComponent);
void KRATOS_API(KRATOS_CORE) AddKratosComponent(const std::string& rName, const Variable<unsigned int>& rComponent);
void KRATOS_API(KRATOS_CORE) AddKratosComponent(const std::string& rName, const Variable<double>& rComponent);
void KRATOS_API(KRATOS_CORE) AddKratosComponent(const std::string& rName, const Variable<array_1d<double, 3>>& rComponent);
void KRATOS_API(KRATOS_CORE) AddKratosComponent(const std::string& rName, const Variable<array_1d<double, 4>>& rComponent);
void KRATOS_API(KRATOS_CORE) AddKratosComponent(const std::string& rName, const Variable<array_1d<double, 6>>& rComponent);
void KRATOS_API(KRATOS_CORE) AddKratosComponent(const std::string& rName, const Variable<array_1d<double, 9>>& rComponent);
void KRATOS_API(KRATOS_CORE) AddKratosComponent(const std::string& rName, const Variable<Quaternion<double>>& rComponent);
void KRATOS_API(KRATOS_CORE) AddKratosComponent(const std::string& rName, const Variable<Vector>& rComponent);
void KRATOS_API(KRATOS_CORE) AddKratosComponent(const std::string& rName, const Variable<Matrix>& rComponent);
void KRATOS_API(KRATOS_CORE) AddKratosComponent(const std::string& rName, const Variable<std::string>& rComponent);
void KRATOS_API(KRATOS_CORE) AddKratosComponent(const std::string& rName, const Flags& rComponent);
void KRATOS_API(KRATOS_CORE) AddKratosComponent(const std::string& rName, const Variable<Flags>& rComponent);
 
template<class TComponentType> void AddKratosComponent(const std::string& rName, const TComponentType& rComponent)
{
}
 
}  // namespace Kratos.