vtkCellArray.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkCellArray_h
#define vtkCellArray_h
 
#include "vtkAbstractCellArray.h"
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkWrappingHints.h"         // For VTK_MARSHALMANUAL
 
#include "vtkAOSDataArrayTemplate.h" // Needed for inline methods
#include "vtkAffineArray.h"          // Needed for inline methods
#include "vtkCell.h"                 // Needed for inline methods
#include "vtkDataArrayRange.h"       // Needed for inline methods
#include "vtkDeprecation.h"          // For VTK_DEPRECATED_IN_9_6_0
#include "vtkFeatures.h"             // for VTK_USE_MEMKIND
#include "vtkSmartPointer.h"         // For vtkSmartPointer
#include "vtkTypeInt32Array.h"       // Needed for inline methods
#include "vtkTypeInt64Array.h"       // Needed for inline methods
#include "vtkTypeList.h"             // Needed for ArrayList definition
 
#include <cassert>          // Needed for assert
#include <initializer_list> // Needed for API
#include <type_traits>      // Needed for std::is_same
#include <utility>          // Needed for std::forward

#define VTK_CELL_ARRAY_V2
 
VTK_ABI_NAMESPACE_BEGIN
class vtkCellArrayIterator;
class vtkIdTypeArray;
 
class VTKCOMMONDATAMODEL_EXPORT VTK_MARSHALMANUAL vtkCellArray : public vtkAbstractCellArray
{
public:
  using ArrayType32 VTK_DEPRECATED_IN_9_6_0("Use AOSArray32 instead.") = vtkTypeInt32Array;
  using ArrayType64 VTK_DEPRECATED_IN_9_6_0("Use AOSArray64 instead.") = vtkTypeInt64Array;
  using AOSArray32 = vtkAOSDataArrayTemplate<vtkTypeInt32>;
  using AOSArray64 = vtkAOSDataArrayTemplate<vtkTypeInt64>;
  using AffineArray32 = vtkAffineArray<vtkTypeInt32>;
  using AffineArray64 = vtkAffineArray<vtkTypeInt64>;


  static vtkCellArray* New();
  vtkTypeMacro(vtkCellArray, vtkAbstractCellArray);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  void PrintDebug(ostream& os);


  using StorageArrayList VTK_DEPRECATED_IN_9_6_0(
    "Use vtkArrayDispatch::OffsetsArrays/ConnectivityArrays instead.") =
    vtkTypeList::Create<vtkTypeInt32Array, vtkTypeInt64Array>;


  using InputArrayList VTK_DEPRECATED_IN_9_6_0(
    "No longer relevant.") = vtkTypeList::Unique<vtkTypeList::Create<vtkAOSDataArrayTemplate<int>,
    vtkAOSDataArrayTemplate<long>, vtkAOSDataArrayTemplate<long long>>>::Result;

   */
  VTK_DEPRECATED_IN_9_6_0("Use AllocateEstimate or AllocateExact instead.")
  vtkTypeBool Allocate(vtkIdType sz, vtkIdType vtkNotUsed(ext) = 1000)
  {
    return this->AllocateExact(sz, sz) ? 1 : 0;
  }

   * @sa Squeeze AllocateExact AllocateCopy
   */
  bool AllocateEstimate(vtkIdType numCells, vtkIdType maxCellSize)
  {
    return this->AllocateExact(numCells, numCells * maxCellSize);
  }

  bool AllocateExact(vtkIdType numCells, vtkIdType connectivitySize);

   * @sa Squeeze AllocateEstimate AllocateExact
   */
  bool AllocateCopy(vtkCellArray* other)
  {
    return this->AllocateExact(other->GetNumberOfCells(), other->GetNumberOfConnectivityIds());
  }

  bool ResizeExact(vtkIdType numCells, vtkIdType connectivitySize);

  void Initialize() override;

  void Reset();

  void Squeeze();

  bool IsValid();

  vtkIdType GetNumberOfCells() const override { return this->Offsets->GetNumberOfValues() - 1; }

  vtkIdType GetNumberOfOffsets() const override { return this->Offsets->GetNumberOfValues(); }

   * Get the offset (into the connectivity) for a specified cell id.
   */
  vtkIdType GetOffset(vtkIdType cellId) override
  {
    return static_cast<vtkIdType>(this->Offsets->GetComponent(cellId, 0));
  }

   * Set the offset (into the connectivity) for a specified cell id.
   */
  void SetOffset(vtkIdType cellId, vtkIdType offset)
  {
    this->Offsets->SetComponent(cellId, 0, static_cast<double>(offset));
  }

   * Get the size of the connectivity array that stores the point ids.
   */
  vtkIdType GetNumberOfConnectivityIds() const override
  {
    return this->Connectivity->GetNumberOfValues();
  }

  VTK_NEWINSTANCE vtkCellArrayIterator* NewIterator();


  void SetData(AOSArray32*, AOSArray32* connectivity);
  void SetData(AOSArray64*, AOSArray64* connectivity);
  void SetData(AffineArray32*, AOSArray32* connectivity);
  void SetData(AffineArray64*, AOSArray64* connectivity);

  bool SetData(vtkDataArray* offsets, vtkDataArray* connectivity);

  bool SetData(vtkIdType cellSize, vtkDataArray* connectivity);
 
  enum StorageTypes
  {
    Int64,
    Int32,
    FixedSizeInt64,
    FixedSizeInt32,
    Generic,
  };

  StorageTypes GetStorageType() const noexcept { return this->StorageType; }

  bool IsStorage64Bit() const { return this->StorageType == StorageTypes::Int64; }

  bool IsStorage32Bit() const { return this->StorageType == StorageTypes::Int32; }

