element_details.h

Go to the documentation of this file.

#pragma once
 
#include <SimoxUtility/meta/type_traits/is_any_of.h>
 
#include "common.h"
#include "config_struct_details.h"
 
//possible details
namespace armarx::meta::cfg
{
    template <class CL, class MT, MT CL::*ptr>
    constexpr undefined_t element_min = {};
 
    template <class CL, class MT, MT CL::*ptr>
    constexpr undefined_t element_max = {};
 
    template <class CL, class MT, MT CL::*ptr>
    constexpr undefined_t element_description = {};
 
    template <class CL, class MT, MT CL::*ptr>
    constexpr undefined_t element_property_name = {};
 
    template <class CL, class MT, MT CL::*ptr>
    constexpr undefined_t element_decimals = {};
 
    template <class CL, class MT, MT CL::*ptr>
    constexpr undefined_t element_steps = {};
 
    template <class CL, class MT, MT CL::*ptr>
    constexpr undefined_t element_label = {};
 
    template <class CL, class MT, MT CL::*ptr>
    constexpr std::false_type element_no_prop = {};
 
    template <class CL, class MT, MT CL::*ptr>
    constexpr std::false_type element_no_rem_gui = {};
 
    template <class CL, class MT, MT CL::*ptr>
    struct element_default : std::false_type
    {
        static const MT&
        get()
        {
            return struct_default<CL>::get().*ptr;
        }
 
        static void
        set(CL& cl)
        {
            cl.*ptr = get();
        }
    };
} // namespace armarx::meta::cfg
 
//collection of details + check of validity
namespace armarx::meta::cfg
{
    template <class CL, class MT, MT CL::*ptr>
    struct element_details
    {
        using class_t = CL;
        using member_t = MT;
        static constexpr auto member_ptr = ptr;
        static constexpr auto member_name = hana_member_name<CL, MT, ptr>;
 
        static constexpr auto min = element_min<CL, MT, ptr>;
        static constexpr auto max = element_max<CL, MT, ptr>;
        static constexpr auto description = element_description<CL, MT, ptr>;
        static constexpr auto property_name = element_property_name<CL, MT, ptr>;
        static constexpr auto decimals = element_decimals<CL, MT, ptr>;
        static constexpr auto steps = element_steps<CL, MT, ptr>;
        static constexpr auto label = element_label<CL, MT, ptr>;
 
        static constexpr bool is_no_prop = decltype(element_no_prop<CL, MT, ptr>)::value;
        static constexpr bool no_remote_gui = decltype(element_no_rem_gui<CL, MT, ptr>)::value;
 
        using min_t = decltype(min);
        using max_t = decltype(max);
        using description_t = decltype(description);
        using property_name_t = decltype(property_name);
        using decimals_t = decltype(decimals);
        using steps_t = decltype(steps);
        using label_t = decltype(label);
        using widget_t = element_widget<CL, MT, ptr>;
 
        static std::string
        description_as_string()
        {
            if constexpr (is_not_undefined_t(description))
            {
                return description;
            }
            return "";
        }
 
        static std::string
        make_property_name(std::string pre)
        {
            if (!pre.empty())
            {
                pre += '.';
            }
            if constexpr (is_not_undefined_t(property_name))
            {
                return pre + property_name;
            }
            return pre + member_name;
        }
 
        //general checks (does not check details for gui)
        static constexpr bool
        assert_settings()
        {
            //check label / description
            static_assert(undefined_t_or_type<const char*>(label),
                          "if set, element_label has to be of type const char*");
            static_assert(undefined_t_or_type<const char*>(description),
                          "if set, element_description has to be of type const char*");
            static_assert(undefined_t_or_type<const char*>(property_name),
                          "if set, element_property_name has to be of type const char*");
 
            //check min / max / steps / decimals
            if constexpr (simox::meta::is_any_of_v<MT, std::string, bool>)
            {
                static_assert(is_undefined_t(min),
                              "element_min can't be set for std::string or bool");
                static_assert(is_undefined_t(max),
                              "element_max can't be set for std::string or bool");
                static_assert(is_undefined_t(steps),
                              "element_steps can't be set for std::string or bool");
                static_assert(is_undefined_t(decimals),
                              "element_decimals can't be set for std::string or bool");
            }
            else if constexpr (std::is_integral_v<MT>)
            {
                static_assert(undefined_t_or_type_or_array_sz_1<MT>(min),
                              "if set, element_min has to be of the same type as the element");
                static_assert(undefined_t_or_type_or_array_sz_1<MT>(max),
                              "if set, element_max has to be of the same type as the element");
 
                static_assert(undefined_t_or_type_or_array_sz_1<int>(steps),
                              "if set, element_steps has to be of type int");
                static_assert(is_undefined_t(decimals),
                              "element_decimals can't be set for integral types");
            }
            else if constexpr (std::is_floating_point_v<MT>)
            {
                static_assert(undefined_t_or_type_or_array_sz_1<MT>(min),
                              "if set, element_min has to be of the same type as the element");
                static_assert(undefined_t_or_type_or_array_sz_1<MT>(max),
                              "if set, element_max has to be of the same type as the element");
 
                static_assert(undefined_t_or_type_or_array_sz_1<int>(steps),
                              "if set, element_steps has to be of type int");
                static_assert(undefined_t_or_type_or_array_sz_1<int>(decimals),
                              "if set, element_decimals has to be of type int");
            }
            else if constexpr (std::is_same_v<MT, Eigen::Vector3f>)
            {
                static_assert(undefined_t_or_type_or_array_sz_1<float>(min),
                              "if set, element_min has to be of the same type as the element");
                static_assert(undefined_t_or_type_or_array_sz_1<float>(max),
                              "if set, element_max has to be of the same type as the element");
 
                static_assert(undefined_t_or_type_or_array_sz_1<int>(steps),
                              "if set, element_steps has to be of type int");
                static_assert(undefined_t_or_type_or_array_sz_1<int>(decimals),
                              "if set, element_decimals has to be of type int");
            }
            else
            {
                ///TODO MX
 
                static_assert(is_undefined_t(min), "element_min can't be set for this type");
                static_assert(is_undefined_t(max), "element_max can't be set for this type");
                static_assert(is_undefined_t(steps), "element_steps can't be set for this type");
                static_assert(is_undefined_t(decimals),
                              "element_decimals can't be set for this type");
            }
            return true;
        }
 
        static_assert(assert_settings());
    };
 
    template <class VarName, class CL, class MT, MT CL::*ptr>
    element_details<CL, MT, ptr> to_element_detail(
        const boost::hana::pair<VarName, boost::hana::struct_detail::member_ptr<MT CL::*, ptr>>&);
} // namespace armarx::meta::cfg