TemplateHelpers.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2017 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
 
#ifndef GZ_PHYSICS_TEMPLATEHELPERS_HH_
#define GZ_PHYSICS_TEMPLATEHELPERS_HH_
 
#include <tuple>
#include <type_traits>
 
namespace gz
{
  namespace physics
  {
    struct Empty { };
 
    template <class... T> struct type { };
 
    template <typename... Ts>
    struct TypeList {
      static constexpr std::size_t size = sizeof...(Ts);
    };
 
    template <typename... Lists>
    struct TypeListCat;
 
    template <>
    struct TypeListCat<> {
      using type = TypeList<>;
    };
 
    template <typename... Ts>
    struct TypeListCat<TypeList<Ts...>> {
      using type = TypeList<Ts...>;
    };
 
    template <typename... T1, typename... T2>
    struct TypeListCat<TypeList<T1...>, TypeList<T2...>> {
      using type = TypeList<T1..., T2...>;
    };
 
    // We explicitly require at least 3 lists (L1, L2, L3) to use this
    // recursive specialization. This prevents an ambiguity error with the
    // 2-element base case `TypeListCat<TypeList<T1...>, TypeList<T2...>>`
    // when exactly 2 lists are provided.
    template <typename L1, typename L2, typename L3, typename... Rest>
    struct TypeListCat<L1, L2, L3, Rest...> {
      using type = typename TypeListCat<
          typename TypeListCat<L1, L2>::type,
          typename TypeListCat<L3, Rest...>::type>::type;
    };
 
    namespace detail
    {
      template <typename T>
      struct ToTuple;
 
      template <typename... Ts>
      struct ToTuple<TypeList<Ts...>> {
        using type = std::tuple<Ts...>;
      };
 
      template <typename T>
      struct TupleToTypeList;
 
      template <typename... Ts>
      struct TupleToTypeList<std::tuple<Ts...>> {
        using type = TypeList<Ts...>;
      };
    }
 
    template <typename To, typename From>
    struct ConstCompatible : std::true_type { };
 
    template <typename To, typename From>
    struct ConstCompatible<To, const From>
        : std::integral_constant<bool, std::is_const<To>::value> { };
  }
}
 
#define GZ_PHYSICS_CREATE_SELECTOR(X) \
  template<typename InFeature> \
  struct Select ## X \
  { \
    template<typename F, typename PolicyT, typename FeaturesT, \
             typename = std::void_t<>> \
    struct Implementation \
    { \
      using type = ::gz::physics::Empty; \
    }; \
    \
    template<typename F, typename PolicyT, typename FeaturesT> \
    struct Implementation<F, PolicyT, FeaturesT, \
                          std::void_t< \
                              typename F::template X <PolicyT, FeaturesT>>> \
    { \
      using type = typename F::template X <PolicyT, FeaturesT>; \
    }; \
    \
    template <typename PolicyT, typename FeaturesT> \
    using type = typename Implementation<InFeature, PolicyT, FeaturesT>::type; \
  };
 
#endif