  bool IsStorageFixedSize64Bit() const { return this->StorageType == StorageTypes::FixedSizeInt64; }

  bool IsStorageFixedSize32Bit() const { return this->StorageType == StorageTypes::FixedSizeInt32; }

   * @return True if the internal storage is using FixedSize arrays.
   */
  bool IsStorageFixedSize() const
  {
    return this->IsStorageFixedSize32Bit() || this->IsStorageFixedSize64Bit();
  }

  bool IsStorageGeneric() const { return this->StorageType == StorageTypes::Generic; }

   * a pointer to vtkIdType can be used.
   */
  bool IsStorageShareable() const override
  {
    switch (this->StorageType)
    {
      case StorageTypes::Int32:
      case StorageTypes::FixedSizeInt32:
        return std::is_same_v<vtkTypeInt32, vtkIdType>;
      case StorageTypes::Int64:
      case StorageTypes::FixedSizeInt64:
        return std::is_same_v<vtkTypeInt64, vtkIdType>;
      case StorageTypes::Generic:
      default:
        return false;
    }
  }

  void Use32BitStorage();
  void Use64BitStorage();
  void UseDefaultStorage();
  void UseFixedSize32BitStorage(vtkIdType cellSize);
  void UseFixedSize64BitStorage(vtkIdType cellSize);
  void UseFixedSizeDefaultStorage(vtkIdType cellSize);

  bool CanConvertTo32BitStorage() const;
  bool CanConvertTo64BitStorage() const;
  bool CanConvertToDefaultStorage() const;
  bool CanConvertToFixedSize32BitStorage() const;
  bool CanConvertToFixedSize64BitStorage() const;
  bool CanConvertToFixedSizeDefaultStorage() const;
  bool CanConvertToStorageType(StorageTypes type) const
  {
    switch (type)
    {
      case StorageTypes::Int32:
        return this->CanConvertTo32BitStorage();
      case StorageTypes::Int64:
        return this->CanConvertTo64BitStorage();
      case StorageTypes::FixedSizeInt32:
        return this->CanConvertToFixedSize32BitStorage();
      case StorageTypes::FixedSizeInt64:
        return this->CanConvertToFixedSize64BitStorage();
      case StorageTypes::Generic:
      default:
        return true;
    }
  }

  bool ConvertTo32BitStorage();
  bool ConvertTo64BitStorage();
  bool ConvertToDefaultStorage();
  bool ConvertToFixedSize32BitStorage();
  bool ConvertToFixedSize64BitStorage();
  bool ConvertToFixedSizeDefaultStorage();
  bool ConvertToSmallestStorage();
  bool ConvertToStorageType(StorageTypes type)
  {
    switch (type)
    {
      case StorageTypes::Int32:
        return this->ConvertTo32BitStorage();
      case StorageTypes::Int64:
        return this->ConvertTo64BitStorage();
      case StorageTypes::FixedSizeInt32:
        return this->ConvertToFixedSize32BitStorage();
      case StorageTypes::FixedSizeInt64:
        return this->ConvertToFixedSize64BitStorage();
      case StorageTypes::Generic:
      default:
        return true;
    }
  }

  vtkDataArray* GetOffsetsArray() const { return this->Offsets; }
  VTK_DEPRECATED_IN_9_6_0("Use GetOffsetsAOSArray32() instead.")
  vtkTypeInt32Array* GetOffsetsArray32() const
  {
    return vtkTypeInt32Array::FastDownCast(this->Offsets);
  }
  AOSArray32* GetOffsetsAOSArray32() const { return AOSArray32::FastDownCast(this->Offsets); }
  VTK_DEPRECATED_IN_9_6_0("Use GetOffsetsAOSArray64() instead.")
  vtkTypeInt64Array* GetOffsetsArray64() const
  {
    return vtkTypeInt64Array::FastDownCast(this->Offsets);
  }
  AOSArray64* GetOffsetsAOSArray64() const { return AOSArray64::FastDownCast(this->Offsets); }
  AffineArray32* GetOffsetsAffineArray32() const
  {
    return AffineArray32::FastDownCast(this->Offsets);
  }
  AffineArray64* GetOffsetsAffineArray64() const
  {
    return AffineArray64::FastDownCast(this->Offsets);
  }

  vtkDataArray* GetConnectivityArray() const { return this->Connectivity; }
  VTK_DEPRECATED_IN_9_6_0("Use GetConnectivityAOSArray32() instead.")
  vtkTypeInt32Array* GetConnectivityArray32() const
  {
    return vtkTypeInt32Array::FastDownCast(this->Connectivity);
  }
  AOSArray32* GetConnectivityAOSArray32() const
  {
    return AOSArray32::FastDownCast(this->Connectivity);
  }
  VTK_DEPRECATED_IN_9_6_0("Use GetConnectivityAOSArray64() instead.")
  vtkTypeInt64Array* GetConnectivityArray64() const
  {
    return vtkTypeInt64Array::FastDownCast(this->Connectivity);
  }
  AOSArray64* GetConnectivityAOSArray64() const
  {
    return AOSArray64::FastDownCast(this->Connectivity);
  }

  vtkIdType IsHomogeneous() const override;

  void InitTraversal();

  int GetNextCell(vtkIdType& npts, vtkIdType const*& pts) VTK_SIZEHINT(pts, npts);

  int GetNextCell(vtkIdList* pts);

  using vtkAbstractCellArray::GetCellAtId;
  inline void GetCellAtId(vtkIdType cellId, vtkIdType& cellSize, vtkIdType const*& cellPoints,
    vtkIdList* ptIds) VTK_SIZEHINT(cellPoints, cellSize)
    VTK_EXPECTS(0 <= cellId && cellId < GetNumberOfCells()) override;

