type_traits.hpp

Go to the documentation of this file.

// Copyright 2021 Apex.AI, Inc.
//
// 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.
//
// Developed by Apex.AI, Inc.
 
#include <common/types.hpp>
#include <common/visibility_control.hpp>
 
#include <cstdint>
#include <tuple>
#include <type_traits>
 
#ifndef COMMON__TYPE_TRAITS_HPP_
#define COMMON__TYPE_TRAITS_HPP_
 
namespace autoware
{
namespace common
{
namespace type_traits
{
 
template<typename T>
constexpr inline autoware::common::types::bool8_t COMMON_PUBLIC impossible_branch() noexcept
{
  return sizeof(T) == 0;
}
 
template<class QueryT, class TupleT>
struct COMMON_PUBLIC index
{
  static_assert(!std::is_same<TupleT, std::tuple<>>::value, "Could not find QueryT in given tuple");
};
 
template<class HeadT, class ... Tail>
struct COMMON_PUBLIC index<HeadT, std::tuple<HeadT, Tail...>>
  : std::integral_constant<std::int32_t, 0> {};
 
template<class QueryT, class HeadT, class ... Tail>
struct COMMON_PUBLIC index<QueryT, std::tuple<HeadT, Tail...>>
  : std::integral_constant<std::int32_t, 1 + index<QueryT, std::tuple<Tail...>>::value> {};
 
template<std::size_t I = 0UL, typename Callable, typename ... TypesT>
COMMON_PUBLIC inline constexpr typename std::enable_if_t<I == sizeof...(TypesT)>
visit(std::tuple<TypesT...> &, Callable) noexcept {}
template<std::size_t I = 0UL, typename Callable, typename ... TypesT>
COMMON_PUBLIC inline constexpr typename std::enable_if_t<I == sizeof...(TypesT)>
visit(const std::tuple<TypesT...> &, Callable) noexcept {}
 
template<std::size_t I = 0UL, typename Callable, typename ... TypesT>
COMMON_PUBLIC inline constexpr typename std::enable_if_t<I != sizeof...(TypesT)>
visit(std::tuple<TypesT...> & tuple, Callable callable) noexcept
{
  callable(std::get<I>(tuple));
  visit<I + 1UL, Callable, TypesT...>(tuple, callable);
}
template<std::size_t I = 0UL, typename Callable, typename ... TypesT>
COMMON_PUBLIC inline constexpr typename std::enable_if_t<I != sizeof...(TypesT)>
visit(const std::tuple<TypesT...> & tuple, Callable callable) noexcept
{
  callable(std::get<I>(tuple));
  visit<I + 1UL, Callable, TypesT...>(tuple, callable);
}
 
template<class ...>
struct COMMON_PUBLIC conjunction : std::true_type {};
template<class TraitT>
struct COMMON_PUBLIC conjunction<TraitT>: TraitT {};
template<class TraitT, class ... TraitsTs>
struct COMMON_PUBLIC conjunction<TraitT, TraitsTs...>
  : std::conditional_t<static_cast<bool>(TraitT::value), conjunction<TraitsTs...>, TraitT> {};
 
 
template<typename QueryT, typename TupleT>
struct has_type;
 
template<typename QueryT>
struct has_type<QueryT, std::tuple<>>: std::false_type {};
 
template<typename QueryT, typename HeadT, typename ... TailTs>
struct has_type<QueryT, std::tuple<HeadT, TailTs...>>: has_type<QueryT, std::tuple<TailTs...>> {};
 
template<typename QueryT, typename ... TailTs>
struct has_type<QueryT, std::tuple<QueryT, TailTs...>>: std::true_type {};
 
 
template<typename TupleT1, typename TupleT2>
struct intersect
{
  template<std::size_t... Indices>
  static constexpr auto make_intersection(std::index_sequence<Indices...>)
  {
    return std::tuple_cat(
      std::conditional_t<
        has_type<std::tuple_element_t<Indices, TupleT1>, TupleT2>::value,
        std::tuple<std::tuple_element_t<Indices, TupleT1>>,
        std::tuple<>>{} ...);
  }
  using type =
    decltype(make_intersection(std::make_index_sequence<std::tuple_size<TupleT1>::value> {}));
};
 
}  // namespace type_traits
}  // namespace common
}  // namespace autoware
 
#endif  // COMMON__TYPE_TRAITS_HPP_