dictionary.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2020-2026, NVIDIA CORPORATION.
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#include <cudf/types.hpp>
 
#include <cuda/std/limits>
#include <cuda_runtime.h>
 
namespace CUDF_EXPORT cudf {
template <typename IndexType>
struct dictionary_wrapper {
  using value_type = IndexType;  
 
  dictionary_wrapper()                          = default;
  ~dictionary_wrapper()                         = default;
  dictionary_wrapper(dictionary_wrapper&&)      = default;  
  dictionary_wrapper(dictionary_wrapper const&) = default;  
 
  dictionary_wrapper& operator=(dictionary_wrapper&&) = default;
 
  dictionary_wrapper& operator=(dictionary_wrapper const&) = default;
 
  CUDF_HOST_DEVICE inline constexpr explicit dictionary_wrapper(value_type v) : _value{v} {}
 
  CUDF_HOST_DEVICE inline explicit operator value_type() const { return _value; }
 
  CUDF_HOST_DEVICE [[nodiscard]] inline value_type value() const { return _value; }
 
  static CUDF_HOST_DEVICE inline constexpr value_type max_value()
  {
    return cuda::std::numeric_limits<value_type>::max();
  }
 
  static CUDF_HOST_DEVICE inline constexpr value_type min_value()
  {
    return cuda::std::numeric_limits<value_type>::min();
  }
 
  static CUDF_HOST_DEVICE inline constexpr value_type lowest_value()
  {
    return cuda::std::numeric_limits<value_type>::lowest();
  }
 
 private:
  value_type _value;
};
 
// comparison operators
template <typename Integer>
CUDF_HOST_DEVICE inline bool operator==(dictionary_wrapper<Integer> const& lhs,
                                        dictionary_wrapper<Integer> const& rhs)
{
  return lhs.value() == rhs.value();
}
 
template <typename Integer>
CUDF_HOST_DEVICE inline bool operator!=(dictionary_wrapper<Integer> const& lhs,
                                        dictionary_wrapper<Integer> const& rhs)
{
  return lhs.value() != rhs.value();
}
 
template <typename Integer>
CUDF_HOST_DEVICE inline bool operator<=(dictionary_wrapper<Integer> const& lhs,
                                        dictionary_wrapper<Integer> const& rhs)
{
  return lhs.value() <= rhs.value();
}
 
template <typename Integer>
CUDF_HOST_DEVICE inline bool operator>=(dictionary_wrapper<Integer> const& lhs,
                                        dictionary_wrapper<Integer> const& rhs)
{
  return lhs.value() >= rhs.value();
}
 
template <typename Integer>
CUDF_HOST_DEVICE inline constexpr bool operator<(dictionary_wrapper<Integer> const& lhs,
                                                 dictionary_wrapper<Integer> const& rhs)
{
  return lhs.value() < rhs.value();
}
 
template <typename Integer>
CUDF_HOST_DEVICE inline bool operator>(dictionary_wrapper<Integer> const& lhs,
                                       dictionary_wrapper<Integer> const& rhs)
{
  return lhs.value() > rhs.value();
}
 
using dictionary32 = dictionary_wrapper<int32_t>;  
  // end of group
}  // namespace CUDF_EXPORT cudf