  inline void GetCellAtId(vtkIdType cellId, vtkIdList* pts)
    VTK_EXPECTS(0 <= cellId && cellId < GetNumberOfCells()) override;

  inline void GetCellAtId(vtkIdType cellId, vtkIdType& cellSize, vtkIdType* cellPoints)
    VTK_SIZEHINT(cellPoints, cellSize)
      VTK_EXPECTS(0 <= cellId && cellId < GetNumberOfCells()) override;

  vtkIdType GetCellPointAtId(vtkIdType cellId, vtkIdType cellPointIndex) const
    VTK_EXPECTS(0 <= cellId && cellId < GetNumberOfCells())
      VTK_EXPECTS(0 <= cellPointIndex && cellPointIndex < this->GetCellSize(cellId));

  vtkIdType GetCellSize(vtkIdType cellId) const override;

  inline vtkIdType InsertNextCell(vtkCell* cell);

  inline vtkIdType InsertNextCell(vtkIdType npts, const vtkIdType* pts) VTK_SIZEHINT(pts, npts);

  inline vtkIdType InsertNextCell(vtkIdList* pts);

   * `InsertNextCell(int)` overload instead.
   */
  vtkIdType InsertNextCell(const std::initializer_list<vtkIdType>& cell)
  {
    return this->InsertNextCell(static_cast<vtkIdType>(cell.size()), cell.begin());
  }

  inline vtkIdType InsertNextCell(int npts);

  void InsertCellPoint(vtkIdType id);

  void UpdateCellCount(int npts);

  vtkIdType GetTraversalCellId();
  void SetTraversalCellId(vtkIdType cellId);

  void ReverseCellAtId(vtkIdType cellId) VTK_EXPECTS(0 <= cellId && cellId < GetNumberOfCells());

  void ReplaceCellAtId(vtkIdType cellId, vtkIdList* list);
  void ReplaceCellAtId(vtkIdType cellId, vtkIdType cellSize, const vtkIdType* cellPoints)
    VTK_EXPECTS(0 <= cellId && cellId < GetNumberOfCells()) VTK_SIZEHINT(cellPoints, cellSize);

  void ReplaceCellPointAtId(vtkIdType cellId, vtkIdType cellPointIndex, vtkIdType newPointId);

   * results.
   */
  void ReplaceCellAtId(vtkIdType cellId, const std::initializer_list<vtkIdType>& cell)
  {
    this->ReplaceCellAtId(cellId, static_cast<vtkIdType>(cell.size()), cell.begin());
  }

  int GetMaxCellSize() override;

  void DeepCopy(vtkAbstractCellArray* ca) override;

  void ShallowCopy(vtkAbstractCellArray* ca) override;

  void Append(vtkCellArray* src, vtkIdType pointOffset = 0);

  void ExportLegacyFormat(vtkIdTypeArray* data);

  void ImportLegacyFormat(vtkIdTypeArray* data);
  void ImportLegacyFormat(const vtkIdType* data, vtkIdType len) VTK_SIZEHINT(data, len);

  void AppendLegacyFormat(vtkIdTypeArray* data, vtkIdType ptOffset = 0);
  void AppendLegacyFormat(const vtkIdType* data, vtkIdType len, vtkIdType ptOffset = 0)
    VTK_SIZEHINT(data, len);

  unsigned long GetActualMemorySize() const;
 
  // The following code is used to support
 
  // The wrappers get understandably confused by some of the template code below
#ifndef __VTK_WRAP__
  /*
   * Utilities class that every dispatch functor used with Dispatch() must inherit
   * or optionally use its static methods.
   */
  struct DispatchUtilities
  {
    template <class ArrayT>
    using GetAPIType = vtk::GetAPIType<ArrayT, vtkIdType>;
 
    template <class OffsetsT>
    vtkIdType GetNumberOfCells(OffsetsT* offsets)
    {
      return offsets->GetNumberOfValues() - 1;
    }
 
    template <class ArrayT>
    static decltype(vtk::DataArrayValueRange<1, vtkIdType>(std::declval<ArrayT>())) GetRange(
      ArrayT* array)
    {
      return vtk::DataArrayValueRange<1, vtkIdType>(array);
    }
 
    template <class OffsetsT>
    static vtkIdType GetBeginOffset(OffsetsT* offsets, vtkIdType cellId)
    {
      return static_cast<vtkIdType>(GetRange(offsets)[cellId]);
    }
 
    template <class OffsetsT>
    static vtkIdType GetEndOffset(OffsetsT* offsets, vtkIdType cellId)
    {
      return static_cast<vtkIdType>(GetRange(offsets)[cellId + 1]);
    }
 
    template <class OffsetsT>
    static vtkIdType GetCellSize(OffsetsT* offsets, vtkIdType cellId)
    {
      auto offsetsRange = GetRange(offsets);
      return static_cast<vtkIdType>(offsetsRange[cellId + 1] - offsetsRange[cellId]);
    }
 
    template <class OffsetsT, class ConnectivityT>
    static decltype(vtk::DataArrayValueRange<1, vtkIdType>(std::declval<ConnectivityT>()))
    GetCellRange(OffsetsT* offsets, ConnectivityT* conn, vtkIdType cellId)
    {
      auto offsetsRange = GetRange(offsets);
      return vtk::DataArrayValueRange<1, vtkIdType>(
        conn, offsetsRange[cellId], offsetsRange[cellId + 1]);
    }
  };


