traits.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2022, NVIDIA CORPORATION.
 *
 * 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.
 */
 
#pragma once
 
#include <cudf/types.hpp>
#include <cudf/utilities/type_dispatcher.hpp>
#include <cudf/wrappers/durations.hpp>
#include <cudf/wrappers/timestamps.hpp>
 
#include <cuda/std/type_traits>
 
namespace cudf {
 
template <typename...>
using void_t = void;
 
#define CUDF_ENABLE_IF(...) std::enable_if_t<(__VA_ARGS__)>* = nullptr
 
template <typename L, typename R>
using less_comparable = decltype(std::declval<L>() < std::declval<R>());
 
template <typename L, typename R>
using greater_comparable = decltype(std::declval<L>() > std::declval<R>());
 
template <typename L, typename R>
using equality_comparable = decltype(std::declval<L>() == std::declval<R>());
 
namespace detail {
template <typename L, typename R, typename = void>
struct is_relationally_comparable_impl : std::false_type {
};
 
template <typename L, typename R>
struct is_relationally_comparable_impl<L,
                                       R,
                                       void_t<less_comparable<L, R>, greater_comparable<L, R>>>
  : std::true_type {
};
 
template <typename L, typename R, typename = void>
struct is_equality_comparable_impl : std::false_type {
};
 
template <typename L, typename R>
struct is_equality_comparable_impl<L, R, void_t<equality_comparable<L, R>>> : std::true_type {
};
 
// has common type
template <typename AlwaysVoid, typename... Ts>
struct has_common_type_impl : std::false_type {
};
 
template <typename... Ts>
struct has_common_type_impl<void_t<std::common_type_t<Ts...>>, Ts...> : std::true_type {
};
}  // namespace detail
 
template <typename... Ts>
using has_common_type = typename detail::has_common_type_impl<void, Ts...>::type;
 
template <typename... Ts>
constexpr inline bool has_common_type_v = detail::has_common_type_impl<void, Ts...>::value;
 
template <typename T>
using is_timestamp_t = cuda::std::disjunction<std::is_same<cudf::timestamp_D, T>,
                                              std::is_same<cudf::timestamp_s, T>,
                                              std::is_same<cudf::timestamp_ms, T>,
                                              std::is_same<cudf::timestamp_us, T>,
                                              std::is_same<cudf::timestamp_ns, T>>;
 
template <typename T>
using is_duration_t = cuda::std::disjunction<std::is_same<cudf::duration_D, T>,
                                             std::is_same<cudf::duration_s, T>,
                                             std::is_same<cudf::duration_ms, T>,
                                             std::is_same<cudf::duration_us, T>,
                                             std::is_same<cudf::duration_ns, T>>;
 
template <typename L, typename R>
constexpr inline bool is_relationally_comparable()
{
  return detail::is_relationally_comparable_impl<L, R>::value;
}
 
namespace detail {
struct unary_relationally_comparable_functor {
  template <typename T>
  inline bool operator()() const
  {
    return cudf::is_relationally_comparable<T, T>();
  }
};
}  // namespace detail
 
inline bool is_relationally_comparable(data_type type)
{
  return type_dispatcher(type, detail::unary_relationally_comparable_functor{});
}
 
template <typename L, typename R>
constexpr inline bool is_equality_comparable()
{
  return detail::is_equality_comparable_impl<L, R>::value;
}
 
namespace detail {
struct unary_equality_comparable_functor {
  template <typename T>
  bool operator()() const
  {
    return cudf::is_equality_comparable<T, T>();
  }
};
}  // namespace detail
 
inline bool is_equality_comparable(data_type type)
{
  return cudf::type_dispatcher(type, detail::unary_equality_comparable_functor{});
}
 
template <typename T>
constexpr inline bool is_numeric()
{
  return cuda::std::is_arithmetic<T>();
}
 
struct is_numeric_impl {
  template <typename T>
  constexpr bool operator()()
  {
    return is_numeric<T>();
  }
};
 
constexpr inline bool is_numeric(data_type type)
{
  return cudf::type_dispatcher(type, is_numeric_impl{});
}
 
template <typename T>
constexpr inline bool is_index_type()
{
  return std::is_integral_v<T> and not std::is_same_v<T, bool>;
}
 
struct is_index_type_impl {
  template <typename T>
  constexpr bool operator()()
  {
    return is_index_type<T>();
  }
};
 
constexpr inline bool is_index_type(data_type type)
{
  return cudf::type_dispatcher(type, is_index_type_impl{});
}
 
template <typename T>
constexpr inline bool is_unsigned()
{
  return std::is_unsigned_v<T>;
}
 
struct is_unsigned_impl {
  template <typename T>
  constexpr bool operator()()
  {
    return is_unsigned<T>();
  }
};
constexpr inline bool is_unsigned(data_type type)
{
  return cudf::type_dispatcher(type, is_unsigned_impl{});
}
 
template <typename Iterator>
constexpr inline bool is_signed_iterator()
{
  return std::is_signed_v<typename std::iterator_traits<Iterator>::value_type>;
}
 
template <typename T>
constexpr inline bool is_floating_point()
{
  return std::is_floating_point_v<T>;
}
 
struct is_floating_point_impl {
  template <typename T>
  constexpr bool operator()()
  {
    return is_floating_point<T>();
  }
};
 
constexpr inline bool is_floating_point(data_type type)
{
  return cudf::type_dispatcher(type, is_floating_point_impl{});
}
 
template <typename T>
constexpr inline bool is_boolean()
{
  return std::is_same_v<T, bool>;
}
 
struct is_boolean_impl {
  template <typename T>
  constexpr bool operator()()
  {
    return is_boolean<T>();
  }
};
 
constexpr inline bool is_boolean(data_type type)
{
  return cudf::type_dispatcher(type, is_boolean_impl{});
}
 
template <typename T>
constexpr inline bool is_timestamp()
{
  return is_timestamp_t<T>::value;
}
 
struct is_timestamp_impl {
  template <typename T>
  constexpr bool operator()()
  {
    return is_timestamp<T>();
  }
};
 
constexpr inline bool is_timestamp(data_type type)
{
  return cudf::type_dispatcher(type, is_timestamp_impl{});
}
 
template <typename T>
constexpr inline bool is_fixed_point()
{
  return std::is_same_v<numeric::decimal32, T> || std::is_same_v<numeric::decimal64, T> ||
         std::is_same_v<numeric::decimal128, T>;
}
 
struct is_fixed_point_impl {
  template <typename T>
  constexpr bool operator()()
  {
    return is_fixed_point<T>();
  }
};
 
constexpr inline bool is_fixed_point(data_type type)
{
  return cudf::type_dispatcher(type, is_fixed_point_impl{});
}
 
template <typename T>
constexpr inline bool is_duration()
{
  return is_duration_t<T>::value;
}
 
struct is_duration_impl {
  template <typename T>
  constexpr bool operator()()
  {
    return is_duration<T>();
  }
};
 
constexpr inline bool is_duration(data_type type)
{
  return cudf::type_dispatcher(type, is_duration_impl{});
}
 
template <typename T>
constexpr inline bool is_chrono()
{
  return is_duration<T>() || is_timestamp<T>();
}
 
struct is_chrono_impl {
  template <typename T>
  constexpr bool operator()()
  {
    return is_chrono<T>();
  }
};
 
constexpr inline bool is_chrono(data_type type)
{
  return cudf::type_dispatcher(type, is_chrono_impl{});
}
 
template <typename T>
constexpr bool is_rep_layout_compatible()
{
  return cudf::is_numeric<T>() or cudf::is_chrono<T>() or cudf::is_boolean<T>();
}
 
template <typename T>
constexpr inline bool is_dictionary()
{
  return std::is_same_v<dictionary32, T>;
}
 
struct is_dictionary_impl {
  template <typename T>
  constexpr bool operator()()
  {
    return is_dictionary<T>();
  }
};
 
constexpr inline bool is_dictionary(data_type type)
{
  return cudf::type_dispatcher(type, is_dictionary_impl{});
}
template <typename T>
constexpr inline bool is_fixed_width()
{
  // TODO Add fixed width wrapper types
  // Is a category fixed width?
  return cudf::is_numeric<T>() || cudf::is_chrono<T>() || cudf::is_fixed_point<T>();
}
 
struct is_fixed_width_impl {
  template <typename T>
  constexpr bool operator()()
  {
    return is_fixed_width<T>();
  }
};
 
constexpr inline bool is_fixed_width(data_type type)
{
  return cudf::type_dispatcher(type, is_fixed_width_impl{});
}
 
class string_view;
 
template <typename T>
constexpr inline bool is_compound()
{
  return std::is_same_v<T, cudf::string_view> or std::is_same_v<T, cudf::dictionary32> or
         std::is_same_v<T, cudf::list_view> or std::is_same_v<T, cudf::struct_view>;
}
 
struct is_compound_impl {
  template <typename T>
  constexpr bool operator()()
  {
    return is_compound<T>();
  }
};
 
constexpr inline bool is_compound(data_type type)
{
  return cudf::type_dispatcher(type, is_compound_impl{});
}
 
template <typename T>
constexpr inline bool is_nested()
{
  return std::is_same_v<T, cudf::list_view> || std::is_same_v<T, cudf::struct_view>;
}
 
struct is_nested_impl {
  template <typename T>
  constexpr bool operator()()
  {
    return is_nested<T>();
  }
};
 
constexpr inline bool is_nested(data_type type)
{
  return cudf::type_dispatcher(type, is_nested_impl{});
}
 
template <typename T>
constexpr inline bool is_struct()
{
  return std::is_same_v<T, cudf::struct_view>;
}
 
struct is_struct_impl {
  template <typename T>
  constexpr bool operator()()
  {
    return is_struct<T>();
  }
};
 
constexpr inline bool is_struct(data_type type)
{
  return cudf::type_dispatcher(type, is_struct_impl{});
}
 
template <typename FromType>
struct is_bit_castable_to_impl {
  template <typename ToType, std::enable_if_t<is_compound<ToType>()>* = nullptr>
  constexpr bool operator()()
  {
    return false;
  }
 
