vtkFieldData.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 vtkFieldData_h
#define vtkFieldData_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkObject.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALMANUAL
 
#include "vtkAbstractArray.h" // Needed for inline methods.
 
#include <array>  // For CachedGhostRangeType
#include <tuple>  // For CachedGhostRangeType
#include <vector> // For list indices
 
VTK_ABI_NAMESPACE_BEGIN
class vtkIdList;
class vtkDoubleArray;
class vtkUnsignedCharArray;
 
class VTKCOMMONDATAMODEL_EXPORT VTK_MARSHALMANUAL vtkFieldData : public vtkObject
{
public:
  static vtkFieldData* New();
  static vtkFieldData* ExtendedNew();
 
  vtkTypeMacro(vtkFieldData, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  virtual void Initialize();

  vtkTypeBool Allocate(vtkIdType sz, vtkIdType ext = 1000);

  void CopyStructure(vtkFieldData*);

  void AllocateArrays(int num);

  int GetNumberOfArrays() { return this->NumberOfActiveArrays; }

  int AddArray(vtkAbstractArray* array);

  void NullData(vtkIdType id);


  virtual void RemoveArray(const char* name);

  virtual void RemoveArray(int index);

  vtkDataArray* GetArray(int i);

  vtkDataArray* GetArray(const char* arrayName, int& index);


  vtkDataArray* GetArray(const char* arrayName)
  {
    int i;
    return this->GetArray(arrayName, i);
  }


  vtkAbstractArray* GetAbstractArray(int i);

  vtkAbstractArray* GetAbstractArray(const char* arrayName, int& index);


  vtkAbstractArray* GetAbstractArray(const char* arrayName)
  {
    int i;
    return this->GetAbstractArray(arrayName, i);
  }



  vtkTypeBool HasArray(const char* name)
  {
    int i;
    vtkAbstractArray* array = this->GetAbstractArray(name, i);
    return array ? 1 : 0;
  }



  const char* GetArrayName(int i)
  {
    vtkAbstractArray* da = this->GetAbstractArray(i);
    return da ? da->GetName() : nullptr;
  }


  virtual void PassData(vtkFieldData* fd);

  void CopyFieldOn(const char* name) { this->CopyFieldOnOff(name, 1); }
  void CopyFieldOff(const char* name) { this->CopyFieldOnOff(name, 0); }

  virtual void CopyAllOn(int unused = 0);

  virtual void CopyAllOff(int unused = 0);

  virtual void DeepCopy(vtkFieldData* da);

  virtual void ShallowCopy(vtkFieldData* da);

  void Squeeze();

  void Reset();

  virtual unsigned long GetActualMemorySize();

  vtkMTimeType GetMTime() override;

  void GetField(vtkIdList* ptId, vtkFieldData* f);

  int GetArrayContainingComponent(int i, int& arrayComp);

  int GetNumberOfComponents();

  vtkIdType GetNumberOfTuples();

  void SetNumberOfTuples(vtkIdType number);

  void SetTuple(vtkIdType i, vtkIdType j, vtkFieldData* source);

  void InsertTuple(vtkIdType i, vtkIdType j, vtkFieldData* source);

  vtkIdType InsertNextTuple(vtkIdType j, vtkFieldData* source);


  bool GetRange(const char* name, double range[2], int comp = 0);
  bool GetRange(int index, double range[2], int comp = 0);
  bool GetFiniteRange(const char* name, double range[2], int comp = 0);
  bool GetFiniteRange(int index, double range[2], int comp = 0);


  vtkGetMacro(GhostsToSkip, unsigned char);
  virtual void SetGhostsToSkip(unsigned char);

  bool HasAnyGhostBitSet(int bitFlag);

  vtkGetObjectMacro(GhostArray, vtkUnsignedCharArray);

  static const char* GhostArrayName() { return "vtkGhostType"; }
 
protected:
  vtkFieldData();
  ~vtkFieldData() override;
 
  int NumberOfArrays;
  int NumberOfActiveArrays;
  vtkAbstractArray** Data;

  void SetArray(int i, vtkAbstractArray* array);

  virtual void InitializeFields();
 
  struct CopyFieldFlag
  {
    char* ArrayName;
    int IsCopied;
  };
 
  CopyFieldFlag* CopyFieldFlags; // the names of fields not to be copied
  int NumberOfFieldFlags;        // the number of fields not to be copied
  void CopyFieldOnOff(const char* name, int onOff);
  void ClearFieldFlags();
  int FindFlag(const char* field);
  int GetFlag(const char* field);
  void CopyFlags(const vtkFieldData* source);
  int DoCopyAllOn;
  int DoCopyAllOff;
 
  /*
   * This tuple holds: [array time stamp, ghost array time stamp, cached ranges].
   * Those time stamps are used to decide whether the cached range should be recomputed or not.
   * when requesting the range of an array.
   *
   * When there is no ghost array, the ghost array time stamp is defined as equal to 0.
   */
  using CachedGhostRangeType = std::tuple<vtkMTimeType, vtkMTimeType, std::vector<double>>;
  unsigned char GhostsToSkip;
  vtkUnsignedCharArray* GhostArray;


  std::vector<std::array<CachedGhostRangeType, 2>> Ranges;
  std::vector<std::array<CachedGhostRangeType, 2>> FiniteRanges;
 
private:
  vtkFieldData(const vtkFieldData&) = delete;
  void operator=(const vtkFieldData&) = delete;
 
  friend class vtkFieldDataSerDesHelper; // for access to SetArray()
 
public:
  class VTKCOMMONDATAMODEL_EXPORT BasicIterator
  {
  public:
    BasicIterator() = default;
    BasicIterator(const BasicIterator& source);
    BasicIterator(const int* list, unsigned int listSize);
    BasicIterator& operator=(const BasicIterator& source);
    virtual ~BasicIterator() = default;
    void PrintSelf(ostream& os, vtkIndent indent);
 
    int GetListSize() const { return static_cast<int>(this->List.size()); }
    int GetCurrentIndex() { return this->List[this->Position]; }
    int BeginIndex()
    {
      this->Position = -1;
      return this->NextIndex();
    }
    int End() const { return (this->Position >= static_cast<int>(this->List.size())); }
    int NextIndex()
    {
      this->Position++;
      return (this->End() ? -1 : this->List[this->Position]);
    }
 
    // Support C++ range-for loops; e.g, code like
    // "for (const auto& i : basicIterator)".
    std::vector<int>::const_iterator begin() { return this->List.begin(); }
    std::vector<int>::const_iterator end() { return this->List.end(); }
 
  protected:
    std::vector<int> List;
    int Position;
  };
 
  class VTKCOMMONDATAMODEL_EXPORT Iterator : public BasicIterator
  {
  public:
    Iterator(const Iterator& source);
    Iterator& operator=(const Iterator& source);
    ~Iterator() override;
    Iterator(vtkFieldData* dsa, const int* list = nullptr, unsigned int listSize = 0);
 
    vtkDataArray* Begin()
    {
      this->Position = -1;
      return this->Next();
    }
 
    vtkDataArray* Next()
    {
      this->Position++;
      if (this->End())
      {
        return nullptr;
      }
 
      // vtkFieldData::GetArray() can return null, which implies that
      // a the array at the given index in not a vtkDataArray subclass.
      // This iterator skips such arrays.
      vtkDataArray* cur = Fields->GetArray(this->List[this->Position]);
      return (cur ? cur : this->Next());
    }
 
    void DetachFieldData();
 
  protected:
    vtkFieldData* Fields;
    int Detached;
  };
};
 
VTK_ABI_NAMESPACE_END
#endif