traits.hpp

前往此文件的文档。

/*
 * Copyright (c) 2019-2025, 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
 *
 * https://apache.ac.cn/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_EXPORT cudf {

template <typename...>
using void_t = void;

#define CUDF_ENABLE_IF(...) cuda::std::enable_if_t<(__VA_ARGS__)>* = nullptr

template <typename L, typename R>
using less_comparable = decltype(cuda::std::declval<L>() < cuda::std::declval<R>());

template <typename L, typename R>
using greater_comparable = decltype(cuda::std::declval<L>() > cuda::std::declval<R>());

template <typename L, typename R>
using equality_comparable = decltype(cuda::std::declval<L>() == cuda::std::declval<R>());

namespace detail {
template <typename L, typename R, typename = void>
struct is_relationally_comparable_impl : cuda::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>>>
 : cuda::std::true_type {};

template <typename L, typename R, typename = void>
struct is_equality_comparable_impl : cuda::std::false_type {};

template <typename L, typename R>
struct is_equality_comparable_impl<L, R, void_t<equality_comparable<L, R>>> : cuda::std::true_type {
};

// has common type
template <typename AlwaysVoid, typename... Ts>
struct has_common_type_impl : cuda::std::false_type {};

template <typename... Ts>
struct has_common_type_impl<void_t<cuda::std::common_type_t<Ts...>>, Ts...> : cuda::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<cuda::std::is_same<cudf::timestamp_D, T>,
 cuda::std::is_same<cudf::timestamp_h, T>,
 cuda::std::is_same<cudf::timestamp_m, T>,
 cuda::std::is_same<cudf::timestamp_s, T>,
 cuda::std::is_same<cudf::timestamp_ms, T>,
 cuda::std::is_same<cudf::timestamp_us, T>,
 cuda::std::is_same<cudf::timestamp_ns, T>>;

template <typename T>
using is_duration_t = cuda::std::disjunction<cuda::std::is_same<cudf::duration_D, T>,
 cuda::std::is_same<cudf::duration_h, T>,
 cuda::std::is_same<cudf::duration_m, T>,
 cuda::std::is_same<cudf::duration_s, T>,
 cuda::std::is_same<cudf::duration_ms, T>,
 cuda::std::is_same<cudf::duration_us, T>,
 cuda::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>
CUDF_HOST_DEVICE 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 cuda::std::is_integral_v<T> and not cuda::std::is_same_v<T, bool>;
}

bool is_index_type(data_type type);

template <typename T>
constexpr inline bool is_signed()
{
 return cuda::std::is_signed_v<T>;
}

bool is_signed(data_type type);

template <typename T>
constexpr inline bool is_unsigned()
{
 return cuda::std::is_unsigned_v<T>;
}

bool is_unsigned(data_type type);

template <typename Iterator>
CUDF_HOST_DEVICE constexpr inline bool is_signed_iterator()
{
 return cuda::std::is_signed_v<typename cuda::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_integral_not_bool()
{
 return cuda::std::is_integral_v<T> and not cuda::std::is_same_v<T, bool>;
}

bool is_integral_not_bool(data_type type);

template <typename T>
constexpr inline bool is_numeric_not_bool()
{
 return cudf::is_numeric<T>() and not cuda::std::is_same_v<T, bool>;
}

bool is_numeric_not_bool(data_type type);

template <typename T>
CUDF_HOST_DEVICE constexpr inline bool is_floating_point()
{
 return cuda::std::is_floating_point_v<T>;
}

bool is_floating_point(data_type type);

template <typename T>
constexpr inline bool is_byte()
{
 return cuda::std::is_same_v<cuda::std::remove_cv_t<T>, std::byte>;
}

template <typename T>
constexpr inline bool is_boolean()
{
 return cuda::std::is_same_v<T, bool>;
}

bool is_boolean(data_type type);

template <typename T>
CUDF_HOST_DEVICE constexpr inline bool is_timestamp()
{
 return is_timestamp_t<T>::value;
}

bool is_timestamp(data_type type);

template <typename T>
CUDF_HOST_DEVICE constexpr inline bool is_fixed_point()
{
 return cuda::std::is_same_v<numeric::decimal32, T> ||
 cuda::std::is_same_v<numeric::decimal64, T> ||
 cuda::std::is_same_v<numeric::decimal128, T> ||
 cuda::std::is_same_v<numeric::fixed_point<int32_t, numeric::Radix::BASE_2>, T> ||
 cuda::std::is_same_v<numeric::fixed_point<int64_t, numeric::Radix::BASE_2>, T> ||
 cuda::std::is_same_v<numeric::fixed_point<__int128_t, numeric::Radix::BASE_2>, T>;
}

bool is_fixed_point(data_type type);

template <typename T>
CUDF_HOST_DEVICE constexpr inline bool is_duration()
{
 return is_duration_t<T>::value;
}

bool is_duration(data_type type);

template <typename T>
CUDF_HOST_DEVICE 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 cuda::std::is_same_v<dictionary32, T>;
}

bool is_dictionary(data_type type);

template <typename T>
CUDF_HOST_DEVICE 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>
CUDF_HOST_DEVICE constexpr inline bool is_compound()
{
 return cuda::std::is_same_v<T, cudf::string_view> or
 cuda::std::is_same_v<T, cudf::dictionary32> or cuda::std::is_same_v<T, cudf::list_view> or
 cuda::std::is_same_v<T, cudf::struct_view>;
}

bool is_compound(data_type type);

template <typename T>
CUDF_HOST_DEVICE constexpr inline bool is_nested()
{
 return cuda::std::is_same_v<T, cudf::list_view> || cuda::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 : cuda::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>>
 : cuda::std::is_convertible<typename cudf::detail::time_point<Duration1>::duration,
 typename cudf::detail::time_point<Duration2>::duration> {};

} // namespace CUDF_EXPORT cudf