   */
  template <typename Functor, typename... Args>
  void Dispatch(Functor&& functor, Args&&... args)
  {
    switch (this->StorageType)
    {
      case StorageTypes::Int32:
        functor(static_cast<AOSArray32*>(this->Offsets.Get()),
          static_cast<AOSArray32*>(this->Connectivity.Get()), std::forward<Args>(args)...);
        break;
      case StorageTypes::Int64:
        functor(static_cast<AOSArray64*>(this->Offsets.Get()),
          static_cast<AOSArray64*>(this->Connectivity.Get()), std::forward<Args>(args)...);
        break;
      case StorageTypes::FixedSizeInt32:
        functor(static_cast<AffineArray32*>(this->Offsets.Get()),
          static_cast<AOSArray32*>(this->Connectivity.Get()), std::forward<Args>(args)...);
        break;
      case StorageTypes::FixedSizeInt64:
        functor(static_cast<AffineArray64*>(this->Offsets.Get()),
          static_cast<AOSArray64*>(this->Connectivity.Get()), std::forward<Args>(args)...);
        break;
      case StorageTypes::Generic:
      default:
        functor(this->Offsets.Get(), this->Connectivity.Get(), std::forward<Args>(args)...);
        break;
    }
  }
  template <typename Functor, typename... Args>
  void Dispatch(Functor&& functor, Args&&... args) const
  {
    switch (this->StorageType)
    {
      case StorageTypes::Int32:
        functor(static_cast<AOSArray32*>(this->Offsets.Get()),
          static_cast<AOSArray32*>(this->Connectivity.Get()), std::forward<Args>(args)...);
        break;
      case StorageTypes::Int64:
        functor(static_cast<AOSArray64*>(this->Offsets.Get()),
          static_cast<AOSArray64*>(this->Connectivity.Get()), std::forward<Args>(args)...);
        break;
      case StorageTypes::FixedSizeInt32:
        functor(static_cast<AffineArray32*>(this->Offsets.Get()),
          static_cast<AOSArray32*>(this->Connectivity.Get()), std::forward<Args>(args)...);
        break;
      case StorageTypes::FixedSizeInt64:
        functor(static_cast<AffineArray64*>(this->Offsets.Get()),
          static_cast<AOSArray64*>(this->Connectivity.Get()), std::forward<Args>(args)...);
        break;
      case StorageTypes::Generic:
      default:
        functor(this->Offsets.Get(), this->Connectivity.Get(), std::forward<Args>(args)...);
        break;
    }
  }
 
  // Holds connectivity and offset arrays of the given ArrayType.
  // VTK_DEPRECATED_IN_9_6_0("Use DispatchUtilities")
  template <typename ArrayT>
  struct VisitState
  {
    using ArrayType = ArrayT;
    using ValueType = typename ArrayType::ValueType;
    using CellRangeType = decltype(vtk::DataArrayValueRange<1>(std::declval<ArrayType>()));
 
    // We can't just use is_same here, since binary compatible representations
    // (e.g. int and long) are distinct types. Instead, ensure that ValueType
    // is a signed integer the same size as vtkIdType.
    // If this value is true, ValueType pointers may be safely converted to
    // vtkIdType pointers via reinterpret cast.
    static constexpr bool ValueTypeIsSameAsIdType = std::is_integral<ValueType>::value &&
      std::is_signed<ValueType>::value && (sizeof(ValueType) == sizeof(vtkIdType));
 
    ArrayType* GetOffsets() { return this->Offsets; }
    const ArrayType* GetOffsets() const { return this->Offsets; }
 
    ArrayType* GetConnectivity() { return this->Connectivity; }
    const ArrayType* GetConnectivity() const { return this->Connectivity; }
 
    vtkIdType GetNumberOfCells() const;
 
    vtkIdType GetBeginOffset(vtkIdType cellId) const;
 
    vtkIdType GetEndOffset(vtkIdType cellId) const;
 
    vtkIdType GetCellSize(vtkIdType cellId) const;
 
    CellRangeType GetCellRange(vtkIdType cellId);
 
    friend class vtkCellArray;
 
  protected:
    VisitState()
    {
      this->Connectivity = vtkSmartPointer<ArrayType>::New();
      this->Offsets = vtkSmartPointer<ArrayType>::New();
      this->Offsets->InsertNextValue(0);
      if (vtkObjectBase::GetUsingMemkind())
      {
        this->IsInMemkind = true;
      }
    }
    ~VisitState() = default;
    void* operator new(size_t nSize)
    {
      void* r;
#ifdef VTK_USE_MEMKIND
      r = vtkObjectBase::GetCurrentMallocFunction()(nSize);
#else
      r = malloc(nSize);
#endif
      return r;
    }
    void operator delete(void* p)
    {
#ifdef VTK_USE_MEMKIND
      VisitState* a = static_cast<VisitState*>(p);
      if (a->IsInMemkind)
      {
        vtkObjectBase::GetAlternateFreeFunction()(p);
      }
      else
      {
        free(p);
      }
#else
      free(p);
#endif
    }
 
    vtkSmartPointer<ArrayType> Connectivity;
    vtkSmartPointer<ArrayType> Offsets;
 
  private:
    VisitState(const VisitState&) = delete;
    VisitState& operator=(const VisitState&) = delete;
    bool IsInMemkind = false;
  };
 
private: // Helpers that allow Visit to return a value:
  template <typename Functor, typename... Args>
  using GetReturnType = decltype(std::declval<Functor>()(
    std::declval<VisitState<AOSArray32>&>(), std::declval<Args>()...));
 