  template <typename ToType, std::enable_if_t<not is_compound<ToType>()>* = nullptr>
  constexpr bool operator()()
  {
    if (not cuda::std::is_trivially_copyable_v<FromType> ||
        not cuda::std::is_trivially_copyable_v<ToType>) {
      return false;
    }
    constexpr auto from_size = sizeof(cudf::device_storage_type_t<FromType>);
    constexpr auto to_size   = sizeof(cudf::device_storage_type_t<ToType>);
    return from_size == to_size;
  }
};
 
struct is_bit_castable_from_impl {
  template <typename FromType, std::enable_if_t<is_compound<FromType>()>* = nullptr>
  constexpr bool operator()(data_type)
  {
    return false;
  }
 
  template <typename FromType, std::enable_if_t<not is_compound<FromType>()>* = nullptr>
  constexpr bool operator()(data_type to)
  {
    return cudf::type_dispatcher(to, is_bit_castable_to_impl<FromType>{});
  }
};
 
constexpr bool is_bit_castable(data_type from, data_type to)
{
  return type_dispatcher(from, is_bit_castable_from_impl{}, to);
}
 
template <typename From, typename To>
struct is_convertible : std::is_convertible<From, To> {
};
 
// This will ensure that timestamps can be promoted to a higher precision. Presently, they can't
// do that due to nvcc/gcc compiler issues
template <typename Duration1, typename Duration2>
struct is_convertible<cudf::detail::timestamp<Duration1>, cudf::detail::timestamp<Duration2>>
  : std::is_convertible<typename cudf::detail::time_point<Duration1>::duration,
                        typename cudf::detail::time_point<Duration2>::duration> {
};
 
}  // namespace cudf