vtkImplicitArray.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
// Funded by CEA, DAM, DIF, F-91297 Arpajon, France
#ifndef vtkImplicitArray_h
#define vtkImplicitArray_h
 
#include "vtkCommonCoreModule.h" // for export macro
#include "vtkGenericDataArray.h"
#include "vtkImplicitArrayTraits.h" // for traits
 
#include <memory>
#include <type_traits>
 
//-------------------------------------------------------------------------------------------------
// Special macro for implicit array types modifying the behavior of NewInstance to provide writable
// AOS arrays instead of empty implicit arrays
#define vtkImplicitArrayTypeMacro(thisClass, superclass)                                           \
  vtkAbstractTypeMacroWithNewInstanceType(thisClass, superclass,                                   \
    vtkAOSDataArrayTemplate<typename thisClass::ValueType>, typeid(thisClass).name());             \
                                                                                                   \
protected:                                                                                         \
  vtkObjectBase* NewInstanceInternal() const override                                              \
  {                                                                                                \
    return vtkAOSDataArrayTemplate<typename thisClass::ValueType>::New();                          \
  }                                                                                                \
                                                                                                   \
public:
//-------------------------------------------------------------------------------------------------
 
VTK_ABI_NAMESPACE_BEGIN
template <class BackendT, int ArrayType = vtkArrayTypes::ImplicitArray>
class vtkImplicitArray
  : public vtkGenericDataArray<vtkImplicitArray<BackendT, ArrayType>,
      typename vtk::detail::implicit_array_traits<BackendT>::rtype, ArrayType>
{
  using trait = vtk::detail::implicit_array_traits<BackendT>;
  static_assert(trait::can_read,
    "Supplied backend type does not have mandatory read trait. Must implement either map() const "
    "or operator() const.");
  using ValueTypeT = typename trait::rtype;
  using GenericDataArrayType =
    vtkGenericDataArray<vtkImplicitArray<BackendT, ArrayType>, ValueTypeT, ArrayType>;
 
public:
  using SelfType = vtkImplicitArray<BackendT, ArrayType>;
  vtkImplicitArrayTypeMacro(SelfType, GenericDataArrayType);
  using typename Superclass::ArrayTypeTag;
  using typename Superclass::DataTypeTag;
  using typename Superclass::ValueType;
  using BackendType = BackendT;
 
  static vtkImplicitArray* New();
 
 
  ValueType GetValue(vtkIdType idx) const { return this->GetValueImpl<BackendT>(idx); }
 
  void SetValue(vtkIdType idx, ValueType value);
 
  void GetTypedTuple(vtkIdType idx, ValueType* tuple) const
  {
    this->GetTypedTupleImpl<BackendT>(idx, tuple);
  }
 
  void SetTypedTuple(vtkIdType tupleIdx, const ValueType* tuple);
 
  ValueType GetTypedComponent(vtkIdType idx, int comp) const
  {
    return this->GetTypedComponentImpl<BackendT>(idx, comp);
  }
 
  void SetTypedComponent(vtkIdType tupleIdx, int comp, ValueType value);
 
 
  void SetBackend(std::shared_ptr<BackendT> newBackend)
  {
    this->Backend = newBackend;
    this->Modified();
  }
  std::shared_ptr<BackendT> GetBackend() { return this->Backend; }
 
  template <typename... Params>
  void ConstructBackend(Params&&... params)
  {
    this->SetBackend(std::make_shared<BackendT>(std::forward<Params>(params)...));
  }
 
  void* GetVoidPointer(vtkIdType valueIdx) override;
 
  void Squeeze() override;
 
  void Initialize() override
  {
    this->Initialize<BackendT>();
    this->Squeeze();
    this->GenericDataArrayType::Initialize();
  }
 
  unsigned long GetActualMemorySize() const override
  {
    return this->GetActualMemorySizeImpl<BackendT>();
  }
 
 
  template <typename OtherBackend, int OtherArrayType>
  void ImplicitDeepCopy(vtkImplicitArray<OtherBackend, OtherArrayType>* other)
  {
    static_assert(std::is_same_v<BackendT, OtherBackend>,
      "Cannot copy implicit array with one type of backend to an implicit array with a different "
      "type of backend");
    static_assert(ArrayTypeTag::value == OtherArrayType,
      "Cannot copy implicit array with one array type to an implicit array with a different "
      "array type");
    this->SetNumberOfComponents(other->GetNumberOfComponents());
    this->SetNumberOfTuples(other->GetNumberOfTuples());
    this->SetBackend(other->GetBackend());
  }
  using vtkDataArray::DeepCopy;
  void DeepCopy(vtkDataArray* da) override
  {
    if (da == nullptr || da == this)
    {
      return;
    }
    // dispatch to the templated version if possible
    if (auto otherImplicit = vtkImplicitArray<BackendT, ArrayTypeTag::value>::FastDownCast(da))
    {
      this->ImplicitDeepCopy(otherImplicit);
    }
    else
    {
      // otherwise fallback to generic implementation that will copy all values
      this->vtkDataArray::DeepCopy(da);
    }
  }
 
 
  static vtkImplicitArray<BackendT, ArrayType>* FastDownCast(vtkAbstractArray* source);
 
protected:
  vtkImplicitArray();
  ~vtkImplicitArray() override;
 
 
  bool AllocateTuples(vtkIdType vtkNotUsed(numTuples)) { return true; }
  bool ReallocateTuples(vtkIdType vtkNotUsed(numTuples)) { return true; }
 
  struct vtkInternals;
  std::unique_ptr<vtkInternals> Internals;
 
  std::shared_ptr<BackendT> Backend;
 
private:
  vtkImplicitArray(const vtkImplicitArray&) = delete;
  void operator=(const vtkImplicitArray&) = delete;
 
 
  template <typename U>
  typename std::enable_if<vtk::detail::has_map_trait<U>::value, ValueType>::type GetValueImpl(
    vtkIdType idx) const
  {
    return this->Backend->map(idx);
  }
 
 
  template <typename U>
  typename std::enable_if<vtk::detail::is_closure_trait<U>::value, ValueType>::type GetValueImpl(
    vtkIdType idx) const
  {
    return (*this->Backend)(idx);
  }
 
 
  template <typename U>
  typename std::enable_if<vtk::detail::implicit_array_traits<U>::default_constructible, void>::type
  Initialize()
  {
    this->Backend = std::make_shared<BackendT>();
  }
 
 
  template <typename U>
  typename std::enable_if<!vtk::detail::implicit_array_traits<U>::default_constructible, void>::type
  Initialize()
  {
    this->Backend = nullptr;
  }
 
 
  template <typename U>
  typename std::enable_if<vtk::detail::implicit_array_traits<U>::can_direct_read_tuple, void>::type
  GetTypedTupleImpl(vtkIdType idx, ValueType* tuple) const
  {
    static_assert(
      std::is_same<typename vtk::detail::can_map_tuple_trait<U>::rtype, ValueType>::value,
      "Tuple type should be the same as the return type of the mapTuple");
    this->Backend->mapTuple(idx, tuple);
  }
 
 
  template <typename U>
  typename std::enable_if<!vtk::detail::implicit_array_traits<U>::can_direct_read_tuple &&
      vtk::detail::implicit_array_traits<U>::can_direct_read_component,
    void>::type
  GetTypedTupleImpl(vtkIdType idx, ValueType* tuple) const
  {
    for (vtkIdType comp = 0; comp < this->NumberOfComponents; comp++)
    {
      tuple[comp] = this->GetTypedComponent(idx, comp);
    }
  }
 
  template <typename U>
  typename std::enable_if<!vtk::detail::implicit_array_traits<U>::can_direct_read_tuple &&
      !vtk::detail::implicit_array_traits<U>::can_direct_read_component,
    void>::type
  GetTypedTupleImpl(vtkIdType idx, ValueType* tuple) const
  {
    const vtkIdType tupIdx = idx * this->NumberOfComponents;
    for (vtkIdType comp = 0; comp < this->NumberOfComponents; comp++)
    {
      tuple[comp] = this->GetValue(tupIdx + comp);
    }
  }
 
 
  template <typename U>
  typename std::enable_if<vtk::detail::implicit_array_traits<U>::can_direct_read_component,
    ValueType>::type
  GetTypedComponentImpl(vtkIdType idx, int comp) const
  {
    static_assert(
      std::is_same<typename vtk::detail::can_map_component_trait<U>::rtype, ValueType>::value,
      "Component return type should be the same as the return type of the mapComponent");
    return this->Backend->mapComponent(idx, comp);
  }
 
 
  template <typename U>
  typename std::enable_if<!vtk::detail::implicit_array_traits<U>::can_direct_read_component,
    ValueType>::type
  GetTypedComponentImpl(vtkIdType idx, int comp) const
  {
    return this->GetValue(idx * this->NumberOfComponents + comp);
  }
 
 
  template <typename U>
  typename std::enable_if<vtk::detail::implicit_array_traits<U>::can_get_memory_size,
    unsigned long>::type
  GetActualMemorySizeImpl() const
  {
    return this->Backend->getMemorySize();
  }
 
  template <typename U>
  typename std::enable_if<!vtk::detail::implicit_array_traits<U>::can_get_memory_size,
    unsigned long>::type
  GetActualMemorySizeImpl() const
  {
    return 1;
  }
 
  friend class vtkGenericDataArray<SelfType, ValueType, ArrayTypeTag::value>;
};
 
