ControllerDescription.h

Go to the documentation of this file.

/**
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @author     Fabian Reister ( fabian dot reister at kit dot edu )
 * @date       2022
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#pragma once
 
#include <type_traits>
 
#include <armarx/control/interface/ConfigurableNJointControllerInterface.h>
 
namespace armarx::control::client
{
    namespace detail::proxy
    {
        template <typename, typename = std::void_t<>>
        struct has_proxy_type : std::false_type
        {
        };
 
        // Specialization that checks for the presence of 'Proxy' member.
        template <typename T>
        struct has_proxy_type<T, std::void_t<typename T::Proxy>> : std::true_type
        {
        };
 
        // Helper variable template for easier usage.
        template <typename T>
        inline constexpr bool has_proxy_type_v = has_proxy_type<T>::value;
 
        // Fallback mechanism using std::conditional_t to safely define ProxyType if it exists
        template <typename T, bool = has_proxy_type_v<T>>
        struct ProxyType
        {
            using type = typename T::Proxy; // If T has a Proxy type, use it
        };
 
        template <typename T>
        struct ProxyType<T, false>
        {
            using type = armarx::control::ConfigurableNJointControllerInterfacePrx; // Fallback type
        };
 
        // Helper to easily get the type
        template <typename T>
        using ProxyType_t = typename ProxyType<T>::type;
 
    } // namespace detail::proxy
 
    namespace detail::ctrl_class_name
    {
        // Check for the existence of 'ctrlConfigClassName' member
        template <typename, typename = std::void_t<>>
        struct has_ctrl_config_class_name : std::false_type
        {
        };
 
        template <typename T>
        struct has_ctrl_config_class_name<T, std::void_t<decltype(T::ctrlConfigClassName)>> :
            std::true_type
        {
        };
 
        template <typename T>
        inline constexpr bool has_ctrl_config_class_name_v = has_ctrl_config_class_name<T>::value;
 
        // Safe ctrlConfigClassName detection with a fallback to 'name'
        template <typename T, bool = has_ctrl_config_class_name_v<T>>
        struct CtrlConfigClassName
        {
            static constexpr const char* value =
                T::ctrlConfigClassName; // If T has ctrlConfigClassName, use it
        };
 
        template <typename T>
        struct CtrlConfigClassName<T, false>
        {
            static constexpr const char* value = T::name; // Fallback to 'name'
        };
 
        template <typename T>
        inline constexpr const char* CtrlConfigClassName_v = CtrlConfigClassName<T>::value;
 
    } // namespace detail::ctrl_class_name
 
    template <auto T>
    struct ControllerDescription
    {
        // using AronDTO = 'your aron type';
        //        using Proxy = armarx::control::ConfigurableNJointControllerInterfacePrx;
    };
 
} // namespace armarx::control::client