utils.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_UTILS_HPP
#define RTCTK_COMPONENTFRAMEWORK_UTILS_HPP
 
#include <type_traits>
 
namespace rtctk::componentFramework {
 
// template function defines an option with its default value
#define RTCTK_DEFINE_OPTION(Name, DefaultValue)                                                 \
                                                                                                \
    template <typename T = DefaultValue> struct Name : T {}                                     \
 
 
#define RTCTK_APPLY_OPTION_ED(Options, Name)                                                    \
                                                                                                \
    std::conditional_t<is_present_v<Name<Enabled>, Options...>, Name<Enabled>,                  \
        std::conditional_t<is_present_v<Name<Disabled>, Options...>, Name<Disabled>, Name<>>>   \
 
 
// convenience macro to check options in an if or switch statement
#define RTCTK_IS_OPTION(Name, Value)                                                            \
                                                                                                \
        std::is_base_of_v<Name<Value>, AppliedOptions>                                          \
 
 
// assert that applied option is either enabled or disabled
#define RTCTK_ASSERT_OPTION_ED(Name)                                                            \
                                                                                                \
        static_assert(RTCTK_IS_OPTION(Name, Enabled) or                                         \
                      RTCTK_IS_OPTION(Name, Disabled),                                          \
                      "Option " #Name " must either be Enabled or Disabled")                    \
 
 
// Default definitions for enabling and disabling options
using Enabled = std::true_type;
using Disabled = std::false_type;
 
 
// This is to check for dependencies between feature layers
 
template <template <typename...> class Base, typename Derived>
struct is_base_of_template_impl {
    template <typename... Ts>
    static constexpr std::true_type test(const Base<Ts...> *);
    static constexpr std::false_type test(...);
    using type = decltype(test(std::declval<Derived *>()));
};
 
template <template <typename...> class Base, typename Derived>
using is_base_of_template = typename is_base_of_template_impl<Base, Derived>::type;
 
template <template <typename...> class Base, typename Derived>
inline constexpr bool is_base_of_template_v = is_base_of_template<Base, Derived>::value;
 
 
// This is to check if options are present or not
 
template <typename What, typename... Args>
struct is_present {
    static constexpr bool value{(std::is_same_v<What, Args> || ...)};
};
 
template <typename What, typename... Args>
inline constexpr bool is_present_v = is_present<What, Args...>::value;
 
 
// This is for optional implementation of interfaces
 
template <class>
struct empty_base {
    empty_base() = default;
 
    template <class... Args>
    constexpr empty_base(Args &&...) {
    }
};
 
template <class T, bool Condition>
using optional_base = std::conditional_t<Condition, T, empty_base<T>>;
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_UTILS_HPP