// Declare vtkArrayDownCast implementations for implicit containers:
vtkArrayDownCast_Template2FastCastMacro(vtkImplicitArray);
VTK_ABI_NAMESPACE_END
 
#include "vtkImplicitArray.txx"
 
#endif // vtkImplicitArray_h
 
#define VTK_WRAP_TEMPLATE(...) __VA_ARGS__
// See vtkGenericDataArray for similar section
#ifdef VTK_USE_EXTERN_TEMPLATE
 
#ifndef VTK_IMPLICIT_TEMPLATE_EXTERN
#define VTK_IMPLICIT_TEMPLATE_EXTERN
#ifdef _MSC_VER
#pragma warning(push)
// The following is needed when the following is declared
// dllexport and is used from another class in vtkCommonCore
#pragma warning(disable : 4910) // extern and dllexport incompatible
#endif
 
VTK_ABI_NAMESPACE_BEGIN
template <typename ValueType>
struct vtkAffineImplicitBackend;
template <typename ValueType>
class vtkCompositeImplicitBackend;
template <typename ValueType>
struct vtkConstantImplicitBackend;
template <typename ValueType>
class vtkStructuredPointBackend;
template <typename ValueType>
class vtkIndexedImplicitBackend;
VTK_ABI_NAMESPACE_END
#include <functional>
 
