EntityProxy.hpp

Go to the documentation of this file.

 
#pragma once
 
// --- Core Includes ---
#include "includes/global_variables.h" // DataLocation
#include "includes/kratos_export_api.h" // KRATOS_API
#include "includes/node.h" // Node
#include "includes/element.h" // Element
#include "includes/condition.h" // Condition
#include "utilities/variable_utils.h" // VariableUtils::HasValue, VariableUtils::GetValue, VariableUtils::SetValue
 
// --- WRApp Includes ---
#include "wrapp/utils/inc/OptionalRef.hpp" // OptionalRef
 
// --- STL Includes ---
#include <type_traits> // remove_reference_t, is_const_v, is_same_v, decay_t
 
 
namespace Kratos::WRApp {
 
 
template <class TEntityProxy>
class ContainerProxy;
 
 
 
 
template <Globals::DataLocation TLocation, bool TMutable>
class KRATOS_API(WR_APPLICATION) EntityProxy
{
private:
    constexpr static Globals::DataLocation Location = TLocation;
 
    constexpr static bool IsMutable = TMutable;
 
    using UnqualifiedEntity = std::conditional_t<
        TLocation == Globals::DataLocation::NodeHistorical || TLocation == Globals::DataLocation::NodeNonHistorical,
        Node,
        std::conditional_t<
            TLocation == Globals::DataLocation::Element,
            Element,
            std::conditional_t<
                TLocation == Globals::DataLocation::Condition,
                Condition,
                std::conditional_t<
                    TLocation == Globals::DataLocation::ProcessInfo,
                    ProcessInfo,
                    std::conditional_t<
                        TLocation == Globals::DataLocation::ModelPart,
                        ModelPart,
                        void // <== invalid fallback type; will throw a compile-time error
                    >
                >
            >
        >
    >;
 
    using QualifiedEntity = std::conditional_t<TMutable,
                                               UnqualifiedEntity,
                                               const UnqualifiedEntity>;
 
    friend class ContainerProxy<EntityProxy>;
 
public:
    EntityProxy() noexcept = default;
 
    EntityProxy(QualifiedEntity& rEntity) noexcept : mrEntity(rEntity) {}
 
    template <class TValue>
    bool HasValue(const Variable<TValue>& rVariable) const noexcept
    {
        return VariableUtils::HasValue<TLocation>(mrEntity.value(), rVariable);
    }
 
    template <class TValue>
    std::conditional_t<std::is_integral_v<TValue> || std::is_floating_point_v<TValue>,
                       TValue,           // <== return by value if scalar type
                       const TValue&>    // <== return by reference in non-scalar type
    GetValue(const Variable<TValue>& rVariable) const
    {
        return VariableUtils::GetValue<TLocation>(mrEntity.value(), rVariable);
    }
 
    template <class TValue, std::enable_if_t</*this is required for SFINAE*/!std::is_same_v<TValue,void> && TMutable,bool> = true>
    TValue& GetValue(const Variable<TValue>& rVariable)
    {
        return VariableUtils::GetValue<TLocation>(mrEntity.value(), rVariable);
    }
 
    template <class TValue, std::enable_if_t</*this is required for SFINAE*/!std::is_same_v<TValue,void> && TMutable,bool> = true>
    void SetValue(const Variable<TValue>& rVariable,
                  std::conditional_t<std::is_integral_v<TValue> || std::is_floating_point_v<TValue>,
                                     TValue,         /*pass scalar types by value*/
                                     const TValue&>  /*pass non-scalar types by reference*/ Value)
    {
        VariableUtils::SetValue<TLocation>(mrEntity.value(), rVariable, Value);
    }
 
    const UnqualifiedEntity& GetEntity() const
    {
        return mrEntity.value();
    }
 
    QualifiedEntity& GetEntity()
    {
        return mrEntity.value();
    }
 
private:
    OptionalRef<QualifiedEntity> mrEntity;
}; // class EntityProxy
 
 
 
template <Globals::DataLocation TLocation, class TEntity>
inline auto MakeProxy(const TEntity& rEntity)
{
    static_assert(std::is_same_v<TEntity,void>, "Invalid DataLocation-Entity combination");
}
 
 
template <Globals::DataLocation TLocation, class TEntity>
inline auto MakeProxy(TEntity& rEntity)
{
    static_assert(std::is_same_v<TEntity,void>, "Invalid DataLocation-Entity combination");
}
 
 
#define WRAPP_DEFINE_ENTITY_PROXY_FACTORY(TLocation, TEntity)                                   \
    \
    template <>                                                                                 \
    inline auto MakeProxy<TLocation,TEntity>(const TEntity& rEntity)                            \
    {return EntityProxy<TLocation,false>(rEntity);}                                             \
      \
    template <>                                                                                 \
    inline auto MakeProxy<TLocation,TEntity>(TEntity& rEntity)                                  \
    {return EntityProxy<TLocation,true>(rEntity);}
 
WRAPP_DEFINE_ENTITY_PROXY_FACTORY(Globals::DataLocation::NodeHistorical, Node)
 
WRAPP_DEFINE_ENTITY_PROXY_FACTORY(Globals::DataLocation::NodeNonHistorical, Node)
 
WRAPP_DEFINE_ENTITY_PROXY_FACTORY(Globals::DataLocation::Element, Element)
 
WRAPP_DEFINE_ENTITY_PROXY_FACTORY(Globals::DataLocation::Condition, Condition)
 
WRAPP_DEFINE_ENTITY_PROXY_FACTORY(Globals::DataLocation::ProcessInfo, ProcessInfo)
 
WRAPP_DEFINE_ENTITY_PROXY_FACTORY(Globals::DataLocation::ModelPart, ModelPart)
 
#undef WRAPP_DEFINE_ENTITY_PROXY_FACTORY
 
 
template <>
inline auto MakeProxy<Globals::DataLocation::ProcessInfo,ModelPart>(const ModelPart& rModelPart)
{
    return EntityProxy<Globals::DataLocation::ProcessInfo,false>(rModelPart.GetProcessInfo());
}
 
 
template <>
inline auto MakeProxy<Globals::DataLocation::ProcessInfo,ModelPart>(ModelPart& rModelPart)
{
    return EntityProxy<Globals::DataLocation::ProcessInfo,true>(rModelPart.GetProcessInfo());
}
 
 
 
 
} // namespace Kratos::WRApp