typeManipulation.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2021, Lawrence Livermore National Security, LLC and LvArray contributors.
 * All rights reserved.
 * See the LICENSE file for details.
 * SPDX-License-Identifier: (BSD-3-Clause)
 */

#pragma once

// Source includes
#include "LvArrayConfig.hpp"
#include "Macros.hpp"

// TPL includes
#include <camp/camp.hpp>

// System includes
#include <initializer_list>
#include <utility>
#include <type_traits>

#if defined(__GLIBCXX__) && __GLIBCXX__ <= 20150626
namespace std
{
template< typename T >
using is_trivially_default_constructible = has_trivial_default_constructor< T >;
}
#endif

#define IS_VALID_EXPRESSION( NAME, T, ... ) \
  template< typename _T > \
  struct NAME ## _impl \
  { \
private: \
    template< typename T > static constexpr auto test( int )->decltype( __VA_ARGS__, bool() ) \
    { return true; } \
    template< typename T > static constexpr auto test( ... )->bool \
    { return false; } \
public: \
    static constexpr bool value = test< _T >( 0 ); \
  }; \
  template< typename T > \
  static constexpr bool NAME = NAME ## _impl< T >::value

#define IS_VALID_EXPRESSION_2( NAME, T, U, ... ) \
  template< typename _T, typename _U > \
  struct NAME ## _impl \
  { \
private: \
    template< typename T, typename U > static constexpr auto test( int )->decltype( __VA_ARGS__, bool() ) \
    { return true; } \
    template< typename T, typename U > static constexpr auto test( ... )->bool \
    { return false; } \
public: \
    static constexpr bool value = test< _T, _U >( 0 ); \
  }; \
  template< typename T, typename U > \
  static constexpr bool NAME = NAME ## _impl< T, U >::value

