traits.h

Go to the documentation of this file.

/*
 * Copyright 2015-2019 CNRS-UM LIRMM, CNRS-AIST JRL
 */
 
#pragma once
 
#include <mc_rtc/constants.h>
 
#include <mc_rbdyn/rpy_utils.h>
 
#include <SpaceVecAlg/SpaceVecAlg>
 
#include <array>
#include <type_traits>
#include <variant>
#include <vector>
 
namespace mc_rtc::gui::details
{
 
template<typename...>
using void_t = void;
 
template<typename GetT>
constexpr bool is_getter_impl(void_t<decltype(std::declval<GetT>()())> *)
{
  using ReturnT = typename std::decay<decltype(std::declval<GetT>()())>::type;
  return !std::is_pointer<ReturnT>::value && !std::is_same<ReturnT, void>::value;
}
 
template<typename GetT>
constexpr bool is_getter_impl(...)
{ return false; }
 
template<typename GetT>
constexpr bool is_getter()
{ return is_getter_impl<GetT>(nullptr); }
 
struct NotAGetter
{
};
 
template<typename GetT, bool is_getter>
struct ReturnTypeImpl
{
  using type = typename std::decay<decltype(std::declval<GetT>()())>::type;
};
 
template<typename GetT>
struct ReturnTypeImpl<GetT, false>
{
  using type = NotAGetter;
};
 
template<typename GetT>
struct ReturnType
{
  using type = typename ReturnTypeImpl<GetT, is_getter<GetT>()>::type;
};
 
template<typename GetT>
using ReturnTypeT = typename ReturnType<GetT>::type;
 
template<typename GetT, typename... Args>
struct CheckReturnType
{
  static constexpr bool value = false;
};
 
template<typename GetT, typename T>
struct CheckReturnType<GetT, T>
{
  static constexpr bool value = std::is_convertible<ReturnTypeT<GetT>, typename std::decay<T>::type>::value;
};
 
template<typename GetT, typename T, typename... Args>
struct CheckReturnType<GetT, T, Args...>
{
  static constexpr bool value = CheckReturnType<GetT, T>::value || CheckReturnType<GetT, Args...>::value;
};
 
template<typename CallbackT, typename FunT>
inline constexpr bool has_compatible_signature_v = std::is_convertible_v<CallbackT, std::function<FunT>>;
 
template<typename T>
struct Labels
{
  static constexpr bool has_labels = false;
  inline static const std::vector<std::string> labels = {};
};
 
template<>
struct Labels<Eigen::Vector2d>
{
  static constexpr bool has_labels = true;
  inline static const std::vector<std::string> labels = {"x", "y"};
};
 
template<>
struct Labels<Eigen::Vector3d>
{
  static constexpr bool has_labels = true;
  inline static const std::vector<std::string> labels = {"x", "y", "z"};
};
 
template<>
struct Labels<Eigen::Vector4d>
{
  static constexpr bool has_labels = true;
  inline static const std::vector<std::string> labels = {"x", "y", "z", "w"};
};
 
template<>
struct Labels<Eigen::Quaterniond>
{
  static constexpr bool has_labels = true;
  inline static const std::vector<std::string> labels = {"w", "x", "y", "z"};
};
 
template<>
struct Labels<sva::MotionVecd>
{
  static constexpr bool has_labels = true;
  inline static const std::vector<std::string> labels = {"wx", "wy", "wz", "vx", "vy", "vz"};
};
 
template<>
struct Labels<sva::ForceVecd>
{
  static constexpr bool has_labels = true;
  inline static const std::vector<std::string> labels = {"cx", "cy", "cz", "fx", "fy", "fz"};
};
 
template<>
struct Labels<sva::ImpedanceVecd>
{
  static constexpr bool has_labels = true;
  inline static const std::vector<std::string> labels = {"cx", "cy", "cz", "fx", "fy", "fz"};
};
 
template<bool Degrees>
struct RPYLabels
{
  inline static const std::vector<std::string> labels = {"r [deg]", "p [deg]", "y [deg]"};
};
 
template<>
struct RPYLabels<false>
{
  inline static const std::vector<std::string> labels = {"r [rad]", "p [rad]", "y [rad]"};
};
 
template<typename T>
auto read(const T && value)
{
  return [value]() -> const T & { return value; };
}
 
template<bool Degrees, typename T>
auto read_rpy(const T && value)
{
  return [value]() -> Eigen::Vector3d
  {
    if constexpr(Degrees) { return mc_rbdyn::rpyFromRotation(value) * 180. / mc_rtc::constants::PI; }
    else
    {
      return mc_rbdyn::rpyFromRotation(value);
    }
  };
}
 
template<typename T>
auto read(const T & value)
{
  return [&value]() -> const T & { return value; };
}
 
template<bool Degrees, typename T>
auto read_rpy(const T & value)
{
  return [&value]() -> Eigen::Vector3d
  {
    if constexpr(Degrees) { return mc_rbdyn::rpyFromRotation(value) * 180. / mc_rtc::constants::PI; }
    else
    {
      return mc_rbdyn::rpyFromRotation(value);
    }
  };
}
 
template<typename T>
auto write(T & value)
{
  return [&value](const T & v) { value = v; };
}
 
template<typename T>
auto GetValueOrCallbackValue(const T & value_or_cb)
{
  if constexpr(std::is_invocable_v<T>) { return value_or_cb(); }
  else
  {
    return value_or_cb;
  }
}
 
template<typename T>
struct is_variant : public std::false_type
{
};
 
template<typename... Args>
struct is_variant<std::variant<Args...>> : public std::true_type
{
};
 
template<typename T>
inline constexpr bool is_variant_v = is_variant<T>::value;
 
} // namespace mc_rtc::gui::details