VecTraits.h

Go to the documentation of this file.

//============================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_VecTraits_h
#define vtk_m_VecTraits_h
 
#include <vtkm/Deprecated.h>
#include <vtkm/StaticAssert.h>
#include <vtkm/Types.h>
 
namespace vtkm
{
 
struct VecTraitsTagMultipleComponents
{
};
 
struct VecTraitsTagSingleComponent
{
};
 
struct VecTraitsTagSizeStatic
{
};
 
struct VecTraitsTagSizeVariable
{
};
 
template <class T>
struct VTKM_NEVER_EXPORT VecTraits
{
  // The base VecTraits should not be used with qualifiers.
  VTKM_STATIC_ASSERT_MSG((std::is_same<std::remove_pointer_t<std::decay_t<T>>, T>::value),
                         "The base VecTraits should not be used with qualifiers.");
 
  using ComponentType = T;
 
  using BaseComponentType = T;
 
  static constexpr vtkm::IdComponent NUM_COMPONENTS = 1;
 
  static constexpr vtkm::IdComponent GetNumberOfComponents(const T&) { return NUM_COMPONENTS; }
 
  using HasMultipleComponents = vtkm::VecTraitsTagSingleComponent;
 
  using IsSizeStatic = vtkm::VecTraitsTagSizeStatic;
 
  VTKM_EXEC_CONT static const ComponentType& GetComponent(const T& vector,
                                                          vtkm::IdComponent vtkmNotUsed(component))
  {
    return vector;
  }
  VTKM_EXEC_CONT static ComponentType& GetComponent(T& vector,
                                                    vtkm::IdComponent vtkmNotUsed(component))
  {
    return vector;
  }
 
  VTKM_EXEC_CONT static void SetComponent(T& vector,
                                          vtkm::IdComponent vtkmNotUsed(component),
                                          ComponentType value)
  {
    vector = value;
  }
 
  // Note: the `%` in the code samples above is a hint to doxygen to avoid attempting
  // to link to the object (i.e. `ReplaceBaseComponentType`), which results in a warning.
  // The `%` is removed from the doxygen text.
  template <typename NewComponentType>
  using ReplaceComponentType = NewComponentType;
 
  // Note: the `%` in the code samples above is a hint to doxygen to avoid attempting
  // to link to the object (i.e. `ReplaceBaseComponentType`), which results in a warning.
  // The `%` is removed from the doxygen text.
  template <typename NewComponentType>
  using ReplaceBaseComponentType = NewComponentType;
 
  template <vtkm::IdComponent destSize>
  VTKM_EXEC_CONT static void CopyInto(const T& src, vtkm::Vec<ComponentType, destSize>& dest)
  {
    dest[0] = src;
  }
};
 
template <typename T>
using HasVecTraits VTKM_DEPRECATED(2.1, "All types now have VecTraits defined.") = std::true_type;
 
// These partial specializations allow VecTraits to work with const and reference qualifiers.
template <typename T>
struct VTKM_NEVER_EXPORT VecTraits<const T> : VecTraits<T>
{
};
template <typename T>
struct VTKM_NEVER_EXPORT VecTraits<T&> : VecTraits<T>
{
};
template <typename T>
struct VTKM_NEVER_EXPORT VecTraits<const T&> : VecTraits<T>
{
};
 
// This partial specialization allows VecTraits to work with pointers.
template <typename T>
struct VTKM_NEVER_EXPORT VecTraits<T*> : VecTraits<T>
{
  VTKM_EXEC_CONT static vtkm::IdComponent GetNumberOfComponents(const T* vector)
  {
    return VecTraits<T>::GetNumberOfComponents(*vector);
  }
  VTKM_EXEC_CONT static auto GetComponent(const T* vector, vtkm::IdComponent component)
    -> decltype(VecTraits<T>::GetComponent(*vector, component))
  {
    return VecTraits<T>::GetComponent(*vector, component);
  }
  VTKM_EXEC_CONT static auto GetComponent(T* vector, vtkm::IdComponent component)
    -> decltype(VecTraits<T>::GetComponent(*vector, component))
  {
    return VecTraits<T>::GetComponent(*vector, component);
  }
  VTKM_EXEC_CONT static void SetComponent(T* vector,
                                          vtkm::IdComponent component,
                                          typename VecTraits<T>::ComponentType value)
  {
    VecTraits<T>::SetComponent(*vector, component, value);
  }
  template <typename NewComponentType>
  using ReplaceComponentType =
    typename VecTraits<T>::template ReplaceComponentType<NewComponentType>*;
  template <typename NewComponentType>
  using ReplaceBaseComponentType =
    typename VecTraits<T>::template ReplaceBaseComponentType<NewComponentType>*;
  template <vtkm::IdComponent destSize>
  VTKM_EXEC_CONT static void CopyInto(
    const T* src,
    vtkm::Vec<typename VecTraits<T>::ComponentType, destSize>& dest)
  {
    VecTraits<T>::CopyInto(*src, dest);
  }
};
template <typename T>
struct VTKM_NEVER_EXPORT VecTraits<const T*> : VecTraits<T*>
{
};
 
#if defined(VTKM_GCC) && (__GNUC__ <= 5)
namespace detail
{
 
template <typename NewT, vtkm::IdComponent Size>
struct VecReplaceComponentTypeGCC4or5
{
  using type = vtkm::Vec<NewT, Size>;
};
 
template <typename T, vtkm::IdComponent Size, typename NewT>
struct VecReplaceBaseComponentTypeGCC4or5
{
  using type =
    vtkm::Vec<typename vtkm::VecTraits<T>::template ReplaceBaseComponentType<NewT>, Size>;
};
 
} // namespace detail
#endif // GCC Version 4.8
 
namespace internal
{
 
template <vtkm::IdComponent numComponents, typename ComponentType>
struct VecTraitsMultipleComponentChooser
{
  using Type = vtkm::VecTraitsTagMultipleComponents;
};
 
template <typename ComponentType>
struct VecTraitsMultipleComponentChooser<1, ComponentType>
{
  using Type = typename vtkm::VecTraits<ComponentType>::HasMultipleComponents;
};
 
} // namespace internal
 
template <typename T, vtkm::IdComponent Size>
struct VTKM_NEVER_EXPORT VecTraits<vtkm::Vec<T, Size>>
{
  using VecType = vtkm::Vec<T, Size>;
 