#define HAS_MEMBER_FUNCTION_NO_RTYPE( NAME, ... ) \
  IS_VALID_EXPRESSION( HasMemberFunction_ ## NAME, CLASS, std::declval< CLASS & >().NAME( __VA_ARGS__ ) )

#define HAS_MEMBER_TYPE( NAME ) \
  IS_VALID_EXPRESSION( HasMemberType_ ## NAME, CLASS, std::declval< typename CLASS::NAME >() )

#define HAS_STATIC_MEMBER( NAME ) \
  IS_VALID_EXPRESSION( HasStaticMember_ ## NAME, CLASS, std::enable_if_t< !std::is_member_pointer< decltype( &CLASS::NAME ) >::value, bool >{} )

namespace LvArray
{

namespace typeManipulation
{

DISABLE_HD_WARNING
template< typename F >
inline constexpr LVARRAY_HOST_DEVICE
void forEachArg( F && f )
{ LVARRAY_UNUSED_VARIABLE( f ); }

DISABLE_HD_WARNING
template< typename F, typename ARG, typename ... ARGS >
inline constexpr LVARRAY_HOST_DEVICE
void forEachArg( F && f, ARG && arg, ARGS && ... args )
{
  f( arg );
  forEachArg( std::forward< F >( f ), std::forward< ARGS >( args ) ... );
}

template< bool ... BOOLS >
using all_of = camp::concepts::metalib::all_of< BOOLS ... >;

template< typename ... TYPES >
using all_of_t = camp::concepts::metalib::all_of_t< TYPES ... >;

template< template< typename ... > class TEMPLATE,
          typename TYPE >
constexpr bool is_instantiation_of = false;

template< template< typename ... > class TEMPLATE,
          typename ... ARGS >
constexpr bool is_instantiation_of< TEMPLATE, TEMPLATE< ARGS... > > = true;

HAS_MEMBER_FUNCTION_NO_RTYPE( toView, );

HAS_MEMBER_FUNCTION_NO_RTYPE( toViewConstSizes, );

HAS_MEMBER_FUNCTION_NO_RTYPE( toViewConst, );

HAS_MEMBER_FUNCTION_NO_RTYPE( toNestedView, );

HAS_MEMBER_FUNCTION_NO_RTYPE( toNestedViewConst, );

namespace internal
{

template< typename T, bool=HasMemberFunction_toView< T > >
struct GetViewType
{
  using type = T &;
};

template< typename T >
struct GetViewType< T, true >
{
  using type = decltype( std::declval< T & >().toView() );
};

template< typename T, bool=HasMemberFunction_toViewConstSizes< T > >
struct GetViewTypeConstSizes
{
  using type = typename GetViewType< T >::type;
};

template< typename T >
struct GetViewTypeConstSizes< T, true >
{
  using type = decltype( std::declval< T & >().toViewConstSizes() );
};

template< typename T, bool=HasMemberFunction_toViewConst< T > >
struct GetViewTypeConst
{
  using type = std::remove_reference_t< T > const &;
};

template< typename T >
struct GetViewTypeConst< T, true >
{
  using type = decltype( std::declval< T & >().toViewConst() );
};

template< typename T, bool=HasMemberFunction_toNestedView< T > >
struct GetNestedViewType
{
  using type = typename GetViewType< T >::type;
};

template< typename T >
struct GetNestedViewType< T, true >
{
  using type = decltype( std::declval< T & >().toNestedView() ) const;
};

template< typename T, bool=HasMemberFunction_toNestedViewConst< T > >
struct GetNestedViewTypeConst
{
  using type = typename GetViewTypeConst< T >::type;
};

template< typename T >
struct GetNestedViewTypeConst< T, true >
{
  using type = decltype( std::declval< T & >().toNestedViewConst() ) const;
};

} // namespace internal

template< typename T >
using ViewType = typename internal::GetViewType< T >::type;

template< typename T >
using ViewTypeConstSizes = typename internal::GetViewTypeConstSizes< T >::type;

template< typename T >
using ViewTypeConst = typename internal::GetViewTypeConst< T >::type;

template< typename T >
using NestedViewType = typename internal::GetNestedViewType< T >::type;

template< typename T >
using NestedViewTypeConst = typename internal::GetNestedViewTypeConst< T >::type;


namespace internal
{

template< camp::idx_t INDEX_TO_FIND, camp::idx_t INDEX >
constexpr bool contains( camp::idx_seq< INDEX > )
{ return INDEX_TO_FIND == INDEX; }

template< camp::idx_t INDEX_TO_FIND, camp::idx_t INDEX0, camp::idx_t INDEX1, camp::idx_t... INDICES >
constexpr bool contains( camp::idx_seq< INDEX0, INDEX1, INDICES... > )
{ return ( INDEX_TO_FIND == INDEX0 ) || contains< INDEX_TO_FIND >( camp::idx_seq< INDEX1, INDICES... > {} ); }

template< typename PERMUTATION, camp::idx_t... INDICES >
constexpr bool isValidPermutation( PERMUTATION, camp::idx_seq< INDICES... > )
{ return all_of< contains< INDICES >( PERMUTATION {} )... >::value; }

template< camp::idx_t... INDICES >
constexpr camp::idx_t getDimension( camp::idx_seq< INDICES... > )
{ return sizeof...( INDICES ); }

} // namespace internal

template< typename T >
static constexpr camp::idx_t getDimension = internal::getDimension( T {} );

template< camp::idx_t... INDICES >
LVARRAY_HOST_DEVICE constexpr camp::idx_t getStrideOneDimension( camp::idx_seq< INDICES... > )
{
  constexpr camp::idx_t dimension = camp::seq_at< sizeof...( INDICES ) - 1, camp::idx_seq< INDICES... > >::value;
  static_assert( dimension >= 0, "The dimension must be greater than zero." );
  static_assert( dimension < sizeof...( INDICES ), "The dimension must be less than NDIM." );
  return dimension;
}

template< typename PERMUTATION >
constexpr bool isValidPermutation( PERMUTATION )
{
  constexpr int NDIM = getDimension< PERMUTATION >;
  return internal::isValidPermutation( PERMUTATION {}, camp::make_idx_seq_t< NDIM > {} );
}

template< typename T, typename U, typename INDEX_TYPE >
constexpr inline LVARRAY_HOST_DEVICE
std::enable_if_t< ( sizeof( T ) <= sizeof( U ) ), INDEX_TYPE >
convertSize( INDEX_TYPE const numU )
{
  static_assert( sizeof( U ) % sizeof( T ) == 0, "T and U need to have compatable sizes." );

  return numU * sizeof( U ) / sizeof( T );
}

template< typename T, typename U, typename INDEX_TYPE >
inline LVARRAY_HOST_DEVICE
std::enable_if_t< ( sizeof( T ) > sizeof( U ) ), INDEX_TYPE >
convertSize( INDEX_TYPE const numU )
{
  static_assert( sizeof( T ) % sizeof( U ) == 0, "T and U need to have compatable sizes." );

  INDEX_TYPE const numUPerT = sizeof( T ) / sizeof( U );
  INDEX_TYPE const remainder = numU % numUPerT;
  LVARRAY_ERROR_IF_NE( remainder, 0 );

  return numU / numUPerT;
}

template< typename T, camp::idx_t N >
struct CArray
{
  LVARRAY_INTEL_CONSTEXPR inline LVARRAY_HOST_DEVICE
  T & operator[]( camp::idx_t const i )
  { return data[ i ]; }

  constexpr inline LVARRAY_HOST_DEVICE
  T const & operator[]( camp::idx_t const i ) const
  { return data[ i ]; }

  constexpr inline LVARRAY_HOST_DEVICE
  camp::idx_t size()
  { return N; }

  // TODO(corbett5) remove {}
  T data[ N ] = {};
};

template< camp::idx_t... INDICES >
LVARRAY_HOST_DEVICE inline constexpr
CArray< camp::idx_t, sizeof...( INDICES ) > asArray( camp::idx_seq< INDICES... > )
{ return { INDICES ... }; }

} // namespace typeManipulation
} // namespace LvArray