  template <typename Functor, typename... Args>
  struct ReturnsVoid : std::is_same<GetReturnType<Functor, Args...>, void>
  {
  };
 
public:
  template <typename Functor, typename... Args,
    typename = typename std::enable_if<ReturnsVoid<Functor, Args...>::value>::type>
  VTK_DEPRECATED_IN_9_6_0("Use Dispatch instead")
  void Visit(Functor&& functor, Args&&... args)
  {
    switch (this->StorageType)
    {
      case StorageTypes::Int32:
      {
        VisitState<AOSArray32> state;
        state.Offsets = AOSArray32::FastDownCast(this->Offsets);
        state.Connectivity = AOSArray32::FastDownCast(this->Connectivity);
        functor(state, std::forward<Args>(args)...);
        break;
      }
      case StorageTypes::Int64:
      {
        VisitState<AOSArray64> state;
        state.Offsets = AOSArray64::FastDownCast(this->Offsets);
        state.Connectivity = AOSArray64::FastDownCast(this->Connectivity);
        functor(state, std::forward<Args>(args)...);
        break;
      }
      case StorageTypes::FixedSizeInt32:
      case StorageTypes::FixedSizeInt64:
      case StorageTypes::Generic:
      default:
      {
        vtkWarningMacro("Use Dispatch");
        break;
      }
    }
  }
 
  template <typename Functor, typename... Args,
    typename = typename std::enable_if<ReturnsVoid<Functor, Args...>::value>::type>
  VTK_DEPRECATED_IN_9_6_0("Use Dispatch instead")
  void Visit(Functor&& functor, Args&&... args) const
  {
    switch (this->StorageType)
    {
      case StorageTypes::Int32:
      {
        VisitState<AOSArray32> state;
        state.Offsets = AOSArray32::FastDownCast(this->Offsets);
        state.Connectivity = AOSArray32::FastDownCast(this->Connectivity);
        functor(state, std::forward<Args>(args)...);
        break;
      }
      case StorageTypes::Int64:
      {
        VisitState<AOSArray64> state;
        state.Offsets = AOSArray64::FastDownCast(this->Offsets);
        state.Connectivity = AOSArray64::FastDownCast(this->Connectivity);
        functor(state, std::forward<Args>(args)...);
        break;
      }
      case StorageTypes::FixedSizeInt32:
      case StorageTypes::FixedSizeInt64:
      case StorageTypes::Generic:
      default:
      {
        vtkWarningMacro("Use Dispatch");
        break;
      }
    }
  }
 
  template <typename Functor, typename... Args,
    typename = typename std::enable_if<!ReturnsVoid<Functor, Args...>::value>::type>
  VTK_DEPRECATED_IN_9_6_0("Use Dispatch instead")
  GetReturnType<Functor, Args...> Visit(Functor&& functor, Args&&... args)
  {
    switch (this->StorageType)
    {
      case StorageTypes::Int32:
      {
        VisitState<AOSArray32> state;
        state.Offsets = AOSArray32::FastDownCast(this->Offsets);
        state.Connectivity = AOSArray32::FastDownCast(this->Connectivity);
        return functor(state, std::forward<Args>(args)...);
      }
      case StorageTypes::Int64:
      {
        VisitState<AOSArray64> state;
        state.Offsets = AOSArray64::FastDownCast(this->Offsets);
        state.Connectivity = AOSArray64::FastDownCast(this->Connectivity);
        return functor(state, std::forward<Args>(args)...);
      }
      case StorageTypes::FixedSizeInt32:
      case StorageTypes::FixedSizeInt64:
      case StorageTypes::Generic:
      default:
      {
        vtkWarningMacro("Use Dispatch");
        return GetReturnType<Functor, Args...>();
      }
    }
  }
  template <typename Functor, typename... Args,
    typename = typename std::enable_if<!ReturnsVoid<Functor, Args...>::value>::type>
  VTK_DEPRECATED_IN_9_6_0("Use Dispatch instead")
  GetReturnType<Functor, Args...> Visit(Functor&& functor, Args&&... args) const
  {
    switch (this->StorageType)
    {
      case StorageTypes::Int32:
      {
        VisitState<AOSArray32> state;
        state.Offsets = AOSArray32::FastDownCast(this->Offsets);
        state.Connectivity = AOSArray32::FastDownCast(this->Connectivity);
        return functor(state, std::forward<Args>(args)...);
      }
      case StorageTypes::Int64:
      {
        VisitState<AOSArray64> state;
        state.Offsets = AOSArray64::FastDownCast(this->Offsets);
        state.Connectivity = AOSArray64::FastDownCast(this->Connectivity);
        return functor(state, std::forward<Args>(args)...);
      }
      case StorageTypes::FixedSizeInt32:
      case StorageTypes::FixedSizeInt64:
      case StorageTypes::Generic:
      default:
      {
        vtkWarningMacro("Use Dispatch");
        return GetReturnType<Functor, Args...>();
      }
    }
  }
 
#endif // __VTK_WRAP__


  static bool GetDefaultStorageIs64Bit() { return vtkCellArray::DefaultStorageIs64Bit; }
  static void SetDefaultStorageIs64Bit(bool val) { vtkCellArray::DefaultStorageIs64Bit = val; }
 
  //=================== Begin Legacy Methods ===================================
  // These should be deprecated at some point as they are confusing or very slow

  VTK_DEPRECATED_IN_9_6_0("This call has no effect.")
  virtual void SetNumberOfCells(vtkIdType);

  VTK_DEPRECATED_IN_9_6_0("Use AllocateEstimate directly instead.")
  vtkIdType EstimateSize(vtkIdType numCells, int maxPtsPerCell);

  VTK_DEPRECATED_IN_9_6_0("Method incompatible with current internal storage.")
  vtkIdType GetSize();

  VTK_DEPRECATED_IN_9_6_0("Method incompatible with current internal storage.")
  vtkIdType GetNumberOfConnectivityEntries();

