traits.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2021, 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/lists/list_view.cuh>
#include <cudf/structs/struct_view.hpp>
#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;
 
template <typename L, typename R, typename = void>
struct is_relationally_comparable_impl : std::false_type {
};
 
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>
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>
using equality_comparable = decltype(std::declval<L>() == std::declval<R>());
 
template <typename L, typename R>
struct is_equality_comparable_impl<L, R, void_t<equality_comparable<L, R>>> : std::true_type {
};
 
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 is_relationally_comparable_impl<L, R>::value;
}
 
template <typename L, typename R>
constexpr inline bool is_equality_comparable()
{
  return is_equality_comparable_impl<L, R>::value;
}
 
template <typename T>
constexpr inline bool is_numeric()
{
  return std::is_integral<T>::value or std::is_floating_point<T>::value;
}
 
struct is_numeric_impl {
  template <typename T>
  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<T>::value and not std::is_same<T, bool>::value;
}
 
struct is_index_type_impl {
  template <typename T>
  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<T>::value;
}
 
struct is_unsigned_impl {
  template <typename T>
  bool operator()()
  {
    return is_unsigned<T>();
  }
};
constexpr inline bool is_unsigned(data_type type)
{
  return cudf::type_dispatcher(type, is_unsigned_impl{});
}
 
template <typename T>
constexpr inline bool is_floating_point()
{
  return std::is_floating_point<T>::value;
}
 
struct is_floating_point_impl {
  template <typename T>
  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<T, bool>::value;
}
 
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>
  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<numeric::decimal32, T>::value || std::is_same<numeric::decimal64, T>::value;
}
 
struct is_fixed_point_impl {
  template <typename T>
  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>
  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>
  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 inline bool is_dictionary()
{
  return std::is_same<dictionary32, T>::value;
}
 
struct is_dictionary_impl {
  template <typename T>
  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>
  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<T, cudf::string_view>::value or std::is_same<T, cudf::dictionary32>::value or
         std::is_same<T, cudf::list_view>::value or std::is_same<T, cudf::struct_view>::value;
}
 
struct is_compound_impl {
  template <typename T>
  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<T, cudf::list_view>::value || std::is_same<T, cudf::struct_view>::value;
}
 
struct is_nested_impl {
  template <typename T>
  bool operator()()
  {
    return is_nested<T>();
  }
};
 
constexpr inline bool is_nested(data_type type)
{
  return cudf::type_dispatcher(type, is_nested_impl{});
}
 
template <typename FromType, typename ToType>
struct is_logically_castable_impl : std::false_type {
};
 
// Allow cast to same type
template <typename Type>
struct is_logically_castable_impl<Type, Type> : std::true_type {
};
 
#ifndef MAP_CASTABLE_TYPES
#define MAP_CASTABLE_TYPES(Type1, Type2)                             \
  template <>                                                        \
  struct is_logically_castable_impl<Type1, Type2> : std::true_type { \
  };                                                                 \
  template <>                                                        \
  struct is_logically_castable_impl<Type2, Type1> : std::true_type { \
  };
#endif
 
// Allow cast between timestamp and integer representation
MAP_CASTABLE_TYPES(cudf::timestamp_D, cudf::timestamp_D::duration::rep);
MAP_CASTABLE_TYPES(cudf::timestamp_s, cudf::timestamp_s::duration::rep);
MAP_CASTABLE_TYPES(cudf::timestamp_ms, cudf::timestamp_ms::duration::rep);
MAP_CASTABLE_TYPES(cudf::timestamp_us, cudf::timestamp_us::duration::rep);
MAP_CASTABLE_TYPES(cudf::timestamp_ns, cudf::timestamp_ns::duration::rep);
// Allow cast between durations and integer representation
MAP_CASTABLE_TYPES(cudf::duration_D, cudf::duration_D::rep);
MAP_CASTABLE_TYPES(cudf::duration_s, cudf::duration_s::rep);
MAP_CASTABLE_TYPES(cudf::duration_ms, cudf::duration_ms::rep);
MAP_CASTABLE_TYPES(cudf::duration_us, cudf::duration_us::rep);
MAP_CASTABLE_TYPES(cudf::duration_ns, cudf::duration_ns::rep);
// Allow cast between decimals and integer representation
MAP_CASTABLE_TYPES(numeric::decimal32, numeric::decimal32::rep);
MAP_CASTABLE_TYPES(numeric::decimal64, numeric::decimal64::rep);
 
template <typename FromType>
struct is_logically_castable_to_impl {
  template <typename ToType>
  constexpr bool operator()()
  {
    return is_logically_castable_impl<FromType, ToType>::value;
  }
};
 
struct is_logically_castable_from_impl {
  template <typename FromType>
  constexpr bool operator()(data_type to)
  {
    return type_dispatcher(to, is_logically_castable_to_impl<FromType>{});
  }
};
 
constexpr bool is_logically_castable(data_type from, data_type to)
{
  return type_dispatcher(from, is_logically_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