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/fixed_point/fixed_point.hpp>
#include <cudf/types.hpp>
#include <cudf/wrappers/dictionary.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;
}
 
bool is_relationally_comparable(data_type type);
 
template <typename L, typename R>
constexpr inline bool is_equality_comparable()
{
  return detail::is_equality_comparable_impl<L, R>::value;
}
 
bool is_equality_comparable(data_type type);
 
template <typename T>
constexpr inline bool is_numeric()
{
  return cuda::std::is_arithmetic<T>();
}
 
bool is_numeric(data_type type);
 
template <typename T>
constexpr inline bool is_index_type()
{
  return std::is_integral_v<T> and not std::is_same_v<T, bool>;
}
 
bool is_index_type(data_type type);
 
template <typename T>
constexpr inline bool is_unsigned()
{
  return std::is_unsigned_v<T>;
}
 
bool is_unsigned(data_type type);
 
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_integral()
{
  return cuda::std::is_integral_v<T>;
}
 
bool is_integral(data_type type);
 
template <typename T>
constexpr inline bool is_floating_point()
{
  return std::is_floating_point_v<T>;
}
 
bool is_floating_point(data_type type);
 
template <typename T>
constexpr inline bool is_byte()
{
  return std::is_same_v<std::remove_cv_t<T>, std::byte>;
}
 
template <typename T>
constexpr inline bool is_boolean()
{
  return std::is_same_v<T, bool>;
}
 
bool is_boolean(data_type type);
 
template <typename T>
constexpr inline bool is_timestamp()
{
  return is_timestamp_t<T>::value;
}
 
bool is_timestamp(data_type type);
 
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>;
}
 
bool is_fixed_point(data_type type);
 
template <typename T>
constexpr inline bool is_duration()
{
  return is_duration_t<T>::value;
}
 
bool is_duration(data_type type);
 
template <typename T>
constexpr inline bool is_chrono()
{
  return is_duration<T>() || is_timestamp<T>();
}
 
bool is_chrono(data_type type);
 
template <typename T>
constexpr bool is_rep_layout_compatible()
{
  return cudf::is_numeric<T>() or cudf::is_chrono<T>() or cudf::is_boolean<T>() or
         cudf::is_byte<T>();
}
 
template <typename T>
constexpr inline bool is_dictionary()
{
  return std::is_same_v<dictionary32, T>;
}
 
bool is_dictionary(data_type type);
 
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>();
}
 
bool is_fixed_width(data_type type);
 
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>;
}
 
bool is_compound(data_type type);
 
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>;
}
 
bool is_nested(data_type type);
 
bool is_bit_castable(data_type from, data_type 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