  VTK_DEPRECATED_IN_9_6_0("Use GetCellAtId.")
  void GetCell(vtkIdType loc, vtkIdType& npts, const vtkIdType*& pts)
    VTK_EXPECTS(0 <= loc && loc < GetNumberOfConnectivityEntries()) VTK_SIZEHINT(pts, npts);

  VTK_DEPRECATED_IN_9_6_0("Use GetCellAtId.")
  void GetCell(vtkIdType loc, vtkIdList* pts)
    VTK_EXPECTS(0 <= loc && loc < GetNumberOfConnectivityEntries());

  VTK_DEPRECATED_IN_9_6_0("Use GetNumberOfCells.")
  vtkIdType GetInsertLocation(int npts);

  VTK_DEPRECATED_IN_9_6_0("Use GetTraversalCellId.")
  vtkIdType GetTraversalLocation();
  VTK_DEPRECATED_IN_9_6_0("Use GetTraversalCellId.")
  vtkIdType GetTraversalLocation(vtkIdType npts);
  VTK_DEPRECATED_IN_9_6_0("Use SetTraversalCellId.")
  void SetTraversalLocation(vtkIdType loc);

  VTK_DEPRECATED_IN_9_6_0("Use ReverseCellAtId.")
  void ReverseCell(vtkIdType loc) VTK_EXPECTS(0 <= loc && loc < GetNumberOfConnectivityEntries());

  VTK_DEPRECATED_IN_9_6_0("Use ReplaceCellAtId.")
  void ReplaceCell(vtkIdType loc, int npts, const vtkIdType pts[])
    VTK_EXPECTS(0 <= loc && loc < GetNumberOfConnectivityEntries()) VTK_SIZEHINT(pts, npts);

  VTK_DEPRECATED_IN_9_6_0("Use ImportLegacyFormat or SetData instead.")
  void SetCells(vtkIdType ncells, vtkIdTypeArray* cells);

  VTK_DEPRECATED_IN_9_6_0(
    "Use ExportLegacyFormat, or GetOffsetsArray/GetConnectivityArray instead.")
  vtkIdTypeArray* GetData();
 
  //=================== End Legacy Methods =====================================
 
  friend class vtkCellArrayIterator;
 
protected:
  vtkCellArray();
  ~vtkCellArray() override;
 
  vtkSmartPointer<vtkDataArray> Offsets;
  vtkSmartPointer<vtkDataArray> Connectivity;
  StorageTypes StorageType;
  vtkIdType TraversalCellId{ 0 };
 
  vtkNew<vtkIdTypeArray> LegacyData; // For GetData().
 
  static bool DefaultStorageIs64Bit;
 
private:
  vtkCellArray(const vtkCellArray&) = delete;
  void operator=(const vtkCellArray&) = delete;
};
 
template <typename ArrayT>
vtkIdType vtkCellArray::VisitState<ArrayT>::GetNumberOfCells() const
{
  return this->Offsets->GetNumberOfValues() - 1;
}
 
template <typename ArrayT>
vtkIdType vtkCellArray::VisitState<ArrayT>::GetBeginOffset(vtkIdType cellId) const
{
  return static_cast<vtkIdType>(this->Offsets->GetValue(cellId));
}
 
template <typename ArrayT>
vtkIdType vtkCellArray::VisitState<ArrayT>::GetEndOffset(vtkIdType cellId) const
{
  return static_cast<vtkIdType>(this->Offsets->GetValue(cellId + 1));
}
 
template <typename ArrayT>
vtkIdType vtkCellArray::VisitState<ArrayT>::GetCellSize(vtkIdType cellId) const
{
  return this->GetEndOffset(cellId) - this->GetBeginOffset(cellId);
}
 
template <typename ArrayT>
typename vtkCellArray::VisitState<ArrayT>::CellRangeType
vtkCellArray::VisitState<ArrayT>::GetCellRange(vtkIdType cellId)
{
  return vtk::DataArrayValueRange<1>(
    this->GetConnectivity(), this->GetBeginOffset(cellId), this->GetEndOffset(cellId));
}
VTK_ABI_NAMESPACE_END
 
namespace vtkCellArray_detail
{
VTK_ABI_NAMESPACE_BEGIN
 
struct InsertNextCellImpl : public vtkCellArray::DispatchUtilities
{
  // Insert full cell
  template <class OffsetsT, class ConnectivityT>
  void operator()(OffsetsT* offsets, ConnectivityT* conn, const vtkIdType npts,
    const vtkIdType pts[], vtkIdType& cellId)
  {
    using ValueType = GetAPIType<OffsetsT>;
    using OffsetsAccessorType = vtkDataArrayAccessor<OffsetsT>;
    using ConnectivityAccessorType = vtkDataArrayAccessor<ConnectivityT>;
    OffsetsAccessorType offsetsAccesor(offsets);
    ConnectivityAccessorType connAccesor(conn);
 
    cellId = offsets->GetNumberOfValues() - 1;
 
    offsetsAccesor.InsertNext(static_cast<ValueType>(conn->GetNumberOfValues() + npts));
 
    for (vtkIdType i = 0; i < npts; ++i)
    {
      connAccesor.InsertNext(static_cast<ValueType>(pts[i]));
    }
  }
 
