IndexValue.hpp

Go to the documentation of this file.

 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
// Copyright (c) Lawrence Livermore National Security, LLC and other
// RAJA Project Developers. See top-level LICENSE and COPYRIGHT
// files for dates and other details. No copyright assignment is required
// to contribute to RAJA.
//
// SPDX-License-Identifier: (BSD-3-Clause)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
 
#ifndef RAJA_INDEXVALUE_HPP
#define RAJA_INDEXVALUE_HPP
 
#include "RAJA/config.hpp"
 
#include <string>
 
#include "RAJA/util/macros.hpp"
#include "RAJA/util/types.hpp"
 
namespace RAJA
{
 
struct IndexValueBase
{};
 
template<typename TYPE, typename VALUE = RAJA::Index_type>
struct IndexValue : public IndexValueBase
{
 
  using value_type = VALUE;
 
  RAJA_INLINE constexpr IndexValue()                   = default;
  constexpr RAJA_INLINE IndexValue(IndexValue const&)  = default;
  constexpr RAJA_INLINE IndexValue(IndexValue&&)       = default;
  RAJA_INLINE IndexValue& operator=(IndexValue const&) = default;
  RAJA_INLINE IndexValue& operator=(IndexValue&&)      = default;
 
  RAJA_HOST_DEVICE RAJA_INLINE constexpr explicit IndexValue(value_type v)
      : value(v)
  {}
 
  RAJA_HOST_DEVICE RAJA_INLINE value_type& operator*() { return value; }
 
