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::VTK_IMPLICIT_ARRAY>
class vtkImplicitArray
  : public vtkGenericDataArray<vtkImplicitArray<BackendT, ArrayType>,
      typename vtk::detail::implicit_array_traits<BackendT>::rtype, ArrayType>
{
  static_assert(vtk::detail::implicit_array_traits<BackendT>::can_read,
    "Supplied backend type does not have mandatory read trait. Must implement either map() const "
    "or operator() const.");
  using GenericDataArrayType = vtkGenericDataArray<vtkImplicitArray<BackendT, ArrayType>,
    typename vtk::detail::implicit_array_traits<BackendT>::rtype, 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 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; }

  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
 
// This macro is used by the subclasses to create dummy
// declarations for these functions such that the wrapper
// can see them. The wrappers ignore vtkImplicitArray.
#define vtkCreateImplicitWrappedArrayInterface(T)                                                  \
  vtkCreateWrappedArrayReadInterface(T);                                                           \
  bool SetNumberOfValues(vtkIdType number) override;
 
#include "vtkImplicitArray.txx"
 
#endif // vtkImplicitArray_h
 
// VTK-HeaderTest-Exclude: vtkImplicitArray.h