  // Just update offset table (for incremental API)
  template <class OffsetsT, class ConnectivityT>
  void operator()(OffsetsT* offsets, ConnectivityT* conn, const vtkIdType npts, vtkIdType& cellId)
  {
    using ValueType = GetAPIType<OffsetsT>;
    using AccessorType = vtkDataArrayAccessor<OffsetsT>;
    AccessorType offsetsAccesor(offsets);
 
    cellId = offsets->GetNumberOfValues() - 1;
 
    offsetsAccesor.InsertNext(static_cast<ValueType>(conn->GetNumberOfValues() + npts));
  }
};
 
// for incremental API:
struct UpdateCellCountImpl : public vtkCellArray::DispatchUtilities
{
  template <class OffsetsT, class ConnectivityT>
  void operator()(OffsetsT* offsets, ConnectivityT* vtkNotUsed(conn), const vtkIdType npts)
  {
    using ValueType = GetAPIType<OffsetsT>;
 
    auto offsetsRange = GetRange(offsets);
    const ValueType cellBegin = offsetsRange[offsets->GetMaxId() - 1];
    offsetsRange[offsets->GetMaxId()] = static_cast<ValueType>(cellBegin + npts);
  }
};
 
struct GetCellSizeImpl : public vtkCellArray::DispatchUtilities
{
  template <class OffsetsT, class ConnectivityT>
  void operator()(
    OffsetsT* offsets, ConnectivityT* vtkNotUsed(conn), vtkIdType cellId, vtkIdType& cellSize)
  {
    cellSize = GetCellSize(offsets, cellId);
  }
};
 
struct GetCellAtIdImpl : public vtkCellArray::DispatchUtilities
{
  template <class OffsetsT, class ConnectivityT>
  void operator()(OffsetsT* offsets, ConnectivityT* conn, const vtkIdType cellId, vtkIdList* ids)
  {
    auto offsetsRange = GetRange(offsets);
    const auto& beginOffset = offsetsRange[cellId];
    const auto& endOffset = offsetsRange[cellId + 1];
    const vtkIdType cellSize = static_cast<vtkIdType>(endOffset - beginOffset);
    const auto cellConnectivity = GetRange(conn).begin() + beginOffset;
 
    // ValueType differs from vtkIdType, so we have to copy into a temporary buffer:
    ids->SetNumberOfIds(cellSize);
    vtkIdType* idPtr = ids->GetPointer(0);
    for (vtkIdType i = 0; i < cellSize; ++i)
    {
      idPtr[i] = static_cast<vtkIdType>(cellConnectivity[i]);
    }
  }
 
  template <class OffsetsT, class ConnectivityT>
  void operator()(OffsetsT* offsets, ConnectivityT* conn, const vtkIdType cellId,
    vtkIdType& cellSize, vtkIdType* cellPoints)
  {
    auto offsetsRange = GetRange(offsets);
    const auto& beginOffset = offsetsRange[cellId];
    const auto& endOffset = offsetsRange[cellId + 1];
    cellSize = static_cast<vtkIdType>(endOffset - beginOffset);
    const auto cellConnectivity = GetRange(conn).begin() + beginOffset;
 
    // ValueType differs from vtkIdType, so we have to copy into a temporary buffer:
    for (vtkIdType i = 0; i < cellSize; ++i)
    {
      cellPoints[i] = static_cast<vtkIdType>(cellConnectivity[i]);
    }
  }
 
  // SFINAE helper to check if a Functors's connectivity array's memory can be used as a vtkIdType*.
  template <typename ConnectivityT>
  struct CanShareConnPtr
  {
    static constexpr bool value =
      std::is_base_of_v<vtkAOSDataArrayTemplate<vtkIdType>, ConnectivityT>;
  };
 
  template <class OffsetsT, class ConnectivityT>
  typename std::enable_if_t<CanShareConnPtr<ConnectivityT>::value, void> operator()(
    OffsetsT* offsets, ConnectivityT* conn, const vtkIdType cellId, vtkIdType& cellSize,
    vtkIdType const*& cellPoints, vtkIdList* vtkNotUsed(temp))
  {
    auto offsetsRange = GetRange(offsets);
    const auto& beginOffset = offsetsRange[cellId];
    const auto& endOffset = offsetsRange[cellId + 1];
    cellSize = static_cast<vtkIdType>(endOffset - beginOffset);
    // This is safe, see CanShareConnPtr helper above.
    cellPoints = conn->GetPointer(beginOffset);
  }
 
  template <class OffsetsT, class ConnectivityT>
  typename std::enable_if_t<!CanShareConnPtr<ConnectivityT>::value, void> operator()(
    OffsetsT* offsets, ConnectivityT* conn, const vtkIdType cellId, vtkIdType& cellSize,
    vtkIdType const*& cellPoints, vtkIdList* temp)
  {
    auto offsetsRange = GetRange(offsets);
    const auto& beginOffset = offsetsRange[cellId];
    const auto& endOffset = offsetsRange[cellId + 1];
    cellSize = static_cast<vtkIdType>(endOffset - beginOffset);
    const auto cellConnectivity = GetRange(conn).begin() + beginOffset;
 
    temp->SetNumberOfIds(cellSize);
    vtkIdType* tempPtr = temp->GetPointer(0);
    for (vtkIdType i = 0; i < cellSize; ++i)
    {
      tempPtr[i] = static_cast<vtkIdType>(cellConnectivity[i]);
    }
 
    cellPoints = tempPtr;
  }
};
 
struct CellPointAtIdImpl : public vtkCellArray::DispatchUtilities
{
  template <class OffsetsT, class ConnectivityT>
  void operator()(OffsetsT* offsets, ConnectivityT* conn, vtkIdType cellId,
    vtkIdType cellPointIndex, vtkIdType& pointId)
  {
    pointId =
      static_cast<vtkIdType>(GetRange(conn)[GetBeginOffset(offsets, cellId) + cellPointIndex]);
  }
};
 
struct ResetImpl : public vtkCellArray::DispatchUtilities
{
  template <class OffsetsT, class ConnectivityT>
  void operator()(OffsetsT* offsets, ConnectivityT* conn)
  {
    using ValueType = GetAPIType<OffsetsT>;
    using AccessorType = vtkDataArrayAccessor<OffsetsT>;
    offsets->Reset();
    conn->Reset();
    AccessorType accessor(offsets);
    ValueType firstOffset = 0;
    accessor.InsertNext(firstOffset);
  }
};
 
struct InsertCellPointImpl : public vtkCellArray::DispatchUtilities
{
  template <class OffsetsT, class ConnectivityT>
  void operator()(OffsetsT* vtkNotUsed(offsets), ConnectivityT* conn, vtkIdType id)
  {
    using ValueType = GetAPIType<ConnectivityT>;
    using AccessorType = vtkDataArrayAccessor<ConnectivityT>;
    AccessorType accessor(conn);
    accessor.InsertNext(static_cast<ValueType>(id));
  }
};
 
VTK_ABI_NAMESPACE_END
} // end namespace vtkCellArray_detail
 