  RAJA_HOST_DEVICE RAJA_INLINE const value_type& operator*() const
  {
    return value;
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE operator++(int)
  {
    TYPE self(value);
    value++;
    return self;
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE& operator++()
  {
    value++;
    return static_cast<TYPE&>(*this);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE operator--(int)
  {
    TYPE self(value);
    value--;
    return self;
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE& operator--()
  {
    value--;
    return static_cast<TYPE&>(*this);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE operator+(value_type a) const
  {
    return TYPE(value + a);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE operator+(TYPE a) const
  {
    return TYPE(value + a.value);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE operator-(value_type a) const
  {
    return TYPE(value - a);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE operator-(TYPE a) const
  {
    return TYPE(value - a.value);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE operator*(value_type a) const
  {
    return TYPE(value * a);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE operator*(TYPE a) const
  {
    return TYPE(value * a.value);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE operator/(value_type a) const
  {
    return TYPE(value / a);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE operator/(TYPE a) const
  {
    return TYPE(value / a.value);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE operator%(value_type a) const
  {
    return TYPE(value % a);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE operator%(TYPE a) const
  {
    return TYPE(value % a.value);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE& operator+=(value_type x)
  {
    value += x;
    return static_cast<TYPE&>(*this);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE& operator+=(TYPE x)
  {
    value += x.value;
    return static_cast<TYPE&>(*this);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE& operator-=(value_type x)
  {
    value -= x;
    return static_cast<TYPE&>(*this);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE& operator-=(TYPE x)
  {
    value -= x.value;
    return static_cast<TYPE&>(*this);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE& operator*=(value_type x)
  {
    value *= x;
    return static_cast<TYPE&>(*this);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE& operator*=(TYPE x)
  {
    value *= x.value;
    return static_cast<TYPE&>(*this);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE& operator/=(value_type x)
  {
    value /= x;
    return static_cast<TYPE&>(*this);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE TYPE& operator/=(TYPE x)
  {
    value /= x.value;
    return static_cast<TYPE&>(*this);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE bool operator<(value_type x) const
  {
    return (value < x);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE bool operator<(TYPE x) const
  {
    return (value < x.value);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE bool operator<=(value_type x) const
  {
    return (value <= x);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE bool operator<=(TYPE x) const
  {
    return (value <= x.value);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE bool operator>(value_type x) const
  {
    return (value > x);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE bool operator>(TYPE x) const
  {
    return (value > x.value);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE bool operator>=(value_type x) const
  {
    return (value >= x);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE bool operator>=(TYPE x) const
  {
    return (value >= x.value);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE bool operator==(value_type x) const
  {
    return (value == x);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE bool operator==(TYPE x) const
  {
    return (value == x.value);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE bool operator!=(value_type x) const
  {
    return (value != x);
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE bool operator!=(TYPE x) const
  {
    return (value != x.value);
  }
 
  // This is not implemented... but should be by the derived type
  // this is done by the macro
  static std::string getName();
 
protected:
  value_type value = 0;
};
 
namespace internal
{
 
template<typename TO, typename FROM>
constexpr RAJA_HOST_DEVICE RAJA_INLINE TO convertIndex_helper(FROM const val)
{
  return TO(val);
}
 
template<typename TO, typename FROM>
constexpr RAJA_HOST_DEVICE RAJA_INLINE TO
convertIndex_helper(typename FROM::IndexValueType const val)
{
  return static_cast<TO>(*val);
}
 
 
}  // namespace internal
 
template<typename TO, typename FROM>
constexpr RAJA_HOST_DEVICE RAJA_INLINE TO convertIndex(FROM const val)
{
  return internal::convertIndex_helper<TO, FROM>(val);
}
 
// This version is enabled if FROM is a strongly typed class
template<typename FROM>
constexpr RAJA_HOST_DEVICE RAJA_INLINE
    typename std::enable_if<std::is_base_of<IndexValueBase, FROM>::value,
                            typename FROM::value_type>::type
    stripIndexType(FROM const val)
{
  return *val;
}
 
/*
 * enabled if FROM is not a strongly typed class
 */
template<typename FROM>
constexpr RAJA_HOST_DEVICE RAJA_INLINE
    typename std::enable_if<!std::is_base_of<IndexValueBase, FROM>::value,
                            FROM>::type
    stripIndexType(FROM const val)
{
  return val;
}
 
namespace internal
{
template<typename FROM, typename Enable = void>
struct StripIndexTypeT
{
  using type = FROM;
};
 
template<typename FROM>
struct StripIndexTypeT<
    FROM,
    typename std::enable_if<std::is_base_of<IndexValueBase, FROM>::value>::type>
{
  using type = typename FROM::value_type;
};
}  // namespace internal
 
template<typename FROM>
using strip_index_type_t = typename internal::StripIndexTypeT<FROM>::type;
 
template<typename FROM>
using make_signed_t =
    typename std::conditional<std::is_floating_point<FROM>::value,
                              std::common_type<FROM>,
                              std::make_signed<FROM>>::type::type;
 
}  // namespace RAJA
 
#define RAJA_INDEX_VALUE(TYPE, NAME)                                           \
  class TYPE : public ::RAJA::IndexValue<TYPE>                                 \
  {                                                                            \
    using parent = ::RAJA::IndexValue<TYPE>;                                   \
                                                                               \
  public:                                                                      \
    using IndexValueType = TYPE;                                               \
    RAJA_HOST_DEVICE RAJA_INLINE TYPE() : parent::IndexValue() {}              \
    RAJA_HOST_DEVICE RAJA_INLINE explicit TYPE(::RAJA::Index_type v)           \
        : parent::IndexValue(v)                                                \
    {}                                                                         \
    static inline std::string getName() { return NAME; }                       \
  };
 
#define RAJA_INDEX_VALUE_T(TYPE, IDXT, NAME)                                   \
  class TYPE : public ::RAJA::IndexValue<TYPE, IDXT>                           \
  {                                                                            \
  public:                                                                      \
    RAJA_HOST_DEVICE RAJA_INLINE TYPE()                                        \
        : RAJA::IndexValue<TYPE, IDXT>::IndexValue()                           \
    {}                                                                         \
    RAJA_HOST_DEVICE RAJA_INLINE explicit TYPE(IDXT v)                         \
        : RAJA::IndexValue<TYPE, IDXT>::IndexValue(v)                          \
    {}                                                                         \
    static inline std::string getName() { return NAME; }                       \
  };
 
#endif