  using ComponentType = typename VecType::ComponentType;
 
  using BaseComponentType = typename vtkm::VecTraits<ComponentType>::BaseComponentType;
 
  static constexpr vtkm::IdComponent NUM_COMPONENTS = VecType::NUM_COMPONENTS;
 
  VTKM_EXEC_CONT
  static vtkm::IdComponent GetNumberOfComponents(const VecType&) { return NUM_COMPONENTS; }
 
  using HasMultipleComponents =
    typename internal::VecTraitsMultipleComponentChooser<NUM_COMPONENTS, ComponentType>::Type;
 
  using IsSizeStatic = vtkm::VecTraitsTagSizeStatic;
 
  VTKM_EXEC_CONT
  static const ComponentType& GetComponent(const VecType& vector, vtkm::IdComponent component)
  {
    return vector[component];
  }
  VTKM_EXEC_CONT
  static ComponentType& GetComponent(VecType& vector, vtkm::IdComponent component)
  {
    return vector[component];
  }
 
  VTKM_EXEC_CONT static void SetComponent(VecType& vector,
                                          vtkm::IdComponent component,
                                          ComponentType value)
  {
    vector[component] = value;
  }
 
#if defined(VTKM_GCC) && (__GNUC__ <= 5)
  // Silly workaround for bug in GCC <= 5
  template <typename NewComponentType>
  using ReplaceComponentType =
    typename detail::VecReplaceComponentTypeGCC4or5<NewComponentType, Size>::type;
#else // !GCC <= 5
  template <typename NewComponentType>
  using ReplaceComponentType = vtkm::Vec<NewComponentType, Size>;
#endif
 
#if defined(VTKM_GCC) && (__GNUC__ <= 5)
  // Silly workaround for bug in GCC <= 5
  template <typename NewComponentType>
  using ReplaceBaseComponentType =
    typename detail::VecReplaceBaseComponentTypeGCC4or5<T, Size, NewComponentType>::type;
#else // !GCC <= 5
  template <typename NewComponentType>
  using ReplaceBaseComponentType = vtkm::Vec<
    typename vtkm::VecTraits<ComponentType>::template ReplaceBaseComponentType<NewComponentType>,
    Size>;
#endif
 
  template <vtkm::IdComponent destSize>
  VTKM_EXEC_CONT static void CopyInto(const VecType& src, vtkm::Vec<ComponentType, destSize>& dest)
  {
    src.CopyInto(dest);
  }
};
 
template <typename T>
struct VTKM_NEVER_EXPORT VecTraits<vtkm::VecC<T>>
{
  using VecType = vtkm::VecC<T>;
 
  using ComponentType = typename VecType::ComponentType;
 
  using BaseComponentType = typename vtkm::VecTraits<ComponentType>::BaseComponentType;
 
  VTKM_EXEC_CONT
  static vtkm::IdComponent GetNumberOfComponents(const VecType& vector)
  {
    return vector.GetNumberOfComponents();
  }
 
  using HasMultipleComponents = vtkm::VecTraitsTagMultipleComponents;
 
  using IsSizeStatic = vtkm::VecTraitsTagSizeVariable;
 
  VTKM_EXEC_CONT
  static const ComponentType& GetComponent(const VecType& vector, vtkm::IdComponent component)
  {
    return vector[component];
  }
  VTKM_EXEC_CONT
  static ComponentType& GetComponent(VecType& vector, vtkm::IdComponent component)
  {
    return vector[component];
  }
 
  VTKM_EXEC_CONT
  static void SetComponent(VecType& vector, vtkm::IdComponent component, ComponentType value)
  {
    vector[component] = value;
  }
 