namespace vtkDataArrayPrivate
{
VTK_ABI_NAMESPACE_BEGIN
template <typename A, typename R, typename T>
VTKCOMMONCORE_EXPORT bool DoComputeScalarRange(
  A*, R*, T, const unsigned char* ghosts, unsigned char ghostsToSkip);
template <typename A, typename R>
VTKCOMMONCORE_EXPORT bool DoComputeVectorRange(
  A*, R[2], AllValues, const unsigned char* ghosts, unsigned char ghostsToSkip);
template <typename A, typename R>
VTKCOMMONCORE_EXPORT bool DoComputeVectorRange(
  A*, R[2], FiniteValues, const unsigned char* ghosts, unsigned char ghostsToSkip);
VTK_ABI_NAMESPACE_END
} // namespace vtkDataArrayPrivate
 
#define VTK_DECLARE_VALUERANGE_IMPLICIT_BACKENDTYPE(BackendT, ArrayTypeValue)                      \
  VTK_DECLARE_VALUERANGE_ARRAYTYPE(                                                                \
    VTK_WRAP_TEMPLATE(vtkImplicitArray<BackendT<float>, ArrayTypeValue>), double)                  \
  VTK_DECLARE_VALUERANGE_ARRAYTYPE(                                                                \
    VTK_WRAP_TEMPLATE(vtkImplicitArray<BackendT<double>, ArrayTypeValue>), double)                 \
  VTK_DECLARE_VALUERANGE_ARRAYTYPE(                                                                \
    VTK_WRAP_TEMPLATE(vtkImplicitArray<BackendT<char>, ArrayTypeValue>), double)                   \
  VTK_DECLARE_VALUERANGE_ARRAYTYPE(                                                                \
    VTK_WRAP_TEMPLATE(vtkImplicitArray<BackendT<signed char>, ArrayTypeValue>), double)            \
  VTK_DECLARE_VALUERANGE_ARRAYTYPE(                                                                \
    VTK_WRAP_TEMPLATE(vtkImplicitArray<BackendT<unsigned char>, ArrayTypeValue>), double)          \
  VTK_DECLARE_VALUERANGE_ARRAYTYPE(                                                                \
    VTK_WRAP_TEMPLATE(vtkImplicitArray<BackendT<short>, ArrayTypeValue>), double)                  \
  VTK_DECLARE_VALUERANGE_ARRAYTYPE(                                                                \
    VTK_WRAP_TEMPLATE(vtkImplicitArray<BackendT<unsigned short>, ArrayTypeValue>), double)         \
  VTK_DECLARE_VALUERANGE_ARRAYTYPE(                                                                \
    VTK_WRAP_TEMPLATE(vtkImplicitArray<BackendT<int>, ArrayTypeValue>), double)                    \
  VTK_DECLARE_VALUERANGE_ARRAYTYPE(                                                                \
    VTK_WRAP_TEMPLATE(vtkImplicitArray<BackendT<unsigned int>, ArrayTypeValue>), double)           \
  VTK_DECLARE_VALUERANGE_ARRAYTYPE(                                                                \
    VTK_WRAP_TEMPLATE(vtkImplicitArray<BackendT<long>, ArrayTypeValue>), double)                   \
  VTK_DECLARE_VALUERANGE_ARRAYTYPE(                                                                \
    VTK_WRAP_TEMPLATE(vtkImplicitArray<BackendT<unsigned long>, ArrayTypeValue>), double)          \
  VTK_DECLARE_VALUERANGE_ARRAYTYPE(                                                                \
    VTK_WRAP_TEMPLATE(vtkImplicitArray<BackendT<long long>, ArrayTypeValue>), double)              \
  VTK_DECLARE_VALUERANGE_ARRAYTYPE(                                                                \
    VTK_WRAP_TEMPLATE(vtkImplicitArray<BackendT<unsigned long long>, ArrayTypeValue>), double)
 