VTK_ABI_NAMESPACE_BEGIN
//----------------------------------------------------------------------------
inline void vtkCellArray::InitTraversal()
{
  this->TraversalCellId = 0;
}
 
//----------------------------------------------------------------------------
inline int vtkCellArray::GetNextCell(vtkIdType& npts, vtkIdType const*& pts) VTK_SIZEHINT(pts, npts)
{
  if (this->TraversalCellId < this->GetNumberOfCells())
  {
    this->GetCellAtId(this->TraversalCellId, npts, pts);
    ++this->TraversalCellId;
    return 1;
  }
 
  npts = 0;
  pts = nullptr;
  return 0;
}
 
//----------------------------------------------------------------------------
inline int vtkCellArray::GetNextCell(vtkIdList* pts)
{
  if (this->TraversalCellId < this->GetNumberOfCells())
  {
    this->GetCellAtId(this->TraversalCellId, pts);
    ++this->TraversalCellId;
    return 1;
  }
 
  pts->Reset();
  return 0;
}
//----------------------------------------------------------------------------
inline vtkIdType vtkCellArray::GetCellSize(const vtkIdType cellId) const
{
  vtkIdType cellSize;
  this->Dispatch(vtkCellArray_detail::GetCellSizeImpl{}, cellId, cellSize);
  return cellSize;
}
 
//----------------------------------------------------------------------------
void vtkCellArray::GetCellAtId(vtkIdType cellId, vtkIdType& cellSize, vtkIdType const*& cellPoints,
  vtkIdList* ptIds) VTK_SIZEHINT(cellPoints, cellSize)
{
  this->Dispatch(vtkCellArray_detail::GetCellAtIdImpl{}, cellId, cellSize, cellPoints, ptIds);
}
 
//----------------------------------------------------------------------------
void vtkCellArray::GetCellAtId(vtkIdType cellId, vtkIdList* pts)
{
  this->Dispatch(vtkCellArray_detail::GetCellAtIdImpl{}, cellId, pts);
}
 
//----------------------------------------------------------------------------
void vtkCellArray::GetCellAtId(vtkIdType cellId, vtkIdType& cellSize, vtkIdType* cellPoints)
{
  this->Dispatch(vtkCellArray_detail::GetCellAtIdImpl{}, cellId, cellSize, cellPoints);
}
 
//----------------------------------------------------------------------------
inline vtkIdType vtkCellArray::GetCellPointAtId(vtkIdType cellId, vtkIdType cellPointIndex) const
{
  vtkIdType pointId;
  this->Dispatch(vtkCellArray_detail::CellPointAtIdImpl{}, cellId, cellPointIndex, pointId);
  return pointId;
}
 
//----------------------------------------------------------------------------
vtkIdType vtkCellArray::InsertNextCell(vtkIdType npts, const vtkIdType* pts) VTK_SIZEHINT(pts, npts)
{
  vtkIdType cellId;
  this->Dispatch(vtkCellArray_detail::InsertNextCellImpl{}, npts, pts, cellId);
  return cellId;
}
 
//----------------------------------------------------------------------------
vtkIdType vtkCellArray::InsertNextCell(int npts)
{
  vtkIdType cellId;
  this->Dispatch(vtkCellArray_detail::InsertNextCellImpl{}, npts, cellId);
  return cellId;
}
 
//----------------------------------------------------------------------------
inline void vtkCellArray::InsertCellPoint(vtkIdType id)
{
  this->Dispatch(vtkCellArray_detail::InsertCellPointImpl{}, id);
}
 
//----------------------------------------------------------------------------
inline void vtkCellArray::UpdateCellCount(int npts)
{
  this->Dispatch(vtkCellArray_detail::UpdateCellCountImpl{}, npts);
}
 
//----------------------------------------------------------------------------
vtkIdType vtkCellArray::InsertNextCell(vtkIdList* pts)
{
  vtkIdType cellId;
  this->Dispatch(
    vtkCellArray_detail::InsertNextCellImpl{}, pts->GetNumberOfIds(), pts->GetPointer(0), cellId);
  return cellId;
}
 
//----------------------------------------------------------------------------
vtkIdType vtkCellArray::InsertNextCell(vtkCell* cell)
{
  vtkIdList* pts = cell->GetPointIds();
  vtkIdType cellId;
  this->Dispatch(
    vtkCellArray_detail::InsertNextCellImpl{}, pts->GetNumberOfIds(), pts->GetPointer(0), cellId);
  return cellId;
}
 
//----------------------------------------------------------------------------
inline void vtkCellArray::Reset()
{
  this->Dispatch(vtkCellArray_detail::ResetImpl{});
}
 
VTK_ABI_NAMESPACE_END
#endif // vtkCellArray.h