  template <typename NewComponentType>
  using ReplaceComponentType = vtkm::VecC<NewComponentType>;
 
  template <typename NewComponentType>
  using ReplaceBaseComponentType = vtkm::VecC<
    typename vtkm::VecTraits<ComponentType>::template ReplaceBaseComponentType<NewComponentType>>;
 
  template <vtkm::IdComponent destSize>
  VTKM_EXEC_CONT static void CopyInto(const VecType& src, vtkm::Vec<ComponentType, destSize>& dest)
  {
    src.CopyInto(dest);
  }
};
 
template <typename T>
struct VTKM_NEVER_EXPORT VecTraits<vtkm::VecCConst<T>>
{
  using VecType = vtkm::VecCConst<T>;
 
  using ComponentType = typename VecType::ComponentType;
 
  using BaseComponentType = typename vtkm::VecTraits<ComponentType>::BaseComponentType;
 
  VTKM_EXEC_CONT
  static vtkm::IdComponent GetNumberOfComponents(const VecType& vector)
  {
    return vector.GetNumberOfComponents();
  }
 
  using HasMultipleComponents = vtkm::VecTraitsTagMultipleComponents;
 
  using IsSizeStatic = vtkm::VecTraitsTagSizeVariable;
 
  VTKM_EXEC_CONT
  static const ComponentType& GetComponent(const VecType& vector, vtkm::IdComponent component)
  {
    return vector[component];
  }
 
  VTKM_EXEC_CONT
  static void SetComponent(VecType& vector, vtkm::IdComponent component, ComponentType value)
  {
    vector[component] = value;
  }
 
  template <typename NewComponentType>
  using ReplaceComponentType = vtkm::VecCConst<NewComponentType>;
 
  template <typename NewComponentType>
  using ReplaceBaseComponentType = vtkm::VecCConst<
    typename vtkm::VecTraits<ComponentType>::template ReplaceBaseComponentType<NewComponentType>>;
 
  template <vtkm::IdComponent destSize>
  VTKM_EXEC_CONT static void CopyInto(const VecType& src, vtkm::Vec<ComponentType, destSize>& dest)
  {
    src.CopyInto(dest);
  }
};
 
namespace internal
{
 
template <typename ScalarType>
struct VTKM_DEPRECATED(2.1, "VecTraitsBasic is now the default implementation for VecTraits.")
  VTKM_NEVER_EXPORT VecTraitsBasic
{
  using ComponentType = ScalarType;
  using BaseComponentType = ScalarType;
  static constexpr vtkm::IdComponent NUM_COMPONENTS = 1;
  using HasMultipleComponents = vtkm::VecTraitsTagSingleComponent;
  using IsSizeStatic = vtkm::VecTraitsTagSizeStatic;
 
  VTKM_EXEC_CONT
  static vtkm::IdComponent GetNumberOfComponents(const ScalarType&) { return 1; }
 
  VTKM_EXEC_CONT
  static const ComponentType& GetComponent(const ScalarType& vector, vtkm::IdComponent)
  {
    return vector;
  }
  VTKM_EXEC_CONT
  static ComponentType& GetComponent(ScalarType& vector, vtkm::IdComponent) { return vector; }
 
  VTKM_EXEC_CONT static void SetComponent(ScalarType& vector,
                                          vtkm::IdComponent,
                                          ComponentType value)
  {
    vector = value;
  }
 
  template <typename NewComponentType>
  using ReplaceComponentType = NewComponentType;
 
  template <typename NewComponentType>
  using ReplaceBaseComponentType = NewComponentType;
 
  template <vtkm::IdComponent destSize>
  VTKM_EXEC_CONT static void CopyInto(const ScalarType& src, vtkm::Vec<ScalarType, destSize>& dest)
  {
    dest[0] = src;
  }
};
 
template <typename T>
struct VTKM_DEPRECATED(2.1 "VecTraits now safe to use on any type.") VTKM_NEVER_EXPORT SafeVecTraits
  : vtkm::VecTraits<T>
{
};
 
} // namespace internal
 
namespace detail
{
 
struct VTKM_DEPRECATED(2.1,
                       "VTKM_BASIC_TYPE_VECTOR is no longer necessary because VecTraits implements "
                       "basic type by default.") VTKM_BASIC_TYPE_VECTOR_is_deprecated
{
};
 
template <typename T>
struct issue_VTKM_BASIC_TYPE_VECTOR_deprecation_warning;
 
}
 
} // namespace vtkm
 
#define VTKM_BASIC_TYPE_VECTOR(type)                            \
  namespace vtkm                                                \
  {                                                             \
  namespace detail                                              \
  {                                                             \
  template <>                                                   \
  struct issue_VTKM_BASIC_TYPE_VECTOR_deprecation_warning<type> \
    : public vtkm::detail::VTKM_BASIC_TYPE_VECTOR_is_deprecated \
  {                                                             \
  };                                                            \
  }                                                             \
  }
 
#endif //vtk_m_VecTraits_h