namespace vtkDataArrayPrivate
{
VTK_ABI_NAMESPACE_BEGIN
VTK_DECLARE_VALUERANGE_IMPLICIT_BACKENDTYPE(vtkAffineImplicitBackend, vtkArrayTypes::AffineArray)
VTK_DECLARE_VALUERANGE_IMPLICIT_BACKENDTYPE(
  vtkConstantImplicitBackend, vtkArrayTypes::ConstantArray)
VTK_DECLARE_VALUERANGE_IMPLICIT_BACKENDTYPE(
  vtkCompositeImplicitBackend, vtkArrayTypes::CompositeArray)
VTK_DECLARE_VALUERANGE_IMPLICIT_BACKENDTYPE(
  vtkStructuredPointBackend, vtkArrayTypes::StructuredPointArray)
VTK_DECLARE_VALUERANGE_IMPLICIT_BACKENDTYPE(vtkIndexedImplicitBackend, vtkArrayTypes::IndexedArray)
 
VTK_DECLARE_VALUERANGE_ARRAYTYPE(
  VTK_WRAP_TEMPLATE(vtkImplicitArray<std::function<float(int)>, vtkArrayTypes::StdFunctionArray>),
  double)
VTK_DECLARE_VALUERANGE_ARRAYTYPE(
  VTK_WRAP_TEMPLATE(vtkImplicitArray<std::function<double(int)>, vtkArrayTypes::StdFunctionArray>),
  double)
VTK_DECLARE_VALUERANGE_ARRAYTYPE(
  VTK_WRAP_TEMPLATE(vtkImplicitArray<std::function<char(int)>, vtkArrayTypes::StdFunctionArray>),
  double)
VTK_DECLARE_VALUERANGE_ARRAYTYPE(
  VTK_WRAP_TEMPLATE(
    vtkImplicitArray<std::function<signed char(int)>, vtkArrayTypes::StdFunctionArray>),
  double)
VTK_DECLARE_VALUERANGE_ARRAYTYPE(
  VTK_WRAP_TEMPLATE(
    vtkImplicitArray<std::function<unsigned char(int)>, vtkArrayTypes::StdFunctionArray>),
  double)
VTK_DECLARE_VALUERANGE_ARRAYTYPE(
  VTK_WRAP_TEMPLATE(vtkImplicitArray<std::function<short(int)>, vtkArrayTypes::StdFunctionArray>),
  double)
VTK_DECLARE_VALUERANGE_ARRAYTYPE(
  VTK_WRAP_TEMPLATE(
    vtkImplicitArray<std::function<unsigned short(int)>, vtkArrayTypes::StdFunctionArray>),
  double)
VTK_DECLARE_VALUERANGE_ARRAYTYPE(
  VTK_WRAP_TEMPLATE(vtkImplicitArray<std::function<int(int)>, vtkArrayTypes::StdFunctionArray>),
  double)
VTK_DECLARE_VALUERANGE_ARRAYTYPE(
  VTK_WRAP_TEMPLATE(
    vtkImplicitArray<std::function<unsigned int(int)>, vtkArrayTypes::StdFunctionArray>),
  double)
VTK_DECLARE_VALUERANGE_ARRAYTYPE(
  VTK_WRAP_TEMPLATE(vtkImplicitArray<std::function<long(int)>, vtkArrayTypes::StdFunctionArray>),
  double)
VTK_DECLARE_VALUERANGE_ARRAYTYPE(
  VTK_WRAP_TEMPLATE(
    vtkImplicitArray<std::function<unsigned long(int)>, vtkArrayTypes::StdFunctionArray>),
  double)
VTK_DECLARE_VALUERANGE_ARRAYTYPE(
  VTK_WRAP_TEMPLATE(
    vtkImplicitArray<std::function<long long(int)>, vtkArrayTypes::StdFunctionArray>),
  double)
VTK_DECLARE_VALUERANGE_ARRAYTYPE(
  VTK_WRAP_TEMPLATE(
    vtkImplicitArray<std::function<unsigned long long(int)>, vtkArrayTypes::StdFunctionArray>),
  double)
VTK_ABI_NAMESPACE_END
}
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#endif // VTK_IMPLICIT_TEMPLATE_EXTERN
 
#endif // VTK_USE_EXTERN_TEMPLATE