dictionary.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2020-2024, 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 <cuda_runtime.h>
 
#include <limits>
 
namespace 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 inline value_type value() const { return _value; }
 
  static CUDF_HOST_DEVICE inline constexpr value_type max_value()
  {
    return std::numeric_limits<value_type>::max();
  }
 
  static CUDF_HOST_DEVICE inline constexpr value_type min_value()
  {
    return std::numeric_limits<value_type>::min();
  }
 
  static CUDF_HOST_DEVICE inline constexpr value_type lowest_value()
  {
    return 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